SqlSession 是 MyBatis 核心接口之一，也是 MyBatis 接口层的主要组成部分，对外提供 MyBatis 常用的 API。mybatis 提供了两个 SqlSession 接口的实现，分别为 DefaultSqlSession、SqlSessionManager，其中最常用的是 DefaultSqlSession。另外，跟前面分析过的源码 mybatis 的源码一样，mybatis 也为 SqlSession 提供了相应的工厂接口 SqlSessionFactory，及实现该接口的实现 DefaultSqlSessionFactory（SqlSessionManager 同时实现了 SqlSession 和 SqlSessionFactory 接口）。

1 SqlSession

在 SqlSession 中定义了常用的数据库操作以及事务的相关操作，为了方便用户使用，每种类型的操作都提供了多种重载。

  1. public interface SqlSession extends Closeable {
  2.   // 泛型方法，参数是要执行查询的sql语句，返回值为查询的结果对象
  3.   <T> T selectOne(String statement);
  5.   // 第二个参数表示 需要用户传入的实参，即 sql语句绑定的实参
  6.   <T> T selectOne(String statement, Object parameter);
  8.   // 查询结果有多条记录，会封装成 结果对象列表 并返回
  9.   <E> List<E> selectList(String statement);
  11.   // 参数 + 多记录结果集
  12.   <E> List<E> selectList(String statement, Object parameter);
  14.   // 参数RowBounds主要用于逻辑分页，逻辑分页会将所有的结果都查询到，
  15.   // 然后根据RowBounds中提供的offset和limit值来获取最后的结果
  16.   <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
  18.   // mapKey表示将结果集中的哪一列（如 主键列或编码列）作为Map的key，
  19.   // value则为列值 对应的那条记录
  20.   <K, V> Map<K, V> selectMap(String statement, String mapKey);
  22.   // 多了个parameter参数，其它与上面相同
  23.   <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
  25.   // 多了个RowBounds参数，其它与上面相同
  26.   <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
  28.   // 除了返回值是Cursor对象，其它与selectList相同
  29.   <T> Cursor<T> selectCursor(String statement);
  30.   <T> Cursor<T> selectCursor(String statement, Object parameter);
  31.   <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
  33.   // 查询出的结果集 将由传入的ResultHandler对象处理，其它与selectList相同
  34.   void select(String statement, Object parameter, ResultHandler handler);
  35.   void select(String statement, ResultHandler handler);
  36.   void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
  38.   // 执行insert语句
  39.   int insert(String statement);
  40.   int insert(String statement, Object parameter);
  42.   // 执行update语句
  43.   int update(String statement);
  44.   int update(String statement, Object parameter);
  46.   // 执行delete语句
  47.   int delete(String statement);
  48.   int delete(String statement, Object parameter);
  50.   // 提交事务
  51.   void commit();
  52.   void commit(boolean force);
  54.   // 回滚事务
  55.   void rollback();
  56.   void rollback(boolean force);
  58.   // 将对数据库的操作请求 刷到数据库
  59.   List<BatchResult> flushStatements();
  61.   // 关闭当前session
  62.   void close();
  64.   // 清空缓存
  65.   void clearCache();
  67.   // 获取Configuration对象
  68.   Configuration getConfiguration();
  70.   // 获取type对应的Mapper对象
  71.   <T> T getMapper(Class<T> type);
  73.   // 获取该SqlSession对应的数据库连接
  74.   Connection getConnection();
  75. }

1.1 DefaultSqlSession

DefaultSqlSession 是单独使用 MyBatis 进行开发时，最常用的 SqISession 接口实现。其实现了 SqISession 接口中定义的方法，及各方法的重载。select()系列方法、selectOne()系列方法、selectList()系列方法、selectMap()系列方法之间的调用关系如下图，殊途同归，它们最终都会调用 Executor 的 query()方法。

avatar

