spring boot @Transactional事物处理

spring boot 添加事物使用 @Transactional 注解

简单使用 在启动类上方添加 @EnableTransactionManagement 注解

使用时直接在类或者方法上使用 @Transactional 注解

如:

  1. package com.zyc;  
  2.   
  3. import org.mybatis.spring.annotation.MapperScan;  
  4. import org.springframework.boot.SpringApplication;  
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;  
  6. import org.springframework.context.annotation.ComponentScan;  
  7. import org.springframework.transaction.annotation.EnableTransactionManagement;  
  8.   
  9. @ComponentScan(value = { "com.zyc" })  
  10. @MapperScan("com.zyc.mapper")  
  11. @EnableTransactionManagement  
  12. @SpringBootApplication  
  13. public class App {  
  14.   
  15.     public static void main(String[] args) {  
  16.         SpringApplication.run(App.class, args);  
  17.     }  
  18. }  
package com.zyc;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@ComponentScan(value = { "com.zyc"})
@MapperScan("com.zyc.mapper")
@EnableTransactionManagement
@SpringBootApplication
public class App {

public static void main(String[] args) {</br>
	SpringApplication.run(App.class, args);</br>
}</br>

}


使用:直接作用在方法上

  1. @Transactional(rollbackFor=Exception.class)  
  2.     public void addData2(User user){  
  3.         userDao.insert(taskInfoTb);  
  4.         int i=9/0;  
  5.     }  
@Transactional(rollbackFor=Exception.class)
public void addData2(User user){
userDao.insert(taskInfoTb);
int i=9/0;
}
使用时需要注意一下几点

  1. 1. 不要在接口上声明 @Transactional ,而要在具体类的方法上使用 @Transactional 注解,否则注解可能无效。  
  2. 2. 将 @Transactional  放置在类级的声明中 放在类声明 会使得所有方法都有事务 故 @Transactional应该放在方法级别 不需要使用事务的方法,就不要放置事务,比如查询方法。否则对性能是有影响的。  
  3. 3. 使用了 @Transactional的方法,对同一个类里面的方法调用, @Transactional无效。比如有一个类 Test,它的一个方法 A,A 再调用 Test 本类的方法 B(不管 B 是否public还是private),但 A 没有声明注解事务,而 B 有。则外部调用 A 之后,B 的事务是不会起作用的。(经常在这里出错)  
  4. 4. 使用了 @Transactional 的方法, 只能是public, @Transactional注解的方法都是被外部其他类调用才有效,故只能是public。道理和上面的有关联。故在 protectedprivate 或者 package-visible 的方法上使用 @Transactional 注解,它也不会报错,但事务无效。  
  5. 5. 经过在 ICORE-CLAIM 中测试,效果如下:  
  6. A. 抛出受查异常 XXXException,事务会回滚。  
  7. B. 抛出运行时异常 NullPointerException,事务会回滚。  
  8. C. Quartz 中,execute 直接调用加了 @Transactional方法,可以回滚;间接调用,不会回滚。(即上文3点提到的)  
  9. D. 异步任务中,execute 直接调用加了 @Transactional方法,可以回滚;间接调用,不会回滚。(即上文3点提到的)  
  10. E. 在 action 中加上 @Transactional,不会回滚。切记不要在 action 中加上事务。  
  11. F. 在 service 中加上 @Transactional,如果是 action 直接调该方法,会回滚,如果是间接调,不会回滚。(即上文3提到的)  
  12. G. 在 service 中的private加上 @Transactional,事务不会回滚。  
1. 不要在接口上声明 @Transactional ,而要在具体类的方法上使用 @Transactional 注解,否则注解可能无效。
2. 将 @Transactional  放置在类级的声明中 放在类声明 会使得所有方法都有事务 故 @Transactional 应该放在方法级别 不需要使用事务的方法,就不要放置事务,比如查询方法。否则对性能是有影响的。
3. 使用了 @Transactional 的方法,对同一个类里面的方法调用, @Transactional 无效。比如有一个类 Test,它的一个方法 A,A 再调用 Test 本类的方法 B(不管 B 是否 public 还是 private),但 A 没有声明注解事务,而 B 有。则外部调用 A 之后,B 的事务是不会起作用的。(经常在这里出错)
4. 使用了 @Transactional 的方法, 只能是 public, @Transactional 注解的方法都是被外部其他类调用才有效,故只能是 public。道理和上面的有关联。故在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解,它也不会报错,但事务无效。
5. 经过在 ICORE-CLAIM 中测试,效果如下:
A. 抛出受查异常 XXXException,事务会回滚。
B. 抛出运行时异常 NullPointerException,事务会回滚。
C. Quartz 中,execute 直接调用加了 @Transactional 方法,可以回滚;间接调用,不会回滚。(即上文 3 点提到的)
D. 异步任务中,execute 直接调用加了 @Transactional 方法,可以回滚;间接调用,不会回滚。(即上文 3 点提到的)
E. 在 action 中加上 @Transactional,不会回滚。切记不要在 action 中加上事务。
F. 在 service 中加上 @Transactional,如果是 action 直接调该方法,会回滚,如果是间接调,不会回滚。(即上文 3 提到的)
G. 在 service 中的 private 加上 @Transactional,事务不会回滚。

如果需要自己定制的事物可以实现 TransactionManagementConfigurer 接口