1. 技术文章
  2. SqlSessionTemplate探究

SqlSessionTemplate探究

由 久未见 提交于 2020-03-26 17:42:40

3 月，跳不动了？>>>

 问题就是：无论是多个dao使用一个SqlSessionTemplate，还是一个dao使用一个SqlSessionTemplate，SqlSessionTemplate都是对应一个sqlSession，当多个web线程调用同一个dao时，它们使用的是同一个SqlSessionTemplate，也就是同一个SqlSession，如何保证线程安全，关键就在于代理：

（1）首先，通过如下代码创建代理类，表示创建SqlSessionFactory的代理类的实例，该代理类实现SqlSession接口，定义了方法拦截器，如果调用代理类实例中实现SqlSession接口定义的方法，该调用则被导向SqlSessionInterceptor的invoke方法


  
  
  1. this.sqlSessionProxy = (SqlSession) newProxyInstance( 
    2. 
  
  
  
  
 
  
 
  
 
   
   
  2.         SqlSessionFactory.class.getClassLoader(), 
    3. 
  
  
  
  
 
  
 
  
 
   
   
  3.         new Class[] { SqlSession.class }, 
    4. 
  
  
  
  
 
  
 
  
 
   
   
  4.         new SqlSessionInterceptor()); 
    5.

（2）所以关键之处转移到invoke方法中，代码如下,该类的注释是代理将Mybatis的方法调用导向从Spring的事务管理器获取的合适的SqlSession，说明虽然都是调用同样一个SqlSession接口，但是实际执行sql的sqlSession会有所不同。


  
  
  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    2. 
  
  
  
  
 
  
 
  
 
   
   
  2.       //调用SqlSessionUtils的getSqlSession方法从Spring的事务管理器获取合适的SqlSession 
    3. 
  
  
  
  
 
  
 
  
 
   
   
  3.    final SqlSession sqlSession = getSqlSession( 
    4. 
  
  
  
  
 
  
 
  
 
   
   
  4.           SqlSessionTemplate.this.sqlSessionFactory, 
    5. 
  
  
  
  
 
  
 
  
 
   
   
  5.           SqlSessionTemplate.this.executorType, 
    6. 
  
  
  
  
 
  
 
  
 
   
   
  6.           SqlSessionTemplate.this.exceptionTranslator); 
    7. 
  
  
  
  
 
  
 
  
 
   
   
  7.       try { 
    8. 
  
  
  
  
 
  
 
  
 
   
   
  8.   //通过sqlSession对象调用该方法 
    9. 
  
  
  
  
 
  
 
  
 
   
   
  9.         Object result = method.invoke(sqlSession, args); 
    10. 
  
  
  
  
 
  
 
  
 
   
   
  10.         //判断sqlSession是否被Spring事务管理，也就是sqlSession被放在Spring事务管理的本地线程缓存中。如果不是，则需要自己提交。如果是，则Spring通过代理机制，进行提交和回滚 
    11. 
  
  
  
  
 
  
 
  
 
   
   
  11.         if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) { 
    12. 
  
  
  
  
 
  
 
  
 
   
   
  12.           // force commit even on non-dirty sessions because some databases require 
    13. 
  
  
  
  
 
  
 
  
 
   
   
  13.           // a commit/rollback before calling close() 
    14. 
  
  
  
  
 
  
 
  
 
   
   
  14.           sqlSession.commit(true); 
    15. 
  
  
  
  
 
  
 
  
 
   
   
  15.         } 
    16. 
  
  
  
  
 
  
 
  
 
   
   
  16.   //返回方法的调用结果 
    17. 
  
  
  
  
 
  
 
  
 
   
   
  17.         return result; 
    18. 
  
  
  
  
 
  
 
  
 
   
   
  18.       } catch (Throwable t) { 
    19. 
  
  
  
  
 
  
 
  
 
   
   
  19.   //如果出现异常，则利用异常转换器将Mybatis的异常转为Spring的DataAccessException 
    20. 
  
  
  
  
 
  
 
  
 
   
   
  20.         Throwable unwrapped = unwrapThrowable(t); 
    21. 
  
  
  
  
 
  
 
  
 
   
   
  21.         if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException)     { 
    22. 
  
  
  
  
 
  
 
  
 
   
   
  22.           Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped); 
    23. 
  
  
  
  
 
  
 
  
 
   
   
  23.           if (translated != null) { 
    24. 
  
  
  
  
 
  
 
  
 
   
   
  24.             unwrapped = translated; 
    25. 
  
  
  
  
 
  
 
  
 
   
   
  25.           } 
    26. 
  
  
  
  
 
  
 
  
 
   
   
  26.         } 
    27. 
  
  
  
  
 
  
 
  
 
   
   
  27.         throw unwrapped; 
    28. 
  
  
  
  
 
  
 
  
 
   
   
  28.       } finally { 
    29. 
  
  
  
  
 
  
 
  
 
   
   
  29.   //方法调用完毕后，关闭sqlSession连接 
    30. 
  
  
  
  
 
  
 
  
 
   
   
  30.         closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory); 
    31. 
  
  
  
  
 
  
 
  
 
   
   
  31.       } 
    32. 
  
  
  
  
 
  
 
  
 
   
   
  32.     } 
    33.

其中，核心有两部分：

（3）如何从Spring的事务管理器中获得合适的sqlSession，从而保证线程安全，很明显所有dao的多个线程不是使用同一个sqlSession，不然其中一个closeSqlSession，其他怎么用。

该方法的注释：从Spring事务管理器中得到一个SqlSession，如果需要创建一个新的。首先努力从当前事务之外得到一个SqlSession，如果没有就创造一个新的。然后，如果Spring TX被激活，也就是事务被打开，且事务管理器是SpringManagedTransactionFactory时，将得到的SqlSession同当前事务同步，下面是该函数的核心代码


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

上述代码中可以看出，只有在一个线程的一个事务中，由同一个sqlSessionFactory创建的执行类型相同的sqlSession才会被复用，其他情况下都是创建新的sqlSession。试想一下，即使只有一个SqlSessionTemplate供所有dao使用，所有地方使用的都是同以个sqlSessionFactory，但是由于是不同线程，所以得到的不是同一个sqlSession，因此不会出现线程安全问题。好处是同一个线程同一个事务中sqlSession会被复用，不会每执行一个sql请求，都创建一个SqlSession，这样很浪费资源，因为SqlSession相当于一次数据库连接。

（4）如何关闭sqlSession连接,主要代码如下


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

 

标签
spring事务管理
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!