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

叁歲伎倆 2023-01-21 14:19 23阅读 0赞

**目录**

一、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);
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70][]

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1][]

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3][]

## 2、 Mapper代理方式 ##

1）源码剖析

进入 sqlSession.getMapper(UserMapper.class )中

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5][]

invoke()源码分析

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6][]

进入execute方法:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70]: /images/20221020/8fcb7fde77964c33a3bf676612cfe461.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1]: /images/20221020/1dfbef0d5de44de48d8febf6cdfd2dc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2]: /images/20221020/df3ac23aa1fe408a96066897a56d3a4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3]: /images/20221020/79e8175dc70f430ea24c2c7aafe2fff3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4]: /images/20221020/ab632595b065411185332fa41866a787.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5]: /images/20221020/792170c2697c4289bed27746b60508d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6]: /images/20221020/cb7d92ed3121446bb142fbdd197ba74d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7]: /images/20221020/3bdc3f43cd1c45168b6ad5d490226eb5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8]: /images/20221020/7e1821de07f74d22a24375abf2b45561.png