mybatis源码分析一

更多精彩内容可以访问我的独立博客

我们从最简单的一段代码开始，分析清楚mybatis的大致工作流程。然后再从代码细节上分析mybatis的一些特性。

基础代码示例

public class test {
  public static void main(String[] args) throws IOException{
    String resource = "example/mybatis-config.xml";
    // 加载配置文件 并构建SqlSessionFactory对象
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
    // 从SqlSessionFactory对象中获取 SqlSession对象
    SqlSession sqlSession = factory.openSession();
    // 执行操作
    User user=new User();
    user.setId(1);
    Object u= (User)sqlSession.selectOne("getUser", user);
    System.out.println(u.toString());
    // 关闭SqlSession
    sqlSession.close();
  }
}

其中User类其实就是一个只有id，username，password的pojo。我就不粘贴代码了。
mybatis当然少不了对应的sql代码了。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="example.Dao.UserMapper">
  <select id="getUser" parameterType="int" resultType="example.Pojo.User">
        select * from user where id= #{id}
    </select>
</mapper>

还有任何框架都少不了的配置。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis_study?useUnicode=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="example/UserMapper.xml"/>
  </mappers>
</configuration>

代码都粘贴出来了，下面我们就以这段代码为例分析，mybatis的执行流程。

执行流程分析

SqlSessionFactory的创建过程

第一行有效的代码是这个InputStream inputStream = Resources.getResourceAsStream(resource);这个地方，Resources是一个工具类，它的作用就是方便我们加载各种资源文件的。至于它的内部是如何实现的，这都不重要。总之，这行代码所做的工作就是简简单单的加载我们的配置文件。

我们的重头戏其实是这行代码 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
我们把这行代码分成两部分分析，第一部分就是new SqlSessionFactoryBuilder(),这个不需要怎么解释，这一部分的作用就是创建一个SqlSessionFactoryBuilder对象，第二部分就是调用了该对象的SqlSessionFactory build(Reader reader)方法，这个方法非常的重要，这个方法实际上最终调用的是另一个重载方法,它的具体实现如下：

 public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

这段代码，如果我们不考虑其它东西的话，这段代码其实就做了三件事情，利用我们传入的配置文件的reader（后面两个参数调用的时候传的是null），创建了一个XMLConfigBuilder对象，然后调用该对象的parse()方法，拿到了一个Configuration对象，利用这个Configuration对象,使用build(Configuration cofig)方法，创建了SqlSessionFactory对象,然后将SqlSessionFactory对象返回。

下面我们就分别解释这三个步骤到底干了什么。

• 第一步：创建XMLConfigBuilder对象。
  虽然看起来简单的new了一下该对象就创建好了.实际上还是比较复杂的.各种重载的构造器层层调用，最终来到了这个构造器。

  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  //创建一个空的Configuration对象，实例化了XMLConfigBuilder对象
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    //对属性各种赋值
    //我们配置时分离出的Properties文件中的信息，就是在这里进入到mybatis的
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    //parser就是用来解析XML文件的，在之前的构造器中，已经将配置文件的inputStream设置到该对象中去了
    this.parser = parser;
  }

既然这个构造器所做的事情基本都是给属性赋值，那么我们就得好好分析一波，XMLConfigBuilder到底有哪些属性，它们的作用是什么。

//下面三个是继承自父类BaseBuilder中的属性

    /**
    * 存储基础配置信息的一个对象
    */
    protected final Configuration configuration; 
    /**
    * 故名思意，就是存储各种类型的别名的一个对象
    */
    protected final TypeAliasRegistry typeAliasRegistry;
    
    /**
    * 存储各种类型的类型处理器的对象
    */
    protected final TypeHandlerRegistry typeHandlerRegistry;


    /**
    * 标记该配置文件是否已经解析过
    */
    private boolean parsed;
    
    /**
    * 解析器模块，配置文件就由它进行解析
    */
    private final XPathParser parser;
    private String environment;
    
    /**
    * 默认反射工厂实现
    */
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

