SpringBoot使用AOP,内部方法失效的解决方案

首先，需要明确AOP（Aspect Oriented Programming）的概念和作用。AOP可以将一些横切关注点（Cross Cutting Concerns）从业务逻辑中独立出来，如日志、权限、事务等通用逻辑，从而提高代码的可维护性和可重用性。在Spring Boot框架中，通过使用注解、切面和切点等技术来实现AOP。

接下来，我们来讲解Spring Boot在使用AOP时可能遇到的问题，及其解决方案。

问题描述

在Spring Boot中使用AOP时，可能会遇到如下问题：内部方法（即同一类中的方法，包含不同的AOP切面）被AOP失效的情况。具体表现为，AOP切面可以作用于类的public方法上，但是对该类中的其他方法（如private方法）不起作用。

造成这种情况的原因是，Spring AOP默认使用的是JDK动态代理，只能代理以接口为基础的类，而无法处理类的内部方法，从而导致切面无法生效。

解决方案

针对Spring Boot中AOP切面失效的问题，我们可以采用如下两种解决方案：

1. 使用CGLIB代理方式

CGLIB代理是基于类的代理方式，可以处理类中的方法，因此可以解决上述AOP切面失效的问题。可以通过在@SpringBootApplication注解中添加(proxyBeanMethods = false)来启用CGLIB代理。

@SpringBootApplication(proxyBeanMethods = false)
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

2. 将AOP切面放到一个单独的Bean中

另一种可行的解决方案是将AOP切面放到一个单独的Bean中，这样Spring AOP就可以正常工作了。具体做法如下：

1. 创建一个AOP切面类，实现切面逻辑。

@Aspect
@Component
public class MyAspect {
    @Around("execution(* com.example.demo..*.*(..))")
    public Object checkPermission(ProceedingJoinPoint point) throws Throwable {
        // AOP逻辑
        return point.proceed();
    }
}

1. 使用@ComponentScan注解来扫描该AOP切面类。

@SpringBootApplication
@ComponentScan(basePackages = {"com.example.demo", "com.example.demo.aspect"})
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

这样，就可以解决AOP切面失效的问题。

示例说明

下面通过两个示例来进一步说明如何解决Spring Boot使用AOP，内部方法失效的问题。

示例一

假设我们有一个UserService，其中包含public和private两个方法。我们想要通过AOP来实现对UserService中所有方法的日志记录。

在UserService中添加如下的public和private方法：

@Service
public class UserService {
    public void publicMethod() {
        System.out.println("publicMethod execute");
    }

    private void privateMethod() {
        System.out.println("privateMethod execute");
    }
}

接下来，我们定义一个AOP切面MyAspect，用来实现日志记录。在MyAspect中添加如下代码：

@Aspect
@Component
public class MyAspect {
    @Around("execution(* com.example.demo.UserService.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start logAround");
        Object result = joinPoint.proceed();
        System.out.println("end logAround");
        return result;
    }
}

由于Spring AOP默认使用JDK动态代理实现AOP，因此切面仅会作用于UserService中的public方法，对private方法不起作用。此时，我们可以通过在@SpringBootApplication注解中添加(proxyBeanMethods = false)或者在定义MyAspect的时候，加入@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)来切换为CGLIB代理方式，从而实现对private方法的切面处理。

示例二

假设我们有一个CalculatorService，其中包含两个public方法，分别用来计算两个数的和和差。我们想要通过AOP来实现对两个方法的前置通知（before）。

首先，创建CalculatorService和CalculatorServiceImpl类，如下所示：

public interface CalculatorService {
    Integer add(Integer a, Integer b);
    Integer sub(Integer a, Integer b);
}

@Service
public class CalculatorServiceImpl implements CalculatorService {

    public Integer add(Integer a, Integer b) {
        return a + b;
    }
    public Integer sub(Integer a, Integer b) {
        return a - b;
    }
}

然后，定义一个AOP切面MyAspect，用来实现前置通知。在MyAspect中添加如下代码：

@Aspect
@Component
public class MyAspect {
    @Before("execution(* com.example.demo.CalculatorService.add(..))")
    public void beforeAdd(JoinPoint joinPoint) {
        System.out.println("before add method");
    }

    @Before("execution(* com.example.demo.CalculatorService.sub(..))")
    public void beforeSub(JoinPoint joinPoint) {
        System.out.println("before sub method");
    }
}

由于MyAspect和CalculatorServiceImpl处于不同的包中，因此默认情况下，MyAspect中的切面仅会作用于CalculatorServiceImpl中的public方法。这时，我们可以将MyAspect放到一个单独的Bean中，从而解决AOP切面失效的问题。具体做法如下：

1. 将MyAspect放到com.example.demo.aspect包下，并添加@Component注解（如示例一中所示）。

2. 在@SpringBootApplication注解中添加@ComponentScan注解，扫描com.example.demo和com.example.demo.aspect两个包（如示例一中所示）。

这样，切面就可以正常工作了，可以在执行CalculatorServiceImpl的add和sub方法时，实现前置通知。

以上就是本文关于“Spring Boot使用AOP,内部方法失效的解决方案”的攻略，希望对您有所帮助。