自定义持久层框架【MyBatis学习笔记】

学习目的

为了更好的深入了解MyBatis框架,仿照MyBatis框架大体原理做一个简单的自定义持久层框架

JDBC问题总结

原始jdbc开发存在的问题如下:

  1. 数据库连接创建、释放频繁造成系统资源浪费,从而影响系统性能。
  2. Sql语句在代码中硬编码,造成代码不易维护,实际应用中sql变化的可能较大,sql变动需要改变
    java代码。
  3. 使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护。
  4. 对结果集解析存在硬编码(查询列名),sql变化导致解析代码变化,系统不易维护,如果能将数据 库记录封装成pojo对象解析比较方便。

问题解决思路

  1. 使用数据库连接池初始化连接资源
  2. 将sql语句抽取到xml配置文件中
  3. 使用反射、内省等底层技术,自动将实体与表进行属性与字段的自动映射

自定义框架设计

使用端(项目端)

需提供两部分配置信息:数据库配置信息、sql配置信息
数据库配置信息:driverClass、jdbcUrl、username、password
sql配置信息:sql语句、参数类型、返回值类型
使用配置文件来提供这两部分配置信息:

  1. sqlMapConfig.xml:存放数据库配置信息,存放mapper.xml的全路径
<configuration>
    <!--数据库配置信息-->
    <dataSource>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///zdy_mybatis"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </dataSource>
    <!--存放mapper.xml的全路径-->
    <mapper resource="UserMapper.xml"></mapper>
</configuration>
  1. mapper.xml:存放sql配置信息
<mapper namespace="com.yyz.dao.IUserDao">
   <select id="findByCondition" resultType="com.yyz.pojo.User" paramterType="com.yyz.pojo.User">
        select * from user where id = #{id} and username = #{username}
    </select>
</mapper>

用Statementid作为找到sql的唯一ID,由mapper标签中的namespace和select标签中的id组成
Statementid = namespace.id

框架端

框架本质是对JDBC代码进行封装,为了更好的使用

加载配置文件

根据配置文件的路径,加载配置文件成字节输入流存在内存中
创建Resource类 方法:InputSteam getResourceAsSteam(String path)

创建容器对象(javaBean)

目的是存放配置文件解析出来的内容

  1. Configuration:核心配置类,存放sqlMapConfig.xml解析出来的内容
  2. MappedStatement:映射配置类,存放mapper.xml解析出来的内容,同时将该类以Map<String,MappedStatement>形式作为属性放入Configuration
public class Configuration {
    private DataSource dataSource;
    private Map<String,MappedStatement> mappedStatementMap;
}
public class MappedStatement {
    private String id;
    private String resultType;
    private String paramterType;
    private String sql;
}

解析

创建类:SqlSessionFactoryBuilder 方法build(InputSteam in)
使用dom4j解析配置文件,将解析出来的内容封装到Configuration中
(1) 创建XMLConfigBuilder,解析配置文件将数据库配置存入Configuration中
(2) 创建XMLMapperBuilder,解析配置文件将Mapper配置存入Configuration中的MappedStatement中,key为statementId
创建sqlSessionFactory对象:工厂类:生产sqlSession:会话对象

创建sqlSession会话对象(工厂模式)

使用sqlSessionFactory对象:工厂类:生产sqlSession:会话对象

  1. 创建sqlSessionFactory接口以及对应实现类DefaultSqlSessionFactory
  2. 创建sqlSession接口以及对应实现类DefaultSqlSession
  3. sqlSessionFactory创建openSession()方法返回SqlSession(实际返回实现类DefaultSqlSession)
  4. sqlSession中创建查询方法以及为Dao接口生成代理实现类方法
