读取配置文件

编写Resource类，将路径转化为InputStream流。
利用SqlSesssionFactoryBuilder，来创建SqlSessionFactory对象。

  1. public class Resources {
  2.     public static InputStream getResourceAsStream(String path) {
  3.         return Resources.class.getClassLoader().getResourceAsStream(path);
  4.     }
  5. }
  7. public class SqlSessionFactoryBuilder {
  8.     // SqlSessionFactory后续创建
  9.     public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {
  11.         return null;
  12.     }
  13. }

创建Configuration对象和MapperStatement对象

需要了解两个容器中需要存放什么内容，根据内容来创建对象，Configuration要保存DataSource的信息，并且需要持有MapperStatement对象。
MapperStatement存放的是sqlMapper中一个标签，也就是select或者其它的标签。

  1. /**
  2.  * mapper的每一个标签都是一个mapperStatement
  3.  */
  4. public class MapperStatement {
  6.     /**
  7.      * id
  8.      */
  9.     private String id;
  11.     /**
  12.      * 返回类型
  13.      */
  14.     private String resultType;
  16.     /**
  17.      * 参数类型
  18.      */
  19.     private String paramterType;
  21.     /**
  22.      * sql内容
  23.      */
  24.     private String sql;
  26.     public MapperStatement() {
  27.     }
  29.     public MapperStatement(String id, String resultType, String paramterType, String sql) {
  30.         this.id = id;
  31.         this.resultType = resultType;
  32.         this.paramterType = paramterType;
  33.         this.sql = sql;
  34.     }
  36.     public String getId() {
  37.         return id;
  38.     }
  40.     public void setId(String id) {
  41.         this.id = id;
  42.     }
  44.     public String getResultType() {
  45.         return resultType;
  46.     }
  48.     public void setResultType(String resultType) {
  49.         this.resultType = resultType;
  50.     }
  52.     public String getParamterType() {
  53.         return paramterType;
  54.     }
  56.     public void setParamterType(String paramterType) {
  57.         this.paramterType = paramterType;
  58.     }
  60.     public String getSql() {
  61.         return sql;
  62.     }
  64.     public void setSql(String sql) {
  65.         this.sql = sql;
  66.     }
  67. }
  70. public class Configuration {
  72.     /**
  73.      * 数据库的连接信息
  74.      */
  75.     private DataSource dataSource;
  77.     /**
  78.      * key是什么呢？ key要能唯一标识MapperStatement，前面说到，使用namespace.id可以唯一标识一个sql映射
  79.      */
  80.     private Map<String, MapperStatement> mapperStatementMap = new HashMap<>();
  82.     public DataSource getDataSource() {
  83.         return dataSource;
  84.     }
  86.     public void setDataSource(DataSource dataSource) {
  87.         this.dataSource = dataSource;
  88.     }
  90.     public Map<String, MapperStatement> getMapperStatementMap() {
  91.         return mapperStatementMap;
  92.     }
  94.     public void setMapperStatementMap(Map<String, MapperStatement> mapperStatementMap) {
  95.         this.mapperStatementMap = mapperStatementMap;
  96.     }
  97. }

dom4j解析配置文件进行封装

