使用步骤:
步骤一、在spring配置文件中引入<tx:>命名空间
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">步骤二、具有@Transactional 注解的bean自动配置为声明式事务支持
<!-- 事务管理器配置, Hibernate单数据源事务 -->
<bean id="defaultTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager="defaultTransactionManager" proxy-target-class="true" />
步骤三、在接口或类的声明处 ,写一个@Transactional.
要是只在接口上写, 接口的实现类就会继承下来、接口的实现类的具体方法,可以覆盖类声明处的设置
@Transactional //类级的注解、适用于类中所有的public的方法
事务的传播行为和隔离级别
大家在使用spring的注解式事务管理时,对事务的传播行为和隔离级别可能有点不知所措,下边就详细的介绍下以备方便查阅。
事物注解方式: @Transactional
当标于类前时, 标示类中所有方法都进行事物处理 , 例子:
@Transactional
public class TestServiceBean implements TestService {}
当类中某些方法不需要事物时:
@Transactional
public class TestServiceBean implements TestService {
private TestDao dao;
public void setDao(TestDao dao) {
this.dao = dao;
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public List<Object> getAll() {
return null;
}
}
事物传播行为介绍:
@Transactional(propagation=Propagation.REQUIRED)
如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED)
容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW)
不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY)
必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER)
必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS)
如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
事物超时设置:@Transactional(timeout=30) //默认是30秒
事务隔离级别:@Transactional(isolation = Isolation.READ_UNCOMMITTED)
读取未提交数据(会出现脏读, 不可重复读) 基本不使用
@Transactional(isolation = Isolation.READ_COMMITTED)
读取已提交数据(会出现不可重复读和幻读)
@Transactional(isolation = Isolation.REPEATABLE_READ)
可重复读(会出现幻读)
@Transactional(isolation = Isolation.SERIALIZABLE)
串行化
MYSQL: 默认为REPEATABLE_READ级别
SQLSERVER: 默认为READ_COMMITTED
脏读 : 一个事务读取到另一事务未提交的更新数据
不可重复读 : 在同一事务中, 多次读取同一数据返回的结果有所不同, 换句话说,
后续读取可以读到另一事务已提交的更新数据. 相反, "可重复读"在同一事务中多次
读取数据时, 能够保证所读数据一样, 也就是后续读取不能读到另一事务已提交的更新数据
幻读 : 一个事务读到另一个事务已提交的insert数据
@Transactional注解中常用参数说明
参 数 名 称 | 功 能 描 述 |
readOnly | 该属性用于设置当前事务是否为只读事务,设置为true表示只读,false则表示可读写,默认值为false。例如:@Transactional(readOnly=true) |
rollbackFor | 该属性用于设置需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,则进行事务回滚。例如: 指定单一异常类:@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类:@Transactional(rollbackFor={RuntimeException.class, Exception.class}) |
续表)
参 数 名 称 | 功 能 描 述 |
rollbackForClassName | 该属性用于设置需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,则进行事务回滚。例如: 指定单一异常类名称:@Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称:@Transactional(rollbackForClassName={"RuntimeException","Exception"}) |
noRollbackFor | 该属性用于设置不需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,不进行事务回滚。例如: 指定单一异常类:@Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类:@Transactional(noRollbackFor={RuntimeException.class, Exception.class}) |
noRollbackForClassName | 该属性用于设置不需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,不进行事务回滚。例如: 指定单一异常类名称:@Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称: @Transactional(noRollbackForClassName={"RuntimeException","Exception"}) |
propagation | 该属性用于设置事务的传播行为,具体取值可参考表6-7。 例如:@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true) |
isolation | 该属性用于设置底层数据库的事务隔离级别,事务隔离级别用于处理多事务并发的情况,通常使用数据库的默认隔离级别即可,基本不需要进行设置 |
timeout | 该属性用于设置事务的超时秒数,默认值为-1表示永不超时 |
注意的几点:
1 @Transactional 只能被应用到public方法上,对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.
2用 spring事务管理器,由spring来负责数据库的打开,提交,回滚.默认遇到运行期例外(throw newRuntimeException("注释");)会回滚,即遇到不受检查(unchecked)的例外时回滚;而遇到需要捕获的例外(thrownewException("注释");)不会回滚,即遇到受检查的例外(就是非运行时抛出的异常,编译器会检查到的异常叫受检查例外或说受检查异常)时,需我们指定方式来让事务回滚要想所有异常都回滚,要加上 @Transactional(rollbackFor={Exception.class,其它异常}) .如果让unchecked例外不回滚:@Transactional(notRollbackFor=RunTimeException.class)
如下:
@Transactional(rollbackFor=Exception.class)//指定回滚,遇到异常Exception时回滚
public void methodName() {
throw new Exception("注释");
}
@Transactional(noRollbackFor=Exception.class)//指定不回滚,遇到运行期例外(thrownew RuntimeException("注释");)会回滚
public ItimDaoImpl getItemDaoImpl() {
throw new RuntimeException("注释");
}
3、@Transactional 注解应该只被应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解,它也不会报错, 但是这个被注解的方法将不会展示已配置的事务设置。
4、@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。然而,请注意仅仅 @Transactional 注解的出现不足于开启事务行为,它仅仅 是一种元数据,能够被可以识别 @Transactional 注解和上述的配置适当的具有事务行为的beans所使用。上面的例子中,其实正是 <tx:annotation-driven/>元素的出现 开启 了事务行为。
5、Spring团队的建议是你在具体的类(或类的方法)上使用 @Transactional 注解,而不要使用在类所要实现的任何接口上。你当然可以在接口上使用 @Transactional 注解,但是这将只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的,这就意味着如果你正在使用基于类的代理时,那么事务的设置将不能被基于类的代理所识别,而且对象也将不会被事务代理所包装(将被确认为严重的)。因此,请接受Spring团队的建议并且在具体的类上使用 @Transactional 注解。
=============================================================================================================
分布式事务是指操作多个数据库之间的事务,spring的org.springframework.transaction.jta.JtaTransactionManager,提供了分布式事务支持。如果使用WAS的JTA支持,把它的属性改为WebSphere对应的TransactionManager。
在tomcat下,是没有分布式事务的,不过可以借助于第三方软件jotm(Java Open Transaction Manager )和AtomikosTransactionsEssentials实现,在spring中分布式事务是通过jta(jotm,atomikos)来进行实现。
1、http://jotm.objectweb.org/
2、http://www.atomikos.com/Main/TransactionsEssentials
一、使用JOTM例子
(1) Dao及实现
GenericDao接口:
[java] view plain copy
1. public interface GenericDao {
2. public int save(String ds, String sql, Object[] obj) throws Exception;
3. public int findRowCount(String ds, String sql);
4. }
GenericDaoImpl 实现:
[java] view plain copy
1. public class GenericDaoImpl implements GenericDao{
2.
3. private JdbcTemplate jdbcTemplateA;
4. private JdbcTemplate jdbcTemplateB;
5.
6. public void setJdbcTemplateA(JdbcTemplate jdbcTemplate) {
7. this.jdbcTemplateA = jdbcTemplate;
8. }
9.
10. public void setJdbcTemplateB(JdbcTemplate jdbcTemplate) {
11. this.jdbcTemplateB = jdbcTemplate;
12. }
13.
14. public int save(String ds, String sql, Object[] obj) throws Exception{
15. if(null == ds || "".equals(ds)) return -1;
16. try{
17. if(ds.equals("A")){
18. return this.jdbcTemplateA.update(sql, obj);
19. else{
20. return this.jdbcTemplateB.update(sql, obj);
21. }
22. catch(Exception e){
23. e.printStackTrace();
24. throw new Exception("执行" + ds + "数据库时失败!");
25. }
26. }
27.
28. public int findRowCount(String ds, String sql) {
29. if(null == ds || "".equals(ds)) return -1;
30.
31. if(ds.equals("A")){
32. return this.jdbcTemplateA.queryForInt(sql);
33. else{
34. return this.jdbcTemplateB.queryForInt(sql);
35. }
36. }
37. }
(2) Service及实现
UserService 接口:
[java] view plain copy
1. public interface UserService {
2. public void saveUser() throws Exception;
3. }
UserServiceImpl 实现:
[java] view plain copy
1. public class UserServiceImpl implements UserService{
2.
3. private GenericDao genericDao;
4.
5. public void setGenericDao(GenericDao genericDao) {
6. this.genericDao = genericDao;
7. }
8.
9. public void saveUser() throws Exception {
10. "user_" + Math.round(Math.random()*10000);
11. System.out.println(userName);
12.
13. new StringBuilder();
14. " insert into t_user(username, gender) values(?,?); ");
15. new Object[]{userName,"1"};
16.
17. "A", sql.toString(), objs);
18.
19. 0, sql.length());
20. " insert into t_user(name, sex) values(?,?); ");
21. new Object[]{userName,"男的"};//值超出范围
22. "B", sql.toString(), objs);
23. }
24. }
(3) applicationContext-jotm.xml
[java] view plain copy
(4) 测试
1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. "http://www.w3.org/2001/XMLSchema-instance"
4. "http://www.springframework.org/schema/context"
5. "http://www.springframework.org/schema/aop"
6. "http://www.springframework.org/schema/tx"
7. //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
8. //www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
9. //www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
10. //www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
11.
12. <description>springJTA</description>
13.
14. <!--指定Spring配置中用到的属性文件-->
15. "propertyConfig"
16. class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
17. "locations">
18. <list>
19. <value>classpath:jdbc.properties</value>
20. </list>
21. </property>
22. </bean>
23.
24. <!-- JOTM实例 -->
25. "jotm" class="org.springframework.transaction.jta.JotmFactoryBean">
26. "defaultTimeout" value="500000"/>
27. </bean>
28.
29. <!-- JTA事务管理器 -->
30. "jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
31. "userTransaction" ref="jotm" />
32. </bean>
33.
34. <!-- 数据源A -->
35. "dataSourceA" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
36. "dataSource">
37. class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
38. "transactionManager" ref="jotm"/>
39. "driverName" value="${jdbc.driver}"/>
40. "url" value="${jdbc.url}"/>
41. </bean>
42. </property>
43. "user" value="${jdbc.username}"/>
44. "password" value="${jdbc.password}"/>
45. </bean>
46.
47. <!-- 数据源B -->
48. "dataSourceB" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">
49. "dataSource">
50. class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">
51. "transactionManager" ref="jotm"/>
52. "driverName" value="${jdbc2.driver}"/>
53. "url" value="${jdbc2.url}"/>
54. </bean>
55. </property>
56. "user" value="${jdbc2.username}"/>
57. "password" value="${jdbc2.password}"/>
58. </bean>
59.
60. "jdbcTemplateA"
61. class = "org.springframework.jdbc.core.JdbcTemplate">
62. "dataSource" ref="dataSourceA"/>
63. </bean>
64.
65. "jdbcTemplateB"
66. class = "org.springframework.jdbc.core.JdbcTemplate">
67. "dataSource" ref="dataSourceB"/>
68. </bean>
69.
70. <!-- 事务切面配置 -->
71. <aop:config>
72. "pointCut"
73. "execution(* com.logcd.service..*.*(..))"/><!-- 包及其子包下的所有方法 -->
74. "pointCut" advice-ref="txAdvice"/>
75.
76. "execution(* *..common.service..*.*(..))" advice-ref="txAdvice"/>
77. </aop:config>
78.
79. <!-- 通知配置 -->
80. "txAdvice" transaction-manager="jtaTransactionManager">
81. <tx:attributes>
82. "delete*" rollback-for="Exception"/>
83. "save*" rollback-for="Exception"/>
84. "update*" rollback-for="Exception"/>
85. "find*" read-only="true" rollback-for="Exception"/>
86. </tx:attributes>
87. </tx:advice>
88.
89. "genericDao" class="com.logcd.dao.impl.GenericDaoImpl" autowire="byName"> </bean>
90. "userService" class="com.logcd.service.impl.UserServiceImpl" autowire="byName"> </bean>
91. </beans>
[java] view plain copy
1. public class TestUserService{
2.
3. private static UserService userService;
4.
5. @BeforeClass
6. public static void init(){
7. new ClassPathXmlApplicationContext("applicationContext-jotm.xml");
8. "userService");
9. }
10.
11. @Test
12. public void save(){
13. "begin...");
14. try{
15. userService.saveUser();
16. catch(Exception e){
17. System.out.println(e.getMessage());
18. }
19. "finish...");
20. }
21. }
二、关于使用atomikos实现
(1) 数据源配置
[java] view plain copy
1. <bean id="dataSourceA" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">
2. "uniqueResourceName">
3. <value>${datasource.uniqueResourceName}</value>
4. </property>
5. "xaDataSourceClassName">
6. <value>${database.driver_class}</value>
7. </property>
8. "xaDataSourceProperties">
9. <value>URL=${database.url};user=${database.username};password=${database.password}</value>
10. </property>
11. "exclusiveConnectionMode">
12. <value>${connection.exclusive.mode}</value>
13. </property>
14. "connectionPoolSize">
15. <value>${connection.pool.size}</value>
16. </property>
17. "connectionTimeout">
18. <value>${connection.timeout}</value>
19. </property>
20. "validatingQuery">
21. 1</value>
22. </property>
23. </bean>
(2)、事务配置
[java] view plain copy
1. <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
2. "init" destroy-method="close">
3. "forceShutdown" value="true"/>
4. </bean>
5.
6. <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
7. "transactionTimeout" value="${transaction.timeout}"/>
8. </bean>
9.
10. <!-- JTA事务管理器 -->
11. <bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
12. "transactionManager" ref="atomikosTransactionManager"/>
13. "userTransaction" ref="atomikosUserTransaction"/>
14. </bean>
15.
16. <!-- 事务切面配置 -->
17. <aop:config>
18. "serviceOperation" expression="execution(* *..service*..*(..))"/>
19. "serviceOperation" advice-ref="txAdvice"/>
20. </aop:config>
21.
22. <!-- 通知配置 -->
23. <tx:advice id="txAdvice" transaction-manager="springTransactionManager">
24. <tx:attributes>
25. "*" rollback-for="Exception"/>
26. </tx:attributes>
27. </tx:advice>
有关JTA
JTA全称为Java Transaction API,顾名思义JTA定义了一组统一的事务编程的接口,这些接口如下:
XAResource
XAResource接口是对实现了X/Open CAE规范的资源管理器 (Resource Manager,数据库就是典型的资源管理器) 的抽象,它由资源适配器 (Resource Apdater) 提供实现。XAResource是支持事务控制的核心。
Transaction
Transaction接口是一个事务实例的抽象,通过它可以控制事务内多个资源的提交或者回滚。二阶段提交过程也是由Transaction接口的实现者来完成的。
TransactionManager
托管模式 (managed mode) 下,TransactionManager接口是被应用服务器调用,以控制事务的边界的。
UserTransaction
非托管模式 (non-managed mode) 下,应用程序可以通过UserTransaction接口控制事务的边界
托管模式下的事务提交场景
注意:在上图中3和5的步骤之间省略了应用程序对资源的操作 (如CRUD)。另外,应用服务器什么时机 enlistResource,又是什么时候delistResource呢?这在后文中会解释。
有关JCA
下图为JCA的架构图
中间涉及元素说明如下:
1)Enterprise Information System
简称EIS,在JTA中它又被称为资源管理器。典型的EIS有数据库,事务处理系统(Transaction Processing System),ERP系统。
2)Resource Adapter
资源适配器(Resource Adaper)是JCA的关键。要想把不同的EIS整合(或者连接)到J2EE运行环境中,就必须为每个EIS提供资源适配器,它会将将EIS适配为一个具备统一编程接口的资源 (Resource) 。这个统一编程接口就是上图中的System Contracts和Client API。下面的UML类图将完美诠释资源适配器。
3)Application Server
应用服务器 (Application Server) 通过System Contracts来管理对EIS的安全、事务、连接等。典型的应用服务器有JBoss、JOnAS、Geronimo、GlassFish等。
4)Application Component
应用组件 (Application Component) ,它封装了应用业务逻辑,像对资源的访问和修改。典型的应用组件就是EJB。
更多细节请参见:
Sun Microsystems Inc.J2EE Connector Architecture 1.5