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

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

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

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

---

切面（Aspect）

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

---

通知（Advice）

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

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

1. 前置通知（Before Advice）： 在目标方法执行前执行。
2. 后置通知（After Advice）： 在目标方法执行后执行，无论方法是否抛出异常。
3. 返回通知（After Returning Advice）： 在目标方法成功执行并返回结果后执行。
4. 异常通知（After Throwing Advice）： 在目标方法抛出异常时执行。
5. 环绕通知（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()方法会报错，需要自行完成具体的代码体，方法框架可以一键生成，如下文
    @Override
    public 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();

        // 创建自定义的 InvocationHandler
        InvocationHandler 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();
    }

    @Override
    public 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动态代理：

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

---

CGLib动态代理：

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

---

选择使用JDK动态代理还是CGLib动态代理取决于我们的需求和场景。

• 如果目标对象实现了接口且你需要更大的灵活性，可以使用JDK动态代理。
• 如果目标对象没有实现接口或性能是关键因素，可以使用CGLib动态代理。
• 在实际应用中，有时候也会同时使用这两种技术，根据需求选择合适的代理方式才是最佳的！

作者：Stevedash

发表于：2023年9月9日19点37分

注：本文内容基于个人学习理解，如有错误或疏漏，欢迎指正。感谢阅读！如果觉得有帮助，请点赞和分享。