Spring AOP失效的场景事务失效的场景

场景一：使用this调用被增强的方法

下面是一个类里面的一个增强方法

@Service
public class MyService  implements CommandLineRunner {
    private  MyService myService;

    public void performTask(int x) {
        System.out.println("Executing performTask method");

        if(x<5) this.performTask(1+x);
//        if(x<5) myService.performTask(1+x);
    }


    @Override
    public void run(String... args) throws Exception {
        myService = AopTestApplication.getBean(MyService.class);
    }
}

增强逻辑是在方法调用的前后输出各一行语句

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.aoptest.MyService.performTask(..))")
    public void performTaskPointcut() {
        // Pointcut for performTask method
    }

    @Before("performTaskPointcut()")
    public void beforePerformTask() {
        System.out.println("方法调用前");
    }

    @After("performTaskPointcut()")
    public void afterPerformTask() {
        System.out.println("方法调用后");
    }
}

运行项目并在Controller层调用方法得到的输出如下

可以看出只有第一次调用是执行了增强逻辑的，剩下那些this调用都没有。

原因

aop代理的原理：使用AOP对某一个Bean的方法进行增强之后，放进IOC容器的这个Bean不会是原本的类实例，而是专门创建的一个代理对象Bean.这个代理对象内部有对原始Bean的引用，在用原始Bean调用方法前会先执行增强逻辑。这里就是相当于加了一层。

用this.失效的原因: 用this.xxx相当于直接调用了原始Bean的方法，而不是外层的代理Bean的方法。示意图如下，左边的是用代理对象调用方法，右边的是在原始Bean的任意方法内部用this.调用增强方法。

解决方案

将this.调用改为Bean调用

代码如下。

必须从IOC容器里面直接获取到Bean对象，而不是使用@Autowried注解注入，否则会出现循环依赖的报错。

@SpringBootApplication
public class AopTestApplication implements ApplicationContextAware {
    private static ApplicationContext context;

    public static void main(String[] args) {
        SpringApplication.run(AopTestApplication.class, args);

    }
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }
}

@Service
public class MyService  implements CommandLineRunner {
    private  MyService myService;

    public void performTask(int x) {
        System.out.println("Executing performTask method");

        if(x<5) myService.performTask(1+x);
    }


    @Override
    public void run(String... args) throws Exception {
        myService = AopTestApplication.getBean(MyService.class);
    }
}

这次的输出如下，可以看见每一次方法调用都有执行增强逻辑。

场景二：增强方法使用private修饰

@RestController
@Service
public class MyService   implements CommandLineRunner  {
    private  MyService myService;

    @PostMapping("test/{x}")
    private void performTask(@PathVariable("x")int x) {

        System.out.println("Executing performTask method");
        if(Objects.isNull(myService))
            System.out.println("222222");
        if(x<5) myService.performTask(1+x);
    }


    @Override
    public void run(String... args) throws Exception {
        myService = AopTestApplication.getBean(MyService.class);
        if(Objects.isNull(myService))
            System.out.println("1111111");
    }
}

上面代码的输出如下，可以看见并没有输出增强逻辑。并且在使用myService调用方法时还报错myService为空。明明run方法里面都已经注入了Bean.

原因

aop代理无法代理私有方法？代理对象无法通过原始Bean调用里面的私有方法？

同一个类里面存在一个私有和公有的两个增强方法时如下

@RestController
@Service
public class MyService   implements CommandLineRunner  {
    private  MyService myService;

    @PostMapping("test/{x}")
    private void performTask(@PathVariable("x")int x) {

        System.out.println("Executing performTask method");
        if(Objects.isNull(myService))
            System.out.println("222222");
        if(x<5) myService.performTask(1+x);
    }

    @PostMapping("test2/{x}")
    public void performTask2(@PathVariable("x")int x) {

        System.out.println("Executing performTask method2");
        if(Objects.isNull(myService))
            System.out.println("222222");
        if(x<5) myService.performTask2(1+x);
    }


    @Override
    public void run(String... args) throws Exception {
        myService = AopTestApplication.getBean(MyService.class);
        if(Objects.isNull(myService))
            System.out.println("1111111");
    }
}

先后调用方法2和方法1得到输出如下

结果是方法2一切正常，方法1还是有问题。

奇怪的点是方法2里面测出局部变量myService是非空的，但是方法1里面却是空的？？？？

解决方案

将private改成public，现在可以看见增强逻辑都正常输出了。

，

AOP失效会导致的问题

估计所有依赖于AOP实现的功能都会有问题

首当其冲的就是事务注解@Transactional，事务注解里面也是依赖了AOp，在方法调用前开启事务，在方法调用后进行回滚或者提交事务。