public interface SqlSession {
    public <T> List<T> selectList(String statementid, Object... params);
    public <T> T selectOne(String statementid, Object... params);
    public <T> T getMapper(Class<?> mapperClass);
}
  1. 用JDK动态代理的方式生成代理实现类
 public <T> T getMapper(Class<?> mapperClass) {
        // 使用JDK动态代理来为Dao接口生成代理对象,并返回
        Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 底层都还是去执行JDBC代码 //根据不同情况,来调用selctList或者selectOne
                // 准备参数 1:statmentid :sql语句的唯一标识:namespace.id= 接口全限定名.方法名
                String methodName = method.getName();
                String className = method.getDeclaringClass().getName();
                String statementId = className+"."+methodName;
                // 准备参数2:params:args
                // 获取被调用方法的返回值类型
                Type genericReturnType = method.getGenericReturnType();
                // 判断是否进行了 泛型类型参数化
                if(genericReturnType instanceof ParameterizedType){
                    List<Object> objects = selectList(statementId, args);
                    return objects;
                }
                return selectOne(statementId,args);
            }
        });
        return (T) proxyInstance;
    }

执行sql的实现(JDBC)

完成上一步查询方法的具体实现,实际用JDBC的方式

  1. 创建Executor接口与具体实现类SimpleExecutor,创建query方法
public interface Executor {
    public <E> List<E> query(Configuration configuration,MappedStatement mappedStatement,Object... params) throws Exception;
}
  1. 由于从mapper中获取的sql语句JDBC无法执行,需转换为JDBC可执行的sql(占位符为?),创建BoundSql容器用于存储转换后的sql
public class BoundSql {
    private String sqlText; //解析过后的sql
    private List<ParameterMapping> parameterMappingList = new ArrayList<>();
}
  1. 创建TokenHandler接口及实现类ParameterMappingTokenHandler做为标记处理器,将mapper中的占位标记转换为?,同时将占位标记List作为属性,用于后面将所有占位标记数据提供给JDBC
public interface TokenHandler {
  String handleToken(String content);
}
public class ParameterMappingTokenHandler implements TokenHandler {
	private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
	// 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;
	}
}
  1. 创建占位标记容器ParameterMapping,实际上属性就是一个String
  2. 创建一个工具类GenericTokenParser用于转换sql
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();
  }
}
  1. 实现query方法
    (1)注册驱动,获取连接
    (2)转换sql,用genericTokenParser工具类获取转换后的sql以及解析出的参数名称存入BoundSql
    (3)获取预处理对象:preparedStatement
    (4)通过mapper中的ParamterType获取参数实体类的全路径
    (5)通过ParamterType获取参数实体类Class<?>
    (6)遍历解析出的参数名称List<ParameterMapping>,通过反射获取实体类Class<?>中对应名称的属性值,放入preparedStatement
    (7)执行sql
    (8)通过mapper中的ResultType获取返回结果实体类的全路径
    (9)通过ResultType获取结果实体类Class<?>
    (10)将返回的结果集用内省的方式进行封装
    (11)将结果以List<E>方式进行返回
public class simpleExecutor implements  Executor {
    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
        // 1. 注册驱动,获取连接
        Connection connection = configuration.getDataSource().getConnection();

        // 2. 获取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);

        // 3.获取预处理对象:preparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
        // 4. 设置参数
        //获取到了参数的全路径
        String paramterType = mappedStatement.getParamterType();
        Class<?> paramtertypeClass = getClassType(paramterType);

        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            //反射
            Field declaredField = paramtertypeClass.getDeclaredField(content);
            //暴力访问
            declaredField.setAccessible(true);
            Object o = declaredField.get(params[0]);
            preparedStatement.setObject(i+1,o);
        }
        // 5. 执行sql
        ResultSet resultSet = preparedStatement.executeQuery();
        String resultType = mappedStatement.getResultType();
        Class<?> resultTypeClass = getClassType(resultType);
        ArrayList<Object> objects = new ArrayList<>();
        // 6. 封装返回结果集
        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);
            }
            objects.add(o);
        }
        return (List<E>) objects;
    }

    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;
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值