Spring AOP 与 Aspect

lryu
97 阅读8分钟

1 Spring AOP（Aspect-Oriented Programming）和AspectJ

Spring AOP（Aspect-Oriented Programming）和AspectJ是两种不同但密切相关的概念，用于实现面向切面编程。 Spring AOP（Aspect-Oriented Programming）和AspectJ是两种不同但密切相关的概念，用于实现面向切面编程。让我们分别解释它们：

  1. Spring AOP(docs.spring.io/spring-fram…):

    Spring AOP是Spring框架的一部分，用于提供面向切面编程的支持。它基于代理模式，在运行时动态生成代理对象来实现切面的功能。Spring AOP的关键特点包括：

    • 轻量级：Spring AOP是Spring框架的一部分，因此不需要引入额外的依赖。
    • 依赖注入：Spring AOP支持依赖注入，可以将切面（通知）作为Spring Bean进行管理。
    • 支持常见的切面类型：Spring AOP支持@Before（前置通知）、@After（后置通知）、@Around（环绕通知）、@AfterReturning（返回通知）和@AfterThrowing（异常通知）等切面类型。

    Spring AOP的主要限制是它只能应用于Spring管理的Bean，它通过代理模式实现切面，因此仅对Bean方法调用起作用，而不会影响Bean内部方法的调用。

  2. AspectJ（eclipse.dev/aspectj/doc…:

    AspectJ是一个独立的面向切面编程框架，它提供了更强大和灵活的AOP支持。AspectJ不仅可以用于Spring应用程序，还可以用于任何Java应用程序。AspectJ的关键特点包括：

    • 强大的切面表达式：AspectJ支持更复杂的切面表达式，允许更精确地定义切入点。
    • 编译时和运行时织入：AspectJ支持编译时织入和运行时织入，这意味着你可以在编译时将切面织入到代码中，或者在运行时动态织入。
    • 更广泛的应用范围：AspectJ可以应用于任何Java类，而不仅仅是Spring管理的Bean

2 AOP的语法与使用

Spring AOP（Aspect-Oriented Programming）是Spring框架的一个重要特性，它允许你将横切关注点（cross-cutting concerns）从应用程序核心逻辑中分离出来，以提高代码的可维护性和可复用性：

基本概念：

  1. 切面（Aspect） ：切面是一种模块化的方式，用于处理横切关注点。它由通知（Advice）和切入点（Pointcut）组成。
  2. 通知（Advice） ：通知是切面中的方法，它定义了在何时（例如方法执行前、后、异常抛出时）以及在何地（切入点）执行特定的操作。
  3. 切入点（Pointcut） ：切入点是一组匹配连接点（Join Points）的表达式，连接点是程序执行过程中可以拦截的点。切入点决定了通知在何处执行。
  4. 连接点（Join Point） ：连接点是程序执行过程中的特定点，如方法调用、方法执行、异常抛出等。通知可以在连接点处执行。
  5. 织入（Weaving） ：织入是将切面与应用程序代码连接起来的过程。织入可以在编译时、类加载时或运行时进行。

语法与使用：

  1. 创建切面：使用@Aspect注解来标识一个类为切面，并在该类中定义通知方法。
  2. 定义切入点：使用@Pointcut注解定义切入点表达式，以匹配连接点。
  3. 编写通知：创建通知方法，通常使用@Before（前置通知）、@After（后置通知）、@Around（环绕通知）、@AfterReturning（返回通知）和@AfterThrowing（异常通知）等注解。
  4. 将切面织入应用程序：Spring支持三种织入方式：编译时织入、类加载时织入和运行时织入。最常见的是运行时织入。
  5. 配置Spring AOP：在Spring配置文件或使用Java配置类中启用AOP，并定义切面和通知的Bean。

JoinPoint语法

JoinPoint表示在程序执行过程中可以被拦截的点。它代表着方法的执行，通常与切面中的通知（advice）一起使用。AspectJ提供了多种JoinPoint语法，以便你精确地选择切入点（即哪些方法需要被拦截）。以下是一些常用的JoinPoint语法：

  1. execution表达式：execution表达式是用于匹配方法执行的语法，它的基本格式是execution(modifiers? return_type package_name.class_name.method_name(parameter_list) throws? exception_list?)，其中各个部分可以使用通配符来匹配。例如：

    • execution(* com.example.service.*.*(..))：匹配com.example.service包下所有类的所有方法。
    • execution(public * com.example.service.MyService.*(..))：匹配com.example.service包下MyService类的所有public方法。
    • execution(* com.example.service.*Service.*(..))：匹配包名以Service结尾的类的所有方法。

  2. within表达式：within表达式用于匹配指定类型内的所有方法。例如：

    • within(com.example.service.*)：匹配com.example.service包下的所有方法。

  3. this表达式：this表达式用于匹配当前被代理对象的类型。例如：

    • this(com.example.service.MyService)：匹配当前被代理对象类型为com.example.service.MyService的方法。

  4. target表达式：target表达式用于匹配当前被代理对象实际执行的类型。例如：

    • target(com.example.service.MyService)：匹配当前被代理对象实际执行类型为com.example.service.MyService的方法。

  5. args表达式：args表达式用于匹配方法参数的类型。例如：

    • args(String)：匹配方法参数为String类型的方法。

  6. @annotation表达式：@annotation表达式用于匹配带有特定注解的方法。例如：

    • @annotation(com.example.annotations.Loggable)：匹配带有@Loggable注解的方法。

