被标记为事务的方法互相调用的坑（下）

参考：https://www.iteye.com/topic/1122740

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

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

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

我们需要新建一个接口：

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

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

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