Mybatis 中sqlsession源码解析

Posted 2021-01-19 kma

一、sqlsession获取过程

1、基础配置

　　在mybatis框架下进行的数据库操作都需要首先获取sqlsession，在mybatis与spring集成后获取sqlsession需要用到sqlsessionTemplate这个类。

首先在spring对sqlsessionTemplate进行配置，使用到的是 org.mybatis.spring.SqlSessionTemplate 这个类。

<!-- SqlSession实例 -->
<bean id="sessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"
        destroy-method="close">
<!--当构造函数有多个参数时，可以使用constructor-arg标签的index属性，index属性的值从0开始，这里将sqlsessionFactory作为第一个参数传入--> 
<constructor-arg index="0" ref="sqlSessionFactory" /> 
</bean>

<!-- 将数据源映射到sqlSessionFactory中 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
    <property name="dataSource" ref="dataSource" />
</bean>

所以在sqlsessionTemplate的初始化过程中，首先会将sqlsessionFactory作为参数传入，sqlsessionFactory中映射了数据源信息。

配置事务，在后来的sqlsession获取过程中会对事务进行判断

<!--======= 事务配置 Begin ================= -->
<!-- 事务管理器（由Spring管理MyBatis的事务） -->
<bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 关联数据源 -->
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />
<!--======= 事务配置 End =================== -->

2、sqlsessionTemplate的初始化

public class SqlSessionTemplate implements SqlSession {
    private final SqlSessionFactory sqlSessionFactory;
    private final ExecutorType executorType;
    private final SqlSession sqlSessionProxy;
    private final PersistenceExceptionTranslator exceptionTranslator;

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
    }

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
        this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
    }

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
        Assert.notNull(sqlSessionFactory, "Property \'sqlSessionFactory\' is required");
        Assert.notNull(executorType, "Property \'executorType\' is required");
        this.sqlSessionFactory = sqlSessionFactory;
        this.executorType = executorType;
        this.exceptionTranslator = exceptionTranslator;
        this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
    }

　　SqlsessionTemplate类的最开始初始化过程中，首先会通过sqlsessionFactory参数进行构造，通过Proxy.newProxyInstance()方法来创建代理类，表示创建SqlSessionFactory的代理类的实例，该代理类实现SqlSession接口，定义了方法拦截器，如果调用代理类实例中实现SqlSession接口定义的方法，该调用则被导向SqlsessionTemplate的一个内部类SqlSessionInterceptor的invoke方法，最终初始化sqlsessionProxy。

3、sqlsession的调用过程

由于上面两个过程中已经将sqlsessionTemplate中的sqlsessionProxy已经初始化完毕，所以在代码中可以进行调用。调用最终都会进入SqlSessionInterceptor的invoke方法。

private class SqlSessionInterceptor implements InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      //获取SqlSession(这个SqlSession才是真正使用的，它不是线程安全的)
      //这个方法可以根据Spring的事物上下文来获取事物范围内的sqlSession
      final SqlSession sqlSession = SqlSessionUtils.getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        //调用真实SqlSession的方法
        Object result = method.invoke(sqlSession, args);
        //然后判断一下当前的sqlSession是否有配置Spring事务 如果没有自动commit
        if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        //返回执行结果
        return result;
      } catch (Throwable t) {
        //如果出现异常则根据情况转换后抛出
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        //关闭sqlSession
        //它会根据当前的sqlSession是否在Spring的事务上下文当中来执行具体的关闭动作
        //如果sqlSession被Spring事务管理 则调用holder.released(); 使计数器-1
        //否则才真正的关闭sqlSession
        SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
      }
    }
  }

在上面的代码中用到两个很关键的方法：

　　获取sqlsession方法：SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

