Spring事务与非事务方法相互调用
Spring事务与非事务方法相互调用
事务
1. 事务的4种特性
序号 参数 含义 1 原子性(Atomicity) 事务是数据库的逻辑工作单位，它对数据库的修改要么全部执行，要么全部不执行。 2 一致性(Consistemcy) 事务前后，数据库的状态都满足所有的完整性约束。 3 隔离性(Isolation) 并发执行的事务是隔离的，一个不影响一个。通过设置数据库的隔离级别，可以达到不同的隔离效果 4 持久性(Durability) 在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
2.Transactional（）控制事务传播的配置项目（默认Propagation.REQUIRED）
@Transactional(propagation=Propagation.REQUIRED) //控制事务传播。默认是Propagation.REQUIRED @Transactional(isolation=Isolation.DEFAULT) //控制事务隔离级别。默认跟数据库的隔离级别相同 @Transactional(readOnly=false) //控制事务可读写、只可读。默认可读写 @Transactional(timeout=30) //控制事务的超时时间，单位秒。默认跟数据库的事务控制系统相同 @Transactional(rollbackFor=RuntimeException.class) //控制事务遇到哪些异常会回滚。默认是RuntimeException @Transactional(rollbackForClassName=RuntimeException) //同上 @Transactional(noRollbackFor=NullPointerException.class) //控制事务遇到哪些异常不会回滚。默认遇到RuntimeException回滚 @Transactional(noRollbackForClassName=NullPointerException)//同上
3.事务的7中传播特性
序号 传播行为 含义 1 REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 2 SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行 3 MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 4 NESTED 如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行 5 NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常 6 REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个已经存在的事务挂起 7 NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务
Spring事务传播属性: 1.propagation-required: 支持当前事务,如果有就加入当前事务中;如果当前方法没有事务,就新建一个事务; 2.propagation-supports: 支持当前事务,如果有就加入当前事务中;如果当前方法没有事务,就以非事务的方式执行; 3.propagation-mandatory: 支持当前事务,如果有就加入当前事务中;如果当前没有事务,就抛出异常; 4.propagation-requires_new: 新建事务,如果当前存在事务,就把当前事务挂起;如果当前方法没有事务,就新建事务; 5.propagation-not-supported: 以非事务方式执行,如果当前方法存在事务就挂起当前事务;如果当前方法不存在事务,就以非事务方式执行; 6.propagation-never: 以非事务方式执行,如果当前方法存在事务就抛出异常;如果当前方法不存在事务,就以非事务方式执行; 7.propagation-nested: 如果当前方法有事务,则在嵌套事务内执行;如果当前方法没有事务,则与required操作类似; 前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。 它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager） 在同一个类中，一个方法调用另外一个有注解（比如@Async，@Transational）的方法，注解是不会生效的
4. 事务的传播案例：
事务在A类的a()方法中调用B类的b()方法的传播案例
A.a() B.b()的事务配置 a()没有事务的结果 a()有事务的结果 REQUIRED b()创建自己的事务; b()接受a()的事务 SUPPORTS b()不创建自己的事务; b()接受a()的事务 MANDATORY b()报异常 b()接受a()的事务 NESTED b()创建自己的事务; b()接受a()的事务，成为a()嵌套的子事务 NEVER b()不创建自己的事务; b()报异常 REQUIRES_NEW b()创建自己的事务; b()不接受a()的事务，b()先执行,内层事务失败不会影响外层事务 NOT_SUPPORTED b()不创建自己的事务; b()不接受a()的事务，b()先执行
事务不生效的场景
问题一：非事务方法A调用事务方法B，方法B事务不生效
spring默认的是PROPAGATION_REQUIRED机制,如果方法A标注了注解@Transactional 是完全没问题的,执行的时候传播给方法B,因为方法A开启了事务,线程内的connection的属性autoCommit=false,并且执行到方法B时,事务传播依然是生效的,得到的还是方法A的connection,autoCommit还是为false,所以事务生效;反之,如果方法A没有注解@Transactional 时,是不受事务管理的,autoCommit=true,那么传播给方法B的也为true,执行完自动提交,即使B标注了@Transactional ;
在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务.是因为spring采用动态代理机制来实现事务控制，而动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了！
所以以上就是为什么在没有标注事务注解的方法A里去调用标注有事务注解的方法B而没有事务滚回的原因;
问题二：在事务方法A中调用另外一个事务方法B，被调用方法B的事务没起作用
产生问题的原因是：spring是通过代理代管理事务的，当在第一个方法insertUser1内直接调用insertUser2的时候 ，insertUser2上的事务是不会起作用的（也就是insertUser2是没有开启事务）
解决方案
开启一下 有关事务 的日志，在 配置文件 中加上下面的配置：
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=debug1.把方法放到不同的类：
我们需要新建一个接口：
public interface OtherService {
void insertCodeMonkey();
}再定义一个类去实现这个接口：
@Service
public class OtherServiceImpl implements OtherService {
@Autowired
AccountMapper mapper;
@Override
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void insertCodeMonkey() {
Account account = new Account();
account.setAccount("CodeMonkey");
account.setPassword("CodeMonkey");
mapper.insert(account);
int a = 1 / 0;
}
}修改原本的实现类：
@Service
public class AccountSerivceImpl implements AccountService {
@Autowired
AccountMapper mapper;
@Autowired
OtherService otherService;
@Transactional
@Override
public void insertCodeBear() {
try {
otherService.insertCodeMonkey();
} catch (Exception e) {
e.printStackTrace();
}
Account account = new Account();
account.setAccount("CodeBear");
account.setPassword("CodeBear");
mapper.insert(account);
}
}运行，查看数据库：
只有一条数据，insertCodeBear方法执行成功了，insertCodeMonkey执行失败，并且回滚了。
让我们再看看控制台的日志：
可以看到是开了两个事务去执行的。
这种解决方案最简单，不需要了解其他东西，但是这种方案需要修改代码结构，本来两个方法都是属于同一个类的，现在需要强行把它们拆开。
2. AopContext：
我们的目标是要在实现类中获取本类的代理对象，Spring提供了Aop上下文，即：AopContext，通过AopContext，可以很方便的获取到代理对象：
@Service
public class AccountSerivceImpl implements AccountService {
@Autowired
AccountMapper mapper;
@Transactional
@Override
public void insertCodeBear() {
try {
((AccountService)AopContext.currentProxy()).insertCodeMonkey();
} catch (Exception ex) {
ex.printStackTrace();
}
Account account = new Account();
account.setAccount("CodeBear");
account.setPassword("CodeBear");
mapper.insert(account);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void insertCodeMonkey() {
Account account = new Account();
account.setAccount("CodeMonkey");
account.setPassword("CodeMonkey");
mapper.insert(account);
int a = 1 / 0;
}
}当写好代码，很愉快的去测试，发现竟然报错了:
翻译下：不能找到当前的代理，需要设置exposeProxy属性为 true使其可以。
expose字面意思就是 暴露。也就是说 我们需要允许暴露代理。
我们需要在Spring Boot启动类上+一个注解：
@EnableAspectJAutoProxy(exposeProxy = true)
@SpringBootApplication
@MapperScan(basePackages = "com.codebear.Dao")
public class SpringbootApplication {
public static void main(String[] args) throws Exception {
SpringApplication.run(SpringbootApplication.class, args);
}
}再次运行：
确实是开启了两个事务去执行的。
再看看数据库，也没有问题。
3. ApplicationContext：
@Service
public class AccountSerivceImpl implements AccountService {
@Autowired
AccountMapper mapper;
@Autowired
ApplicationContext context;
AccountService service;
@PostConstruct
private void setSelf() {
service = context.getBean(AccountService.class);
}
@Transactional
@Override
public void insertCodeBear() {
try {
service.insertCodeMonkey();
} catch (Exception e) {
e.printStackTrace();
}
Account account = new Account();
account.setAccount("CodeBear");
account.setPassword("CodeBear");
mapper.insert(account);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void insertCodeMonkey() {
Account account = new Account();
account.setAccount("CodeMonkey");
account.setPassword("CodeMonkey");
mapper.insert(account);
int a = 1 / 0;
}
}此方法不适用于prototype
在这里，我用了一个@PostConstruct注解，在初始化的时候，会调用被@PostConstruct标记的方法(注意，仅仅是初始化的时候，才会被调用。以后都不会被调用了，大家可以打个断点试一下)，这里这么做的目的就是为了提升一下效率，不用每次都getBean。所以如果这个类是prototype的，就不适用这个方法了。如果是prototype的话，就在insertCodeBear方法中使用getBean方法吧。
上两种方法比较方便，没有新建其他的接口或者是类，但是没有很好的封装获得Aop代理对象的过程，也不是很符合 迪比特法则，也就是最少知识原则。
4. 重写BeanPostProcessor接口：
关于这个接口是做什么的，这里就不详细阐述了，简单的来说这是Spring提供的接口，我们可以通过重写它，在初始化Bean之前或者之后，自定义一些额外的逻辑。 首先，我们需要定义一个接口：
public interface WeavingSelfProxy {
void setSelfProxy(Object bean);
}要获得代理对象的类，需要去实现它：
@Service
public class AccountSerivceImpl implements AccountService, WeavingSelfProxy {
@Autowired
AccountMapper mapper;
AccountService service;
@Override
public void setSelfProxy(Object bean) {
System.out.println("进入到setSelfProxy方法");
service = (AccountService) bean;
}
@Transactional
@Override
public void insertCodeBear() {
try {
service.insertCodeMonkey();
} catch (Exception e) {
e.printStackTrace();
}
Account account = new Account();
account.setAccount("CodeBear");
account.setPassword("CodeBear");
mapper.insert(account);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void insertCodeMonkey() {
Account account = new Account();
account.setAccount("CodeMonkey");
account.setPassword("CodeMonkey");
mapper.insert(account);
int a = 1 / 0;
}
}重写BeanPostProcessor接口：
@Component
public class SetSelfProxyProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if(bean instanceof WeavingSelfProxy){
System.out.println("实现了WeavingSelfProxy接口");
((WeavingSelfProxy) bean).setSelfProxy(bean);
}
return bean;
}
}参考：
@Transactional 同一个类中无事务方法a()内部调用有事务方法b()的问题：https://www.cnblogs.com/lukelook/p/11246180.html
被标记为事务的方法互相调用的坑（上）：https://www.jianshu.com/p/ba13144dba20?from=timeline&isappinstalled=0
被标记为事务的方法互相调用的坑（下）：https://www.jianshu.com/p/b375c52f2a71