【Spring】Aop使用详解

概述

① AOP（Aspect Orient Programming）, 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充；
② 面向切面编程，不修改源代码给程序动态统一添加额外功能的一种技术，实现业务代码解耦；
③ 应用主要体现在事务处理、日志管理、权限控制、异常处理等方面，分离功能性需求和非功能性需求，增强代码的可读性和可维护性。

graph LR
日志记录---事务管理---权限验证---性能监控

静态代理

Spring Aop底层实现原理是动态代理，因此先介绍一下静态代理。

特点

① 静态代理要求目标对象和代理对象实现同一个业务接口。代理对象中的核心功能是由目标对象来完成，代理对象负责增强功能；
② 目标对象(被代理对象)必须实现接口;
③ 代理对象在程序运行前就已经存在——>扩展代理类Agent；
④ 支持目标对象灵活的切换，无法对功能灵活的处理——>动态代理可解决此问题。
<font color= 'red'>注意：静态代理只适合业务功能固定不变的情况。(业务接口方法不进行增加和减少，实现类就不需要改动)</font>

使用示例

需求描述：一个司机具有开车的能力，在开车前需要加油，开车结束后需要洗车和保养，开车前后的动作，在不改变开车内部逻辑的情况下，就可以采用静态代理实现，如下：

// 定义一个驾驶员接口，具有开车功能
public interface Driver {
    /**
     * 驾驶功能
     */
    void drive();
}

// 小轿车驾驶员实现驾驶员接口
public class CarDriver implements Driver{
    @Override
    public void drive(){
        System.out.println("正在开小轿车。");
    }
}

// 小轿车代理类
public class CarAgent implements Driver{
    @Override
    public void drive(){
        System.out.println("开车前要记得加油。");
        CarDriver carDriver = new CarDriver();
        carDriver.drive();
        System.out.println("开车后记得洗车和保养");
    }
}

// 测试类
public class CarAgentTest {
    @Test
    void testDrive(){
        CarAgent carAgent = new CarAgent();
        carAgent.drive();
    }
}

[图片上传失败...(image-44f9d6-1684200501221)]

动态代理

1、是使用反射和字节码的技术，在运行期创建指定接口或类的子类，以及其实例对象的技术，通过这个技术可以无侵入的为代码进行增强，动态代理主要有JDK和CGLIB两种方式；
2、如果代理方法很多，我们需要在每个代理方法都要写一遍，很麻烦。而动态代理则不需要。

JDK

// 编写动态代理类
public class CarJdkAgent<T> implements InvocationHandler {
    private T target;
    public CarJdkAgent(T target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable{
        System.out.println("调用方法前");
        Object ret = method.invoke(target,args);
        return ret;
    }
}

// 动态代理测试
public class DynAgentTest {

    @Test
    void testJdkAgent1(){
        Driver carDriver = new CarDriver();
        Driver proxyCarDriver = (Driver)Proxy.newProxyInstance(carDriver.getClass().getClassLoader(),
                carDriver.getClass().getInterfaces(),new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //args表示有几个参数，这里只有一个参数
                System.out.println("动态代理-开车前记得加油");
                //这里调用真实对象的方法
                return method.invoke(carDriver, args);
            }
        });
        proxyCarDriver.drive();
    }

    @Test
    void testJdkAgent2(){
        Driver carDriver = new CarDriver();
        InvocationHandler carJdkAgent = new CarJdkAgent<Driver>(carDriver);
        Driver proxyDriver= (Driver)Proxy.newProxyInstance(carDriver.getClass().getClassLoader(),
                carDriver.getClass().getInterfaces(), carJdkAgent);
        proxyDriver.drive();
    }
}

以上测试类两种方式，方式一采用匿名方法调用，可以不编写动态代理类，方式二通过编写动态代理类实现。

CGLIB

1、动态代理需要被代理类实现接口，如果被代理类没有实现接口，那么这么实现动态代理？这时候就需要用到CGLib了。这种代理方式就叫做CGlib代理；
2、Cglib代理也叫作子类代理，他是通过在内存中构建一个子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，然后加入自己需要的操作。因为使用继承的方式，所以不能代理final 类；
3、需要导入cglib的jar包,另外Spring的核心包中已经包括了Cglib功能,也可以导入spring-core-3.2.5.jar。

