spring 事务处理中，同一个类中:A方法（无事务）调B方法（有事务）,事务不生效问题

简称： test=a,test2=b

此时，调用a方法，b里的事务将不生效

这个问题，表面上是事务声明失效的问题，实质上很可能是Spring的AOP机制实现角度的问题。我想到很久以前研究Spring的AOP实现时发现的一个现象：对于以Cglib方式增强的AOP目标类，会创建两个对象，一个事Bean实例本身，一个是Cglib增强代理对象，而不仅仅是只有后者。我曾经疑惑过这一点，但当时没有再仔细探究下去。

我们知道，Spring的AOP实现方式有两种：1、Java代理方式；2、Cglib动态增强方式，这两种方式在Spring中是可以无缝自由切换的。Java代理方式的优点是不依赖第三方jar包，缺点是不能代理类，只能代理接口。

Spring通过AopProxy接口，抽象了这两种实现，实现了一致的AOP方式：

现在看来，这种抽象同样带了一个缺陷，那就是抹杀了Cglib能够直接创建普通类的增强子类的能力，Spring相当于把Cglib动态生成的子类，当普通的代理类了，这也是为什么会创建两个对象的原因。下图显示了Spring的AOP代理类的实际调用过程：

因此，从上面的分析可以看出，methodB没有被AopProxy通知到，导致最终结果是：被Spring的AOP增强的类，在同一个类的内部方法调用时，其被调用方法上的增强通知将不起作用。

而这种结果，会造成什么影响呢：

  1：内部调用时，被调用方法的事务声明将不起作用

  2：换句话说，你在某个方法上声明它需要事务的时候，如果这个类还有其他开发者，你将不能保证这个方法真的会在事务环境中

  3：再换句话说，Spring的事务传播策略在内部方法调用时将不起作用。不管你希望某个方法需要单独事务，是RequiresNew，还是要嵌套事务，要Nested，等等，统统不起作用。

  4：不仅仅是事务通知，所有你自己利用Spring实现的AOP通知，都会受到同样限制。。。。

解决办法：

可以把方法B放到另外一个service或者dao，然后把这个server或者dao通过@Autowired注入到方法A的bean里面，这样即使方法A没用事务，方法B也可以执行自己的事务了。

以上参考原文出处：https://www.jianshu.com/p/9f472a68f240

 

 

 

 

 

其他解决方案：

spring同类调用事务不生效-原因及三种解决方式

spring提供的声明式事务注解@Transactional，极大的方便了开发者管理事务，无需手动编写开启、提交、回滚事务的代码。
但是也带来了一些隐患，如果注解使用不当，可能导致事务不生效，最终导致脏数据也入库。

如果在同一个类直接调用事务方法，就会导致事务不生效，示例如下

public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public void insertStudent(){
        insert();
    }

    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        StudentDO studentDO = new StudentDO();
        studentDO.setName("小民");
        studentDO.setAge(22);
        studentMapper.insert(studentDO);

        if (studentDO.getAge() > 18) {
            throw new RuntimeException("年龄不能大于18岁");
        }
    }
}

事务不生效的原因在于，spring基于AOP机制实现事务的管理，@Authwired StudentService studentService这样的方式，调用StudentService的方法时，实际上是通过StudentService的代理类调用StudentService的方法，代理类在执行目标方法前后，加上了事务管理的代码。

 

因此，只有通过注入的StudentService调用事务方法，才会走代理类，才会执行事务管理；如果在同类直接调用，没走代理类，事务就无效。
注意：除了@Transactional，@Async同样需要代理类调用，异步才会生效

但是在实际的业务场景中，同类调用事务方法难以避免，怎么让同类调用时事务依然生效呢？有以下三个方法

方法一

自己@Autowired自己，示例如下

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private StudentService studentService;

    @Override
    public void insertStudent(){
        studentService.insert();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        StudentDO studentDO = new StudentDO();
        studentDO.setName("小民");
        studentDO.setAge(22);
        studentMapper.insert(studentDO);

        if (studentDO.getAge() > 18) {
            throw new RuntimeException("年龄不能大于18岁");
        }
    }
}

可能有人会担心这样会有循环依赖的问题，事实上，spring通过三级缓存解决了循环依赖的问题，所以上面的写法不会有循环依赖问题。
但是！！！，这不代表spring永远没有循环依赖的问题（@Async导致循环依赖了解下）

方法二

使用AopContext获取到当前代理类，需要在启动类加上@EnableAspectJAutoProxy(exposeProxy = true)，
示例如下

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public void insertStudent(){
        getService().insert();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        StudentDO studentDO = new StudentDO();
        studentDO.setName("小民");
        studentDO.setAge(22);
        studentMapper.insert(studentDO);

        if (studentDO.getAge() > 18) {
            throw new RuntimeException("年龄不能大于18岁");
        }
    }

    /**
     * 通过AopContext获取代理类
     * @return StudentService代理类
     */
    private StudentService getService(){
        return Objects.nonNull(AopContext.currentProxy()) ? (StudentService)AopContext.currentProxy() : this;
    }
}

exposeProxy = true用于控制AOP框架公开代理，公开后才可以通过AopContext获取到当前代理类。（默认情况下不会公开代理，因为会降低性能）
注意：不能保证这种方式一定有效，使用@Async时，本方式可能失效。
（从@Async案例找到Spring框架的bug：exposeProxy=true不生效原因大剖析）

 

方式三（推荐）

通过spring上下文获取到当前代理类，示例如下

@Component
public class SpringBeanUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    /**
     * 通过class获取Bean
     * @param clazz class
     * @param <T> 泛型
     * @return bean
     */
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
}

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public void insertStudent(){
        StudentService bean = SpringBeanUtil.getBean(StudentService.class);
        if (null != bean) {
            bean.insert();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        StudentDO studentDO = new StudentDO();
        studentDO.setName("小民");
        studentDO.setAge(22);
        studentMapper.insert(studentDO);

        if (studentDO.getAge() > 18) {
            throw new RuntimeException("年龄不能大于18岁");
        }
    }
}

当一个类实现ApplicationContextAware接口后，就可以方便的获得ApplicationContext中的所有bean。

原文出处：https://www.jianshu.com/p/083605986c8f
来源：简书