声明式通知在springboot中的使用

以下是一个包含Spring Boot Aspect的完整示例，演示了AspectJ注解的用法，包括@Before、@After、@Around和@AfterReturning：

  1. 创建一个Spring Boot项目，添加以下依赖到你的pom.xml文件中：
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>
  1. 创建一个简单的Service类，例如：
package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class MyService {
    public void doSomething() {
        System.out.println("MyService.doSomething() is called.");
    }
}
  1. 创建一个Aspect类，例如：
package com.example.demo;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {
    @Pointcut("execution(* com.example.demo.MyService.*(..))")
    private void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeServiceMethod() {
        System.out.println("Before executing service method.");
    }

    @After("serviceMethods()")
    public void afterServiceMethod() {
        System.out.println("After executing service method.");
    }

    @Around("serviceMethods()")
    public Object aroundServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method execution (around advice).");
        Object result = joinPoint.proceed();
        System.out.println("After method execution (around advice).");
        return result;
    }

    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void afterReturningServiceMethod(Object result) {
        System.out.println("After returning from service method with result: " + result);
    }
}
  1. 创建一个Spring Boot应用主类：
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

5.创建一个Controller类，用于触发Service中的方法：

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    private final MyService myService;

    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/doSomething")
    public String doSomething() {
        myService.doSomething();
        return "Service method executed.";
    }
}
  1. 行应用并访问 http://localhost:8080/doSomething，你将看到Aspect中的各种通知在Service方法执行前后起作用。

这个示例演示了Spring Boot中使用AspectJ注解的各种用法，包括@Before、@After、@Around和@AfterReturning，它们可以在方法执行前后或返回结果时执行自定义的逻辑。

最佳实践

编写高质量的AspectJ切面的最佳实践可以帮助你确保AOP功能的有效性和可维护性。以下是一些AspectJ切面的最佳实践：

  1. 保持切面简洁和专注：

    • 切面应该专注于解决特定的横切关注点（cross-cutting concerns），而不是尝试处理多个不相关的关注点。切面的职责应该是单一的。

  2. 选择切入点明智：

    • 仔细选择切入点表达式，确保只有需要的方法被拦截。不要使用过于宽泛的表达式，以免影响性能和引入不必要的复杂性。

  3. 优先考虑使用@Before和@AfterReturning：

    • 在可能的情况下，首选使用@Before（前置通知）和@AfterReturning（返回通知），因为它们对于维护代码和理解切面的行为更容易。

  4. 避免滥用@Around：

    • @Around（环绕通知）提供了最大的灵活性，但也容易滥用。只有在必要时才使用@Around，因为它可能会引入复杂性和性能开销。

  5. 测试切面：

    • 编写单元测试来验证切面和通知的行为。确保切面按预期工作，并覆盖各种边界情况。

  6. 文档和注释：

    • 提供清晰的文档和注释，以描述切面的目的和行为。这有助于团队成员理解和正确使用切面。

  7. 异常处理：

    • 如果切面处理了异常，确保它们以一种明智的方式处理。避免吞噬异常，最好将它们记录或传播给上层调用者。

  8. 了解代理模式：

    • 理解代理模式对于正确使用切面非常重要。AspectJ通常使用代理来织入切面，了解代理的工作原理有助于避免潜在的问题。

  9. 性能注意事项：

    • 考虑AOP对性能的影响。避免在性能关键的代码路径上使用AOP，以及使用合理的切入点表达式来限制AOP的执行。

  10. 版本控制：

    • 使用版本控制来管理切面代码，以便跟踪和恢复到先前的版本。

  11. 持续维护和改进：

    • 定期审查和改进切面代码，以适应应用程序的演变。确保切面仍然满足需求并保持高质量。

小结

Spring AOP（Aspect-Oriented Programming）是Spring框架的一个核心特性，它允许你将横切关注点（cross-cutting concerns）从应用程序核心逻辑中分离出来，以提高代码的可维护性和可复用性。

avatar
文章
阅读
粉丝