SpringAOP的实现机制（底层原理）、应用场景等详解-编程知识

SpringAOP的实现机制（底层原理）应用场景等详解

Spring框架是Java开发中最流行的应用程序框架之一。它提供了广泛的功能，其中之一就是面向切面编程（AOP）。Spring AOP允许我们将关注点（例如日志记录、事务管理）模块化，并将它们应用到应用程序中的多个部分，而不是将它们散布在整个代码库中。

本文将深入探讨Spring AOP的底层原理，帮助更好地理解这一关键概念。

切面（Aspect）

在Spring AOP中，切面是通知（Advice）和切点（Pointcut）的组合。通知定义了在何时以及何方式执行代码，而切点定义了何处执行这些代码。通常，切面用于跨越多个模块的关注点，例如日志记录或事务管理。

通知（Advice）

通知是切面的核心。它定义了在切点处执行的代码。

Spring AOP支持以下几种通知类型：

前置通知（Before Advice）： 在目标方法执行前执行。
后置通知（After Advice）： 在目标方法执行后执行，无论方法是否抛出异常。
返回通知（After Returning Advice）： 在目标方法成功执行并返回结果后执行。
异常通知（After Throwing Advice）： 在目标方法抛出异常时执行。
环绕通知（Around Advice）： 在目标方法执行前后都执行，可以控制方法的执行流程。

切入点（Pointcut）

切点定义了通知应该被执行的位置。它使用表达式或规则匹配方法的名称和参数。例如，可以使用切点来匹配所有以“get”开头的方法。

代理（Proxy）

Spring AOP依赖于代理模式来实现切面。将通知应用到目标对象之后，程序动态创建的通知对象，就称为代理。

代理类既可能是和原类具有相同接口的类，也可能是原类的子类，可以采用调用原类相同的方式调用代理类。也就是我们昨天说的如何判断是哪种动态代理方式的区别。

Spring AOP的俩种动态代理方式

JDK动态代理（默认代理方式）
CGLIB动态代理

JDK动态代理的底层机制

默认情况下，Spring AOP使用JDK动态代理，JDK动态代理是通过java.lang.reflect.Proxy 类实现的，可以调用Proxy类的newProxyInstance()方法创建代理对象。JDK动态代理可以实现无侵入式的代码扩展，并且可以在不修改源代码的情况下，通知/增强某些方法。

下面我们通过一个案例，来演示Spring中JDK动态代理的实现过程

案例具体实现步骤如下：

①创建任意Maven项目，这里以springAopExplain为例

②在pom中引入依赖SpringAOP依赖文件

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.10</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.7</version></dependency>

③编写接口UserDao，以及接口的实现类，分别实现里面的方法（这里没有跟传统的三层架构一样编写，这里主要是为了了解底层机制，是如何实现动态代理的，所以理解原理模拟过程即可）

package com.steveDash.dao;import com.steveDash.entity.User;public interface UserDao {public void saveUser(User user);public void deleteUser(User user);
}

package com.steveDash.dao;import com.steveDash.entity.User;public class UserDaoImpl implements UserDao {private UserDao userDao;public void saveUser(User user) {System.out.println("添加用户成功");}public void deleteUser(User user) {System.out.println("删除用户成功");}
}

④编写切面类，用来作为AOP通知集合的类（这里顺手写了一下之前学习的注解实现AOP写法，除此之外还得在applicationContext中进行一个AOP的设置才能够进行使用）

package com.steveDash.dao;import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;//定义的切面类：里面编写的是各种通知方法Advice(通知或者增强方法)
@Aspect
public class TestAspect {@Pointcut("execution(public void com.steveDash.dao.UserDaoImpl.saveUser())")public void pointcut(){}@Before("pointcut()")public void before(){System.out.println("使用前检查是否满足条件？");}@Pointcut("execution(public void com.steveDash.dao.UserDaoImpl.deleteUser())")public void pointcut1(){}@AfterReturning("pointcut1()")public void afterResult(){System.out.println("调用结束后返回日志结果，进行记录");}
}

⑤因为我们的切入点所属的对象是接口的实现类，那么就是JDK动态代理，接下来我们创建MyInvocationHandler，作为模拟实现InvocationHandler接口设置代理类的调用处理程序。

package com.steveDash.jdkTest;import com.steveDash.dao.UserDao;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler {private UserDao target;public MyInvocationHandler(UserDao target) {this.target =target;}//若省略invoke()方法会报错，需要自行完成具体的代码体，方法框架可以一键生成，如下文@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 在方法调用前执行一些操作System.out.println("Before invoking method: " + method.getName());// 调用目标对象的方法Object result = method.invoke(target, args);// 在方法调用后执行一些操作System.out.println("After invoking method: " + method.getName());return result;}
}

进行导包，选择第一个java.lang.reflect，跟我们前面说的一样

在这里插入图片描述

下面的Proxy也得进行导包，也是Java.lang.reflect

在这里插入图片描述

到这里就跟我上面的代码块的效果基本一致了，会发现还有报错的地方，这里的意思就是说缺少了invoke()方法的代码，让我们实现该方法，鼠标移至灰色处，点击Implement methods，选择invoke方法

在这里插入图片描述

仔细查看这一块的代码，并且可以尝试替换成TestAspect里面的Before和AfterReturing的方法，这里只是用简单的输出来模拟过程。

⑥创建测试类JDKTest，模拟动态代理的过程

package com.steveDash.dao;import com.steveDash.entity.User;
import com.steveDash.jdkTest.MyInvocationHandler;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;public class JDKTest {public static void main(String[] args) {// 创建实际的目标对象UserDao userDao = new UserDaoImpl();// 创建自定义的 InvocationHandlerInvocationHandler handler = new MyInvocationHandler(userDao);// 使用 Proxy 创建代理对象UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(JDKTest.class.getClassLoader(),new Class[]{UserDao.class},handler);// 创建一个用户对象User user = new User(1,"SteveDash");// 通过代理对象调用方法userDaoProxy.saveUser(user);userDaoProxy.deleteUser(user);}
}

在这里插入图片描述

整个过程就很明啦

下面我们通过一个案例，来演示CGLib动态代理的实现过程

JDK动态代理存在缺陷，它只能为接口创建代理对象，当需要为类创建代理对象时，就需要使用CGLib（Code Generation Library）动态代理，它采用底层的字节码技术，通过继承的方式动态创建代理对象。

Spring的核心包已经集成了CGLib所需要的包，所以开发中不需要另外导入JAR包。

①因为CGLib动态代理的是类，那么我们就新建一个包myDao，在包内完成所有文件的创建用于模拟CGLib动态代理的全过程。

package com.steveDash.myDao;public class UserDao {public void saveUser() {System.out.println("Saving user data...");}
}

②创建CGLib的代理类：

package com.steveDash.myDao;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class UserDaoCglibProxy implements MethodInterceptor {private UserDao target;public UserDaoCglibProxy(UserDao target) {this.target = target;}public Object createProxy() {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(target.getClass());enhancer.setCallback(this);return enhancer.create();}@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("Before method execution...");Object result = proxy.invokeSuper(obj, args); // 调用目标对象的方法System.out.println("After method execution...");return result;}
}

和上面一样进行导包，在爆红的地方

在这里插入图片描述

导入第一个带有cglib的

在这里插入图片描述

然后整体就是这个样子的

在这里插入图片描述

代码详解：

在这里**UserDaoCglibProxy 类实现了 MethodInterceptor 接口，它会在目标方法执行前后进行拦截**。

Enhancer 类用于创建代理对象，通过设置目标类的超类（setSuperclass）和回调拦截器（setCallback）来生成代理对象。

在拦截器的 intercept 方法中，我们可以在调用目标方法前后执行自定义的通知方法。就跟前面的AspectTest里面的通知一样。

③创建测试类CglibTest

在这里插入图片描述

从这里就可以看出，CGLib确实是动态代理成功并且拦截了我们的目标方法的调用

在这里插入图片描述

关于AOP的实现昨天我们已经编写过啦，这里就不再重复。三层架构设计模式MVC和AOP面向切面编程—SSM框架的学习与应用(Spring + Spring MVC + MyBatis)-Java EE企业级应用开发学习记录（第九天）_Stevedash的博客-CSDN博客

总结

JDK动态代理和CGLib动态代理都是Java中用于实现代理模式的技术，它们允许我们创建代理对象来控制对其他对象的访问。

以下是关于这两种代理技术的知识点总结：

JDK动态代理：

基于接口： JDK动态代理要求目标类实现接口，代理对象也必须实现与目标对象相同的接口。
InvocationHandler接口： JDK动态代理使用 InvocationHandler 接口来创建代理对象，该接口包含一个方法 invoke，在代理对象的方法被调用时，该方法会被执行。
Proxy类： 使用 java.lang.reflect.Proxy 类来创建代理对象。
限制： JDK动态代理只能代理实现了接口的类，无法代理没有实现接口的类。
性能： 通常情况下，JDK动态代理相对于CGLib动态代理性能较低，因为它需要通过反射来调用目标对象的方法。
示例： 常见的使用JDK动态代理的场景包括Spring的AOP和RMI（远程方法调用）。

CGLib动态代理：

基于继承： CGLib动态代理不要求目标类实现接口，它通过继承目标类来创建代理对象。
Enhancer类： 使用 net.sf.cglib.proxy.Enhancer 类来创建代理对象。
MethodInterceptor接口： CGLib动态代理使用 MethodInterceptor 接口来实现代理逻辑，该接口包含一个方法 intercept，在代理对象的方法被调用时，该方法会被执行。
性能： 通常情况下，CGLib动态代理性能较高，因为它直接调用目标对象的方法，无需通过反射。
限制： CGLib动态代理无法代理被 final 声明的类和方法。
示例： 常见的使用CGLib动态代理的场景包括Hibernate的实体对象加载和Spring的AOP（Aspect-Oriented Programming）。