这个步骤非常重要，要解析Config配置文件和sql配置文件，解析应该放在 SqlSessionFactoryBuilder 类中，层层向下传递。

  1. 整个过程用到的pom依赖如下：
  2. <dependencies>
  3.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  4.         <dependency>
  5.             <groupId>mysql</groupId>
  6.             <artifactId>mysql-connector-java</artifactId>
  7.             <version>8.0.22</version>
  8.         </dependency>
  11.         <dependency>
  12.             <groupId>c3p0</groupId>
  13.             <artifactId>c3p0</artifactId>
  14.             <version>0.9.1.2</version>
  15.         </dependency>
  17.         <dependency>
  18.             <groupId>log4j</groupId>
  19.             <artifactId>log4j</artifactId>
  20.             <version>1.2.12</version>
  21.         </dependency>
  23.         <dependency>
  24.             <groupId>junit</groupId>
  25.             <artifactId>junit</artifactId>
  26.             <version>4.10</version>
  27.         </dependency>
  29.         <dependency>
  30.             <groupId>dom4j</groupId>
  31.             <artifactId>dom4j</artifactId>
  32.             <version>1.6.1</version>
  33.         </dependency>
  35.         <dependency>
  36.             <groupId>jaxen</groupId>
  37.             <artifactId>jaxen</artifactId>
  38.             <version>1.1.6</version>
  39.         </dependency>
  41.     </dependencies>
  45. public class SqlSessionFactoryBuilder {
  46.     public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {
  47.         // 读取配置文件
  48.         XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
  49.         Configuration configuration = xmlConfigBuilder.parseConfiguration(inputStream);
  51.         return null;
  52.     }
  53. }
  55. 工具类进行解析：
  56. public class XMLConfigBuilder {
  57.     private Configuration configuration;
  59.     public XMLConfigBuilder() {
  60.         this.configuration = new Configuration();
  61.     }
  62.     /**
  63.      * 封装Configuration
  64.      * @param inputStream
  65.      * @return
  66.      * @throws DocumentException
  67.      * @throws PropertyVetoException
  68.      */
  69.     public Configuration parseConfiguration(InputStream inputStream) throws DocumentException, PropertyVetoException {
  70.         Document document = new SAXReader().read(inputStream);
  71.         Element rootElement = document.getRootElement();
  72.         List<Element> list = rootElement.selectNodes("//property");
  73.         Properties properties = new Properties();
  74.         for (Element element : list) {
  75.             properties.put(element.attributeValue("name"), element.attributeValue("value"));
  76.         }
  77.         // 获取数据库连接池,使用c3p0
  78.         ComboPooledDataSource comboPooledDataSource = getComboPooledDataSource(properties);
  79.         configuration.setDataSource(comboPooledDataSource);
  80.         // 封装mapperStatement
  81.         XMLMapperConfigBuilder xmlMapperConfigBuilder = new XMLMapperConfigBuilder(configuration);
  82.         List<Element> mappers = document.selectNodes("//mapper");
  83.         for (Element mapper : mappers) {
  84.             String resource = mapper.attributeValue("resource");
  85.             xmlMapperConfigBuilder.parse(Resources.getResourceAsStream(resource));
  86.         }
  87.         return configuration;
  88.     }
  90.     /**
  91.      * 根据配置信息创建c3p0连接池
  92.      * @param properties
  93.      * @return
  94.      * @throws PropertyVetoException
  95.      */
  96.     private ComboPooledDataSource getComboPooledDataSource(Properties properties) throws PropertyVetoException {
  97.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
  98.         comboPooledDataSource.setDriverClass(properties.getProperty("jdbcDriver"));
  99.         comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
  100.         comboPooledDataSource.setUser(properties.getProperty("jdbcUser"));
  101.         comboPooledDataSource.setPassword(properties.getProperty("jdbcPassword"));
  102.         return comboPooledDataSource;
  103.     }
  104. }
  107. public class XMLMapperConfigBuilder {
  109.     private Configuration configuration;
  111.     public XMLMapperConfigBuilder(Configuration configuration) {
  112.         this.configuration = configuration;
  113.     }
  115.     public void parse(InputStream inputStream) throws DocumentException {
  116.         Document document = new SAXReader().read(inputStream);
  117.         String nameSpaceURI = document.getRootElement().attributeValue("namespace");
  118.         List<Element> selectNodes = document.selectNodes("//select");
  119.         for (Element selectNode : selectNodes) {
  120.             String id = selectNode.attributeValue("id");
  121.             MapperStatement mapperStatement = new MapperStatement(id, selectNode.attributeValue("resultType"), selectNode.attributeValue("paramterType"), selectNode.getTextTrim());
  122.             configuration.getMapperStatementMap().put(nameSpaceURI + "." + id, mapperStatement);
  123.         }
  124.     }
  125. }