public class CarCglibAgent implements MethodInterceptor {
    public Object getProxy(Class cls) {
        // CGLIB <u>enhancer</u>增强类对象
        Enhancer enhancer = new Enhancer();
        // 设置增强类型
        enhancer.setSuperclass(cls);
        // 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
        enhancer.setCallback(this);
        // 生成并返回代理对象
        return enhancer.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        System.out.println("开车前先加油");
        // 执行目标对象的方法
        Object result = methodProxy.invokeSuper(obj, args);
        System.out.println("开完车记得洗车");
        return result;
    }
    // 测试调用
    public static void main(String[] args) {
        CarCglibAgent carCglibAgent = new CarCglibAgent();
        CarDriver carDriver = (CarDriver)carCglibAgent.getProxy(CarDriver.class);
        carDriver.drive();
    }

Spring Aop名词解释

关于AOP的概念这里不做过多介绍，我们只需要知道其中有三个非常重要的概念：
aspect（切面）、pointcut（切入点）、advice（通知）。

pointcut（切入点）

也就是具体拦截的某个业务点。
分为 execution（路径表达式）和 annotation 方式，被这两种方式修饰的代码将会被切面拦截处理;

advice（通知）

切面当中的处理方式，声明通知方法在业务层的执行位置，类型如下：
@Before：前置通知，在方法执行之前执行
@After：后置通知，在方法执行之后执行
@AfterRunning：返回通知，在方法返回结果后执行
@AfterThrowing：异常通知，在方法执行异常后执行
@Around：环绕通知，可以替代上述通知方法，并且可以控制方法是否执行以及何时执行。

aspect（切面）

即 pointcut+ advice ，和拦截器（HandlerInterceptorAdapter）的作用并没有太大的区别，只是两者的作用域不同，相对而言，切面的作用域更灵活一些。

使用介绍

基于自定义注解实现方式

// 定义自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface CustomAnnotation {
    public String ceShiValue() default "";
}

// 定义切面类
@Component
@Aspect
public class CustomAnnotationAspect {
    @Pointcut(value = "@annotation(com.zhc.javabase.aop.CustomAnnotation)")
    public void pointCut(){}
    @Before("pointCut()")
    public void beforeHandle(JoinPoint joinPoint){
        System.out.println("基于注解方法执行之前调用");
    }
    @After("pointCut()")
    public void afterHandle(JoinPoint joinPoint){
        System.out.println("方法执行之后调用");
    }
}

// Controller类中添加注解
@RestController
@RequestMapping("com/zhc/javabase/aop")
public class AopUseController {
    @GetMapping("/firstAop")
    @CustomAnnotation
    public String firstAop(){
        System.out.println("哈哈，aop学习");
        return "hello aop";
    }
}

基于路径表达式方式

// 定义切面类
@Component
@Aspect
public class CustomAnnotationAspect {
    @Pointcut(value = "execution(public * com.zhc.javabase.aop..*.*(..)))")
    public void executionPointCut(){}

    @Before("executionPointCut()")
    public void beforeHandle1(JoinPoint joinPoint){
        System.out.println("基于非注解方式，方法执行之前调用");
    }
}

在对应包路径下的接口会被切面所拦截，执行对应切面逻辑。

execution 切点表达式

由于Spring切面粒度最小是达到方法级别，而execution表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且在Spring中，大部分需要使用AOP的业务场景也只需要达到方法级别即可，因而execution表达式的使用是最为广泛的。如下是execution表达式的语法：

execution(modifiers-patternret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

这里问号表示当前项可以有也可以没有，其中各项的语义如下：

modifiers-pattern：方法的可见性，如public，protected；
ret-type-pattern：方法的返回值类型，如int，void等；
declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
name-pattern：方法名类型，如buisinessService()；
param-pattern：方法的参数类型，如java.lang.String；
throws-pattern：方法抛出的异常类型，如java.lang.Exception。