解析MyBatis源码实现自定义持久层框架

< configuration >

         <!--数据库配置信息-->

     < dataSource >

         < property name = "driverClass" value = "com.mysql.jdbc.Driver" ></ property >

         < property name = "jdbcUrl" value = "jdbc:mysql:///learning_db" ></ property >

         < property name = "username" value = "root" ></ property >

         < property name = "password" value = "123456" ></ property >

     </ dataSource >

     <!--存放mapper.xml的全路径-->

     < mapper resource = "UserMapper.xml" ></ mapper >

</ configuration >

< mapper namespace = "com.snf.mapper.UserMapper" >

     <!--sql的唯一标识：namespace.id来组成 ： mappedStatementId-->

     < select id = "findAll" resultType = "com.snf.domain.User" >

         select * from user

     </ select >

     <!--

         User user = new User()

         user.setId(1);

         user.setUsername("zhangsan")

     -->

     < select id = "findByCondition" resultType = "com.snf.domain.User" parameterType = "com.snf.domain.User" >

         select * from user where id = #{id} and username = #{username}

     </ select >

</ mapper >

public class User {

     private Integer id;

     private String username;

     public User() {

     }

     public User(Integer id, String username) {

         this .id = id;

         this .username = username;

     }

     public Integer getId() {

         return id;

     }

     public void setId(Integer id) {

         this .id = id;

     }

     public String getUsername() {

         return username;

     }

     public void setUsername(String username) {

         this .username = username;

     }

     @Override

     public String toString() {

         return "User{" +

                 "id=" + id +

                 ", username='" + username + '\ '' +

                 '}' ;

     }

}

< properties >

  < project.build.sourceEncoding >UTF-8</ project.build.sourceEncoding >

  < maven.compiler.encoding >UTF-8</ maven.compiler.encoding >

  < java.version >1.8</ java.version >

  < maven.compiler.source >1.8</ maven.compiler.source >

  < maven.compiler.target >1.8</ maven.compiler.target >

</ properties >

< dependencies >

  < dependency >

  < groupId >mysql</ groupId >

  < artifactId >mysql-connector-java</ artifactId >

  < version >5.1.17</ version >

  </ dependency >

  < dependency >

  < groupId >c3p0</ groupId >

  < artifactId >c3p0</ artifactId >

  < version >0.9.1.2</ version >

  </ dependency >

  < dependency >

  < groupId >log4j</ groupId >

  < artifactId >log4j</ artifactId >

  < version >1.2.12</ version >

  </ dependency >

  < dependency >

  < groupId >junit</ groupId >

  < artifactId >junit</ artifactId >

  < version >4.10</ version >

  </ dependency >

  < dependency >

  < groupId >dom4j</ groupId >

  < artifactId >dom4j</ artifactId >

  < version >1.6.1</ version >

  </ dependency >

  < dependency >

  < groupId >jaxen</ groupId >

  < artifactId >jaxen</ artifactId >

  < version >1.1.6</ version >

  </ dependency >

</ dependencies >

public class Configuration {

     private DataSource dataSource;

     /**

      * key:statementId value:封装好的mappedStatement对象

      */

     private Map<String,MappedStatement> mappedStatementMap = new HashMap<>();

     public DataSource getDataSource() {

         return dataSource;

     }

     public void setDataSource(DataSource dataSource) {

         this .dataSource = dataSource;

     }

     public Map<String, MappedStatement> getMappedStatementMap() {

         return mappedStatementMap;

     }

     public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {

         this .mappedStatementMap = mappedStatementMap;

     }

}

public class MappedStatement {

     //sql语句id

     private String id;

     //sql语句

     private String sql;

     //输入参数类型

     private String parameterType;

     //返回参数类型

     private String resultType;

     public String getId() {

         return id;

     }

     public void setId(String id) {

         this .id = id;

     }

     public String getSql() {

         return sql;

     }

     public void setSql(String sql) {

         this .sql = sql;

     }

     public String getParameterType() {

         return parameterType;

     }

     public void setParameterType(String parameterType) {

         this .parameterType = parameterType;

     }

     public String getResultType() {

         return resultType;

     }

