第三章 mybatis源码系列-mybatis的源码分析

我会带着你远行 2022-10-09 00:41 214阅读 0赞

**目录**

一、源码剖析-初始化

1.1 加载配置文件 mybatis-config

1.2 加载配置文件 mapper.xml

二、源码剖析-SqlSession

三、源码剖析-executor

四、源码剖析-StatementHandler

--------------------

# 一、源码剖析-初始化 #

## 1.1 加载配置文件 mybatis-config ##

Inputstream inputstream = Resources.getResourceAsStream("mybatis-
    config.xml");
        //这一行代码正是初始化工作的开始。
        SqlSessionFactory factory = new
    SqlSessionFactoryBuilder().build(inputStream);

咱们来分析从读取配置文件开始进行源码分析：

// 1.我们最初调用的build
        public SqlSessionFactory build (InputStream inputStream){
          //调用了重载方法
          return build(inputStream, null, null);
       }
       
        // 2.调用的重载方法
        public SqlSessionFactory build (InputStream inputStream, String
    environment,
            Properties properties){
          try {
            //XMLConfigBuilder是专门解析mybatis的配置文件的类
            XMLConfigBuilder parser = new XMLConfigBuilder(inputstream,
    environment, properties);
            //这里又调用了一个重载方法。parser.parse()的返回值是Configuration对象
            return build(parser.parse());
         } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building
    SqlSession.", e)
         }

MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，org.apache.ibatis.session.Configuration 实例来维护。  
下面进入对配置文件解析部分。

Configuration对象的结构和xml配置文件的对象几乎相同。xml中的配置标签有：properties (属性)，settings (设置)，typeAliases (类型别名)，typeHandlers (类型处理器)，objectFactory (对象工厂)，mappers (映射器)等。Configuration也有对应的对象属性来封装它们，也就是说，初始化配置文件信息的本质就是创建Configuration对象，将解析的xml数据封装到Configuration内部属性中。

/**
        * 解析 XML 成 Configuration 对象。
        */
        public Configuration parse () {
          //若已解析，抛出BuilderException异常
          if (parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be
    used once.");
         }
          //标记已解析
          parsed = true;
          // 解析 XML configuration 节点
          parseConfiguration(parser.evalNode("/configuration"));
          return configuration;
       }
          /**
          *解析XML
          */
        private void parseConfiguration (XNode root){
          try {
            //issue #117 read properties first
            // 解析 <properties /> 标签
            propertiesElement(root.evalNode("properties"));
            // 解析〈settings /> 标签
            Properties settings =
                settingsAsProperties(root.evalNode("settings"));
            //加载自定义的VFS实现类
            loadCustomVfs(settings);
            // 解析 <typeAliases /> 标签
            typeAliasesElement(root.evalNode("typeAliases"));
            //解析<plugins />标签
            pluginElement(root.evalNode("plugins"));
            // 解析 <objectFactory /> 标签
            objectFactoryElement(root.evalNode("objectFactory"));
            // 解析 <objectWrapperFactory /> 标签    
     objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            // 解析 <reflectorFactory /> 标签
            reflectorFactoryElement(root.evalNode("reflectorFactory"));
            // 赋值 <settings /> 至 Configuration 属性
            settingsElement(settings);
            // read it after objectFactory and objectWrapperFactory issue
    #631
            // 解析〈environments /> 标签
            environmentsElement(root.evalNode("environments"));
            // 解析 <databaseIdProvider /> 标签
            databaseldProviderElement(root.evalNode("databaseldProvider"));
            // 解析 <typeHandlers /> 标签
            typeHandlerElement(root.evalNode("typeHandlers"));
            //解析<mappers />标签
            mapperElement(root.evalNode("mappers"));
         } catch (Exception e) {
            throw new BuilderException("Error parsing SQL Mapper
                Configuration.Cause:" + e, e);
         }
       }

## 1.2 加载配置文件 mapper.xml ##

在1.1 解析主配置文件时候，会对mybatis-config.xm l中的各个标签都进行解析，其中有mappers 标签用来引入mapper.xml文件或者配置mapper接口的目录。每个mapper文件中的一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key=全限定类名+方法名，value =对应的MappedStatement对象。

在 XMLConfigBuilder 中的处理：

private void parseConfiguration(XNode root) {
        try {
    //省略其他标签的处理
          mapperElement(root.evalNode("mappers"));
       } catch (Exception e) {
          throw new BuilderException("Error parsing SQL Mapper Configuration.
              Cause:" + e, e);
       }
     }

到此对xml配置文件的解析就结束了，调用的重载build方法：

// 调用重载方法
    public SqlSessionFactory build(Configuration config) {
    //创建了 DefaultSqlSessionFactory 对象，传入 Configuration 对象。
    return new DefaultSqlSessionFactory(config);
    }

# 二、源码剖析-SqlSession #

按照第二章的mybatis主要执行流程，在第一步读取配置生成sqlsessionFacory后，下面就到了SqlSession和实际的sql执行者Executor接口。我们先重点讲一下SqlSession这个接口。

public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;
    private final Executor executor;
    }

SqlSession是一个接口，它有两个实现类：DefaultSqlSession (默认)和SqlSessionManager (弃用，不做介绍)。SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一 个SqlSession,并且在使用完毕后需要close。SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器。

继续分析，初始化完毕后，我们就要执行SQL 。

SqlSession sqlSession = factory.openSession();
    List<User> list =
    sqlSession.selectList("com.lagou.mapper.UserMapper.getUserByName");

第一步，我们看获取sqlsession的源码：

//6. 进入 o penSession 方法。
    public SqlSession openSession() {
        //getDefaultExecutorType()传递的是SimpleExecutor
        return openSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);
     }
    
      //7. 进入openSessionFromDataSource。
      //ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，autoCommit是否开启事务
      //openSession的多个重载方法可以指定获得的SeqSession的Executor类型和事务的处理
    private SqlSession openSessionFromDataSource(ExecutorType execType,TransactionIsolationLevel level, boolean autoCommit) {
      
         Transaction tx = null;
      
     try{
        final Environment environment = configuration.getEnvironment();
        final TransactionFactory transactionFactory =
        getTransactionFactoryFromEnvironment(environment);
        tx = transactionFactory.newTransaction(environment.getDataSource(),level, 
        autoCommit);
    
        //根据参数创建指定类型的Executor
        final Executor executor = configuration.newExecutor(tx, execType);
        
        //返回的是 DefaultSqlSession
        return new DefaultSqlSession(configuration, executor, autoCommit);
     } catch(Exception e){
        closeTransaction(tx); // may have fetched a connection so lets call
        close();
      }

第二步，分析执行sqlsession中的api源码，发现实际调用的是excutor里面的方法:

//8.进入selectList方法，多个重载方法。
    public <E> List <E> selectList(String statement) {
    
        return this.selectList(statement, null);
    }
    
    public <E> List <E> selectList(String statement, Object parameter) {
    
          return this.selectList(statement, parameter, RowBounds.DEFAULT);
    }
    
    public <E> List <E> selectList(String statement, Object parameter, RowBounds rowBounds) {
            try {
    
              //根据传入的全限定名+方法名从映射的Map中取出MappedStatement对象
              MappedStatement ms =configuration.getMappedStatement(statement);
    
              //调用Executor中的方法处理
              //RowBounds是用来逻辑分页
              // wrapCollection(parameter)是用来装饰集合或者数组参数
              return executor.query(ms,wrapCollection(parameter),rowBounds,Executor.NO_RESULT_HANDLER);
           } catch (Exception e) {
              throw ExceptionFactory.wrapException("Error queryingdatabase. Cause: + e, e);
           } finally {
              ErrorContext.instance().reset();
           }
    }

# 三、源码剖析-executor #

Executor也是一个接口，他有三个常用的实现类：

*  BatchExecutor (重用语句并执行批量更新)
 *  ReuseExecutor (重用预处理语句 prepared statements)
 *  SimpleExecutor (普通的执行器，默认)

继续分析源码，进入executor.query()：

//此方法在SimpleExecutor的父类BaseExecutor中实现
      public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds
    rowBounds, ResultHandler resultHandler) throws SQLException {
    
        //根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示
        BoundSql boundSql = ms.getBoundSql(parameter);
    
        //为本次查询创建缓存的Key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
     }
    
     //进入query的重载方法中
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws
    SQLException {
    
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    
        if (closed) {
          throw new ExecutorException("Executor was closed.");
       }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
          clearLocalCache();
       }
        List<E> list;
        try {
          queryStack++;
          list = resultHandler == null ? (List<E>) localCache.getObject(key) :
    null;
          if (list != null) {
            handleLocallyCachedOutputParameters(ms, key, parameter,
    boundSql);
         } else {
            //如果缓存中没有本次查找的值，那么从数据库中查询
            list = queryFromDatabase(ms, parameter, rowBounds,
    resultHandler, key, boundSql);
         }
       } finally {
          queryStack--;
       }
        if (queryStack == 0) {
          for (DeferredLoad deferredLoad : deferredLoads) {
            deferredLoad.load();
         }
          // issue #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT)
    { // issue #482 clearLocalCache();
         }
       }
        return list;
     }
      //从数据库查询
      private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter,
    RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql
    boundSql) throws SQLException {
        List<E> list;
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
          //查询的方法
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
       } finally {
          localCache.removeObject(key);
       }
        //将查询结果放入缓存
        localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
          localOutputParameterCache.putObject(key, parameter);
       }
        return list;
    
     }
    
    // SimpleExecutor中实现父类的doQuery抽象方法
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds
    rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;
        try {
          Configuration configuration = ms.getConfiguration();
          //传入参数创建StatementHanlder对象来执行查询
          StatementHandler handler =
    configuration.newStatementHandler(wrapper, ms, parameter, rowBounds,
    resultHandler, boundSql);
          //创建jdbc中的statement对象
          stmt = prepareStatement(handler, ms.getStatementLog());
          // StatementHandler 进行处理
          return handler.query(stmt, resultHandler);
       } finally {
          closeStatement(stmt);
       }
     }
      //创建Statement的方法
      private Statement prepareStatement(StatementHandler handler, Log
    statementLog) throws SQLException {
        Statement stmt;
        //条代码中的getConnection方法经过重重调用最后会调用openConnection方法，从连接池中
    获 得连接。
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection, transaction.getTimeout());
        handler.parameterize(stmt);
        return stmt;
     }
      //从连接池获得连接的方法
      protected void openConnection() throws SQLException {
        if (log.isDebugEnabled()) {
          log.debug("Opening JDBC Connection");
       }
        //从连接池获得连接
        connection = dataSource.getConnection();
        if (level != null) {
          connection.setTransactionIsolation(level.getLevel());
       }
     }

