详解MyBatis的SqlSession获取流程

Dear 丶 2024-03-26 22:00 36阅读 0赞

### 前言 ###

已知在**MyBatis**的使用中，使用**MyBatis**时会先读取配置文件**mybatis-config.xml**为字符流或者字节流，然后通过**SqlSessionFactoryBuilder**基于配置文件的字符流或字节流来构建**SqlSessionFactory**，然后再通过**SqlSessionFactory**的**openSession()** 方法获取**SqlSession**，示例代码如下所示。

public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession = sqlSessionFactory.openSession();
    }
    复制代码

上述示例代码中的**SqlSessionFactory**实际为**DefaultSqlSessionFactory**，本篇文章将对**DefaultSqlSessionFactory**获取**SqlSession**的流程进行学习。

### 正文 ###

**DefaultSqlSessionFactory**的**openSession()** 方法如下所示。

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

继续看**openSessionFromDataSource()** 方法的实现，如下所示。

private SqlSession openSessionFromDataSource(ExecutorType execType, 
                                                 TransactionIsolationLevel level, 
                                                 boolean autoCommit) {
        Transaction tx = null;
        try {
            // Environment中包含有事务工厂和数据源
            final Environment environment = configuration.getEnvironment();
            // 获取事务工厂
            // 如果配置了JDBC事务，则获取JDBC事务工厂，否则获取MANAGED事务工厂
            final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
            // 创建事务
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            // 创建执行器
            final Executor executor = configuration.newExecutor(tx, execType);
            // 构建DefaultSqlSession并返回
            return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
            closeTransaction(tx);
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
    复制代码

**openSessionFromDataSource()** 方法会先从**Configuration**中将**Environment**获取出来，**Environment**中包含有事务工厂和数据源，**Environment**是在**MyBatis**配置文件中进行配置并会在加载**MyBatis**配置文件时被添加到**Configuration**中。

**MyBatis**的配置文件中可以配置两种事务工厂，为**JDBC**事务工厂和**MANAGED**事务工厂，它们分别可以创建**JDBC**事务和**MANAGED**事务，类图如下所示。

![format_png][]

获取事务工厂的**getTransactionFactoryFromEnvironment()** 方法如下所示。

private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
        if (environment == null || environment.getTransactionFactory() == null) {
            // 配置了事务工厂则使用配置的事务工厂
            // MyBatis可以配置JDBC和MANAGED这两种事务工厂
            return new ManagedTransactionFactory();
        }
        // 没做配置的情况下使用MANAGED事务工厂
        return environment.getTransactionFactory();
    }
    复制代码

**MyBatis**中如果使用**JDBC**事务，则事务的管理由**java.sql.Connection**完成，如果使用**MANAGED**事务，则**MyBatis**会将事务的管理交由**WEB**容器（**Tomcat**，**JBoss**等）来完成。以**commit()** 和**rollback()** 方法为例，看下**JdbcTransaction**和**ManagedTransaction**对这两个方法的实现，如下所示。

public class JdbcTransaction implements Transaction {
    
        // ......
    
        @Override
        public void commit() throws SQLException {
            if (connection != null && !connection.getAutoCommit()) {
                if (log.isDebugEnabled()) {
                    log.debug("Committing JDBC Connection [" + connection + "]");
                }
                connection.commit();
            }
        }
    
        @Override
        public void rollback() throws SQLException {
            if (connection != null && !connection.getAutoCommit()) {
                if (log.isDebugEnabled()) {
                    log.debug("Rolling back JDBC Connection [" + connection + "]");
                }
                connection.rollback();
            }
        }
    
        // ......
    
    }
    
    public class ManagedTransaction implements Transaction {
    
        // ......
    
        @Override
        public void commit() throws SQLException {
            // 不做任何事情
        }
    
        @Override
        public void rollback() throws SQLException {
            // 不做任何事情
        }
    
        // ......
    
    }
    复制代码

回到**openSessionFromDataSource()** 方法，创建好事务后，会构建执行器**Executor**，看一下**newExecutor(Transaction transaction, ExecutorType executorType)** 方法的实现，如下所示。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Executor executor;
        // 根据ExecutorType的枚举值创建对应类型的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);
        }
        // 如果MyBatis配置文件中开启了二级缓存
        if (cacheEnabled) {
            // 创建CachingExecutor作为Executor的装饰器，为Executor增加二级缓存功能
            executor = new CachingExecutor(executor);
        }
        // 将插件逻辑添加到Executor中
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
    }
    复制代码

在上面构建执行器**Executor**的方法中，主要是做了三件事情，解释如下。

**`第一件事情`**，根据**ExecutorType**的枚举值创建对应类型的**Executor**，**ExecutorType**枚举值如下所示。

public enum ExecutorType {
        SIMPLE, REUSE, BATCH
    }
    复制代码

**MyBatis**提供了三种类型的**Executor**，分别为**BatchExecutor**，**ReuseExecutor**和**SimpleExecutor**，类图如下所示。

![format_png 1][]

在**BaseExecutor**中定义了四个抽象方法，如下所示。

protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
    
    protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;
    
    protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
        throws SQLException;
    
    protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)
        throws SQLException;
    复制代码

**BaseExecutor**提供的方法中会调用这四个抽象方法，同时这四个抽象方法需要由**BatchExecutor**，**ReuseExecutor**和**SimpleExecutor**根据各自的功能进行实现，所以**Executor**的设计使用了模板设计模式。

**`第二件事情`**，如果在**MyBatis**配置文件中开启了二级缓存，则为**Executor**创建装饰器**CachingExecutor**，以增加对二级缓存功能的支持。**CachingExecutor**与**Executor**的关系如下所示。

![format_png 2][]

**CachingExecutor**实现了**Executor**接口，同时**CachingExecutor**持有**Executor**的引用，这是装饰器模式的应用。关于**MyBatis**中的缓存，会在后续的文章中进行介绍。

**`第三件事情`**，如果配置了插件，则将插件的逻辑添加到**Executor**中。关于**MyBatis**中的插件，会在后续的文章中进行介绍。

回到**openSessionFromDataSource()** 方法，创建好**Executor**后，就会调用**DefaultSqlSession**的构造方法创建一个**DefaultSqlSession**并返回，在**DefaultSqlSession**的构造方法中只是进行了简单的赋值，如下所示。

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

至此，**SqlSession**就创建出来了。

### 总结 ###

**SqlSession**的获取是通过**SqlSessionFactory**的**openSession()** 方法，**SqlSession**的创建过程主要先是创建事务管理器，然后基于事务管理器创建执行器**Executor**，最后基于**Executor**创建**SqlSession**。

通常，**SqlSessionFactory**为**DefaultSqlSessionFactory**，创建出来的**SqlSession**为**DefaultSqlSession**。

整体的一个流程图如下所示。

![format_png 3][]

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a234857fb85641a781d25bcd2ebc65d5.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c16b5f9b20794c25914351a35f18a621.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/22d8b44350a842d99f16daf233f44419.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5ae14a9aca3f42b881fe0c31ce3003b4.png