上述重载方法最终都是通过调用 Executor 的 query(MappedStatement, Object, RowBounds,ResultHandler)方法实现数据库查询操作的，但各自对结果对象进行了相应的调整，例如：selectOne()方法是从结果对象集合中获取了第一个元素返回；selectMap()方法会将 List 类型的结果集 转换成 Map 类型集合返回；select()方法是将结果集交由用户指定的 ResultHandler 对象处理，且没有返回值；selectList()方法则是直接返回结果对象集合。 DefaultSqlSession 的 insert()方法、update()方法、delete()方法也有多个重载，它们最后都是通过调用 DefaultSqlSession 的 update(String, Object)方法实现的，该重载首先会将 dirty 字段置为 true，然后再通过 Executor 的 update()方法完成数据库修改操作。 DefaultSqlSession 的 commit()方法、rollback()方法以及 close()方法都会调用 Executor 中相应的方法，其中就会涉及清空缓存的操作，之后就会将 dirty 字段设置为 false。 上述的 dirty 字段主要在 isCommitOrRollbackRequired()方法中，与 autoCommit 字段以及用户传入的 force 参数共同决定是否提交/回滚事务。该方法的返回值将作为 Executor 的 commit()方法和 rollback()方法的参数。

  1.   private boolean isCommitOrRollbackRequired(boolean force) {
  2.     return (!autoCommit && dirty) || force;
  3.   }

2 SqlSessionFactory

SqlSessionFactory 负责创建 SqlSession 对象，其中包含了多个 openSession()方法的重载，可以通过其参数指定事务的隔离级别、底层使用 Executor 的类型、以及是否自动提交事务等方面的配置。

  1. public interface SqlSessionFactory {
  3.   // 提供了openSession()方法的多种重载，根据相应的参数 可以指定事务的隔离级别、
  4.   // 底层使用的Executor类型、以及是否自动提交事务等配置
  5.   SqlSession openSession();
  6.   SqlSession openSession(boolean autoCommit);
  7.   SqlSession openSession(Connection connection);
  8.   SqlSession openSession(TransactionIsolationLevel level);
  9.   SqlSession openSession(ExecutorType execType);
  10.   SqlSession openSession(ExecutorType execType, boolean autoCommit);
  11.   SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
  12.   SqlSession openSession(ExecutorType execType, Connection connection);
  14.   Configuration getConfiguration();
  15. }

2.1 DefaultSqlSessionFactory

DefaultSqlSessionFactory 是 SqlSessionFactory 接口的默认实现，主要提供了两种创建 DefaultSqlSession 对象的方式，一种方式是通过数据源获取数据库连接，并创建 Executor 对象以及 DefaultSqlSession 对象；另一种方式是用户提供数据库连接对象，DefaultSqlSessionFactory 根据该数据库连接对象获取 autoCommit 属性，创建 Executor 对象以及 DefaultSqlSession 对象。

