被标记为事务的方法互相调用的坑（下）_java事务能够互相引用-优快云博客

上一节，主要分析了被标记为事务的方法互相调用，事务失效的原因，思考比较多，这一节主要说说解决方案，思考会少一些。

解决方案的核心：通过代理对象去调用方法

1.把方法放到不同的类：

如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：854630135，群里有阿里大牛直播讲解技术，以及Java大型互联网技术的视频免费分享给大家。

我们需要新建一个接口：

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;
 }
}

这样就可以了，验证的图片也省略了。

以上就是四种解决方案，可以说各有千秋，没有哪个好，哪个坏，只有适不适合。