上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传  
递给  
StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能和作用是：

*  根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用
 *  为查询创建缓存，以提高性能
 *  创建JDBC的Statement连接对象，传递给\*StatementHandler\*对象，返回List查询结果

# 四、源码剖析-StatementHandler #

在第三节我们看到excutor在具体执行时候，在具体查询前进行了StatementHandler拼装然后进行了query查询。

StatementHandler对象主要完成两个工作：

*  对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符，我们其后再对占位符进行设值。StatementHandler通过parameterize(statement)方法对 Statement 进行设值；
 *  StatementHandler 通过 List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；进入到

进入到 StatementHandler 的 parameterize(statement)方法的实现：

public void parameterize(Statement statement) throws SQLException {
           //使用ParameterHandler对象来完成对Statement的设值
           parameterHandler.setParameters((PreparedStatement) statement);
    }
    
    /** ParameterHandler 类的 setParameters(PreparedStatement ps) 实现
     * 对某一个Statement进行设置参数
     * */
    public void setParameters(PreparedStatement ps) throws SQLException {
    ErrorContext.instance().activity("setting
          parameters").object(mappedStatement.getParameterMap().getId());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) { for (int i = 0; i <
    parameterMappings.size(); i++) { ParameterMapping parameterMapping =
    parameterMappings.get(i); if (parameterMapping.getMode() != ParameterMode.OUT) {
    Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448
    ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
         } else if (parameterObject == null) { value = null;
         } else if
    (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { value =
    parameterObject;
         } else {
            MetaObject metaObject =
    configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName); }
          // 每一个 Mapping都有一个 TypeHandler，根据 TypeHandler 来对
    preparedStatement 进 行设置参数
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) jdbcType =
    configuration.getJdbcTypeForNull();
          //设置参数
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
       }
      }
     }
    }

从上述的代码可以看到,StatementHandler的parameterize(Statement)方法调用ParameterHandler的setParameters(statement)方法，ParameterHandler的setParameters(Statement )方法负责根据我们输入的参数，对statement对象的 ?占位符处进行赋值。  
进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的实现：

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
    throws SQLException {
    // 1.调用preparedStatemnt。execute()方法，然后将resultSet交给ResultSetHandler处理
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
     
    //2.使用 ResultHandler 来处理 ResultSet
    return resultSetHandler.<E> handleResultSets(ps);
    }

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler  
resultHandler)方法的实现，是调用了 ResultSetHandler 的 handleResultSets(Statement)方法。  
ResultSetHandler 的 handleResultSets(Statement)方法会将 Statement 语句执行后生成的 resultSet结果集转换成List结果集。