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.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>

    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.7version>
    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方法

SpringAOP的实现机制(底层原理)、应用场景等详解_第1张图片

仔细查看这一块的代码,并且可以尝试替换成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

SpringAOP的实现机制(底层原理)、应用场景等详解_第2张图片

从这里就可以看出,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分

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

你可能感兴趣的:(SSM框架的学习,JAVA企业级应用开发必学框架,java,springAOP知识点,俩种动态代理,JDK动态代理,CGLib动态代理)