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代码了。




  

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




  
    
      
      
        
        
        
        
      
    
  
  
    
  

代码都粘贴出来了,下面我们就以这段代码为例分析,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的创建过程时,我们就分析到XMLConfigBuilderConfiguration 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配置有三种写法:

  
    
    
    
  

这个方法看起来非常的复杂,但是它也不过是做三件事情,拿到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 selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List 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 list = this.selectList(statement, parameter);这段代码,其余代码都是用于处理返回值的。

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

  public  List selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }
  
  //最终调用了这个重载实现
    public  List 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 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 map = new StrictMap<>();
      map.put("array", object);
      return map;
    }
    return object;
  }
 
 

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

  public  List 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  List 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 list = (List) 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  List 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 list;
    try {
      queryStack++;
      list = resultHandler == null ? (List) 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  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List 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  List 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  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.handleResultSets(ps);
  }
  
  
    public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    //这里的sql就是可以执行的sql了
    String sql = boundSql.getSql();
    
    statement.execute(sql);
    //对查询的结果集进行处理
    return resultSetHandler.handleResultSets(statement);
  }

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

你可能感兴趣的:(mybatis源码分析一)