SqlSession模块与策略模式

一、策略模式

策略模式请参考：03-行为型模式(上)

二、功能

SqlSession是Mybatis的对外最核心的接口，通过该接口来实现数据库的读写命令，事物管理等。SqlSession本质是提供数据库操作的，包括数据库的四大操作。如下是ibatis的编程方式，我们直接通过Sqlsession来访问数据库。

    @Test
        public void query() {
            SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactoryInstace().openSession();
            List<Object> list = sqlSession.selectList("com.intellif.mozping.dao.ItemMapper.findItemById", 1);
            for (Object obj : list) {
                System.out.println(((Item) obj).toString());
            }
        }

这里我们不分析面向接口编程后，通过接口调用如何最后又回到sqlsession的方法，这里有兴趣可以阅读参考文献[2]。本文主要分析SqlSession本身的设计方式，包括其子类，工厂类等。

三、源码

SqlSession继承图

3.1 实现类

SqlSession接口的主要实现类是DefaultSqlSession，SqlSessionFactory的主要实现是DefaultSqlSessionFactory。不过从类图我们看到有一个SqlSessionManager类，他继承了2个接口，一方面具备生产SqlSession的能力，另一方面又具备SqlSession的能力，我们比较一下2个实现类的区别。

SqlSession实现类	区别
DefaultSqlSession	每次访问数据库创建一个新的sqlsession，一个sqlsession代表一次数据库连接(默认，也是我们重点分析的)
SqlsessionManager	内部通过ThreadLocal来保证一个线程只创建一个sqlsession,但是也可以每次创建一个新的(和DefaultSqlSession一样，支持2种模式，了解)

3.2 DefaultSqlSession源码分析

SqlSession的默认实现是DefaultSqlSession。SqlSession提供的数据库操作在底层都是调用Executor来执行。SqlSession提供很多增删改查的方法，在DefaultSqlSession中看方法执行流程，所有的查询方法最后都会走到一个方法，底层调用Executor的query，更新和删除也类似，都会走到Executor的更新方法。简单抽取部分代码如下，更多源码可以阅读参考文章[6]：

      // -> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds)
      @Override
      public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
        return this.selectMap(statement, null, mapKey, RowBounds.DEFAULT);
      }
    
        // -> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds)
      @Override
      public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
        return this.selectMap(statement, parameter, mapKey, RowBounds.DEFAULT);
      }
    
        // -> selectList(String statement, Object parameter, RowBounds rowBounds)
      @Override
      public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
          //selectMap底层走的还是selectList(String statement, Object parameter, RowBounds rowBounds)方法
        final List<? extends V> list = selectList(statement, parameter, rowBounds);
        //因为是按照resultMap的形式返回，因此拿到结果集之后，需要对结果进行处理，通过mapResultHandler处理
        final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<K, V>(mapKey,
            configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
        final DefaultResultContext<V> context = new DefaultResultContext<V>();
        for (V o : list) {
          context.nextResultObject(o);
          mapResultHandler.handleResult(context);
        }
        //返回处理后的结果集
        return mapResultHandler.getMappedResults();
      }

逻辑图如下：

四、SqlSessionFactory

SqlSessionFactory是创建SqlSession的工厂。

4.1 SqlSessionFactory接口

    /**
     * Creates an {@link SqlSession} out of a connection or a DataSource
     * 创建SqlSession，通过数据库连接创建或者从数据源创建
     * @author Clinton Begin
     */
    public interface SqlSessionFactory {
    
      SqlSession openSession();
    
      SqlSession openSession(boolean autoCommit);
      SqlSession openSession(Connection connection);
      SqlSession openSession(TransactionIsolationLevel level);
    
      SqlSession openSession(ExecutorType execType);
      SqlSession openSession(ExecutorType execType, boolean autoCommit);
      SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType, Connection connection);
    
      Configuration getConfiguration();
    }

4.2 实现类DefaultSqlSessionFactory

