一、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等分布式缓存可能成本更低，安全性也更高。