mybatis接口层与SqlSession系列，源码解析

5 years ago · 990d1b4697
parent d22f141c96
commit 990d1b4697
1 changed files with 489 additions and 0 deletions
--- a/docs/Mybatis/核心处理层/6、接口层及SqlSession系列.md
+++ b/docs/Mybatis/核心处理层/6、接口层及SqlSession系列.md
@ -0,0 +1,489 @@
+SqlSession是MyBatis核心接口之一，也是MyBatis接口层的主要组成部分，对外提供MyBatis常用的API。mybatis提供了两个SqlSession接口的实现，分别为DefaultSqlSession、SqlSessionManager，其中最常用的是DefaultSqlSession。另外，跟前面分析过的源码mybatis的源码一样，mybatis也为SqlSession提供了相应的工厂接口SqlSessionFactory，及实现该接口的实现DefaultSqlSessionFactory（SqlSessionManager同时实现了SqlSession和SqlSessionFactory接口）。
+## 1 SqlSession
+在SqlSession中定义了常用的数据库操作以及事务的相关操作，为了方便用户使用，每种类型的操作都提供了多种重载。
+```java
+public interface SqlSession extends Closeable {
+  // 泛型方法，参数是要执行查询的sql语句，返回值为查询的结果对象
+  <T> T selectOne(String statement);
+
+  // 第二个参数表示 需要用户传入的实参，即 sql语句绑定的实参
+  <T> T selectOne(String statement, Object parameter);
+
+  // 查询结果有多条记录，会封装成 结果对象列表 并返回
+  <E> List<E> selectList(String statement);
+
+  // 参数 + 多记录结果集
+  <E> List<E> selectList(String statement, Object parameter);
+
+  // 参数RowBounds主要用于逻辑分页，逻辑分页会将所有的结果都查询到，
+  // 然后根据RowBounds中提供的offset和limit值来获取最后的结果
+  <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
+
+  // mapKey表示将结果集中的哪一列（如 主键列或编码列）作为Map的key，
+  // value则为列值 对应的那条记录
+  <K, V> Map<K, V> selectMap(String statement, String mapKey);
+
+  // 多了个parameter参数，其它与上面相同
+  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
+
+  // 多了个RowBounds参数，其它与上面相同
+  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
+
+  // 除了返回值是Cursor对象，其它与selectList相同
+  <T> Cursor<T> selectCursor(String statement);
+  <T> Cursor<T> selectCursor(String statement, Object parameter);
+  <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
+
+  // 查询出的结果集 将由传入的ResultHandler对象处理，其它与selectList相同
+  void select(String statement, Object parameter, ResultHandler handler);
+  void select(String statement, ResultHandler handler);
+  void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
+
+  // 执行insert语句
+  int insert(String statement);
+  int insert(String statement, Object parameter);
+
+  // 执行update语句
+  int update(String statement);
+  int update(String statement, Object parameter);
+
+  // 执行delete语句
+  int delete(String statement);
+  int delete(String statement, Object parameter);
+
+  // 提交事务
+  void commit();
+  void commit(boolean force);
+
+  // 回滚事务
+  void rollback();
+  void rollback(boolean force);
+
+  // 将对数据库的操作请求 刷到数据库
+  List<BatchResult> flushStatements();
+
+  // 关闭当前session
+  void close();
+
+  // 清空缓存
+  void clearCache();
+
+  // 获取Configuration对象
+  Configuration getConfiguration();
+
+  // 获取type对应的Mapper对象
+  <T> T getMapper(Class<T> type);
+
+  // 获取该SqlSession对应的数据库连接
+  Connection getConnection();
+}
+```
+### 1.1 DefaultSqlSession
+DefaultSqlSession是单独使用MyBatis进行开发时，最常用的SqISession接口实现。其实现了SqISession接口中定义的方法，及各方法的重载。select()系列方法、selectOne()系列方法、selectList()系列方法、selectMap()系列方法之间的调用关系如下图，殊途同归，它们最终都会调用Executor的query()方法。
+
+![avatar](/images/mybatis/DefaultSqlSession方法调用栈.png)
+
+上述重载方法最终都是通过调用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()方法的参数。
+```java
+  private boolean isCommitOrRollbackRequired(boolean force) {
+    return (!autoCommit && dirty) || force;
+  }
+```
+
+## 2 SqlSessionFactory 
+SqlSessionFactory负责创建SqlSession对象，其中包含了多个openSession()方法的重载，可以通过其参数指定事务的隔离级别、底层使用Executor的类型、以及是否自动提交事务等方面的配置。
+```java
+public interface SqlSessionFactory {
+
+  // 提供了openSession()方法的多种重载，根据相应的参数 可以指定事务的隔离级别、
+  // 底层使用的Executor类型、以及是否自动提交事务等配置
+  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();
+}
+```
+### 2.1 DefaultSqlSessionFactory
+DefaultSqlSessionFactory是SqlSessionFactory接口的默认实现，主要提供了两种创建DefaultSqlSession对象的方式，一种方式是通过数据源获取数据库连接，并创建Executor对象以及DefaultSqlSession对象；另一种方式是用户提供数据库连接对象，DefaultSqlSessionFactory根据该数据库连接对象获取autoCommit属性，创建Executor对象以及DefaultSqlSession对象。
+
+DefaultSqISessionFactory提供的所有openSession()方法重载都是基于上述两种方式创建DefaultSqlSession对象的。
+```java
+public class DefaultSqlSessionFactory implements SqlSessionFactory {
+
+  private final Configuration configuration;
+
+  public DefaultSqlSessionFactory(Configuration configuration) {
+    this.configuration = configuration;
+  }
+
+  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
+    Transaction tx = null;
+    try {
+      // 获取配置的Environment对象
+      final Environment environment = configuration.getEnvironment();
+      // 从environment中获取TransactionFactory对象，如果没有，就创建一个ManagedTransactionFactory实例并返回
+      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
+      // 从事务工厂中获取一个事务对象
+      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
+      // 根据事务对象tx和配置的Executor类型execType创建Executor实例
+      // ExecutorType是个枚举类型，有三个值 SIMPLE, REUSE, BATCH，分别对应了
+      // SimpleExecutor、ReuseExecutor、BatchExecutor
+      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()
+      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
+    } finally {
+      ErrorContext.instance().reset();
+    }
+  }
+
+  private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
+    try {
+      boolean autoCommit;
+      try {
+        // 根据当前连接对象获取autoCommit属性（是否自动提交事务）
+        autoCommit = connection.getAutoCommit();
+      } catch (SQLException e) {
+        autoCommit = true;
+      }
+      // 除了获取autoCommit属性的方式和上面不一样外，下面的处理都与上面完全相同
+      final Environment environment = configuration.getEnvironment();
+      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
+      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();
+    }
+  }
+
+  private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
+    if (environment == null || environment.getTransactionFactory() == null) {
+      return new ManagedTransactionFactory();
+    }
+    return environment.getTransactionFactory();
+  }
+
+  private void closeTransaction(Transaction tx) {
+    if (tx != null) {
+      try {
+        tx.close();
+      } catch (SQLException ignore) {
+        // Intentionally ignore. Prefer previous error.
+      }
+    }
+  }
+
+  @Override
+  public SqlSession openSession() {
+    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
+  }
+
+  @Override
+  public SqlSession openSession(boolean autoCommit) {
+    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType) {
+    return openSessionFromDataSource(execType, null, false);
+  }
+
+  @Override
+  public SqlSession openSession(TransactionIsolationLevel level) {
+    return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
+    return openSessionFromDataSource(execType, level, false);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
+    return openSessionFromDataSource(execType, null, autoCommit);
+  }
+
+  @Override
+  public SqlSession openSession(Connection connection) {
+    return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, Connection connection) {
+    return openSessionFromConnection(execType, connection);
+  }
+
+  @Override
+  public Configuration getConfiguration() {
+    return configuration;
+  }
+}
+```
+### 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实例来实现的。
+```java
+public class SqlSessionManager implements SqlSessionFactory, SqlSession {
+
+  // 通过持有DefaultSqlSessionFactory对象 来产生SqlSession对象
+  private final SqlSessionFactory sqlSessionFactory;
+
+  // 用于记录一个与当前线程绑定的SqlSession对象
+  private final ThreadLocal<SqlSession> localSqlSession = new ThreadLocal<SqlSession>();
+
+  // localSqlSession中记录的SqlSession对象的代理对象（JDK动态代理）
+  // SqlSessionManager初始化时 生成本代理对象，可以看下 下面的构造函数
+  private final SqlSession sqlSessionProxy;
+
+  // 私有的构造函数，也是SqlSessionManager唯一的构造函数
+  private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
+    // 传入的这个SqlSessionFactory对象 往往是DefaultSqlSessionFactory的实例
+    this.sqlSessionFactory = sqlSessionFactory;
+    // JDK动态代理生成代理对象，可以看得出，SqlSessionInterceptor一定实现了
+    // InvocationHandler接口
+    this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
+        SqlSessionFactory.class.getClassLoader(),
+        new Class[]{SqlSession.class},
+        new SqlSessionInterceptor());
+  }
+
+  // 通过newInstance()方法创建SqlSessionManager对象，有多种重载，
+  // 但最后都是new了一个DefaultSqlSessionFactory的实例
+  public static SqlSessionManager newInstance(Reader reader) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, null));
+  }
+
+  public static SqlSessionManager newInstance(Reader reader, String environment) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, environment, null));
+  }
+
+  public static SqlSessionManager newInstance(Reader reader, Properties properties) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, properties));
+  }
+
+  public static SqlSessionManager newInstance(InputStream inputStream) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, null, null));
+  }
+
+  public static SqlSessionManager newInstance(InputStream inputStream, String environment) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, environment, null));
+  }
+
+  public static SqlSessionManager newInstance(InputStream inputStream, Properties properties) {
+    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(inputStream, null, properties));
+  }
+
+  public static SqlSessionManager newInstance(SqlSessionFactory sqlSessionFactory) {
+    return new SqlSessionManager(sqlSessionFactory);
+  }
+
+  // openSession()系列方法都是通过当前SqlSessionManager对象持有的
+  // DefaultSqlSessionFactory实例的openSession()实现的
+  @Override
+  public SqlSession openSession() {
+    return sqlSessionFactory.openSession();
+  }
+
+  @Override
+  public SqlSession openSession(boolean autoCommit) {
+    return sqlSessionFactory.openSession(autoCommit);
+  }
+
+  @Override
+  public SqlSession openSession(Connection connection) {
+    return sqlSessionFactory.openSession(connection);
+  }
+
+  @Override
+  public SqlSession openSession(TransactionIsolationLevel level) {
+    return sqlSessionFactory.openSession(level);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType) {
+    return sqlSessionFactory.openSession(execType);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
+    return sqlSessionFactory.openSession(execType, autoCommit);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
+    return sqlSessionFactory.openSession(execType, level);
+  }
+
+  @Override
+  public SqlSession openSession(ExecutorType execType, Connection connection) {
+    return sqlSessionFactory.openSession(execType, connection);
+  }
+}
+```
+SqlSessionManager中实现的SqlSession接口方法，例如select ()系列方法、update()系列方法等，都是直接调用sqlSessionProxy代理对象对应的方法实现的。在创建该代理对象时使用的InvocationHandler对象是SqlSessionlnterceptor，它是SqISessionManager的内部类。
+```java
+  private class SqlSessionInterceptor implements InvocationHandler {
+
+    public SqlSessionInterceptor() { }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      // 获取 与当前线程绑定的SqlSession
+      final SqlSession sqlSession = SqlSessionManager.this.localSqlSession.get();
+      // 如果有绑定的SqlSession对象
+      if (sqlSession != null) { // 模式二
+        try {
+          // 调用真正的sqlSession对象，完成数据库操作
+          return method.invoke(sqlSession, args);
+        } catch (Throwable t) {
+          throw ExceptionUtil.unwrapThrowable(t);
+        }
+      // 如果没有绑定的SqlSession对象
+      } else { // 模式一
+        // 创建一个新的SqlSession对象
+        final SqlSession autoSqlSession = openSession();
+        try {
+          // 通过反射调用该SqlSession对象的方法，完成数据库操作
+          final Object result = method.invoke(autoSqlSession, args);
+          // 提交事务
+          autoSqlSession.commit();
+          return result;
+        } catch (Throwable t) {
+          // 出异常就回滚
+          autoSqlSession.rollback();
+          throw ExceptionUtil.unwrapThrowable(t);
+        } finally {
+          // 关闭该SqlSession对象
+          autoSqlSession.close();
+        }
+      }
+    }
+  }
+```
+通过对SqlSessionlnterceptor的分析可知，第一种模式中新建的SqlSession在使用完成后会立即关闭。在第二种模式中，与当前线程绑定的SqISession对象需要先通过SqlSessionManager的startManagedSession()方法进行设置，此方法也存在多种重载，但都彼此相似 且简单。
+```java
+  public void startManagedSession() { 
+    this.localSqlSession.set(openSession()); 
+  }
+
+  public void startManagedSession(boolean autoCommit) {
+    this.localSqlSession.set(openSession(autoCommit));
+  }
+
+  public void startManagedSession(Connection connection) {
+    this.localSqlSession.set(openSession(connection));
+  }
+
+  public void startManagedSession(TransactionIsolationLevel level) {
+    this.localSqlSession.set(openSession(level));
+  }
+
+  public void startManagedSession(ExecutorType execType) {
+    this.localSqlSession.set(openSession(execType));
+  }
+
+  public void startManagedSession(ExecutorType execType, boolean autoCommit) {
+    this.localSqlSession.set(openSession(execType, autoCommit));
+  }
+
+  public void startManagedSession(ExecutorType execType, TransactionIsolationLevel level) {
+    this.localSqlSession.set(openSession(execType, level));
+  }
+
+  public void startManagedSession(ExecutorType execType, Connection connection) {
+    this.localSqlSession.set(openSession(execType, connection));
+  }
+
+  public boolean isManagedSessionStarted() {
+    return this.localSqlSession.get() != null;
+  }
+```
+当需要提交/回滚事务，或关闭IocalSqlSession中记录的SqlSession对象时，需要通过SqlSessionManager的commit()、rollback()以及close()方法完成，其中会先检测当前线程是否绑定了SqlSession对象，如果未绑定则抛出异常，如果绑定了则调用该SqlSession对象的相应方法。
+```java
+  @Override
+  public void clearCache() {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot clear the cache.  No managed session is started.");
+    }
+    sqlSession.clearCache();
+  }
+
+  @Override
+  public void commit() {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot commit.  No managed session is started.");
+    }
+    sqlSession.commit();
+  }
+
+  @Override
+  public void commit(boolean force) {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot commit.  No managed session is started.");
+    }
+    sqlSession.commit(force);
+  }
+
+  @Override
+  public void rollback() {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
+    }
+    sqlSession.rollback();
+  }
+
+  @Override
+  public void rollback(boolean force) {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
+    }
+    sqlSession.rollback(force);
+  }
+
+  @Override
+  public List<BatchResult> flushStatements() {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot rollback.  No managed session is started.");
+    }
+    return sqlSession.flushStatements();
+  }
+
+  @Override
+  public void close() {
+    final SqlSession sqlSession = localSqlSession.get();
+    if (sqlSession == null) {
+      throw new SqlSessionException("Error:  Cannot close.  No managed session is started.");
+    }
+    try {
+      sqlSession.close();
+    } finally {
+      localSqlSession.set(null);
+    }
+  }
+```