但是像上面失效的场景下就事务注解就会失效，试想，在一个方法内用this调用了同一个类中的一个事务方法，那这个事务方法的事务就会失效，里面的事务方法报错回滚会无法回滚。

事务失效场景一：抛出检查异常checked

默认情况下，Spring事务管理器只在抛出未检查（unchecked）异常（即RuntimeException及其子类）时才会回滚事务。如果方法抛出的是检查（checked）异常，事务不会回滚，除非你显式配置了事务注解的rollbackFor属性。

如下所示，我在业务代码中手动抛出了一个自定义的检查异常，报错是报错了，但是事务并没有回滚。


@Service
public class UserServiceImpl implements UserService , CommandLineRunner {

    public class MyCheckedException extends Exception {
        public MyCheckedException(String message) {
            super(message);
        }
    }


    private UserMapper userMapper;
    private UserService userService;
    @Override
    @Transactional
    public void createUser(String name) throws MyCheckedException{
        user user = new user();
        user.setName(name);
        userMapper.insert(user);

        throw new MyCheckedException("This is a custom checked exception");
    }

    @Override
    public void run(String... args) throws Exception {
        userMapper = AopTestApplication.getBean(UserMapper.class);
        userService = AopTestApplication.getBean(UserService.class);
    }
}

原因

spring事务默认是只在抛出未检查异常时才会进行回滚。

解决方案

显式配置rollback属性

在上面代码的事务注解改成如下，这样子无论是什么异常都会自动回滚了

    @Transactional(rollbackFor = Exception.class)

当然，还有一个属性选择是Throwable，这个是Exception和Error的父类，这样不管是抛出异常还是错误都会进行回滚了，正常来想，应该也是要这样设置的。

    @Transactional(rollbackFor = Throwable.class)

事务失效场景二：捕获异常之后不抛出

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createUser(String name) throws MyCheckedException{
        user user = new user();
        user.setName(name);
        userMapper.insert(user);
        try{
            throw new MyCheckedException("This is a custom checked exception");
        }
        catch(Exception ex){

        }

    }

如上所示，没有将异常抛出就不会触发回滚。

解决方案

记得抛出异常

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createUser(String name) throws MyCheckedException{
        user user = new user();
        user.setName(name);
        userMapper.insert(user);
        try{
            throw new MyCheckedException("This is a custom checked exception");
        }
        catch(Exception ex){
            throw  ex;
        }
    }

事务失效场景三：使用了非public方法

Spring的事务管理依赖于AOP代理，而AOP只能代理public方法。如果你在非public方法上使用了@Transactional注解，这个注解将不起作用，事务也不会生效。

原理和上面aop失效的原理一样。

事务失效场景四：内部方法调用

如果在同一个类中，一个方法调用了另一个带有@Transactional注解的方法，Spring的AOP代理将无法拦截这个内部调用，导致事务注解失效。解决方法之一是将被调用的方法提取到另一个bean中。

原理也和上面aop使用this调用失效的原理一样。

代码如下：

一个普通方法调用了一个事务方法，并且事务方法里面手动抛出异常，正常来说应该回滚的，但是因为是this.调用，aop失效就无法回滚了。

@Service
public class UserServiceImpl implements UserService , CommandLineRunner {

    public class MyCheckedException extends Exception {
        public MyCheckedException(String message) {
            super(message);
        }
    }


    private UserMapper userMapper;
    private UserService userService;
    @Override
    public void createUser(String name) throws MyCheckedException {
        user user = new user();
        user.setName(name);
//        userMapper.insert(user);
        this.test();
    }
    @Transactional(rollbackFor = Exception.class)
    public void test() throws MyCheckedException {
        user user = new user();
        user.setName(new Date().toString());
        userMapper.insert(user);
        try{
            throw new MyCheckedException("This is a custom checked exception");
        }
        catch(Exception ex){
            throw  ex;
        }
    }

    @Override
    public void run(String... args) throws Exception {
        userMapper = AopTestApplication.getBean(UserMapper.class);
        userService = AopTestApplication.getBean(UserService.class);
    }
}

解决方案一

将this.调用换成Bean调用

解决方案二

使用事务方法调用事务方法，这样子即使是this调用也会回滚了。

代码如下所示，但是这个的本质是外层事务方法进行的回滚，里面调用的事务方法并没有执行回滚。

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createUser(String name) throws MyCheckedException {
        user user = new user();
        user.setName(name);
//        userMapper.insert(user);
        this.test();
    }

    @Transactional(rollbackFor = Exception.class)
    public void test() throws MyCheckedException {
        user user = new user();
        user.setName(new Date().toString());
        userMapper.insert(user);
        try{
            throw new MyCheckedException("This is a custom checked exception");
        }
        catch(Exception ex){
            throw  ex;
        }
    }