spring aop底层实现原理 spring aop原理详解

转载

mob6454cc6f8e48 2024-02-21 20:35:22

文章标签 spring aop底层实现原理 spring java 代理模式 AOP 文章分类 架构后端开发

在软件开发中，面向切面编程（Aspect-Oriented Programming，简称 AOP）是一种重要的编程范式，它可以帮助我们更好地解耦复杂的系统，提高代码的可维护性。

在 Spring 框架中，AOP 是一个核心组件，本文将为你剖析 Spring AOP 的原理，带你领略 AOP 的魅力。

一、AOP 基本概念

在介绍 Spring AOP 之前，我们先了解一下 AOP 的基本概念：

切面（Aspect）：封装横切关注点的模块，如日志记录、权限控制等。
连接点（JoinPoint）：程序执行过程中的某个特定位置，如方法调用、异常抛出等。
切入点（Pointcut）：选定连接点的表达式，用于确定应用切面的位置。
通知（Advice）：切面的具体操作，如前置通知、后置通知、环绕通知等。
织入（Weaving）：将切面与目标对象结合，创建代理对象的过程。

二、Spring AOP 原理

Spring AOP 的实现主要基于动态代理模式，通过代理对象将横切关注点与业务代码分离，从而实现解耦。Spring AOP 支持两种代理方式：JDK 动态代理和 CGLIB 动态代理。

JDK 动态代理

JDK 动态代理基于 Java 反射机制，要求目标对象必须实现接口。

代理对象在运行时生成，实现目标对象的接口，并将请求转发给目标对象。

以下是一个简单的 JDK 动态代理示例：

public interface UserService {
  void addUser();
}
public class UserServiceImpl implements UserService {
  @Override
  public void addUser() {
      System.out.println("添加用户");
  }
}
public class JDKDynamicProxy implements InvocationHandler {
  private Object target;
  public JDKDynamicProxy(Object target) {
      this.target = target;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("前置通知");
      Object result = method.invoke(target, args);
      System.out.println("后置通知");
      return result;
  }
  public static void main(String[] args) {
      UserService userService = new UserServiceImpl();
      JDKDynamicProxy proxy = new JDKDynamicProxy(userService);
      UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), proxy);
      userServiceProxy.addUser();
  }
}

CGLIB 动态代理

CGLIB（Code Generation Library）是一个代码生成库，可以在运行时为目标对象创建子类并覆盖其方法。

与 JDK 动态代理不同，CGLIB 动态代理不要求目标对象实现接口，但目标类不能为 final。

以下是一个简单的 CGLIB 动态代理示例：

public class UserService {
  public void addUser() {
      System.out.println("添加用户");
  }
}
public class CGLIBDynamicProxy implements MethodInterceptor {
  private Object target;
  public CGLIBDynamicProxy(Object target) {
      this.target = target;
  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
      System.out.println("前置通知");
      Object result = proxy.invokeSuper(obj, args);
      System.out.println("后置通知");
      return result;
  }

  public static void main(String[] args) {
      UserService userService = new UserService();
      Enhancer enhancer = new Enhancer();
      enhancer.setSuperclass(userService.getClass());
      enhancer.setCallback(new CGLIBDynamicProxy(userService));
      UserService userServiceProxy = (UserService) enhancer.create();
      userServiceProxy.addUser();
  }
}

三、Spring AOP 实践

在 Spring 框架中，我们可以通过注解或 XML 配置的方式实现 AOP。以下是一个使用注解实现 AOP 的实际案例：

添加依赖

首先，我们需要添加 Spring AOP 和 AspectJ 的依赖：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>${spring.version}</version>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>${aspectj.version}</version>
</dependency>

定义切面

接下来，我们定义一个切面，包含前置通知和后置通知：

@Component
@Aspect
public class LogAspect {
  @Pointcut("execution(* com.example.service.UserService.addUser(..))")
  public void pointcut() {}
  @Before("pointcut()")
  public void before() {
      System.out.println("前置通知");
  }

  @After("pointcut()")
  public void after() {
      System.out.println("后置通知");
  }
}

配置 AOP

在 Spring 配置文件中，我们需要开启自动代理和组件扫描：

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">

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

现在，当我们调用 UserService.addUser() 方法时，切面的前置通知和后置通知将自动执行，实现了横切关注点与业务代码的分离。

public class Application {
  public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      UserService userService = context.getBean(UserService.class);
      userService.addUser();
  }
}

输出结果：