DefaultSqISessionFactory 提供的所有 openSession()方法重载都是基于上述两种方式创建 DefaultSqlSession 对象的。

  1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  3.   private final Configuration configuration;
  5.   public DefaultSqlSessionFactory(Configuration configuration) {
  6.     this.configuration = configuration;
  7.   }
  9.   private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  10.     Transaction tx = null;
  11.     try {
  12.       // 获取配置的Environment对象
  13.       final Environment environment = configuration.getEnvironment();
  14.       // 从environment中获取TransactionFactory对象，如果没有，就创建一个ManagedTransactionFactory实例并返回
  15.       final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
  16.       // 从事务工厂中获取一个事务对象
  17.       tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
  18.       // 根据事务对象tx和配置的Executor类型execType创建Executor实例
  19.       // ExecutorType是个枚举类型，有三个值 SIMPLE, REUSE, BATCH，分别对应了
  20.       // SimpleExecutor、ReuseExecutor、BatchExecutor
  21.       final Executor executor = configuration.newExecutor(tx, execType);
  22.       // 创建DefaultSqlSession对象
  23.       return new DefaultSqlSession(configuration, executor, autoCommit);
  24.     } catch (Exception e) {
  25.       closeTransaction(tx); // may have fetched a connection so lets call close()
  26.       throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  27.     } finally {
  28.       ErrorContext.instance().reset();
  29.     }
  30.   }
  32.   private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
  33.     try {
  34.       boolean autoCommit;
  35.       try {
  36.         // 根据当前连接对象获取autoCommit属性（是否自动提交事务）
  37.         autoCommit = connection.getAutoCommit();
  38.       } catch (SQLException e) {
  39.         autoCommit = true;
  40.       }
  41.       // 除了获取autoCommit属性的方式和上面不一样外，下面的处理都与上面完全相同
  42.       final Environment environment = configuration.getEnvironment();
  43.       final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
  44.       final Transaction tx = transactionFactory.newTransaction(connection);
  45.       final Executor executor = configuration.newExecutor(tx, execType);
  46.       return new DefaultSqlSession(configuration, executor, autoCommit);
  47.     } catch (Exception e) {
  48.       throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  49.     } finally {
  50.       ErrorContext.instance().reset();
  51.     }
  52.   }
  54.   private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
  55.     if (environment == null || environment.getTransactionFactory() == null) {
  56.       return new ManagedTransactionFactory();
  57.     }
  58.     return environment.getTransactionFactory();
  59.   }
  61.   private void closeTransaction(Transaction tx) {
  62.     if (tx != null) {
  63.       try {
  64.         tx.close();
  65.       } catch (SQLException ignore) {
  66.         // Intentionally ignore. Prefer previous error.
  67.       }
  68.     }
  69.   }
  71.   @Override
  72.   public SqlSession openSession() {
  73.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  74.   }
  76.   @Override
  77.   public SqlSession openSession(boolean autoCommit) {
  78.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
  79.   }
  81.   @Override
  82.   public SqlSession openSession(ExecutorType execType) {
  83.     return openSessionFromDataSource(execType, null, false);
  84.   }
  86.   @Override
  87.   public SqlSession openSession(TransactionIsolationLevel level) {
  88.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
  89.   }
  91.   @Override
  92.   public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
  93.     return openSessionFromDataSource(execType, level, false);
  94.   }
  96.   @Override
  97.   public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
  98.     return openSessionFromDataSource(execType, null, autoCommit);
  99.   }
  101.   @Override
  102.   public SqlSession openSession(Connection connection) {
  103.     return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
  104.   }
  106.   @Override
  107.   public SqlSession openSession(ExecutorType execType, Connection connection) {
  108.     return openSessionFromConnection(execType, connection);
  109.   }
  111.   @Override
  112.   public Configuration getConfiguration() {
  113.     return configuration;
  114.   }
  115. }

2.2 SqlSessionManager

SqlSessionManager 同时实现了 SqlSession 接口和 SqlSessionFactory 接口，所以同时提供了 SqlSessionFactory 创建 SqlSession 对象，以及 SqlSession 操纵数据库的功能。

SqlSessionManager 与 DefaultSqlSessionFactory 的主要不同点 SqlSessionManager 提供了两种模式，第一种模式与 DefaultSqlSessionFactory 的行为相同，同一线程每次通过 SqlSessionManager 对象访问数据库时，都会创建新的 SqlSession 对象完成数据库操作。第二种模式是 SqlSessionManager 通过 localSqlSession 这 ThreadLocal 变量，记录与当前线程绑定的 SqlSession 对象，供当前线程循环使用，从而避免在同一线程多次创建 SqlSession 对象带来的性能损失。

SqlSessionManager 的构造方法是唯一且私有的，如果要创建 SqlSessionManager 对象，需要调用其 newInstance()方法（但需要注意的是，这不是单例模式，因为每次调用 newInstance()方法都返回了一个新的对象）。