     public void setResultType(String resultType) {

         this .resultType = resultType;

     }

}

public class Resources {

     //以流的形式读取配置文件

     public static InputStream getResourceAsStream(String path){

         InputStream resourceAsStream = Resources. class .getClassLoader().getResourceAsStream(path);

         return resourceAsStream;

     }

}

public class SqlSessionFactoryBuilder {

     public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException {

         //使用dom4j解析配置文件,将解析出来的内容封装到Configuration中

         XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();

         Configuration configuration = xmlConfigBuilder.parseConfig(inputStream);

         //创建sqlSessionFactory工厂对象：生产sqlSession

         DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);

         return defaultSqlSessionFactory;

     }

}

public class XMLConfigBuilder {

     private Configuration configuration;

     public XMLConfigBuilder() {

         this .configuration = new Configuration();

     }

     /**

      * 使用dom4j对配置文件进行封装,封装Configuration

      */

     public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {

         Document document = new SAXReader().read(inputStream);

         Element rootElement = document.getRootElement();

         List<Element> list = rootElement.selectNodes( "//property" );

         Properties properties = new Properties();

         list.forEach(element -> {

             String name = element.attributeValue( "name" );

             String value = element.attributeValue( "value" );

             properties.setProperty(name, value);

         });

         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();

         comboPooledDataSource.setDriverClass(properties.getProperty( "driverClass" ));

         comboPooledDataSource.setJdbcUrl(properties.getProperty( "jdbcUrl" ));

         comboPooledDataSource.setUser(properties.getProperty( "username" ));

         comboPooledDataSource.setPassword(properties.getProperty( "password" ));

         configuration.setDataSource(comboPooledDataSource);

         //解析<Mapper>标签

         List<Element> mapperList = rootElement.selectNodes( "//mapper" );

         mapperList.stream()

                 .map(x -> x.attributeValue( "resource" ))

                 .map(Resources::getResourceAsStream)

                 .forEach(resourceAsStream -> {

                     XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);

                     try {

                         xmlMapperBuilder.parse(resourceAsStream);

                     } catch (DocumentException e) {

                         e.printStackTrace();

                     }

                 });

         return configuration;

     }

}

public class XmlMapperBuilder {

     private Configuration configuration;

     public XmlMapperBuilder(Configuration configuration) {

         this .configuration = configuration;

     }

     public void parse(InputStream inputStream) throws DocumentException {

         Document document = new SAXReader().read(inputStream);

         Element rootElement = document.getRootElement();

         String namespace = rootElement.attributeValue( "namespace" );

         List<Element> list = rootElement.selectNodes( "//select" );

         list.forEach(element -> {

             String id = element.attributeValue( "id" );

             String parameterType = element.attributeValue( "parameterType" );

             String resultType = element.attributeValue( "resultType" );

             String sqlText = element.getTextTrim();

             MappedStatement mappedStatement = new MappedStatement();

             mappedStatement.setId(id);

             mappedStatement.setParameterType(parameterType);

             mappedStatement.setResultType(resultType);

             mappedStatement.setSql(sqlText);

             String key = namespace.concat( "." ).concat(id);

             configuration.getMappedStatementMap().put(key, mappedStatement);

         });

     }

}

public interface SqlSessionFactory {

     SqlSession openSession();

}

public class DefaultSqlSessionFactory implements SqlSessionFactory {

     private Configuration configuration;

     public DefaultSqlSessionFactory(Configuration configuration) {

         this .configuration = configuration;

     }

     @Override

     public SqlSession openSession() {

         return new DefaultSqlSession(configuration);

     }

}

public interface SqlSession {

     //查询所有