• 第二步：使用XMLConfigBuilder对象的，Configuration parse()方法，获取到Configuration对象。
  该方法的实现如下：

  public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;//将该配置文件标记为已解析
    
    //对配置文件中的configuration节点下的所有属性进行解析，并将解析到的信息封装到
    //XMLConfigBuilder对象的configuration属性中。
    parseConfiguration(parser.evalNode("/configuration"));
    //将填充好各种值的configuration返回
    return configuration;
  }

看完这段代码，我们可以知道，第二部其实就是去解析配置文件中的configuration节点下的信息，去初始化XMLConfigBuilder对象中的configuration属性，然后将初始化完毕的configuration返回即可。

• 第三步：利用刚才得到的充满各种配置信息的configuration作为参数，调用SqlSessionFactory build(Configuration config)方法，来构建SqlSessionFactory对象

它首先是调用了这个方法：

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

这个方法实例化了一个SqlSessionFactory接口的实现类DefaultSqlSessionFactory.
具体的实例化过程如下：

  public DefaultSqlSessionFactory(Configuration configuration) {
    this.configuration = configuration;
  }

非常的简单，只不过是将configuration传递到了DefaultSqlSessionFactory对象。
到此我们已经成功的创建了SqlSessionFactory对象。
不过到这里，我们好像忽略了一个非常重要的环节，我们的UserMapperx.xml文件在解析配置文件的configuration节点的时候，是如何处理的呢？

创建SqlSessionFactory时是如何处理Mapper.xml的呢？

想要知道我们的Mapper.xml文件是如何处理的，首先要找到是在哪个地方处理的。
在我们之前分析SqlSessionFactory的创建过程时，我们就分析到XMLConfigBuilder的Configuration parse()方法，这个方法中就进行了配置文件的解析。那么处理Mapper.xml文件也应该是从这个地方开始的。
在Configuration parse()中调用了一个重要的方法void parseConfiguration(XNode root),它的具体实现如下；

 private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      
      //在这个地方处理的mappers
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

我们查看处理mappers的具体的地方：它的实现如下：

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

这个方法看起来非常的复杂，但我们至少可以得到一点信息：
mapper配置有三种写法：

  <mappers>
    <mapper url=""/>
    <mapper class=""/>
    <mapper resource=""/>
  </mappers>

这个方法看起来非常的复杂，但是它也不过是做三件事情，拿到mapper文件，创建XMLMapperBuilder对象，解析mapper文件。

• 第一步：根据配置的信息，获取每个节点所指定的mapper文件
  以mapper的一种配置为例：
  InputStream inputStream = Resources.getResourceAsStream(resource);
  它还是利用了用来加载各种资源文件的强大的Resources工具类。

• 第二步：创建XMLMapperBuilder对象。
  XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  创建 XMLMapperBuilder的过程，基本上就是实例化，然后将参数中的各种值注入。

• 第三步：解析对应的mapper节点
  mapperParser.parse();

