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对象

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

1
2
3

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

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

1
2
3

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();
它的具体实现如下:

1
2
3

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是如何操作数据库的

我们以查询为例：

1	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);
}

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