架构师进阶之路——1、持久化框架（二）

目录

 

一、Mybatis源码剖析

1、传统方式源码剖析

1）初始化

2）执行SQL流程

 3）executor

4)、StatementHandler

2、 Mapper代理方式

---

一、Mybatis源码剖析

1、传统方式源码剖析

1）初始化

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.Configuratio  实例来维护

下面进入对配置文件解析部分: 首先对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;
}
        
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);
    // 解析〈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
    } 
}

介绍一下 MappedStatement :

作用:MappedStatement与Mapper配置文件中的一个select/update/insert/delete节点相对应。

mapper中配置的标签都被封装到了此对象中，主要用途是描述一条SQL语句。

初始化过程:回顾刚开 始介绍的加载配置文件的过程中，会对mybatis-config.xm l中的各个标签都进行 解析，其中有mappers 标签用来引入mapper.xml文件或者配置mapper接口的目录。

<select id="getUser" resultType="user" >
    select * from user where id=#{id}
</select>

这样的一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在 Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key =全限定类名+方法名，value =对应的MappedStatement对象。

•在configuration中对应的属性为

Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>
("Mapped Statements collection")

 

在 XMLConfigBuilder 中的处理:

private void parseConfiguration(XNode root) {
    try {
        //省略其他标签的处理
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
    } 
}

到此对xml配置文件的解析就结束了，回到步骤2.中调用的重载build方法

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

2）执行SQL流程

先简单介绍SqlSession :

SqlSession是一个接口，它有两个实现类:DefaultSqlSession (默认)和SqlSessionManager (弃用，不做介绍)

SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一 个 SqlSession,并且在使用完毕后需要close

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

SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器 Executor:
Executor也是一个接口，他有三个常用的实现类:
BatchExecutor (重用语句并执行批量更新)

ReuseExecutor (重用预处理语句 prepared statements)

SimpleExecutor (普通的执行器，默认)

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

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

获得 sqlSession

//进入 o penSession 方法。
public SqlSession openSession() {
        //getDefaultExecutorType()传递的是SimpleExecutor
        return openSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);
}
//7. 进入penSessionFromDataSource。
//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

//进入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 querying database. Cause: + e, e);
    } finally {
          ErrorContext.instance().reset();
    }
}

 3）executor

继续源码中的步骤，进入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) :
            if (list != null) {
                handleLocallyCachedOutputParameters(ms, key, parameter,
            } else {
                //如果缓存中没有本次查找的值，那么从数据库中查询
                list = queryFromDatabase(ms, parameter, rowBounds,
                resultHandler, key, boundSql);
            }
         } finally {
            queryStack--;
         }
         if (queryStack == 0) {
             for (DeferredLoad deferredLoad : deferredLoads) {
                  deferredLoad.load();
         }
         deferredLoads.clear();
         if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT)
         {
                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的功能和作用是:

(1、根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用;

(2、为查询创建缓存，以提高性能

(3、创建JDBC的Statement连接对象，传递给*StatementHandler*对象，返回List查询结果。

4)、StatementHandler

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

对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包 含若干个?占位符，我们其后再对占位符进行设值。StatementHandler通过 parameterize(statement)方法对 S tatement 进行设值;
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);
}

从上述的代码可以看到,StatementHandler的parameterize(Statement)方法调用了 ParameterHandler的setParameters(statement)方法，

ParameterHandler的setParameters(Statement )方法负责根据我们输入的参数，对statement对象的 ? 占位符处进行赋值。

进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的 实现:

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了 ResultSetHandler 的 handleResultSets(Statement)方法。

ResultSetHandler 的 handleResultSets(Statement)方法会将 Statement 语句执行后生成的 resultSet 结 果集转换成List结果集

2、 Mapper代理方式

1）源码剖析

进入 sqlSession.getMapper(UserMapper.class )中

 

 invoke()源码分析

在动态代理返回了示例后，我们就可以直接调用mapper类中的方法了，但代理对象调用方法，执行是在MapperProxy中的invoke方法中，底层还是调用sqlSession.<E>selectList

 进入execute方法: