四、AOP原理

L_D_Y_K

已于 2022-08-25 09:53:26 修改

阅读量180

点赞数

分类专栏： Spring 文章标签： spring aop 代理 jdk cglib

于 2021-01-04 11:27:47 首次发布

本文链接：https://blog.csdn.net/L_D_Y_K/article/details/112171072

版权

Spring 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

四、AOP原理

1、概述

面向切面编程（Aspect Oriented Programming），AOP是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP是OOP的延续，主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF（Gang of Four）设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。假设把应用程序想成一个立体结构的话，OOP是纵向切入系统，把系统划分为很多个模块（如：用户模块，订单模块等等），而AOP是横向切入系统，提取各个模块可能都要重复操作的部分（如：权限检查，日志记录等等）。由此可见，AOP是OOP的一个有效补充。

注意：AOP不是一种技术，实际上是编程思想。凡是符合AOP思想的技术，都可以看成是AOP的实现。

2、基础概念

(1)、ASM

ASM是一个Java字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM可以直接产生二进制class文件，也可以在类被加载入Java虚拟机之前动态改变类行为。ASM从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。不过ASM在创建class字节码的过程中，操纵的级别是底层JVM的汇编指令级别，这要求ASM使用者要对class组织结构和JVM汇编指令有一定的了解。

3、代理模式

(1)、概述

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：在不改动原有代码的前提下，在已有代码基础上添加新的功能，从而增强原功能。这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需改修改，可以通过代理的方式来扩展该方法。Spring AOP就是基于动态代理的，如果要代理的对象实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，Spring AOP会使用Cglib，这时候Spring AOP会使用Cglib生成一个被代理对象的子类来作为代理。

(2)、分类

①、静态代理（静态定义代理类）：静态代理实现起来比较简单，需要提前定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。但静态代理需要去实现每一个被代理的类以及方法，如果被代理的方法比较多，会比较繁琐。

②、动态代理（动态生成代理类）：

a、JDK动态代理：需要被代理类一定要实现某个接口，而代理类只需要实现InvocationHandler接口。代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）。只能对实现了接口的类生成代理，而不能针对类，对于没有实现接口的类无法实现JDK动态代理。

b、cglib动态代理：提供的动态代理不需要类实现了某个接口，是针对类实现代理。cglib采用继承的方式实现动态代理，主要是对指定的类生成一个子类，覆盖其中的方法。因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。

(3)、静态代理的代码实现

①、定义Automobile接口

public interface Automobile {
    String doSomething(String series);
}

②、被代理类实现Automobile接口

public class Benz implements Automobile {
    @Override
    public String doSomething(String series) {
        return String.format("德国奔驰：%s",series);
    }
}

③、代理类实现Automobile接口

public class BeijingBenz implements Automobile {

    private Benz benz;
    public BeijingBenz(Benz benz){
        this.benz = benz;
    }

    @Override
    public String doSomething(String series) {
        System.out.println("我是北京奔驰，我代理德国奔驰");
        String msg =  benz.doSomething(series);
        System.out.println(msg);
        return msg;
    }
}

④、实现静态代理

public class Main {
    public static void main(String[] args) {
        Benz benz = new Benz();
        BeijingBenz beijingBenz = new BeijingBenz(benz);
        beijingBenz.doSomething("S600");
    }
}

(4)、JDK动态代理的代码实现

①、定义Automobile接口

public interface Automobile {
    String doSomething(String series);
}

②、被代理类实现Automobile接口

public class BMW implements Automobile {
    @Override
    public String doSomething(String series) {
        return String.format("德国宝马 %s", series);
    }
}

③、代理类实现InvocationHandler接口

public class HuachenBMW implements InvocationHandler {

    public Automobile target;
    
    public HuachenBMW(Automobile 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);
        System.out.println("代理车系是：" + ret);
        return ret;
    }
}

④、实现JDK动态代理

public class Main {

    public static void main(String[] args) {
        BMW BMW = new BMW();
        HuachenBMW huachenBMW = new HuachenBMW(BMW);

        Automobile automobile =(Automobile)Proxy.newProxyInstance(BMW.getClass().getClassLoader(),
                BMW.getClass().getInterfaces(),
                huachenBMW);

        String series = automobile.doSomething("X6");
        System.out.println("抢到一辆："+ series);
    }
}

(5)、cglib动态代理的代码实现

①、引入cglib的jar包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.10</version>
</dependency>

②、定义被代理类

public class Audi {
    public String doSomething(String series){
        System.out.println("原产于德国的奥迪汽车");
        return String.format("德国奥迪，车系是：%s", series);
    }
}

③、代理类实现MethodInterceptor接口

public class FirstAudi implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理德国奥迪汽车");
        Object series =  methodProxy.invokeSuper(o, objects);
        System.out.println(series);
        return series;
    }
}

④、实现cglib动态代理

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Audi.class);
        enhancer.setCallback(new FirstAudi());

        Audi audi = (Audi) enhancer.create();
        audi.doSomethin("A8");
    }
}

注：JDK内置动态代码采用Java反射机制实现，cglib库实现的动态代理，采用的是ASM直接操作字节码方式实现。由于反射操作的效率要低于直接操作字节码的效率，所以，cglib实现动态代理效率上比JDK内置的动态代理要好。

4、AOP代码实现

(1)、Spring4和Spring5的AOP区别（基于注解实现测试）

SpringBoot 1.*.*版本对应Spring4版本

SpringBoot 2.*.*版本对应Spring5版本

此问题会在SpringBoot由1版本升级到2版本会出现，因为Spring版本由4升级到了5。

①、Spring4（SpringBoot 1 ）

a、正常执行顺序：@Before(前置通知)===@After(后置通知)===@AfterReturning(正常返回)

b、异常执行顺序：@Before(前置通知)===@After(后置通知)===@AfterThrowing(方法异常)

②、Spring5（SpringBoot 2 ）

a、正常执行顺序：@Before(前置通知)===@AfterReturning(正常返回)===@After(后置通知)

b、异常执行顺序：@Before(前置通知)===@AfterThrowing(方法异常)===@After(后置通知)

(2)、注解实现AOP

①、配置信息

//开启事物注解权限
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

②、切面类

/**
* 注解释义
 * @Aspect：指定一个类为切面类
 * @Component：注解的类看为组件，当使用基于注解的配置和类路径扫描的时候，这些类就会被实例化
 * @Pointcut("execution(* com.warehouse.controller.*.*.*(..))")：指定切入点表达式
 * @Before("execution(* com.warehouse.controller.*.*.*(..))")：前置通知，即目标方法执行前调用
 * @After("execution(* com.warehouse.controller.*.*.*(..))")：后置通知，即目标方法执行后调用（始终执行）
 * @AfterReturning("execution(* com.warehouse.controller.*.*.*(..))")：返回值通知，即执行方法结束前执行（异常不执行）
 * @AfterThrowing("execution(* com.warehouse.controller.*.*.*(..))")：异常通知，即出现异常时候执行
 * @Around("execution(* com.warehouse.controller.*.*.*(..))")：环绕通知，即环绕目标方法执行
 */

@Component
@Aspect
public class AopLog {
    // 前置通知：目标方法之前执行
    @Before("execution(* com.warehouse.controller.*.*.*(..))")
    public void begin() {
        System.out.println("前置通知");
    }
    // 后置通知：目标方法之后执行（始终执行）
    @After("execution(* com.warehouse.controller.*.*.*(..))")
    public void commit() {
        System.out.println("后置通知");
    }
    // 返回后通知：执行目标方法结束前执行（异常不执行）
    @AfterReturning("execution(* com.warehouse.controller.*.*.*(..))")
    public void returning() {
        System.out.println("运行通知");
    }
    // 异常通知：出现异常时候执行
    @AfterThrowing("execution(* com.warehouse.controller.*.*.*(..))")
    public void afterThrowing() {
        System.out.println("异常通知");
    }
    // 环绕通知：环绕目标方法执行
    @Around("execution(* com.warehouse.controller.*.*.*(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }
}

(3)、XML配置实现AOP

①、XML配置

<!-- 切面类 -->
<bean id="aop" class="com.aop.AopLog"></bean>
<!-- Aop配置 -->
<aop:config>
    <!-- 定义一个切入点表达式： 拦截哪些方法 -->
    <aop:pointcut expression="execution(* com.warehouse.controller.*.*.*(..))"
    id="pt" />
    <!-- 切面 -->
    <aop:aspect ref="aop">
        <!-- 环绕通知 -->
        <aop:around method="around" pointcut-ref="pt" />
        <!-- 前置通知： 在目标方法调用前执行 -->
        <aop:before method="begin" pointcut-ref="pt" />
        <!-- 后置通知： -->
        <aop:after method="after" pointcut-ref="pt" />
        <!-- 返回后通知 -->
        <aop:after-returning method="afterReturning"
    pointcut-ref="pt" />
        <!-- 异常通知 -->
        <aop:after-throwing method="afterThrowing"
    pointcut-ref="pt" />
    </aop:aspect>
</aop:config>

②、切面类

public class AopLog {
    // 前置通知
    public void begin() {
        System.out.println("前置通知");
    }
    // 后置通知
    public void commit() {
        System.out.println("后置通知");
    }
    // 运行通知
    public void returning() {
        System.out.println("运行通知");
    }
    // 异常通知
    public void afterThrowing() {
        System.out.println("异常通知");
    }
    // 环绕通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }
}