SqlSessionManager 的 openSession()系列方法，都是通过直接调用其持有的 DefaultSqlSessionFactory 实例来实现的。

  1. public class SqlSessionManager implements SqlSessionFactory, SqlSession {
  3.   // 通过持有DefaultSqlSessionFactory对象 来产生SqlSession对象
  4.   private final SqlSessionFactory sqlSessionFactory;
  6.   // 用于记录一个与当前线程绑定的SqlSession对象
  7.   private final ThreadLocal<SqlSession> localSqlSession = new ThreadLocal<SqlSession>();
  9.   // localSqlSession中记录的SqlSession对象的代理对象（JDK动态代理）
  10.   // SqlSessionManager初始化时 生成本代理对象，可以看下 下面的构造函数
  11.   private final SqlSession sqlSessionProxy;
  13.   // 私有的构造函数，也是SqlSessionManager唯一的构造函数
  14.   private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
  15.     // 传入的这个SqlSessionFactory对象 往往是DefaultSqlSessionFactory的实例
  16.     this.sqlSessionFactory = sqlSessionFactory;
  17.     // JDK动态代理生成代理对象，可以看得出，SqlSessionInterceptor一定实现了
  18.     // InvocationHandler接口
  19.     this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
  20.         SqlSessionFactory.class.getClassLoader(),
  21.         new Class[]{SqlSession.class},
  22.         new SqlSessionInterceptor());
  23.   }
  25.   // 通过newInstance()方法创建SqlSessionManager对象，有多种重载，
  26.   // 但最后都是new了一个DefaultSqlSessionFactory的实例
  27.   public static SqlSessionManager newInstance(Reader reader) {
  28.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, null));
  29.   }
  31.   public static SqlSessionManager newInstance(Reader reader, String environment) {
  32.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, environment, null));
  33.   }
  35.   public static SqlSessionManager newInstance(Reader reader, Properties properties) {
  36.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, properties));
  37.   }
  39.   public static SqlSessionManager newInstance(InputStream inputStream) {
  40.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, null, null));
  41.   }
  43.   public static SqlSessionManager newInstance(InputStream inputStream, String environment) {
  44.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, environment, null));
  45.   }
  47.   public static SqlSessionManager newInstance(InputStream inputStream, Properties properties) {
  48.     return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, null, properties));
  49.   }
  51.   public static SqlSessionManager newInstance(SqlSessionFactory sqlSessionFactory) {
  52.     return new SqlSessionManager(sqlSessionFactory);
  53.   }
  55.   // openSession()系列方法都是通过当前SqlSessionManager对象持有的
  56.   // DefaultSqlSessionFactory实例的openSession()实现的
  57.   @Override
  58.   public SqlSession openSession() {
  59.     return sqlSessionFactory.openSession();
  60.   }
  62.   @Override
  63.   public SqlSession openSession(boolean autoCommit) {
  64.     return sqlSessionFactory.openSession(autoCommit);
  65.   }
  67.   @Override
  68.   public SqlSession openSession(Connection connection) {
  69.     return sqlSessionFactory.openSession(connection);
  70.   }
  72.   @Override
  73.   public SqlSession openSession(TransactionIsolationLevel level) {
  74.     return sqlSessionFactory.openSession(level);
  75.   }
  77.   @Override
  78.   public SqlSession openSession(ExecutorType execType) {
  79.     return sqlSessionFactory.openSession(execType);
  80.   }
  82.   @Override
  83.   public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
  84.     return sqlSessionFactory.openSession(execType, autoCommit);
  85.   }
  87.   @Override
  88.   public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
  89.     return sqlSessionFactory.openSession(execType, level);
  90.   }
  92.   @Override
  93.   public SqlSession openSession(ExecutorType execType, Connection connection) {
  94.     return sqlSessionFactory.openSession(execType, connection);
  95.   }
  96. }

SqlSessionManager 中实现的 SqlSession 接口方法，例如 select ()系列方法、update()系列方法等，都是直接调用 sqlSessionProxy 代理对象对应的方法实现的。在创建该代理对象时使用的 InvocationHandler 对象是 SqlSessionlnterceptor，它是 SqISessionManager 的内部类。

  1.   private class SqlSessionInterceptor implements InvocationHandler {
  3.     public SqlSessionInterceptor() { }
  5.     @Override
  6.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  7.       // 获取 与当前线程绑定的SqlSession
  8.       final SqlSession sqlSession = SqlSessionManager.this.localSqlSession.get();
  9.       // 如果有绑定的SqlSession对象
  10.       if (sqlSession != null) { // 模式二
  11.         try {
  12.           // 调用真正的sqlSession对象，完成数据库操作
  13.           return method.invoke(sqlSession, args);
  14.         } catch (Throwable t) {
  15.           throw ExceptionUtil.unwrapThrowable(t);
  16.         }
  17.       // 如果没有绑定的SqlSession对象
  18.       } else { // 模式一
  19.         // 创建一个新的SqlSession对象
  20.         final SqlSession autoSqlSession = openSession();
  21.         try {
  22.           // 通过反射调用该SqlSession对象的方法，完成数据库操作
  23.           final Object result = method.invoke(autoSqlSession, args);
  24.           // 提交事务
  25.           autoSqlSession.commit();
  26.           return result;
  27.         } catch (Throwable t) {
  28.           // 出异常就回滚
  29.           autoSqlSession.rollback();
  30.           throw ExceptionUtil.unwrapThrowable(t);
  31.         } finally {
  32.           // 关闭该SqlSession对象
  33.           autoSqlSession.close();
  34.         }
  35.       }
  36.     }
  37.   }

