Spring 实现你自己的事务同步

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



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

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

模拟一个session类:

view plain copy to clipboard print ?

1. packagecn.partner4java.myptm;
3. importjava.io.Serializable;
5. /**
6. * 模拟一个session类
7. * @author partner4java
8. *
9. */
10. publicclassMySession {
11. /** 用来标识一个session */
12. privateLong sessionId;
14. publicvoidsave(Serializable entity){
15. System.out.println(sessionId +":save");
16. }
18. publicvoidbeginTransaction(){
19. System.out.println(sessionId +":beginTransaction");
20. }
22. publicvoidcommit(){
23. System.out.println(sessionId +":commit");
24. }
26. publicvoidrollback(){
27. System.out.println(sessionId +":rollback");
28. }
30. publicLong getSessionId() {
31. returnsessionId;
32. }
34. publicvoidsetSessionId(Long sessionId) {
35. this.sessionId = sessionId;
36. }
38. @Override
39. publicString toString() {
40. return"MySession [sessionId="+ sessionId +"]";
41. }
44. }

简单模拟SessionFactory：

view plain copy to clipboard print ?

1. packagecn.partner4java.myptm;
3. importorg.springframework.transaction.support.TransactionSynchronization;
4. importorg.springframework.transaction.support.TransactionSynchronizationManager;
7. /**
8. * 简单模拟SessionFactory<br/>
9. * 通判传递的类都为MySessionFactory而不是MySession，通过MySessionFactory获得当前线程的MySession或者开启一个新的MySession
10. * @author partner4java
11. *
12. */
13. publicclassMySessionFactory {
15. /**
16. * 如果当前线程存在MySession，就使用该MySession，否者开启一个新的MySession
17. * @return
18. */
19. publicMySession getSession(){
20. //传入this，是因为，我们以当前factory类作为键保存的MySession
21. if(TransactionSynchronizationManager.hasResource(this)){
22. returngetCurrentSession();
23. }else{
24. returnopenSession();
25. }
27. }
30. /**
31. * 开启一个新MySession
32. * @return
33. */
34. privateMySession openSession() {
35. MySession mySession =newMySession();
36. mySession.setSessionId(System.currentTimeMillis());
38. //注册进当前线程管理一个Synchronization
39. TransactionSynchronization transactionSynchronization =newMyTransactionSynchronizationAdapter(this);
40. TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
42. //绑定新开启的一个MySession进当前线程事务管理器
43. TransactionSynchronizationManager.bindResource(this, mySession);
45. returnmySession;
46. }
48. /**
49. * 获取当前线程的MySession
50. * @return
51. */
52. privateMySession getCurrentSession() {
53. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(this);
54. returnmySession;
55. }
56. }

核心事务同步适配器：

view plain copy to clipboard print ?

1. packagecn.partner4java.myptm;
3. importorg.springframework.transaction.support.TransactionSynchronizationAdapter;
4. importorg.springframework.transaction.support.TransactionSynchronizationManager;
6. /**
7. * 核心事务同步适配器<br/>
8. * 当方法上面定义了@Transactional注解，那么当每次状态发生时就会调用本同步适配器
9. * for transaction synchronization callbacks
10. * @author partner4java
11. *
12. */
13. publicclassMyTransactionSynchronizationAdapterextends
14. TransactionSynchronizationAdapter {
15. privateMySessionFactory mySessionFactory;
17. publicMyTransactionSynchronizationAdapter(MySessionFactory mySessionFactory) {
18. this.mySessionFactory = mySessionFactory;
19. }
22. @Override
23. publicvoidbeforeCommit(booleanreadOnly) {
24. //readOnly标识是否是一个只读线程
25. if(!readOnly){
26. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
27. mySession.beginTransaction();
28. }
29. }
31. @Override
32. publicvoidafterCompletion(intstatus) {
33. MySession mySession = (MySession) TransactionSynchronizationManager.getResource(mySessionFactory);
34. if(STATUS_COMMITTED == status) {
35. mySession.commit();
36. }
37. //当然，你还可以定义回滚方法
38. }
41. }

调用起的DAO：

view plain copy to clipboard print ?

1. packagecn.partner4java.dao;
3. publicinterfaceHelloDao {
4. publicvoidsaveHello();
5. }

view plain copy to clipboard print ?

1. packagecn.partner4java.dao;
3. importorg.springframework.jdbc.core.support.JdbcDaoSupport;
4. importorg.springframework.transaction.annotation.Transactional;
6. importcn.partner4java.myptm.MySessionFactory;
8. /**
9. * 一个hello world dao，起到模拟调用自定义事务同步的作用
10. * @author partner4java
11. *
12. */
13. publicclassHelloDaoImplextendsJdbcDaoSupportimplementsHelloDao {
14. privateMySessionFactory mySessionFactory;
16. publicvoidsetMySessionFactory(MySessionFactory mySessionFactory) {
17. this.mySessionFactory = mySessionFactory;
18. }
20. @Transactional
21. publicvoidsaveHello(){
22. mySessionFactory.getSession().save(null);
23. this.getJdbcTemplate().execute("select * from user");
24. }
25. }

配置文件：

view plain copy to clipboard print ?

1. <?xml version="1.0"encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:aop="http://www.springframework.org/schema/aop"
4. xmlns:tx="http://www.springframework.org/schema/tx"
5. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6. xsi:schemaLocation="
7. http://www.springframework.org/schema/beans
8. http://www.springframework.org/schema/beans/spring-beans.xsd
9. http://www.springframework.org/schema/tx
10. http://www.springframework.org/schema/tx/spring-tx.xsd
11. http://www.springframework.org/schema/aop
12. http://www.springframework.org/schema/aop/spring-aop.xsd">
14. <bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"destroy-method="close">
15. <property name="driverClassName"value="com.mysql.jdbc.Driver"/>
16. <property name="url"value="jdbc:mysql://localhost:3306/springdb"/>
17. <property name="username"value="root"/>
18. <property name="password"value="123456"/>
19. </bean>
21. <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
22. <property name="dataSource"ref="dataSource"/>
23. </bean>
25. <tx:annotation-driven transaction-manager="transactionManager"/>
27. <aop:aspectj-autoproxy />
29. <bean id="mySessionFactory"class="cn.partner4java.myptm.MySessionFactory"/>
31. <bean id="helloDao"class="cn.partner4java.dao.HelloDaoImpl">
32. <property name="dataSource"ref="dataSource"/>
33. <property name="mySessionFactory"ref="mySessionFactory"></property>
34. </bean>
36. </beans>

测试：

view plain copy to clipboard print ?

1. ApplicationContext ac =newClassPathXmlApplicationContext("/META-INF/spring/myptm.xml");
3. HelloDao helloDao = (HelloDao) ac.getBean("helloDao");
4. helloDao.saveHello();
5. // 后台打印：
6. // 1322395163008:save
7. // 1322395163008:beginTransaction
8. // 1322395163008:commit

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

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