     <E> List<E> selectList(String mappedStatementId,Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException;

     //根据条件

     <T> T selectOne(String mappedStatementId,Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException;

     //为Dao接口生成代理实现类

     <T> T getMapper(Class<T> mapperClass);

}

public class DefaultSqlSession implements SqlSession {

     private Configuration configuration;

     public DefaultSqlSession(Configuration configuration) {

         this .configuration = configuration;

     }

     @Override

     public <E> List<E> selectList(String mappedStatementId, Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException {

         SimpleExecutor simpleExecutor = new SimpleExecutor();

         MappedStatement mappedStatement = configuration.getMappedStatementMap().get(mappedStatementId);

         List<Object> objectList = simpleExecutor.query(configuration, mappedStatement, params);

         return (List<E>) objectList;

     }

     @Override

     public <T> T selectOne(String mappedStatementId, Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException {

         List<Object> objectList = selectList(mappedStatementId, params);

         if (objectList.size() == 1 ) {

             return (T) objectList.get( 0 );

         } else {

             throw new RuntimeException( "查询结果为空或者返回结果过多！" );

         }

     }

     @Override

     public <T> T getMapper(Class<T> mapperClass) {

         //使用JDK动态代理来为Dao接口生成代理对象,并返回

         return (T) Proxy.newProxyInstance(DefaultSqlSession. class .getClassLoader(), new Class[]{mapperClass}, ((proxy, method, args) -> {

             String methodName = method.getName();

             String className = method.getDeclaringClass().getName();

             String mappedStatementId = className.concat( "." ).concat(methodName);

             //获取被调用方法的返回值类型

             Type genericReturnType = method.getGenericReturnType();

             //判断是否进行了泛型类型参数化

             if (genericReturnType instanceof ParameterizedType){

                 List<Object> objectList = selectList(mappedStatementId, args);

                 return objectList;

             }

             return selectOne(mappedStatementId,args);

         }));

     }

}

public interface Executor {

     <E>List<E> query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException;

}

public class SimpleExecutor implements Executor {

     @Override

     public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException {

         //注册驱动,获取连接

         Connection connection = configuration.getDataSource().getConnection();

         //获取sql语句：select * from user where id = #{id} and username = #{username}

         //转换sql语句：select * from user where id = ? and username = ?

         //转换的过程中,还需要对#{}里面的参数名称进行解析存储

         String sql = mappedStatement.getSql();

         BoundSql boundSql = getBoundSql(sql);

         //获取预处理对象：preparedStatement

         PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());

         //设置参数

         //获取到了参数的全路径

         String parameterType = mappedStatement.getParameterType();

         Class<?> parameterTypeClass = getClassType(parameterType);

         List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();

         for ( int i = 0 ; i < parameterMappingList.size(); i++) {

             ParameterMapping parameterMapping = parameterMappingList.get(i);

             String content = parameterMapping.getContent();

             //反射

             Field declaredField = parameterTypeClass.getDeclaredField(content);

             //暴力访问

             declaredField.setAccessible( true );

             Object o = declaredField.get(params[ 0 ]);

             preparedStatement.setObject(i + 1 , o);

         }

         //执行sql

         ResultSet resultSet = preparedStatement.executeQuery();

         String resultType = mappedStatement.getResultType();

         Class<?> resultTypeClass = getClassType(resultType);

         List<Object> objectList = new ArrayList<>();

         //封装返回结果集

         while (resultSet.next()) {

             Object o = resultTypeClass.newInstance();

             //元数据

             ResultSetMetaData metaData = resultSet.getMetaData();

             for ( int i = 1 ; i <= metaData.getColumnCount(); i++) {

                 // 字段名

                 String columnName = metaData.getColumnName(i);

                 // 字段的值

                 Object value = resultSet.getObject(columnName);

                 //使用反射或者内省,根据数据库表和实体的对应关系,完成封装

                 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);

                 Method writeMethod = propertyDescriptor.getWriteMethod();

                 writeMethod.invoke(o, value);

             }

             objectList.add(o);

         }

         return (List<E>) objectList;

     }

     private Class<?> getClassType(String paramterType) throws ClassNotFoundException {

         if (paramterType != null ) {

             Class<?> aClass = Class.forName(paramterType);

             return aClass;

         }

         return null ;

     }

     /**

      * 完成对#{}的解析工作

      * 1.将#{}使用?进行代替

      * 2.解析出#{}里面的字段名进行存储

      *

      * @param sql

      * @return

      */

     private BoundSql getBoundSql(String sql) {

         //标记处理类：配置标记解析器来完成对占位符的解析处理工作

         ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();

         GenericTokenParser genericTokenParser = new GenericTokenParser( "#{" , "}" , parameterMappingTokenHandler);

         //解析出来的sql

         String parseSql = genericTokenParser.parse(sql);

         //#{}里面解析出来的参数名称

         List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();

         BoundSql boundSql = new BoundSql(parseSql, parameterMappings);

         return boundSql;

     }

}

public class BoundSql {

     private String sqlText; //解析过后的sql

     private List<ParameterMapping> parameterMappingList = new ArrayList<>();

     public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) {

         this .sqlText = sqlText;

         this .parameterMappingList = parameterMappingList;

     }

     public String getSqlText() {

         return sqlText;

     }

     public void setSqlText(String sqlText) {

         this .sqlText = sqlText;

     }

     public List<ParameterMapping> getParameterMappingList() {

         return parameterMappingList;

     }

     public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {

         this .parameterMappingList = parameterMappingList;

     }

}

public class GenericTokenParser {