通过对 SqlSessionlnterceptor 的分析可知，第一种模式中新建的 SqlSession 在使用完成后会立即关闭。在第二种模式中，与当前线程绑定的 SqISession 对象需要先通过 SqlSessionManager 的 startManagedSession()方法进行设置，此方法也存在多种重载，但都彼此相似 且简单。

  1.   public void startManagedSession() {
  2.     this.localSqlSession.set(openSession());
  3.   }
  5.   public void startManagedSession(boolean autoCommit) {
  6.     this.localSqlSession.set(openSession(autoCommit));
  7.   }
  9.   public void startManagedSession(Connection connection) {
  10.     this.localSqlSession.set(openSession(connection));
  11.   }
  13.   public void startManagedSession(TransactionIsolationLevel level) {
  14.     this.localSqlSession.set(openSession(level));
  15.   }
  17.   public void startManagedSession(ExecutorType execType) {
  18.     this.localSqlSession.set(openSession(execType));
  19.   }
  21.   public void startManagedSession(ExecutorType execType, boolean autoCommit) {
  22.     this.localSqlSession.set(openSession(execType, autoCommit));
  23.   }
  25.   public void startManagedSession(ExecutorType execType, TransactionIsolationLevel level) {
  26.     this.localSqlSession.set(openSession(execType, level));
  27.   }
  29.   public void startManagedSession(ExecutorType execType, Connection connection) {
  30.     this.localSqlSession.set(openSession(execType, connection));
  31.   }
  33.   public boolean isManagedSessionStarted() {
  34.     return this.localSqlSession.get() != null;
  35.   }

当需要提交/回滚事务，或关闭 IocalSqlSession 中记录的 SqlSession 对象时，需要通过 SqlSessionManager 的 commit()、rollback()以及 close()方法完成，其中会先检测当前线程是否绑定了 SqlSession 对象，如果未绑定则抛出异常，如果绑定了则调用该 SqlSession 对象的相应方法。

  1.   @Override
  2.   public void clearCache() {
  3.     final SqlSession sqlSession = localSqlSession.get();
  4.     if (sqlSession == null) {
  5.       throw new SqlSessionException("Error:  Cannot clear the cache.  No managed session is started.");
  6.     }
  7.     sqlSession.clearCache();
  8.   }
  10.   @Override
  11.   public void commit() {
  12.     final SqlSession sqlSession = localSqlSession.get();
  13.     if (sqlSession == null) {
  14.       throw new SqlSessionException("Error:  Cannot commit.  No managed session is started.");
  15.     }
  16.     sqlSession.commit();
  17.   }
  19.   @Override
  20.   public void commit(boolean force) {
  21.     final SqlSession sqlSession = localSqlSession.get();
  22.     if (sqlSession == null) {
  23.       throw new SqlSessionException("Error:  Cannot commit.  No managed session is started.");
  24.     }
  25.     sqlSession.commit(force);
  26.   }
  28.   @Override
  29.   public void rollback() {
  30.     final SqlSession sqlSession = localSqlSession.get();
  31.     if (sqlSession == null) {
  32.       throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
  33.     }
  34.     sqlSession.rollback();
  35.   }
  37.   @Override
  38.   public void rollback(boolean force) {
  39.     final SqlSession sqlSession = localSqlSession.get();
  40.     if (sqlSession == null) {
  41.       throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
  42.     }
  43.     sqlSession.rollback(force);
  44.   }
  46.   @Override
  47.   public List<BatchResult> flushStatements() {
  48.     final SqlSession sqlSession = localSqlSession.get();
  49.     if (sqlSession == null) {
  50.       throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
  51.     }
  52.     return sqlSession.flushStatements();
  53.   }
  55.   @Override
  56.   public void close() {
  57.     final SqlSession sqlSession = localSqlSession.get();
  58.     if (sqlSession == null) {
  59.       throw new SqlSessionException("Error:  Cannot close.  No managed session is started.");
  60.     }
  61.     try {
  62.       sqlSession.close();
  63.     } finally {
  64.       localSqlSession.set(null);
  65.     }
  66.   }