Spring AOP与静态代理/动态代理

---

一、代理模式

代理模式是一种结构型设计模式，它允许对象提供替代品或占位符，以控制对这个对象的访问。代理对象通常充当客户端和实际服务对象之间的中介，以实现对服务对象的间接访问。
代理模式的实现有许多种方式，其中最常见的方式是静态代理和动态代理。

静态代理

静态代理是指，在编译期间就已经确定了代理类和目标类的关系，代理类和目标类的关系在程序运行之前就已经确定。下面是一个简单的静态代理模式示例：

假设有一个接口 IPrinter 表示打印机，它有一个 print 方法：

public interface IPrinter {
    void print(String document);
}

现在有一个实现了 IPrinter 接口的类 Printer：

public class Printer implements IPrinter {
    @Override
    public void print(String document) {
        System.out.println("打印机正在打印：" + document);
    }
}

现在我们想通过代理来记录打印机打印了哪些文件，我们可以创建一个代理类 PrinterProxy：

public class PrinterProxy implements IPrinter {
    private IPrinter printer;

    public PrinterProxy(IPrinter printer) {
        this.printer = printer;
    }

    @Override
    public void print(String document) {
        System.out.println("打印机开始工作，正在打印：" + document);
        printer.print(document);
        System.out.println("打印机打印完成。");
    }
}

PrinterProxy 类实现了 IPrinter 接口，并在 print 方法中调用真正的打印机的 print 方法，同时在这个方法之前和之后打印一些信息来记录打印机工作的情况。

现在我们可以使用以下代码来测试代理类的工作：

IPrinter printer = new Printer();
IPrinter printerProxy = new PrinterProxy(printer);

printerProxy.print("茶叶蛋的前端简历");

运行程序后，输出的结果将是：

打印机开始工作，正在打印：茶叶蛋的前端简历
打印机正在打印：茶叶蛋的前端简历
打印机打印完成。

从输出结果可以看出，代理类 PrinterProxy 确实在调用真正的打印机类 Printer 的 print 方法之前和之后打印了一些信息。这是静态代理模式的基本实现方式。

结合我们生活来理解的话：最常见就是在大城市里租房了，房源太多，你忙于工作，此时你找了个代理人（上面👆的代理类） ，帮你处理找房子这个事（你的业务逻辑）。这里时候代理人就可以在找房子🏠这个事的前前后后（@defore @after @around 等）做文章了。例如，在找房子之前给你索取代理费（织入的逻辑）。找到房子帮你办理入住手续。

动态代理

Java提供了动态代理的支持，通过Java反射机制可以实现动态代理。我们可以使用Java自带的 java.lang.reflect.Proxy 类来实现动态代理。

以静态代理的打印机为例，我们可以使用动态代理来生成代理类。需要实现一个 InvocationHandler 接口，该接口包含一个 invoke 方法，我们可以在这个方法中实现代理的逻辑。

示例代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface IPrinter {
    void print(String document);
}

class Printer implements IPrinter {
    @Override
    public void print(String document) {
        System.out.println("打印机正在打印：" + document);
    }
}

class PrinterHandler implements InvocationHandler {
    private Object target;

    public PrinterHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("打印机开始工作，正在打印：" + args[0]);
        Object result = method.invoke(target, args);
        System.out.println("打印机打印完成。");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        PrinterHandler handler = new PrinterHandler(printer);
        IPrinter printerProxy = (IPrinter) Proxy.newProxyInstance(
                printer.getClass().getClassLoader(),
                printer.getClass().getInterfaces(),
                handler);
        printerProxy.print("茶叶蛋的简历");
    }
}

在此示例中，我们实现了 InvocationHandler 接口，并在 invoke 方法中实现了代理逻辑。在 main 方法中，我们首先创建了一个真正的打印机类 Printer 的实例，然后创建了一个 PrinterHandler 对象并将其传递给 Proxy.newProxyInstance 方法，该方法返回一个实现了 IPrinter 接口的代理类的实例。

在运行过程中，当使用代理类的 print 方法时，它将被拦截并调用 PrinterHandler 的 invoke 方法，该方法将在真实的打印机类 Printer 的 print 方法之前和之后执行一些逻辑。