   private final String openToken; //开始标记

   private final String closeToken; //结束标记

   private final TokenHandler handler; //标记处理器

   public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {

     this .openToken = openToken;

     this .closeToken = closeToken;

     this .handler = handler;

   }

   /**

    * 解析${}和#{}

    * @param text

    * @return

    * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。

    * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现

    */

   public String parse(String text) {

     // 验证参数问题，如果是null，就返回空字符串。

     if (text == null || text.isEmpty()) {

       return "" ;

     }

     // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。

     int start = text.indexOf(openToken, 0 );

     if (start == - 1 ) {

       return text;

     }

    // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，

     // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码

     char [] src = text.toCharArray();

     int offset = 0 ;

     final StringBuilder builder = new StringBuilder();

     StringBuilder expression = null ;

     while (start > - 1 ) {

      // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理

       if (start > 0 && src[start - 1 ] == '\\' ) {

         builder.append(src, offset, start - offset - 1 ).append(openToken);

         offset = start + openToken.length();

       } else {

         //重置expression变量，避免空指针或者老数据干扰。

         if (expression == null ) {

           expression = new StringBuilder();

         } else {

           expression.setLength( 0 );

         }

         builder.append(src, offset, start - offset);

         offset = start + openToken.length();

         int end = text.indexOf(closeToken, offset);

         while (end > - 1 ) { ////存在结束标记时

           if (end > offset && src[end - 1 ] == '\\' ) { //如果结束标记前面有转义字符时

             // this close token is escaped. remove the backslash and continue.

             expression.append(src, offset, end - offset - 1 ).append(closeToken);

             offset = end + closeToken.length();

             end = text.indexOf(closeToken, offset);

           } else { //不存在转义字符，即需要作为参数进行处理

             expression.append(src, offset, end - offset);

             offset = end + closeToken.length();

             break ;

           }

         }

         if (end == - 1 ) {

           // close token was not found.

           builder.append(src, start, src.length - start);

           offset = src.length;

         } else {

           //首先根据参数的key（即expression）进行参数处理，返回?作为占位符

           builder.append(handler.handleToken(expression.toString()));

           offset = end + closeToken.length();

         }

       }

       start = text.indexOf(openToken, offset);

     }

     if (offset < src.length) {

       builder.append(src, offset, src.length - offset);

     }

     return builder.toString();

   }

}

public class ParameterMapping {

     private String content;

     public ParameterMapping(String content) {

         this .content = content;

     }

     public String getContent() {

         return content;

     }

     public void setContent(String content) {

         this .content = content;

     }

}

public interface TokenHandler {

   String handleToken(String content);

}

public class ParameterMappingTokenHandler implements TokenHandler {

     private List<ParameterMapping> parameterMappings = new ArrayList<>();

     // context是参数名称 #{id} #{username}

     public String handleToken(String content) {

         parameterMappings.add(buildParameterMapping(content));

         return "?" ;

     }

     private ParameterMapping buildParameterMapping(String content) {

         ParameterMapping parameterMapping = new ParameterMapping(content);

         return parameterMapping;

     }

     public List<ParameterMapping> getParameterMappings() {

         return parameterMappings;

     }

     public void setParameterMappings(List<ParameterMapping> parameterMappings) {

         this .parameterMappings = parameterMappings;

     }

}