• 手写Mybatis

    Mybatis核心配置文件就是为了配置Configration

    因此要首先会解析Mybatis核心配置文件

    首先使用dom4J解析Mybatis核心配置文件

    新建模块演示dom4j解析.xml

    目录放错了  无所谓

    引入依赖

    从原来项目可以拷贝过来

    就些简单配置就好

    解析核心配置文件和解析xxxMapper.xml映射文件代码

    1. import org.dom4j.Document;
    2. import org.dom4j.DocumentException;
    3. import org.dom4j.Element;
    4. import org.dom4j.Node;
    5. import org.dom4j.io.SAXReader;
    6. import org.junit.Test;
    7.  
    8. import java.io.InputStream;
    9. import java.util.List;
    10.  
    11. /**
    12.  * @author hrui
    13.  * @date 2023/9/10 18:24
    14.  */
    15. public class ParseXMLByDom4JTest {
    16.  
    17.  
    18.     //解析Mapper映射文件
    19.     @Test
    20.     public void testParseSqlMapperXML() throws DocumentException {
    21.         //创建SAXReader对象
    22.         SAXReader reader=new SAXReader();
    23.         //获取输入流(将resources目录下的mybatis-config1.xml转输入流)
    24.         InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("mapper/CarMapperABC.xml");
    25.         //读XML文件
    26.         Document document=reader.read(inputStream);
    27.         String xpath="/mapper";
    28.         Element mapper =(Element) document.selectSingleNode(xpath);
    29.         String namespace = mapper.attributeValue("namespace");
    30.         System.out.println(namespace);//aaa
    31.         //获取mapper节点下所有子节点
    32.         List<Element> elements = mapper.elements();
    33.         elements.forEach(e->{
    34.             //获取sqlId
    35.             String id = e.attributeValue("id");
    36.             //获取resultType  没有返回null
    37.             System.out.println(id);
    38.             //获取标签中的sql语句,取出前后空白
    39.             String sql = e.getTextTrim();
    40.             System.out.println(sql);//insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values(null,#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})
    41.             //现在是:insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values(null,#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})
    42.             //内部肯定使用JDBC:insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values(null,？,？,？,？,？)
    43.             //转换
    44.             String newSql = sql.replaceAll("#\\{[0-9A-Za-z_$]*}", "?");//使用正则替换
    45.             System.out.println(newSql);//insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values(null,?,?,?,?,?)
    46.         });
    47.     }
    48.  
    49.  
    50.  
    51.     //解析核心配置文件
    52.     @Test
    53.     public void testParseMybatisConfigXML() throws DocumentException {
    54.         //创建SAXReader对象
    55.         SAXReader reader=new SAXReader();
    56.         //获取输入流(将resources目录下的mybatis-config1.xml转输入流)
    57.         InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("mybatis-config1.xml");
    58.         //读XML文件
    59.         Document document=reader.read(inputStream);
    60.         //System.out.println(document);
    61.         //获取根标签
    62.         Element root = document.getRootElement();
    63.         //System.out.println(root.getName());//configuration
    64.         //获取跟标签后肯定是去获取环境 environments 获取里面的default数据库id
    65.         //获取默认的环境id
    66.         //xpath是做标签路径匹配的.能够让我们快速定位XML文件中的元素
    67.         //以下的xpath:从跟下开始找configuration,然后找configuration标签下的子标签environments
    68.         String xpath="/configuration/environments";
    69.         Element element = (Element)document.selectSingleNode(xpath);
    70.         //System.out.println(element);
    71.         //获取属性的值 默认环境id
    72.         String aDefaultEnvivironmentId = element.attributeValue("default");
    73.         //System.out.println("默认环境id是:"+aDefaultEnvivironmentId);//development
    74.  
    75.         //去找environment的 id属性,然后和默认环境id比较,确定默认使用哪个数据库
    76.         //下面是xpath的写法 意思找
    77.         xpath="/configuration/environments/environment[@id='"+aDefaultEnvivironmentId+"']";
    78.         Element enviroment =(Element) document.selectSingleNode(xpath);
    79.         //System.out.println(enviroment.getName());environment
    80.         //获取environment节点下的transactionManager
    81.         Element transactionManager = enviroment.element("transactionManager");
    82.         String transactionType = transactionManager.attributeValue("type");
    83.         //System.out.println("事务管理器的类型:"+transactionType);//获取事务管理器类型----->JDBC
    84.         //接着获取datasource节点
    85.         Element datasource = enviroment.element("dataSource");
    86.         String dataSourcetype = datasource.attributeValue("type");
    87.         System.out.println("数据源的类型:"+dataSourcetype);//POOLED
    88.         //获取dataSource下的所有子节点
    89.         List<Element> propertyElements = datasource.elements();
    90.         //遍历
    91.         propertyElements.forEach(e->{
    92.             String name = e.attributeValue("name");
    93.             String value = e.attributeValue("value");
    94.             System.out.println("name="+name+",value="+value);
    95.         });
    96.  
    97.         //获取所有的mapper标签
    98.         //如果你不想从跟下开始获取,而是想从任意位置开始,获取某个标签,xpath可以这样写
    99.         xpath="//mapper";//  两个//开始
    100.         List<Node> mappers = document.selectNodes(xpath);
    101.         //遍历
    102.         mappers.forEach(n->{
    103.             Element e=(Element)n;
    104.             String resource = e.attributeValue("resource");
    105.             System.out.println(resource);
    106.         });
    107.  
    108.     }
    109. }

    新建module 

    引入依赖

    可以回顾下标准写法

    逆推下

    Resources

    SqlSessionFactoryBuilder

    SqlSessionFactory

    transaction  

    SqlSession

    SQL Mapper

    思路:1.Resources用来加载核心配置文件,返回一个InputStream流,

    2.SqlSessionFactoryBuilder里有个build方法,该方法用来返回一个SqlSessionFactory对象

    这里要考虑,SqlSessionFactory里有些什么,用来做什么.

    那么这样就明了了,build方法用来解析核心配置文件,用以给SqlSessionFactory里的属性赋值,而属性有哪些,就是上面这些呗(事务管理器,JDBC连接需要的driver,url,username,password)

    另外

    和映射文件

    是否考虑用一个容器Map存放,key为sql的id   value是其他

    将这个对象也封装到SqlSessionFactory中

    这个对象中该有哪些属性:暂时放sql语句和resultType  当然实际放的不只这两个  获取不到就是null

    SqlSessionFactory中还需要一个事务管理器,这个事务管理器可以是JDBC也可以是MANAGED,那么可以定义为接口,另外定义两个具体的实现  这里使用JDBC事务管理器

    而我们定义了事务管理器之后,事务管理器需要搞定的就三个方法,commit,rollback,close

    但是这三个方法需要连接对象,而要获取连接对象可以定义个数据源

    在核心配置文件中,数据源有三个选项,分别是POOLED   UNPOOLED  JNDI

    那好办,定义为接口呗

    这里有个JDK规范,不管你是POOLED   UNPOOLED  JNDI所有的数据源都需要实现JDK里的DataSource接口  那么接口也不用定义了 直接写三个实现类  这里使用UNPOOLED 不使用连接池

    那么在实现类里需要driver url username password属性

    然后又个SqlSession对象

    里面又insert方法   xxx 方法  需要用到什么,再解决

    基本思路就是这样

    整体结构

    1.Resources

    1. package com.gmybatis.utils;
    2.  
    3. import java.io.InputStream;
    4.  
    5. /**
    6.  * 工具类
    7.  * 用于"类路径"中资源的加载
    8.  * @author hrui
    9.  * @date 2023/9/10 20:25
    10.  */
    11. public class Resources {
    12.     //工具类建议构造方法私有化,因为工具类一般方法都是静态的,是种编程习惯
    13.  
    14.     public Resources() {
    15.     }
    16.  
    17.     /**
    18.      * 用于"类路径"种加载资源
    19.      * @param resource
    20.      * @return
    21.      */
    22.     public static InputStream getResourceAsStream(String resource){
    23.         return ClassLoader.getSystemClassLoader().getResourceAsStream(resource);
    24.     }
    25. }

    2.SqlSessionFactoryBuilder   构建器对象

    1. package com.gmybatis.core;
    2.  
    3. import com.gmybatis.utils.Resources;
    4. import jdk.nashorn.internal.ir.ReturnNode;
    5. import org.dom4j.Document;
    6. import org.dom4j.DocumentException;
    7. import org.dom4j.Element;
    8. import org.dom4j.Node;
    9. import org.dom4j.io.SAXReader;
    10.  
    11.  
    12. import javax.sql.DataSource;
    13. import java.io.InputStream;
    14. import java.util.ArrayList;
    15. import java.util.HashMap;
    16. import java.util.List;
    17. import java.util.Map;
    18.  
    19. /**
    20.  * SqlSessionFactory的构建器对象
    21.  * 通过SqlSessionFactoryBuilder的build方法来解析核心配置文件,
    22.  * 然后创建SqlSessionFactory对象
    23.  * @author hrui
    24.  * @date 2023/9/10 20:31
    25.  */
    26. public class SqlSessionFactoryBuilder {
    27.  
    28.     public SqlSessionFactoryBuilder() {
    29.     }
    30.  
    31.  
    32.     /**
    33.      * 解析核心配置文件,来构建SqlSessionFactory
    34.      * @param in
    35.      * @return
    36.      */
    37.     public SqlSessionFactory build(InputStream in){
    38.         SqlSessionFactory sqlSessionFactory=null;
    39.         try {
    40.             //解析核心配置文件
    41.             //创建SAXReader对象
    42.             SAXReader reader=new SAXReader();
    43.  
    44.             //读XML文件
    45.             Document document=reader.read(in);
    46.             //获取environments
    47.             Element environments =(Element) document.selectSingleNode("/configuration/environments");
    48.             //获取default属性值
    49.             String defaultId = environments.attributeValue("default");
    50.  
    51.             //拿匹配的环境节点
    52.             Element environment = (Element)document.selectSingleNode("/configuration/environments/environment[@id='"+defaultId+"']");
    53.             //获取transactionManager
    54.             Element transactionManagerEle = environment.element("transactionManager");
    55.             //获取dataSource
    56.             Element dataSourceEle = environment.element("dataSource");
    57.             //获取mapper
    58.             List<Node> mapperList = document.selectNodes("//mapper");//获取整个配置文件中所有的mapper标签
    59.             //用于封装所有mappers里面的mapper的路径
    60.             List<String> sqlMapperXMLPathList=new ArrayList<>();
    61.             mapperList.forEach(n->{
    62.                 Element e=(Element) n;
    63.                 String resource = e.attributeValue("resource");
    64.                 sqlMapperXMLPathList.add(resource);
    65.             });
    66.  
    67.  
    68.             //获取数据源对象
    69.             DataSource dataSource=getDataSource(dataSourceEle);
    70.  
    71.             //定义事务管理器
    72.             Transaction transaction=getTransaction(transactionManagerEle,dataSource);
    73.  
    74.  
    75.             //key是namespase+sql的id
    76.             Map<String,MappedStatement> MappedStatements=getMappedStatements(sqlMapperXMLPathList);
    77.  
    78.             //解析完成之后,构建出SqlSessionFactory对象
    79.             sqlSessionFactory=new SqlSessionFactory(transaction,MappedStatements);
    80.         } catch (Exception e) {
    81.             e.printStackTrace();
    82.         }
    83.         return sqlSessionFactory;
    84.     }
    85.  
    86.     private Map<String, MappedStatement> getMappedStatements(List<String> sqlMapperXMLPathList) {
    87.         Map<String,MappedStatement> map=new HashMap<>();
    88.         sqlMapperXMLPathList.forEach(path->{
    89.             try {
    90.                 //创建SAXReader对象
    91.                 SAXReader reader=new SAXReader();
    92.                 //读XXXMapper.XML映射文件
    93.                 Document document=reader.read(Resources.getResourceAsStream(path));
    94.                 //解析映射文件
    95.                 Element mapper = (Element)document.selectSingleNode("mapper");//带不带/都可以
    96.                 String namespace = mapper.attributeValue("namespace");
    97.                 List<Element> elements = mapper.elements();
    98.                 elements.forEach(e->{
    99.                     String id = e.attributeValue("id");
    100.                     //namespase+id
    101.                     String sqlId=namespace+"."+id;
    102.                     String resultType = e.attributeValue("resultType");
    103.                     String sqlContent = e.getTextTrim();
    104.                     MappedStatement mappedStatement=new MappedStatement(sqlContent,resultType);
    105.  
    106.                     map.put(sqlId,mappedStatement);
    107.                 });
    108.             } catch (DocumentException e) {
    109.                 e.printStackTrace();
    110.             }
    111.         });
    112.         return map;
    113.     }
    114.  
    115.     private DataSource getDataSource(Element dataSourceEle) {
    116.         Map<String,String> map=new HashMap<>();
    117.         //获取节点下所有property
    118.         List<Element> propertys = dataSourceEle.elements("property");
    119.         propertys.forEach(e->{
    120.             String name = e.attributeValue("name");
    121.             String value = e.attributeValue("value");
    122.             map.put(name,value);
    123.         });
    124.  
    125.         DataSource dataSource=null;
    126.         //type 可能是  POOLED UNPOOLED JNDI
    127.         String type = dataSourceEle.attributeValue("type");
    128. //        if(type.equalsIgnoreCase("POOLED")){  //这里简易定义常量类
    129. //
    130. //        }
    131.         if(type.equalsIgnoreCase(Const.POOLED_DATASOURCE)){
    132.             dataSource=new POOLEDDataSource();
    133.         }
    134.         if(type.equalsIgnoreCase(Const.UN_POOLED_DATASOURCE)){//只对这个做了实现
    135.             dataSource=new UNPOOLEDDataSource(map.get("driver"),map.get("url"),map.get("username"),map.get("password"));
    136.         }
    137.         if(type.equalsIgnoreCase(Const.JNDI_DATASOURCE)){
    138.             dataSource=new JNDIDataSource();
    139.         }
    140.         return dataSource;
    141.     }
    142.  
    143.     private Transaction getTransaction(Element transactionManager, DataSource dataSource) {
    144.  
    145.         Transaction transaction=null;
    146.         String type = transactionManager.attributeValue("type");
    147.         if(type.equalsIgnoreCase(Const.JDBC_TRANSACTION)){
    148.             transaction=new JDBCTransaction(dataSource,false );//只对JDBCTransaction做了实现
    149.         }
    150.         if(type.equalsIgnoreCase(Const.MANAGED_TRANSACTION)){
    151.             transaction=new MANAGEDTransaction();
    152.         }
    153.         return transaction;
    154.     }
    155.  
    156.  
    157. }

    3.SqlSessionFactory

    1. package com.gmybatis.core;
    2.  
    3. import java.util.Map;
    4.  
    5. /**
    6.  *SqlSessionFactory对象,一个数据库对应一个SqlSessionFactory对象
    7.  * 通过SqlSessionFactory对象可以获得SqlSession对象(开启会话)
    8.  * 一个SqlSessionFactory对象可以开启多个SqlSession会话
    9.  * @author hrui
    10.  * @date 2023/9/10 20:34
    11.  */
    12. public class SqlSessionFactory {
    13.     //事务管理器 可以是JDBC:原生JDBC事务 也可以是MANAGED:交容器管理,比如Spring   可以灵活切换建议定义为接口
    14.     private Transaction transaction;
    15.  
    16.     //数据源属性 因为已经在事务管理器里定义了数据源,因此这里不需要定义  可以通过事务管理器来获取
    17.  
    18.  
    19.     private Map<String,MappedStatement> mappedStatementMap;
    20.  
    21.     public SqlSessionFactory() {
    22.     }
    23.  
    24.     public SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatementMap) {
    25.         this.transaction = transaction;
    26.         this.mappedStatementMap = mappedStatementMap;
    27.     }
    28.  
    29.     public Transaction getTransaction() {
    30.         return transaction;
    31.     }
    32.  
    33.     public void setTransaction(Transaction transaction) {
    34.         this.transaction = transaction;
    35.     }
    36.  
    37.     public Map<String, MappedStatement> getMappedStatementMap() {
    38.         return mappedStatementMap;
    39.     }
    40.  
    41.     public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
    42.         this.mappedStatementMap = mappedStatementMap;
    43.     }
    44.  
    45.     //    public SqlSession openSession(boolean flag){
    46. //        return null;
    47. //    }
    48. }

    Transaction接口及实现类,这里只实现了JDBCTransaction

    1. package com.gmybatis.core;
    2.  
    3. import java.sql.Connection;
    4.  
    5. /**
    6.  * 事务管理器接口,所有的事务管理器都应该实现该接口
    7.  * JDBC事务管理器,MANAGED事务管理器都应该实现这个接口
    8.  * 提供控制事务的方法
    9.  * @author hrui
    10.  * @date 2023/9/10 21:14
    11.  */
    12. public interface Transaction {
    13.  
    14.     //提交事务
    15.     void commit();
    16.  
    17.     //回滚事务
    18.     void rollback();
    19.  
    20.     //关闭事务
    21.     void close();
    22.  
    23.     /**
    24.      * 是否需要其他方法后续再看
    25.      * 真正开启数据库连接
    26.      */
    27.     void openConnection();
    28.  
    29.     Connection getConnection();
    30. }

    JDBCTransaction

    1. package com.gmybatis.core;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.SQLException;
    6.  
    7. /**
    8.  * JDBC事务管理器
    9.  * @author hrui
    10.  * @date 2023/9/10 21:19
    11.  */
    12. public class JDBCTransaction implements Transaction{
    13.  
    14.     //数据源属性
    15.     private  DataSource dataSource;
    16.  
    17.     /**
    18.      * 自动提交标志
    19.      * true为自动提交
    20.      * false为不自动提交
    21.      */
    22.     private Boolean aotoCommit;
    23.  
    24.     private Connection connection;
    25.  
    26.     /**
    27.      * 用于外界获取Connection
    28.      * 外界用的Connection对象 必须和事务管理器的是同一个
    29.      * 这样才可以在事务管理器里  commit  rollback  closed
    30.      * @return
    31.      */
    32.     @Override
    33.     public Connection getConnection() {
    34.         return connection;
    35.     }
    36.  
    37.     //用于给属性connection赋值 只要事务管理器不换 连接就是同一个连接、
    38.     @Override
    39.     public void openConnection(){
    40.         if(connection==null){
    41.             try {
    42.                 connection=dataSource.getConnection();
    43.             } catch (SQLException e) {
    44.                 e.printStackTrace();
    45.             }
    46.         }
    47.     }
    48.  
    49.     public JDBCTransaction(DataSource dataSource, Boolean aotoCommit) {
    50.         this.dataSource = dataSource;
    51.         this.aotoCommit = aotoCommit;
    52.     }
    53.  
    54.     @Override
    55.     public void commit() {
    56.         //控制事务的时候需要调用JDBC里的连接对象 需要数据源
    57.         try {
    58.             connection.commit();
    59.         } catch (SQLException e) {
    60.             e.printStackTrace();
    61.         }
    62.     }
    63.  
    64.     @Override
    65.     public void rollback() {
    66.         try {
    67.             connection.rollback();
    68.         } catch (SQLException e) {
    69.             e.printStackTrace();
    70.         }
    71.     }
    72.  
    73.     @Override
    74.     public void close() {
    75.         try {
    76.             connection.commit();
    77.         } catch (SQLException e) {
    78.             e.printStackTrace();
    79.         }
    80.     }
    81. }

    MANAGEDTransaction

    1. package com.gmybatis.core;
    2.  
    3. import java.sql.Connection;
    4.  
    5. /**
    6.  * MANAGED事务管理器
    7.  * @author hrui
    8.  * @date 2023/9/10 21:19
    9.  */
    10. public class MANAGEDTransaction implements Transaction{
    11.     @Override
    12.     public void commit() {
    13.  
    14.     }
    15.  
    16.     @Override
    17.     public void rollback() {
    18.  
    19.     }
    20.  
    21.     @Override
    22.     public void close() {
    23.  
    24.     }
    25.  
    26.     @Override
    27.     public void openConnection() {
    28.  
    29.     }
    30.  
    31.     @Override
    32.     public Connection getConnection() {
    33.         return null;
    34.     }
    35. }

    实现DataSource的3个实现   只实现了UNPOOLEDDataSource

    1. package com.gmybatis.core;
    2.  
    3. import javax.sql.DataSource;
    4. import java.io.PrintWriter;
    5. import java.sql.Connection;
    6. import java.sql.DriverManager;
    7. import java.sql.SQLException;
    8. import java.sql.SQLFeatureNotSupportedException;
    9. import java.util.logging.Logger;
    10.  
    11. /**
    12.  * 数据源的实现类--->UNPOOLED
    13.  * 不使用数据库连接池
    14.  * @author hrui
    15.  * @date 2023/9/10 21:33
    16.  */
    17. public class UNPOOLEDDataSource implements DataSource {
    18.  
    19.     private String driver;
    20.  
    21.     private String url;
    22.  
    23.     private String username;
    24.  
    25.     private String password;
    26.  
    27.  
    28.     public UNPOOLEDDataSource(String driver, String url, String username, String password) {
    29.         try {
    30.             //直接注册驱动
    31.             Class.forName("com.mysql.cj.jdbc.Driver");
    32.         } catch (ClassNotFoundException e) {
    33.             e.printStackTrace();
    34.         }
    35.         this.driver = driver;
    36.         this.url = url;
    37.         this.username = username;
    38.         this.password = password;
    39.     }
    40.  
    41.  
    42.  
    43.     @Override
    44.     public Connection getConnection() throws SQLException {
    45.         //需要driver url username password 定义为属性
    46.         Connection connection = DriverManager.getConnection(url, username, password);
    47.         return connection;
    48.     }
    49.  
    50.     @Override
    51.     public Connection getConnection(String username, String password) throws SQLException {
    52.         return null;
    53.     }
    54.  
    55.     @Override
    56.     public  T unwrap(Class iface) throws SQLException {
    57.         return null;
    58.     }
    59.  
    60.     @Override
    61.     public boolean isWrapperFor(Class iface) throws SQLException {
    62.         return false;
    63.     }
    64.  
    65.     @Override
    66.     public PrintWriter getLogWriter() throws SQLException {
    67.         return null;
    68.     }
    69.  
    70.     @Override
    71.     public void setLogWriter(PrintWriter out) throws SQLException {
    72.  
    73.     }
    74.  
    75.     @Override
    76.     public void setLoginTimeout(int seconds) throws SQLException {
    77.  
    78.     }
    79.  
    80.     @Override
    81.     public int getLoginTimeout() throws SQLException {
    82.         return 0;
    83.     }
    84.  
    85.     @Override
    86.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    87.         return null;
    88.     }
    89. }
    1. package com.gmybatis.core;
    2.  
    3. import javax.sql.DataSource;
    4. import java.io.PrintWriter;
    5. import java.sql.Connection;
    6. import java.sql.SQLException;
    7. import java.sql.SQLFeatureNotSupportedException;
    8. import java.util.logging.Logger;
    9.  
    10. /**
    11.  * 数据源的实现类--->POOLED
    12.  * 使用数据库连接池  这里不写连接池
    13.  * @author hrui
    14.  * @date 2023/9/10 21:32
    15.  */
    16. public class POOLEDDataSource implements DataSource {
    17.     @Override
    18.     public Connection getConnection() throws SQLException {
    19.         //从数据库连接池获取Connection对象 这里不写连接池
    20.         return null;
    21.     }
    22.  
    23.     @Override
    24.     public Connection getConnection(String username, String password) throws SQLException {
    25.         return null;
    26.     }
    27.  
    28.     @Override
    29.     public  T unwrap(Class iface) throws SQLException {
    30.         return null;
    31.     }
    32.  
    33.     @Override
    34.     public boolean isWrapperFor(Class iface) throws SQLException {
    35.         return false;
    36.     }
    37.  
    38.     @Override
    39.     public PrintWriter getLogWriter() throws SQLException {
    40.         return null;
    41.     }
    42.  
    43.     @Override
    44.     public void setLogWriter(PrintWriter out) throws SQLException {
    45.  
    46.     }
    47.  
    48.     @Override
    49.     public void setLoginTimeout(int seconds) throws SQLException {
    50.  
    51.     }
    52.  
    53.     @Override
    54.     public int getLoginTimeout() throws SQLException {
    55.         return 0;
    56.     }
    57.  
    58.     @Override
    59.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    60.         return null;
    61.     }
    62. }

    JNDIDataSource

    1. package com.gmybatis.core;
    2.  
    3. import javax.sql.DataSource;
    4. import java.io.PrintWriter;
    5. import java.sql.Connection;
    6. import java.sql.SQLException;
    7. import java.sql.SQLFeatureNotSupportedException;
    8. import java.util.logging.Logger;
    9.  
    10. /**
    11.  * 数据源的实现类--->JNDI
    12.  * 使用第三方的数据库连接池获取Connection对象
    13.  * @author hrui
    14.  * @date 2023/9/10 21:33
    15.  */
    16. public class JNDIDataSource implements DataSource {
    17.     @Override
    18.     public Connection getConnection() throws SQLException {
    19.         return null;
    20.     }
    21.  
    22.     @Override
    23.     public Connection getConnection(String username, String password) throws SQLException {
    24.  
    25.         return null;
    26.     }
    27.  
    28.     @Override
    29.     public  T unwrap(Class iface) throws SQLException {
    30.         return null;
    31.     }
    32.  
    33.     @Override
    34.     public boolean isWrapperFor(Class iface) throws SQLException {
    35.         return false;
    36.     }
    37.  
    38.     @Override
    39.     public PrintWriter getLogWriter() throws SQLException {
    40.         return null;
    41.     }
    42.  
    43.     @Override
    44.     public void setLogWriter(PrintWriter out) throws SQLException {
    45.  
    46.     }
    47.  
    48.     @Override
    49.     public void setLoginTimeout(int seconds) throws SQLException {
    50.  
    51.     }
    52.  
    53.     @Override
    54.     public int getLoginTimeout() throws SQLException {
    55.         return 0;
    56.     }
    57.  
    58.     @Override
    59.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    60.         return null;
    61.     }
    62. }

    定义了一个常量类

    1. package com.gmybatis.core;
    2.  
    3. /**
    4.  * 整个框架的常量类
    5.  * @author hrui
    6.  * @date 2023/9/10 22:26
    7.  */
    8. public class Const {
    9.  
    10.     public static final String UN_POOLED_DATASOURCE="UNPOOLED";
    11.  
    12.     public static final String POOLED_DATASOURCE="POOLED";
    13.  
    14.     public static final String JNDI_DATASOURCE="JNDI";
    15.  
    16.     public static final String JDBC_TRANSACTION="JDBC";
    17.  
    18.     public static final String MANAGED_TRANSACTION="MANAGED";
    19. }

    注意测试时候事务管理要选用JDBC   数据源类型要选用UNPOOLED

    mapper路径要写对

    测试基本没问题

    下面把SqlSession加进去

    1. package com.gmybatis.core;
    2.  
    3. import java.lang.reflect.Method;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8. import java.util.Locale;
    9.  
    10. /**
    11.  * 专门负责执行SQL语句的会话对象
    12.  * @author hrui
    13.  * @date 2023/9/10 23:40
    14.  */
    15. public class SqlSession {
    16.  
    17.     private SqlSessionFactory sqlSessionFactory;
    18.  
    19.     public SqlSession(SqlSessionFactory sqlSessionFactory) {
    20.         this.sqlSessionFactory = sqlSessionFactory;
    21.     }
    22.  
    23.  
    24.     //测试
    25.     public static void main(String[] args) {
    26.         String sql="insert into t_car values(#{id},#{asd},#{name})";
    27.         int fromIndex=0;
    28.         int index=1;
    29.         while(true) {
    30.             int jingIndex = sql.indexOf("#",fromIndex);
    31.  
    32.             if(jingIndex<0){
    33.                 break;
    34.             }
    35.             System.out.println(index);
    36.             index++;
    37.             int youkuohaoIndex = sql.indexOf("}",fromIndex);
    38.             String propertyName = sql.substring(jingIndex + 2, youkuohaoIndex).trim();
    39.             System.out.println(propertyName);
    40.             fromIndex = youkuohaoIndex + 1;
    41.         }
    42.  
    43.     }
    44.  
    45.  
    46.     public int insert(String sqlId,Object obj){
    47.         //JDBC代码
    48.         Connection connection=null;
    49.         PreparedStatement ps=null;
    50.         ResultSet rs=null;
    51.         int count = 0;
    52.         try {
    53.             connection=sqlSessionFactory.getTransaction().getConnection();
    54.             String sql=sqlSessionFactory.getMappedStatementMap().get(sqlId).getSql();
    55.             String sql1 = sql.replaceAll("#\\{[0-9A-Za-z_$]*}", "?");//使用正则替换
    56.             ps = connection.prepareStatement(sql1);
    57.             //有几个?号 不知道将pojo对象中的哪个属性给哪个 暂时全当String
    58.  
    59.             int fromIndex=0;
    60.             int index=1;
    61.             while(true) {
    62.                 int jingIndex = sql.indexOf("#",fromIndex);
    63.  
    64.                 if(jingIndex<0){
    65.                     break;
    66.                 }
    67.                 //System.out.println(index);
    68.  
    69.                 int youkuohaoIndex = sql.indexOf("}",fromIndex);
    70.                 String propertyName = sql.substring(jingIndex + 2, youkuohaoIndex).trim();
    71.                 //System.out.println(propertyName);
    72.                 fromIndex = youkuohaoIndex + 1;
    73.                 String getMethodName="get"+propertyName.toUpperCase().charAt(0)+propertyName.substring(1);
    74.                 Method getMethod=obj.getClass().getDeclaredMethod(getMethodName);
    75.                 Object invoke = getMethod.invoke(obj);
    76.                 ps.setString(index,invoke.toString());
    77.                 index++;
    78.             }
    79.  
    80.             count = ps.executeUpdate();
    81.         } catch (Exception e) {
    82.             e.printStackTrace();
    83.         }
    84.         //这里不要加 不然直接关闭了
    85. //        finally {
    86. //            if(rs!=null){
    87. //                try {
    88. //                    rs.close();
    89. //                } catch (SQLException e) {
    90. //                    e.printStackTrace();
    91. //                }
    92. //            }
    93. //            if(ps!=null){
    94. //                try {
    95. //                    ps.close();
    96. //                } catch (SQLException e) {
    97. //                    e.printStackTrace();
    98. //                }
    99. //            }
    100. //            if(connection!=null){
    101. //                try {
    102. //                    connection.close();
    103. //                } catch (SQLException e) {
    104. //                    e.printStackTrace();
    105. //                }
    106. //            }
    107. //        }
    108.         return count;
    109.     }
    110.  
    111.  
    112.     public Object selectOne(){
    113.         return null;
    114.     }
    115.  
    116.     public void commit(){
    117.         sqlSessionFactory.getTransaction().commit();
    118.     }
    119.  
    120.     public void rollback(){
    121.         sqlSessionFactory.getTransaction().rollback();
    122.     }
    123.  
    124.     public void close(){
    125.         sqlSessionFactory.getTransaction().close();
    126.     }
    127. }

    修改sqlSessionFactory

    1. package com.gmybatis.core;
    2.  
    3. import java.util.Map;
    4.  
    5. /**
    6.  *SqlSessionFactory对象,一个数据库对应一个SqlSessionFactory对象
    7.  * 通过SqlSessionFactory对象可以获得SqlSession对象(开启会话)
    8.  * 一个SqlSessionFactory对象可以开启多个SqlSession会话
    9.  * @author hrui
    10.  * @date 2023/9/10 20:34
    11.  */
    12. public class SqlSessionFactory {
    13.     //事务管理器 可以是JDBC:原生JDBC事务 也可以是MANAGED:交容器管理,比如Spring   可以灵活切换建议定义为接口
    14.     private Transaction transaction;
    15.  
    16.     //数据源属性 因为已经在事务管理器里定义了数据源,因此这里不需要定义  可以通过事务管理器来获取
    17.  
    18.  
    19.     private Map<String,MappedStatement> mappedStatementMap;
    20.  
    21.     public SqlSessionFactory() {
    22.     }
    23.  
    24.     public SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatementMap) {
    25.         this.transaction = transaction;
    26.         this.mappedStatementMap = mappedStatementMap;
    27.     }
    28.  
    29.     public Transaction getTransaction() {
    30.         return transaction;
    31.     }
    32.  
    33.     public void setTransaction(Transaction transaction) {
    34.         this.transaction = transaction;
    35.     }
    36.  
    37.     public Map<String, MappedStatement> getMappedStatementMap() {
    38.         return mappedStatementMap;
    39.     }
    40.  
    41.     public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
    42.         this.mappedStatementMap = mappedStatementMap;
    43.     }
    44.  
    45.     /**
    46.      * 获取sql会话对象
    47.      * @param flag
    48.      * @return
    49.      */
    50.     public SqlSession openSession(){
    51.         //开启会话的前提是开启连接
    52.         transaction.openConnection();
    53.         //创建SqlSession对象
    54.         SqlSession sqlSession=new SqlSession(this);
    55.         return sqlSession;
    56.     }
    57. }

    JDBCTransaction的openConnection的代码加上开启事务

    1. package com.gmybatis.core;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.SQLException;
    6.  
    7. /**
    8.  * JDBC事务管理器
    9.  * @author hrui
    10.  * @date 2023/9/10 21:19
    11.  */
    12. public class JDBCTransaction implements Transaction{
    13.  
    14.     //数据源属性
    15.     private  DataSource dataSource;
    16.  
    17.     /**
    18.      * 自动提交标志
    19.      * true为自动提交
    20.      * false为不自动提交
    21.      */
    22.     private boolean aotoCommit;
    23.  
    24.     private Connection connection;
    25.  
    26.     /**
    27.      * 用于外界获取Connection
    28.      * 外界用的Connection对象 必须和事务管理器的是同一个
    29.      * 这样才可以在事务管理器里  commit  rollback  closed
    30.      * @return
    31.      */
    32.     @Override
    33.     public Connection getConnection() {
    34.         return connection;
    35.     }
    36.  
    37.     //用于给属性connection赋值 只要事务管理器不换 连接就是同一个连接、
    38.     @Override
    39.     public void openConnection(){
    40.         if(connection==null){
    41.             try {
    42.                 connection=dataSource.getConnection();
    43.                 //开启事务
    44.                 connection.setAutoCommit(aotoCommit);
    45.             } catch (SQLException e) {
    46.                 e.printStackTrace();
    47.             }
    48.         }
    49.     }
    50.  
    51.     public JDBCTransaction(DataSource dataSource, Boolean aotoCommit) {
    52.         this.dataSource = dataSource;
    53.         this.aotoCommit = aotoCommit;
    54.     }
    55.  
    56.     @Override
    57.     public void commit() {
    58.         //控制事务的时候需要调用JDBC里的连接对象 需要数据源
    59.         try {
    60.             connection.commit();
    61.         } catch (SQLException e) {
    62.             e.printStackTrace();
    63.         }
    64.     }
    65.  
    66.     @Override
    67.     public void rollback() {
    68.         try {
    69.             connection.rollback();
    70.         } catch (SQLException e) {
    71.             e.printStackTrace();
    72.         }
    73.     }
    74.  
    75.     @Override
    76.     public void close() {
    77.         try {
    78.             connection.commit();
    79.         } catch (SQLException e) {
    80.             e.printStackTrace();
    81.         }
    82.     }
    83. }

    引入mysql依赖测试  新建表

    新建实体类

    1. package com.gmybatis.core;
    2.  
    3. /**
    4.  * @author hrui
    5.  * @date 2023/9/11 0:31
    6.  */
    7. public class Car {
    8.     private String id;
    9.     private String name;
    10.     private String age;
    11.  
    12.     public Car() {
    13.     }
    14.  
    15.     public Car(String id, String name, String age) {
    16.         this.id = id;
    17.         this.name = name;
    18.         this.age = age;
    19.     }
    20.  
    21.     public String getId() {
    22.         return id;
    23.     }
    24.  
    25.     public void setId(String id) {
    26.         this.id = id;
    27.     }
    28.  
    29.     public String getName() {
    30.         return name;
    31.     }
    32.  
    33.     public void setName(String name) {
    34.         this.name = name;
    35.     }
    36.  
    37.     public String getAge() {
    38.         return age;
    39.     }
    40.  
    41.     public void setAge(String age) {
    42.         this.age = age;
    43.     }
    44. }

    映射文件

  • 相关阅读:
    ubuntu安装nvm
    C++ 运算符
    java中的instanceof 的用法
    Python windows安装3.10.0版本
    ES8(Java API Client)查询详解
    深入探索Spring Boot的自动配置机制
    typora使用PicGo自动上传图片到chevereto图床
    SSM - Springboot - MyBatis-Plus 全栈体系（八）
    AI绘画，我们究竟该支持还是反对？
    Windows10找不到msvcr100.dll如何修复呢？详细有效的修复方法分享
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/132793874