从输出结果可以看出，动态代理确实实现了和静态代理相同的代理逻辑。

打印机开始工作，正在打印：茶叶蛋的简历
打印机正在打印：茶叶蛋的简历
打印机打印完成。

代理模式与AOP

代理模式和AOP（面向切面编程）是两个不同的概念，但在某些方面存在相似之处。

代理模式是一种结构型设计模式，用于为其他对象提供一个替代或协助的代理对象，控制对原始对象的访问。代理对象通常具有与原始对象相同的接口，因此可以无缝地替换原始对象，但在访问原始对象时，代理对象可以执行额外的逻辑或限制，比如缓存对象或限制访问。

AOP是一种编程范式，用于将通用功能与应用程序的业务逻辑相分离。AOP通过在程序中定义切面（横切关注点）并在运行时将它们与各种连接点（方法调用、异常处理等）连接起来，实现了针对具体业务逻辑之外的通用功能的重用。

虽然代理模式可以在一定程度上实现AOP，但AOP是更高级别的概念，涵盖了更广泛的应用，包括动态代理、依赖注入、解耦等方面。因此，代理模式只是AOP的一种实现方式，而AOP更多地考虑了程序的整体结构和可维护性。

切面理解：

二、Spring AOP

2）使用AOP需要的一些概念。

1.通知(Advice)

通知定义了在切入点代码执行时间点附近需要做的工作。支持五种类型的通知：

Before(前) org.apringframework.aop.MethodBeforeAdvice
After-returning(返回后) org.springframework.aop.AfterReturningAdvice
After-throwing(抛出后) org.springframework.aop.ThrowsAdvice
Arround(周围) org.aopaliance.intercept.MethodInterceptor
Introduction(引入) org.springframework.aop.IntroductionInterceptor

2.连接点(Joinpoint)
程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法调用时、异常抛出时、方法返回后等等。

3.切入点(Pointcut)

通知定义了切面要发生的“故事”，连接点定义了“故事”发生的时机，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定。

4.切面(Aspect)

通知、连接点、切入点共同组成了切面：时间、地点和要发生的“故事”。

5.引入(Introduction)

引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）。

6.目标(Target)

即被通知的对象，如果没有AOP，那么通知的逻辑就要写在目标对象中，有了AOP之后它可以只关注自己要做的事，解耦合

7.代理(proxy)
应用通知的对象，详细内容参见设计模式里面的动态代理模式。

8.织入(Weaving)
把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:

(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器；

(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码；

(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术。

Sping AOP用来处理什么场景

下面是一个简单的基于Spring AOP的例子：

首先，定义一个接口UserService和实现类UserServiceImpl：

public interface UserService {
    void addUser(User user);
    User getUser(int id);
}

@Service
public class UserServiceImpl implements UserService {
    private Map<Integer, User> users = new HashMap<>();

    @Override
    public void addUser(User user) {
        users.put(user.getId(), user);
    }

    @Override
    public User getUser(int id) {
        return users.get(id);
    }
}

然后，定义一个切面LoggingAspect来记录方法的执行时间：

@Aspect
@Component
public class LoggingAspect {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Around("execution(* com.example.demo.UserService.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;
        logger.info(joinPoint.getSignature() + " executed in " + executionTime + " ms");
        return proceed;
    }
}

在这个切面中，我们定义了一个@Around通知，用于环绕目标方法的执行。在执行方法前记录当前时间，执行方法后计算时间差，并将结果输出到日志中。

最后，在Spring配置文件中开启AOP：

<beans>
    <context:component-scan base-package="com.example.demo"/>

    <aop:aspectj-autoproxy/>
</beans>

使用<aop:aspectj-autoproxy>标签，Spring会自动查找所有被@Aspect注解标记的切面，并为它们创建代理对象。

现在，我们可以注入UserService并调用它的方法，来测试AOP是否生效：

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    @ResponseBody
    public String getUser(@PathVariable int id) {
        userService.getUser(id);
        return "User retrieved";
    }

    @PostMapping("/user")
    @ResponseBody
    public String addUser(@RequestBody User user) {
        userService.addUser(user);
        return "User added";
    }
}

当我们访问/user/{id}或/user时，控制台会输出类似于下面的日志：

com.example.demo.UserServiceImpl@xxxx executed in 10 ms

jdk 动态代理

JDK动态代理是一种在运行时动态生成代理类的机制，所以也被称为运行时代理。它主要涉及到以下两个核心类：

1. java.lang.reflect.Proxy：该类是实现动态代理的关键类，它提供了构造代理类实例所需的方法。
2. java.lang.reflect.InvocationHandler：该接口是实际处理代理对象方法调用的地方，通过调用它的 invoke() 方法实现代理对象的方法调用。

JDK动态代理的实现原理：

• 定义一个接口或者抽象类，指定了需要被代理的方法。
• 创建一个实现 InvocationHandler 接口的类，它需要实现 invoke() 方法，该方法是代理类的调用处理器，负责处理被代理对象的方法调用。
• 通过 Proxy 类的静态方法 newProxyInstance() 获取代理对象实例，该方法接收三个参数：ClassLoader、Class[] 和 InvocationHandler。其中，ClassLoader 是代理类的 ClassLoader，Class[] 是指定被代理类实现的接口列表，InvocationHandler 是实现了 invoke() 方法的调用处理器对象。
• 当代理对象的方法被调用时，代理对象会调用 InvocationHandler 实例的 invoke() 方法。该方法使用 Method 对象来调用实际的被代理对象的方法，并返回结果。

总体来说，JDK动态代理的实现过程涉及到反射和动态生成类的机制，它可以在运行时创建代理对象，并将代理对象的方法调用转发给 InvocationHandler 接口的实现类处理。

cglib 动态代理

CGLIB（Code Generation Library）是一个基于ASM（一个 Java 字节码操作框架）的代码生成库，它可以在运行时动态生成字节码，从而实现动态代理、AOP 等功能。

相比于 Java 中的 JDK 动态代理，CGLIB 动态代理具有以下特点：

1. JDK 动态代理只能代理接口，而 CGLIB 可以代理普通类；
2. JDK 动态代理调用代理方法时需要通过反射调用，而 CGLIB 利用字节码技术直接调用方法，性能更高。

CGLIB 动态代理的基本原理是继承原始类或实现接口，并在子类中重写原始类或接口的方法，在方法中添加前置、后置等代理逻辑。CGLIB 动态代理一般使用 Enhancer 类来实现，其核心 API 包括：

1. setSuperclass：设置被代理类的父类；
2. setCallback：设置回调对象；
3. create：创建代理对象。

使用 CGLIB 动态代理可以实现更加灵活的代理逻辑，但是代理对象的创建和调用会消耗更多的资源，需要根据实际情况进行使用。

面试题：讲讲Spring AOP的原理与执行流程

Spring AOP（面向切面编程）是一种通过动态代理或字节码增强等技术，在程序运行期间对指定方法进行增强的技术。Spring AOP的原理是基于动态代理技术，利用Java的反射机制，在不改变原有代码的情况下，对指定方法进行增强。它提供了一种使程序横向通用化的能力，比如事务管理、日志记录等功能。在Spring AOP中，切面是应用横向关注点的一种特殊对象，而横向关注点是指跨越应用程序多个接口的功能或行为，比如安全，事务，日志等。

执行流程如下：

首先，程序通过配置文件或注解，定义好需要被增强的方法，以及增强的方式。Spring AOP提供了五个增强类型，分别是前置增强（Before Advice），后置增强（After Advice），环绕增强（Around Advice），异常抛出增强（After-Throwing Advice）和最终增强（After-Finally Advice

然后，Spring框架在程序运行期间，根据这些定义，动态生成一个代理对象。

当程序调用被增强的方法时，代理对象会先调用相应的增强方法，然后再执行被增强的方法。

在增强方法中，可以进行一些额外的处理，例如记录日志、验证权限、性能统计等。

最后，程序返回执行结果。

---

总结

我们一开始简单的初步认识了下代理模式，其中常见的实现方式有静态代理与动态代理，同时写了打印机🖨️的调用时机代码。接着我们思考🤔代理模式和我们使用spring aop有什么联系？简单的了解aop 与spring aop的实现方式。 最后我们比较了jdk 与cglib 的代理模式 ，接着简单过一遍Spring aop 的原理与执行流程。