这个方法的具体实现如下；

  public void parse() {
    if (!configuration.isResourceLoaded(resource)) { //如果没有解析过
        //解析每个mapper节点中的信息
      configurationElement(parser.evalNode("/mapper"));
      //将当前文件加入已解析文件集合
      configuration.addLoadedResource(resource);
      //将mapper和命名空间进行绑定
      //本质就是将命名空间所对应的类和mapper文件都加入configuration中
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

这个部分涉及到的细节非常的多，如果你熟悉mybatis中mapper的写法你就会知道，mapper中的标签非常的多，写法也比较复杂，所有这部分的源码其实也非常的复杂，因此这部分我准备之后专门分析一波。

SqlSession的创建过程

经过前面的努力，我们已经拿到了SqlSessionFactory对象。现在就需要创建SqlSession对象了。这个过程，由这行代码来完成。
SqlSession sqlSession = factory.openSession();
它的具体实现如下:

  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

这个方法中涉及到一个非常重要的方法：

  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);
      //创建执行器
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

这个方法比较关键的地方就是拿到事务对象，创建执行器。
创建执行器的具体实现如下：

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

观察这个方法，我们首先能够得到的信息就是执行器有三种类型。它们分别是：
ExecutorType.SIMPLE：这个类型不做任何其它的事情，它为每个语句创建一个PreparedStatement
ExecutorType.REUSE：这种类型会重复使用PreparedStatements。
ExecutorType.BATCH：这个类型这个类型批量更新，且必要地区别开其中的select 语句，确保动作易于理解。

我们就以ExecutorType.SIMPLE类型为例，来看一些，创建执行器的时候，到底做了什么事情。
executor = new SimpleExecutor(this, transaction);
这行代码实质上是调用了SimpleExecutor的父类BaseExecutor的构造方法。
其具体实现如下：

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

在构造函数中完成了一些重要属性的注入。其中比较关键的就是transaction属性，这个对象包括了获取数据库连接，提交，回滚等一系列直接操作数据库的方法。
这个接口如下：

public interface Transaction {

  /**
   * Retrieve inner database connection.
   * @return DataBase connection
   * @throws SQLException
   */
  Connection getConnection() throws SQLException;

  /**
   * Commit inner database connection.
   * @throws SQLException
   */
  void commit() throws SQLException;

  /**
   * Rollback inner database connection.
   * @throws SQLException
   */
  void rollback() throws SQLException;

  /**
   * Close inner database connection.
   * @throws SQLException
   */
  void close() throws SQLException;

  /**
   * Get transaction timeout if set.
   * @throws SQLException
   */
  Integer getTimeout() throws SQLException;

}

我们回到刚才分析的SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit).
拿到构造器，就可创建SqlSession.
具体实现是这行代码：
return new DefaultSqlSession(configuration, executor, autoCommit);
调用的构造器的具体实现如下：

  public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }

我们可以看出，将配置信息与执行器封装起来，就得到了SqlSession

SqlSession是如何操作数据库的

我们以查询为例：

Object u= (User)sqlSession.selectOne("getUser", user);

具体的实现如下：

  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

从这段代码，可以看出这段代码起主要作用的就是 List<T> list = this.selectList(statement, parameter);这段代码，其余代码都是用于处理返回值的。

那么下面我们就分析一波selectList(statement, parameter)的具体实现：

  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 {
        /*MappedStatement就是对sql语句和相关配置信息的封装，
        基本上执行一个sql所需的信息，MappedStatement中都有*/
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

这段代码，首先拿到封装了执行该sql的所有信息的MappedStatement对象，然后就调用执行器执行sql。
不过，在调用执行器之前，它还对我们的传入的参数进行处理，处理参数的代码是wrapCollection(parameter)
处理参数的逻辑也非常的简单，基本上就是对复杂参数类型的一种标记。对普通的对象不进行处理。

  private Object wrapCollection(final Object object) {
    if (object instanceof Collection) {
      StrictMap<Object> map = new StrictMap<>();
      map.put("collection", object);
      if (object instanceof List) {
        map.put("list", object);
      }
      return map;
    } else if (object != null && object.getClass().isArray()) {
      StrictMap<Object> map = new StrictMap<>();
      map.put("array", object);
      return map;
    }
    return object;
  }

所有的准备工作，都准备好了之后，就是执行器去执行查询了。

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  //可以理解为对sql信息的进一步处理，更加接近jdbc
    BoundSql boundSql = ms.getBoundSql(parameter);
    //计算缓存的key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }
  
  //接下来调用了这个方法
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
      //尝试从缓存中读取
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
        //缓存中，查询结果为空，就继续查询
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
  
  //如果没有缓存，或缓存无效的话，会调用这个方法，从数据库中查询
  
    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;
  }
  
  
  
    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
    //获取configuration对象
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }
  
  
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.handleResultSets(ps);
  }
  
  
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    //这里的sql就是可以执行的sql了
    String sql = boundSql.getSql();
    
    statement.execute(sql);
    //对查询的结果集进行处理
    return resultSetHandler.handleResultSets(statement);
  }

这部分也非常的复杂，以后专门研究一波，在写个博客吧。