DefaultSqlSessionFactory是SqlSessionFactory的重要实现类，它是创建SqlSession的工厂。创建SqlSession有2种方式，从数据源获取或者从数据库连接获取，具体看下面代码和注释:

    /**
         * 方式一：从数据源获取SqlSession
         * */
        private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
            Transaction tx = null;
            try {
                final Environment environment = configuration.getEnvironment();
                final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
                //1.从数据源DataSource获取tx，这是和方式二最大的区别，其他的都差不多
                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();
            }
        }
    
        /**
         * 方式二：从数据库连接获取SqlSession
         * */
        private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
            try {
                //1.确认是否自动提交
                boolean autoCommit;
                try {
                    autoCommit = connection.getAutoCommit();
                } catch (SQLException e) {
                    // Failover to true, as most poor drivers
                    // or databases won't support transactions
                    autoCommit = true;
                }
                final Environment environment = configuration.getEnvironment();
                final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
                //2.从一个连接connection获取tx，这是和方式一最大的区别，其他的都差不多
                final Transaction tx = transactionFactory.newTransaction(connection);
                final Executor executor = configuration.newExecutor(tx, execType);
                return new DefaultSqlSession(configuration, executor, autoCommit);
            } catch (Exception e) {
                throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
            } finally {
                ErrorContext.instance().reset();
            }
        }

我们看到2种创建方式的区别只在transactionFactory.newTransaction(connection);这一行，只是构造Transaction有区别，这里稍微跟进去其实区别在中2个构造方法，这就不深入了。

      //通过Connection构造ManagedTransaction
      public ManagedTransaction(Connection connection, boolean closeConnection) {
        this.connection = connection;
        this.closeConnection = closeConnection;
      }
      //通过DataSource构造ManagedTransaction
      public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
        this.dataSource = ds;
        this.level = level;
        this.closeConnection = closeConnection;
      }

DefaultSqlSessionFactory提供了很多创建的方法，底层最后都是走上面的2个方法，逻辑图如下：

SqlSession中的策略模式体现在：创建数据源有3种方式，POOL、UNPOOL和JNDI。在创建Sqlsession的时候，是根据环境创建的，在Environment里面会指定数据源的方式，对于Sqlsession的使用代码来说，不管底层是如何创建Sqlsession的，都没有关系。只需要改配置，数据源模块就能够生产出3种不同类型的SqlSession。在上面的2个方法中，configuration.newExecutor(tx, execType)说明传到DefaultSqlSession的executor都是根据具体的类型execType创建的，我们看看Configuration#newExecutor()方法

        //Configuration.java
        
        //是否开启2级缓存
        protected boolean cacheEnabled = true;
        
        /**
         * 配置对象创建Executor组件，BatchExecutor/ReuseExecutor/SimpleExecutor三种
         * 该方法在SqlSessionFactory的实现类DefaultSqlSessionFactory中会调用，得到的Executor组件会传到SqlSession中，
         * 因为SqlSession对数据库的访问需要使用Executor来实现
         * */
        public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
            //1.如果executorType是null，那就使用defaultExecutorType = ExecutorType.SIMPLE
            executorType = executorType == null ? defaultExecutorType : executorType;
            executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
            Executor executor;
            //2.BATCH
            if (ExecutorType.BATCH == executorType) {
                executor = new BatchExecutor(this, transaction);
            //3.REUSE
            } else if (ExecutorType.REUSE == executorType) {
                executor = new ReuseExecutor(this, transaction);
            //4.SIMPLE
            } else {
                executor = new SimpleExecutor(this, transaction);
            }
            //5.如果开启了二级缓存，那么就装饰一下
            if (cacheEnabled) {
                executor = new CachingExecutor(executor);
            }
            //6.处理插件
            executor = (Executor) interceptorChain.pluginAll(executor);
            return executor;
        }

关于CachingExecutor的装饰器模式，有兴趣阅读参考文章[4]的4.4小节
关于插件处理，有兴趣阅读参考文章[5]

五、小结

SqlSession是用户使用Mybatis编程的关键接口，我们通过SqlSessionFactory获取SqlSession。
SqlSessionFactory的初始化过程在配置初始化阶段完成，之后就可以通过SqlSessionFactory获取SqlSession了(可以阅读参考文章[1],其中6.2 Mybais的初始化流程图给出了DefaultSqlSessionFactory的实例化过程)
通过SqlSession，我们可以获取接口的代理对象，继而进行增删改查操作，经过一层代理之后，真正的查询入口还是SqlSession的方法(ibatis编程模型，关于代理，可以阅读参考文章[2])
SqlSession中很多数据库读取的重载方法，这些方法最后都走到一个方法里面，并且会使用Executor组件去访问数据库(Executor会引出其他三大对象来完成数据库的读写)，整个SqlSession查询逻辑有兴趣可以阅读参考文章[3]

六、参考

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】即可免费领取。

阅读全文

Mybatis 教程

Mybatis源码和设计模式(SqlSession模块与策略模式)