　　关闭sqlsession方法：SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {     
    //根据sqlSessionFactory从当前线程对应的资源map中获取SqlSessionHolder，当sqlSessionFactory创建了sqlSession，就会在事务管理器中添加一对映射：key为sqlSessionFactory，value为SqlSessionHolder，该类保存sqlSession及执行方式 
    SqlSessionHolder holder = (SqlSessionHolder) getResource(sessionFactory); 
 //如果holder不为空，且和当前事务同步 
    if (holder != null && holder.isSynchronizedWithTransaction()) { 
      //hodler保存的执行类型和获取SqlSession的执行类型不一致，就会抛出异常，也就是说在同一个事务中，执行类型不能变化，原因就是同一个事务中同一个sqlSessionFactory创建的sqlSession会被重用 
      if (holder.getExecutorType() != executorType) { 
        throw new TransientDataAccessResourceException("Cannot change the ExecutorType when there is an existing transaction"); 
      } 
      //增加该holder,也就是同一事务中同一个sqlSessionFactory创建的唯一sqlSession，其引用数增加，被使用的次数增加 
      holder.requested(); 
   //返回sqlSession 
      return holder.getSqlSession(); 
    } 
 //如果找不到，则根据执行类型构造一个新的sqlSession 
    SqlSession session = sessionFactory.openSession(executorType); 
 //判断同步是否激活，只要SpringTX被激活，就是true 
    if (isSynchronizationActive()) { 
   //加载环境变量，判断注册的事务管理器是否是SpringManagedTransaction，也就是Spring管理事务 
      Environment environment = sessionFactory.getConfiguration().getEnvironment(); 
      if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) { 
  //如果是，则将sqlSession加载进事务管理的本地线程缓存中 
        holder = new SqlSessionHolder(session, executorType, exceptionTranslator); 
  //以sessionFactory为key，hodler为value，加入到TransactionSynchronizationManager管理的本地缓存ThreadLocal<Map<Object, Object>> resources中 
        bindResource(sessionFactory, holder); 
  //将holder, sessionFactory的同步加入本地线程缓存中ThreadLocal<Set<TransactionSynchronization>> synchronizations 
        registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory)); 
        //设置当前holder和当前事务同步 
  holder.setSynchronizedWithTransaction(true); 
  //增加引用数 
        holder.requested(); 
      } else { 
        if (getResource(environment.getDataSource()) == null) { 
        } else { 
          throw new TransientDataAccessResourceException( 
              "SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization"); 
        } 
      } 
    } else { 
    } 
    return session; 
  }

public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) { 
 //其实下面就是判断session是否被Spring事务管理，如果管理就会得到holder  
    SqlSessionHolder holder = (SqlSessionHolder) getResource(sessionFactory); 
    if ((holder != null) && (holder.getSqlSession() == session)) { 
   //这里释放的作用，不是关闭，只是减少一下引用数，因为后面可能会被复用 
      holder.released(); 
    } else { 
   //如果不是被spring管理，那么就不会被Spring去关闭回收，就需要自己close 
      session.close(); 
    } 
  }

二、mybatis的缓存

1、一级缓存

　　Mybatis的一级缓存是默认开启的，主要是通过sqlsession来实现的，每个sqlsession对象会在本地创建一个缓存（local cache），对于每次查询都会在本地缓存中进行查询，如果命中则直接返回，如果没查到则进入到数据库中进行查找。一级缓存是sqlsession级别的。

　　从上面sqlsession的获取源码中可以看到，每次获取一个全新的sqlsession最终都是会保存在ThreadLocal中跟线程绑定，如果在spring中配置了事务则整个事务周期里面都共享一个sqlsession，如果没有配置事务则每次请求都是一个独立的sqlsession。每次执行完后数据库操作后，如果还在事务周期中只对sqlsession的引用次数减一，否则直接关闭sqlsession。

一级缓存执行的时序图：

 

小结：

MyBatis一级缓存的生命周期和SqlSession一致。
MyBatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺。
MyBatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为Statement。

2、二级缓存

在系统中如果需要使用二级缓存则直接在spring中进行配置声明即可。

<!-- 这个配置使全局的映射器启用或禁用 缓存 -->
<setting name="cacheEnabled" value="true" />
<!-- 开启二级缓存开关 -->
<cache/>

　　MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。
　　MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。
　　在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis,Memcached等分布式缓存可能成本更低，安全性也更高。