Spring 实现你自己的事务同步

在《Spring Transaction 分析事务属性（事务的基本概念、配置）》基础上



将介绍如何实现你自己的事务同步，只要是活动的事务状态发生变化就会收到TransactionSynchronizationManager的回调。

书中的demo：
使用TransactionSynchronizationManager注册了TransactionSynchronization回调，同时MyTransactionSynchronizationAdapter会根据事务的完成状态去调用MySession.beginTransaction()、MySession.commit()或MySession.rollback()方法。

模拟一个session类:

 packagecn.partner4java.myptm;

 importjava.io.Serializable;

 /**
 * 模拟一个session类
 * @author partner4java
 *
 */
 publicclassMySession {
 /** 用来标识一个session */
 privateLong sessionId;

 publicvoidsave(Serializable entity){
 System.out.println(sessionId +":save");
 }

 publicvoidbeginTransaction(){
 System.out.println(sessionId +":beginTransaction");
 }

 publicvoidcommit(){
 System.out.println(sessionId +":commit");
 }

 publicvoidrollback(){
 System.out.println(sessionId +":rollback");
 }

 publicLong getSessionId() {
 returnsessionId;
 }

 publicvoidsetSessionId(Long sessionId) {
 this.sessionId = sessionId;
 }

 @Override
 publicString toString() {
 return"MySession [sessionId="+ sessionId +"]";
 }


 }

简单模拟SessionFactory：

 packagecn.partner4java.myptm;

 importorg.springframework.transaction.support.TransactionSynchronization;
 importorg.springframework.transaction.support.TransactionSynchronizationManager;


 /**
 * 简单模拟SessionFactory
 * 通判传递的类都为MySessionFactory而不是MySession，通过MySessionFactory获得当前线程的MySession或者开启一个新的MySession
 * @author partner4java
 *
 */
 publicclassMySessionFactory {

 /**
  * 如果当前线程存在MySession，就使用该MySession，否者开启一个新的MySession
  * @return
  */
 publicMySession getSession(){
 //传入this，是因为，我们以当前factory类作为键保存的MySession
 if(TransactionSynchronizationManager.hasResource(this)){
 returngetCurrentSession();
 }else{
 returnopenSession();
 }

 }


 /**
  * 开启一个新MySession
  * @return
  */
 privateMySession openSession() {
 MySession mySession =newMySession();
 mySession.setSessionId(System.currentTimeMillis());

 //注册进当前线程管理一个Synchronization
 TransactionSynchronization transactionSynchronization =newMyTransactionSynchronizationAdapter(this);
 TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);

 //绑定新开启的一个MySession进当前线程事务管理器
 TransactionSynchronizationManager.bindResource(this, mySession);

 returnmySession;
 }

 /**
  * 获取当前线程的MySession
  * @return
  */
 privateMySession getCurrentSession() {
 MySession mySession = (MySession) TransactionSynchronizationManager.getResource(this);
 returnmySession;
 }
 }

核心事务同步适配器：

 packagecn.partner4java.myptm;

 importorg.springframework.transaction.support.TransactionSynchronizationAdapter;
 importorg.springframework.transaction.support.TransactionSynchronizationManager;

 /**
 * 核心事务同步适配器
 * 当方法上面定义了@Transactional注解，那么当每次状态发生时就会调用本同步适配器
 * for transaction synchronization callbacks
 * @author partner4java
 *
 */
 publicclassMyTransactionSynchronizationAdapterextends
 TransactionSynchronizationAdapter {
 privateMySessionFactory mySessionFactory;

 publicMyTransactionSynchronizationAdapter(MySessionFactory mySessionFactory) {
 this.mySessionFactory = mySessionFactory;
 }


 @Override
 publicvoidbeforeCommit(booleanreadOnly) {
 //readOnly标识是否是一个只读线程
 if(!readOnly){
 MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
 mySession.beginTransaction();
 }
 }

 @Override
 publicvoidafterCompletion(intstatus) {
 MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
 if(STATUS_COMMITTED == status) {
 mySession.commit();
 }
 //当然，你还可以定义回滚方法
 }


 }

调用起的DAO：

 packagecn.partner4java.dao;

 publicinterfaceHelloDao {
 publicvoidsaveHello();
 }

 packagecn.partner4java.dao;

 importorg.springframework.jdbc.core.support.JdbcDaoSupport;
 importorg.springframework.transaction.annotation.Transactional;

 importcn.partner4java.myptm.MySessionFactory;

 /**
 * 一个hello world dao，起到模拟调用自定义事务同步的作用
 * @author partner4java
 *
 */
 publicclassHelloDaoImplextendsJdbcDaoSupportimplementsHelloDao {
 privateMySessionFactory mySessionFactory;

 publicvoidsetMySessionFactory(MySessionFactory mySessionFactory) {
 this.mySessionFactory = mySessionFactory;
 }

 @Transactional
 publicvoidsaveHello(){
 mySessionFactory.getSession().save(null);
 this.getJdbcTemplate().execute("select * from user");
 }
 }

配置文件：

 "1.0"encoding="UTF-8"?>
 "http://www.springframework.org/schema/beans"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd">

 "dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"destroy-method="close">
 "driverClassName"value="com.mysql.jdbc.Driver"/>
 "url"value="jdbc:mysql://localhost:3306/springdb"/>
 "username"value="root"/>
 "password"value="123456"/>


 "transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 "dataSource"ref="dataSource"/>


 "transactionManager"/>



 "mySessionFactory"class="cn.partner4java.myptm.MySessionFactory"/>

 "helloDao"class="cn.partner4java.dao.HelloDaoImpl">
 "dataSource"ref="dataSource"/>
 "mySessionFactory"ref="mySessionFactory">

测试：

  ApplicationContext ac =newClassPathXmlApplicationContext("/META-INF/spring/myptm.xml");

  HelloDao helloDao = (HelloDao) ac.getBean("helloDao");
  helloDao.saveHello();
 // 后台打印：
 // 1322395163008:save
 // 1322395163008:beginTransaction
 // 1322395163008:commit

总结：有两个核心的Spring类支持了这个功能，TransactionSynchronization接口，TransactionSynchronizationManager类。
TransactionSynchronizationManager负责管理当前线程在资源，资源可以主动绑定到TransactionSynchronizationManager中。
TransactionSynchronization提供了同步调用，当方法上面定义了@Transactional注解，那么当每次状态发生时就会调用本同步适配器。

PlatformTransactionManager的各种实现也是借助了上面这两个类，你可以查阅一下源码。所以，我们自然而然的也可以自己实现一个PlatformTransactionManager，来管理真正的sessionFactory，然后像其他实现一样，交给Spring，然后再给他声明事务。