SqlSessionFactory

SOLID原则，面向接口编程，SqlSessionFactory的作用是生产SqlSession会话对象，如下：

  1. /**
  2.  * 工厂类，用于创建会话对象 SqlSession
  3.  */
  4. public interface SqlSessionFactory {
  5.     public SqlSession openSession();
  6. }
  9. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  11.     private Configuration configuration;
  13.     public DefaultSqlSessionFactory(Configuration configuration) {
  14.         this.configuration = configuration;
  15.     }
  17.     @Override
  18.     public SqlSession openSession() {
  19.         return new DefaultSqlSession(configuration);
  20.     }
  21. }
  23. public class SqlSessionFactoryBuilder {
  24.     public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {
  26.         // 读取配置文件
  27.         XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
  28.         Configuration configuration = xmlConfigBuilder.parseConfiguration(inputStream);
  30.         // 创建SqlSessionFactory
  31.         SqlSessionFactory sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
  32.         return sqlSessionFactory;
  33.     }
  34. }

至此SqlSessionFactoryBuilder完成。

SqlSession

同样，面向接口编程，SqlSession要做的是就是去定义数据库的执行方法

  1. public interface SqlSession {
  3.     <E> List<E> selectAll(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InstantiationException, InvocationTargetException, IntrospectionException;
  5.     <T> T selectOne(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException;
  6. }
  8. public class DefaultSqlSession implements SqlSession {
  10.     private Configuration configuration;
  12.     public DefaultSqlSession(Configuration configuration) {
  13.         this.configuration = configuration;
  14.     }
  16.     @Override
  17.     public <E> List<E> selectAll(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InstantiationException, InvocationTargetException, IntrospectionException {
  18.         SimpleExecutor simpleExecutor = new SimpleExecutor();
  19.         List<E> query = simpleExecutor.query(configuration, configuration.getMapperStatementMap().get(statementId), params);
  20.         return query;
  21.     }
  23.     @Override
  24.     public <T> T selectOne(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException {
  25.         List<Object> objects = selectAll(statementId, params);
  26.         if (objects.size() == 1) {
  27.             return (T)objects.get(0);
  28.         } else {
  29.             throw new RuntimeException("查询结果过多或者查询结果为空");
  30.         }
  31.     }
  32. }

Executor执行

执行器，进行具体的执行操作，从连接 - 预处理sql - 执行sql - 封装结果集都在这一步

  1. public interface MyExecutor {
  3.     <E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException;
  4. }
  6. package com.wangzhi.config.sqlsession;
  9. import com.wangzhi.config.pojo.BoundSql;
  10. import com.wangzhi.config.pojo.Configuration;
  11. import com.wangzhi.config.pojo.MapperStatement;
  12. import com.wangzhi.config.utils.GenericTokenParser;
  13. import com.wangzhi.config.utils.ParameterMapping;
  14. import com.wangzhi.config.utils.ParameterMappingTokenHandler;
  16. import java.beans.IntrospectionException;
  17. import java.beans.PropertyDescriptor;
  18. import java.lang.reflect.Field;
  19. import java.lang.reflect.InvocationTargetException;
  20. import java.lang.reflect.Method;
  21. import java.sql.*;
  22. import java.util.ArrayList;
  23. import java.util.List;
  25. public class SimpleExecutor implements MyExecutor {
  26.     @Override
  27.     public <E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException {
  28.         // 封装数据库的操作步骤，获取数据库连接
  29.         Connection connection = configuration.getDataSource().getConnection();
  30.         // 替换占位符（这个步骤是重点，sql转换过程）
  31.         BoundSql boundSql = getBoundSql(mapperStatement.getSql());
  32.         // 预处理sql
  33.         PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
  34.         // 设置参数开始
  35.         // 利用反射来获取，先要获取类的字节码文件
  36.         Class<?> parameterClazz = getClassType(mapperStatement.getParamterType());
  37.         List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  38.         for (int i = 0; i < parameterMappings.size(); i++) {
  39.             // 需要获取的字段
  40.             ParameterMapping parameterMapping = parameterMappings.get(i);
  41.             Field declaredField = parameterClazz.getDeclaredField(parameterMapping.getContent());
  42.             declaredField.setAccessible(true);
  43.             Object obj = declaredField.get(params[0]);
  44.             preparedStatement.setObject(i + 1, obj);
  45.         }
  46.         // 设置参数结束
  47.         // 执行sql
  48.         ResultSet resultSet = preparedStatement.executeQuery();
  49.         // 处理结果集
  50.         Class<?> resultClazzType = getClassType(mapperStatement.getResultType());
  52.         List<Object> resultList = new ArrayList<>();
  53.         while (resultSet.next()) {
  54.             Object obj = resultClazzType.getDeclaredConstructor().newInstance();
  55.             ResultSetMetaData metaData = resultSet.getMetaData();
  56.             for (int i = 1; i <= metaData.getColumnCount(); i++) {
  57.                 // 字段名  metaDate的下标从1开始
  58.                 String columnName = metaData.getColumnName(i);
  59.                 // 字段值
  60.                 Object columnValue = resultSet.getObject(columnName);
  61.                 // 用来设置值，内省，用来获取方法的读写权限
  62.                 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultClazzType);
  63.                 Method writeMethod = propertyDescriptor.getWriteMethod();
  64.                 writeMethod.invoke(obj, columnValue);
  65.             }
  66.             resultList.add(obj);
  67.         }
  68.         return (List<E>) resultList;
  69.     }
  71.     private Class<?> getClassType(String paramterType) throws ClassNotFoundException {
  72.         if (paramterType != null) {
  73.             Class<?> aClass = Class.forName(paramterType);
  74.             return aClass;
  75.         }
  76.         return null;
  77.     }
  79.     /**
  80.      * 处理sql，替换占位符，接触的工具类属于Mybatis源码的内容
  81.      * @param sql  替换之前的sql
  82.      * @return
  83.      */
  84.     private BoundSql getBoundSql(String sql) {
  85.         // 标记处理器，配置标记解析器来完成对占位符的解析处理工作
  86.         ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
  87.         // 标记解析器
  88.         GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
  89.         // 解析sql，返回替换占位符后的sql，也就是将占位符替换为 ？
  90.         String parse = genericTokenParser.parse(sql);
  91.         // 保存了占位符里面的内容，针对于示例中selectOne的id和name
  92.         List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
  93.         BoundSql boundSql = new BoundSql(parse, parameterMappings);
  95.         return boundSql;
  96.     }
  97. }

上面用到了工具类，可以再具体的代码里面找到，放在码云中。
到这基本就结束了，目前存在的问题就是在使用方，还有硬编码的实现以及代码重复性严重。为了模仿mybatis，需要使用动态代理来进行方法的执行。

优化：

  1. public interface UserMapper {
  3.     List<User> findAll();
  5.     User findByCondition(User user);
  7. }
  9. 在sqlSession中添加getMapper方法，来进行动态代理执行
  11. public interface SqlSession {
  13.     <E> List<E> selectAll(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InstantiationException, InvocationTargetException, IntrospectionException;
  15.     <T> T selectOne(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException;
  17.     <T> T getMapper(Class<T> mapperClass);
  18. }
  20. public class DefaultSqlSession implements SqlSession {
  22.     private Configuration configuration;
  24.     public DefaultSqlSession(Configuration configuration) {
  25.         this.configuration = configuration;
  26.     }
  28.     @Override
  29.     public <E> List<E> selectAll(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InstantiationException, InvocationTargetException, IntrospectionException {
  30.         SimpleExecutor simpleExecutor = new SimpleExecutor();
  31.         List<E> query = simpleExecutor.query(configuration, configuration.getMapperStatementMap().get(statementId), params);
  32.         return query;
  33.     }
  35.     @Override
  36.     public <T> T selectOne(String statementId, Object... params) throws SQLException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, IntrospectionException {
  37.         List<Object> objects = selectAll(statementId, params);
  38.         if (objects.size() == 1) {
  39.             return (T)objects.get(0);
  40.         } else {
  41.             throw new RuntimeException("查询结果过多或者查询结果为空");
  42.         }
  43.     }
  45.     /**
  46.      * 动态代理生产对象，在使用该对象调用方法的时候，全部执行改方法里面的invoke方法
  47.      * @param mapperClass
  48.      * @param <T>
  49.      * @return
  50.      */
  51.     @Override
  52.     public <T> T getMapper(Class<T> mapperClass) {
  53.         Object proxy = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
  54.             // proxy 当前代理对象的引用  method 当前被调用方法的引用  args就是传递的参数
  55.             @Override
  56.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  57.                 // invoke方法中来调用具体的方法，要做的事有下面两件
  58.                 // 封装参数开始
  59.                 // 获取方法名
  60.                 String methodName = method.getName();
  61.                 // 获取全限定类名
  62.                 String className = method.getDeclaringClass().getName();
  63.                 // 组合成为statementId
  64.                 // 封装参数结束
  65.                 // 确认调用的方法
  66.                 Type genericReturnType = method.getGenericReturnType();
  67.                 // 判断是否进行了参数泛型化，如果存在泛型就是集合，调用List方法
  68.                 if (genericReturnType instanceof ParameterizedType) {
  69.                     return selectAll(className + "." + methodName, args);
  70.                 }
  71.                 return selectOne(className + "." + methodName, args);
  72.             }
  73.         });
  74.         return (T) proxy;
  75.     }
  76. }
  78. 优化Mapper.xml，也就是sql配置，标准化并且保证statementId的唯一性
  79. <mapper namespace="com.wangzhi.dao.UserMapper">
  80.     <select id="findAll" resultType="com.wangzhi.pojo.User">
  81.         select * from user
  82.     </select>
  84.     <select id="findByCondition" resultType="com.wangzhi.pojo.User" paramterType="com.wangzhi.pojo.User">
  85.         SELECT * FROM user
  86.         WHERE id = #{id} AND name = #{name}
  87.     </select>
  88. </mapper>
  89. 至此，如果安装了mybatis插件就可以看到，在xml文件中提示可以跳转到interface
  92. 测试类的优化和使用如下：
  93.   @Test
  94.     public void testResources() throws PropertyVetoException, DocumentException, IllegalAccessException, InvocationTargetException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, NoSuchMethodException, ClassNotFoundException {
  95.         InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapperConfig.xml");
  96.         SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  97.         SqlSession sqlSession = sqlSessionFactoryBuilder.build(resourceAsStream).openSession();
  99.         // 这里动态代理生成对象
  100.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  101.         // 调用方法实际上调用的是getMapper中的invoke方法
  102.         List<User> all = mapper.findAll();
  103.         all.forEach(System.out::println);
  104.         User user = new User();
  105.         user.setId(1);
  106.         user.setName("王智");
  107.         User byCondition = mapper.findByCondition(user);
  108.         System.out.println(byCondition);
  110.     }

整个代码放在码云，IPersistence为编写的框架类，后面有_test的为测试类。

整个过程学到了什么，回顾了什么？

  • JDBC的整个操作流程，回顾细化。 从加载驱动 - 建立连接 - 预处理sql - 执行sql - 处理结果集的整个流程
  • dom4j的文档解析
  • 反射技术
  • 工厂模式
  • SOLID原则，面向接口编程
  • 动态代理
  • mybatis的一点点原理