likes
comments
collection
share

Spring 整合 AspectJ AOP 的使用

作者站长头像
站长
· 阅读数 46

日积月累，水滴石穿 😄

什么是AOP

AOP 为 Aspect Oriented Programming 的缩写,翻译为面向切面编程，利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。通俗理解就是在不修改源代码的情况下，在主干功能里面添加新的功能。

AOP中的专业术语

  • Advisor：切面，也可以称为 Aspect，由 切点（pointCut）和 建议（advice）组成。

  • Advice：单词意思是建议，不过国内程序员一般称为通知。建议切面在何时执行以及如何执行增强处理。说的直白点就是代理逻辑。通知分为如下几种：

    • Before ：前置通知，在连接点前调用。如果抛出异常则不会流转到连接点。
    • After ：后置通知，在连接点后调用，不管连接点是否执行正常、异常都会执行的通知。
    • AfterReturning：返回通知，在连接点执行正常并返回后调用，执行正常也就是说在执行过程中没有发生异常。
    • AfterThrowing：异常通知，当连接点执行发生异常时调用。
    • Around：环绕通知，连接点执行的前后可以执行自定义代码。

  • Join point：连接点，在 Spring AOP中一个连接点就是一个方法。

  • PointCut：切点，一系列连接点的集合，可以通过表达式找到一系列的连接点。

  • Target object：目标对象。被一个或多个切面建议的对象，也就是被代理对象。

  • AOP proxy：代理对象。由 AOP 框架创建的对象，使用的是JDK 动态代理或 CGLIB 代理。

  • Weaving：织入，就是将代理逻辑添加到对目标类具体连接点上，并创建代理对象的过程。

Spring 框架是基于 AspectJ 实现 AOP 操作！但各位需要知道， AspectJ 并不是 Spring 的组成部分，它是一个独立的框架，Spring AOP引入了对 AspectJ 的支持，也建议使用 AspectJ 来开发 AOP。

使用 Spring 实现 AOP 方式有两种，分别如下：

  • XML 配置文件实现
  • 注解实现 先来看一下不使用 AOP 的代码！

加入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>

配置类

@ComponentScan(basePackages = "com.cxyxj.aopannon")
public class AppMain {
}

类中就一个@ComponentScan注解。

业务代码

@Controller
public class UserController {
    public String queryUser(String name){
        System.out.println("查询用户信息");
        return name;
    }
}

测试类

public class AppTest {
    public static void main(String[] args)
    {
      AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
        AppMain.class);
      UserController bean = context.getBean(UserController.class);
      String cxyxj = bean.queryUser("cxyxj");
      System.out.println("方法返回值为 = " + cxyxj);
    }
}

测试代码，运行结果如下：

查询用户信息

过了一段时间，项目经理跟你聊天。。。

  • 项目经理：我想在 queryUser方法中加一个方法执行开始时间和方法执行结束时间吧，但是有个要求不能改动原逻辑！你有什么好注意。

  • 你：稍作考虑，我们可以使用 Spring AOP 进行实现。

  • 项目经理：怎么使用 AOP 呢？

  • 你：我所了解到的方式有两种，分别是 XML 配置文件实现 和 注解实现。

  • 项目经理：嗯，看来你胸有成竹了，那这任务就交给你了，别让我失望哦！

  • 你：嗯好的，我先写个 demo 给您过目一下。

配置文件方式

加入依赖

既然要使用 Spring AOP，那先在 pom.xml 文件中引入相关依赖：

<!--aspectj 支持-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.6</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

Spring AOP 的依赖就不需要再次加入了，spring-context中有 Spring AOP 的依赖。

AOP配置元素

XML方式的 AOP 配置有许多的标签，在这里进行介绍一下。

元素备注
aop:aspectj-autoproxy启用 @AspectJ 注解支持，与 @EnableAspectJAutoProxy效果一致
aop:config最外层的 AOP 元素，大多数的其他AOP元素（切面、切点、通知）需要写在 aop:config 元素内。
aop:advisor定义 AOP 通知器，通知器跟切面一样，也包括通知和切点。
aop:aspect定义一个切面，aop:aspect 元素内可以定义通知类型！
aop:pointcut定义切点
aop:before前置通知，在连接点执行前调用。
aop:after后置通知，在连接点执行后调用。不管目标方法是否发生异常。
aop:after-returning返回通知，在连接点执行正常并返回后调用。
aop:after-throwing异常通知，当连接点执行发生异常时调用。
aop:around环绕通知，连接点执行之前和之后都可以执行额外代码。
  • ProductController
public class ProductController {
    
    public String productQuery(String name){
        System.out.println("产品查询===");
        return name;
    }
}
  • ProductAspect
public class ProductAspect {

    private static final String Pattern = "yyyy-MM-dd HH:mm:ss";
    
    public void before(JoinPoint joinPoint){
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
        String timeStr = now.format(formatter);
        System.out.println("方法执行开始时间：" + timeStr);
    }
    public void after(JoinPoint joinPoint){
	LocalDateTime now = LocalDateTime.now();
	DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
	String timeStr = now.format(formatter);
	System.out.println("方法执行完成时间：" + timeStr);
    }
}

进行配置

<bean class="com.cxyxj.aopxml.ProductAspect" id="productAspect"></bean>
<bean class="com.cxyxj.aopxml.ProductController" id="productController"></bean>

测试类

public static void main(String[] args) {
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
    "AOP01.xml");
  ProductController bean = context.getBean(ProductController.class);
  String cxyxj = bean.productQuery("cxyxj");
  System.out.println("方法返回值： " + cxyxj);
}

测试代码，运行结果如下：

产品查询===
方法返回值： cxyxj

接下来就对该方法进行 AOP 增强！

配置文件增加AOP配置

  • 1、增加 aop 命名空间
<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/aop 
       https://www.springframework.org/schema/aop/spring-aop.xsd">
  • 2、增加如下配置
<aop:config>
    <!--配置切面  ref指向切面类 该元素可以将定义好的 普通Bean 转换为切面 Bean-->
    <aop:aspect ref="productAspect">
            <aop:before method="before" pointcut="execution(* com.cxyxj.aopxml.ProductController.productQuery(..))"></aop:before>
            <aop:after method="after" pointcut="execution(* com.cxyxj.aopxml.ProductController.productQuery(..))"></aop:after>
    </aop:aspect>
</aop:config>

测试代码，运行结果如下：

方法执行开始时间：2022-04-19 21:43:51
产品查询===
方法执行完成时间：2022-04-19 21:43:51
方法返回值： cxyxj

xml 方式可以对重复使用的切点表达式进行提取，使用标签aop:pointcut。

抽取公用切点表达式

<aop:config>
    <!--配置切点-->
    <aop:pointcut id="productPointcut" expression="execution(* com.cxyxj.aopxml.ProductController.productQuery(..))"/>
    <!--配置切面  ref指向切面类 该元素可以将定义好的 普通Bean 转换为切面 Bean-->
    <aop:aspect ref="productAspect">
            <aop:before method="before" pointcut-ref="productPointcut"></aop:before>
            <aop:after method="after" pointcut-ref="productPointcut"></aop:after>
    </aop:aspect>
</aop:config>
  • 当 <aop:pointcut>元素作为 <aop:config> 元素的子元素定义时，表示它可被多个切面所共享。
  • 当 <aop:pointcut> 元素作为 <aop:aspect> 元素的子元素时，表示该切入点只对当前切面有效。

上面展示了 aop:aspect定义切面的使用方式。下面介绍<aop:advisor>标签的使用方式。<aop:advisor>，定义 AOP 通知器，通知器跟切面一样，也包括通知和切点。但需要注意一点：<aop:aspect>定义切面时，可以引用普通 bean，而定义<aop:advisor>时，引用的通知必须实现 Advice 接口。

advisor 标签使用

1、创建名为 ProductAdvice 的类，实现 MethodBeforeAdvice, AfterReturningAdvice两个接口！

public class ProductAdvice implements MethodBeforeAdvice, AfterReturningAdvice  {
    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("方法执行前===》");
    }
 
    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("方法执行后！");
    }
}
    • MethodBeforeAdvice：前置通知，在连接点执行前调用。
    • AfterReturningAdvice：返回通知，在连接点执行正常并返回后调用。

  • 2、在Spring配置文件中增加如下代码：

<bean class="com.cxyxj.aopxml.ProductAdvice" id="productAdvice"></bean>

<aop:config>

    <aop:advisor advice-ref="productAdvice" pointcut="execution(* com.cxyxj.aopxml.ProductController.productQuery(..))"></aop:advisor>
    
</aop:config>
  • 3、启动结果如下：
方法执行前===》
产品查询===
方法执行后！
方法返回值： cxyxj

注解方式

为了防止与上面的代码冲突，在其 aopannon包下，所有类重新进行创建！

配置相关注解

@ComponentScan(basePackages = "com.cxyxj.aopannon")
@EnableAspectJAutoProxy
public class AppMain {
}

在配置类中新增注解@EnableAspectJAutoProxy，代表开启 @AspectJ 注解支持。

也可以使用 xml 方式开启 AOP 方式，如以下示例所示：

<aop:aspectj-autoproxy/>

创建普通 Bean


@Component
public class UserController {

    public String queryUser(String name) {
        System.out.println("用户查询===");
        return  "用户查询" + name;
    }

}

定义切面

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Aspect
@Component
public class TimeAspect {

private static final String Pattern = "yyyy-MM-dd HH:mm:ss";

@Before("execution(* com.cxyxj.aopannon.UserController.queryUser(..))")
public void before(JoinPoint joinPoint){
    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
    String timeStr = now.format(formatter);
    System.out.println("方法执行开始时间：" + timeStr);
}

@After("execution(* com.cxyxj.aopannon.UserController.queryUser(..))")
public void after(JoinPoint joinPoint){
    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
    String timeStr = now.format(formatter);
    System.out.println("方法执行完成时间：" + timeStr);
}
}

TimeAspect类上， 使用@Component注解表示它将作为一个 Spring Bean 被容器管理，使用注解 @Aspect 表示它是一个切面。

类中有两个方法 before、after，分别使用 @Before、@After注解进行标注。代表在目标方法执行前、目标方法执行后执行。具体用法下面介绍。

两个方法都有一个类型为 JoinPoint的参数，这个参数是 Spring 提供的，可以用来获取到方法信息。比如：目标方法参数、目标对象等等。这个参数是非必选的。

("execution(*)") 声明了切点，也就是 PointCut，表明在该切面的切点是com.cxyxj.aopannon.UserController这个类中的queryUser方法，queryUser 就是一个连接点。 对于execution的具体用法下面会简单介绍介绍。

测试类

public class AppTest {
    public static void main(String[] args)
    {
      AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
        AppMain.class);
      UserController bean = context.getBean(UserController.class);
      String cxyxj = bean.queryUser("cxyxj");
      System.out.println("方法返回值为 = " + cxyxj);
    }
}

测试代码，运行结果如下：

方法执行开始时间：2022-04-20 22:14:07
用户查询===
方法执行完成时间：2022-04-20 22:14:07
方法返回值为 = 用户查询cxyxj

完美达到项目经理的要求！

通知类型

注解方式也有 5 种通知类型，分别如下：

  • Before ：前置通知，在连接点执行前调用。
属性备注
value绑定切入点表达式。可以直接设置切入点表达式，也可以设置切入点声明

  • After ：后置通知，在连接点执行后调用。不管目标方法是否发生异常。 | 属性 | 备注 | | --- | --- | |value| 绑定切入点表达式。可以直接设置切入点表达式，也可以设置切入点声明|

  • AfterReturning：返回通知，在连接点执行正常并返回后调用，执行正常也就是说在执行过程中没有发生异常。 | 属性 | 备注 | | --- | --- | |value| 绑定切入点表达式。可以直接设置切入点表达式，也可以设置切入点声明| |pointcut| 跟 value 效果一致，但优先级高于 value| |returning| 将目标方法的返回值绑定到指定的参数名称|

  • AfterThrowing：异常通知，当连接点执行发生异常时调用。 | 属性 | 备注 | | --- | --- | |value| 绑定切入点表达式。可以直接设置切入点表达式，也可以设置切入点声明| |pointcut| 跟 value 效果一致，但优先级高于 value| |throwing| 将目标方法发生的异常绑定到指定的参数名称|

  • Around：环绕通知，连接点执行之前和之后都可以执行额外代码。 | 属性 | 备注 | | --- | --- | |value| 绑定切入点表达式。可以直接设置切入点表达式，也可以设置切入点声明|

那如何使用呢？在上述例子中已经使用到Before和 After两种通知，接下来将其他类型的通知补全，然后进行测试，观察它们的执行顺序。


/**
 * @param result：需要与 returning 指定的值保存一致，两者需要同时使用！
 * result参数的类型需要与目标方法的返回值类型保存一致，如果两者不一致则不会执行该通知方法！
 * 如果不确定目标方法返回的类型，则可以使用 Object
 */
@AfterReturning(value =
  "execution(* com.cxyxj.aopannon.UserController.queryUser(..))",
  returning = "result")
public void afterReturning(Object result) {
  System.out.println("返回通知：afterReturning = " + result);
}

/**
 * @param ex：需要与 throwing 指定的值保存一致，两者需要同时使用！
 */
@AfterThrowing(value =
  "execution(* com.cxyxj.aopannon.UserController.queryUser(..))",
  throwing = "ex")
public void afterThrowing(Throwable ex) {
  if(ex instanceof ArithmeticException) {
    System.out.println("异常通知：afterThrowing");
  }
}

@Around("execution(* com.cxyxj.aopannon.UserController.queryUser(..))")
public void around(ProceedingJoinPoint joinPoint) {
  System.out.println("环绕通知前：around");
  try {
        //执行下一个流程
        Object proceed = joinPoint.proceed();
        // proceed 目标方法的返回值
        System.out.println("目标方法的返回值 = " + proceed);
        System.out.println("环绕通知后：around");
  } catch(Throwable throwable) {
    System.out.println("环绕通知执行下一个流程异常：around");
  }
 
}

测试代码，运行结果如下：

环绕通知前：around
方法执行开始时间：2022-04-20 22:29:26
用户查询===
返回通知：afterReturning = 用户查询cxyxj
方法执行完成时间：2022-04-20 22:29:26
目标方法的返回值 = 用户查询cxyxj
环绕通知后：around
方法返回值为 = null

可以发现执行顺序为 环绕通知前逻辑 -》 前置通知 -》 目标方法 -》返回通知 -》后置通知 -》 环绕通知后逻辑。 注意不同的 Spring 版本可能会有差异。比如 5.0.8.RELEASE 和 5.3.17。

环绕通知是五种通知中最复杂、也是最强大的一种，需要传入类型为 ProceedingJoinPoint 参数，这个参数也只能加在环绕通知上。有了这个参数就可以干其他逻辑，比如：获得当前方法的参数、方法、目标对象。

并且还需要显示调用 ProceedingJoinPoint 的 proceed() 方法。 如果没调用该方法，那执行结果如下 ：

环绕通知前：around
环绕通知后：around
方法返回值为 = null
  • 可以发现并没有将 方法执行开始时间： 用户查询、返回通知、方法执行完成时间这几句话打印出来，也就是说，如果不调用 proceed() 方法，则不会执行 前置通知 和 目标方法逻辑、返回通知、后置通知。当然正常来说，也不会如此使用！

根据打印的日志还可以发现最终方法返回值为变为了 null。但是在环绕通知里还是有返回值的，这是为什么呢？

因为被@Around标注的方法是 void，那么就需要给 @Around的方法设置返回参数，

@Around("execution(* com.cxyxj.aopannon.UserController.queryUser(..))")
public Object around(ProceedingJoinPoint joinPoint){
    System.out.println("环绕通知前：around");
    try {
        //执行下一个流程
        Object proceed = joinPoint.proceed();
        // proceed 目标方法的返回值
        System.out.println("目标方法的返回值 = " + proceed);
        System.out.println("环绕通知后：around");
        return proceed;
    } catch (Throwable throwable) {
        System.out.println("环绕通知执行下一个流程异常：around");
        return null;
    }
}

测试代码，运行结果如下：

环绕通知前：around
方法执行开始时间：2022-04-20 22:34:17
用户查询===
返回通知：afterReturning = 用户查询cxyxj
方法执行完成时间：2022-04-20 22:34:17
proceed = 用户查询cxyxj
环绕通知后：around
方法返回值为 = 用户查询cxyxj
  • 上面的例子并没有执行异常通知，那异常通知需要怎么才能被执行呢？需要当连接点执行发生异常时调用。那就在 queryUser方法中抛一个异常吧！
public String queryUser(String name) {
    System.out.println("用户查询===");
    int i = 1/0;
    return  "用户查询" + name;
}

测试代码，运行结果如下：

环绕通知前：around
方法执行开始时间：2022-04-20 22:36:26
用户查询===
异常通知：afterThrowing
方法执行完成时间：2022-04-20 22:36:26
环绕通知执行下一个流程异常：around
方法返回值为 = null

OK，达到目的，返回通知并没有被执行，并且异常通知有执行。

抽取公用切点表达式

上面我们定义了五种通知，但是五种通知的切入点表达式都是一致的。是不是觉得代码重复率挺高的。对于这种频繁出现的相同的表达式，可以使用 @Pointcut注解声明切点表达式，抽取公用切点表达式，然后在各种通知中进行使用，具体使用如下：

@Pointcut("execution(* com.cxyxj.aopannon.UserController.queryUser(..))")
public void pointcutCommon(){

}
@Before(value = "pointcutCommon()")
public void before(JoinPoint joinPoint) {
  LocalDateTime now = LocalDateTime.now();
  DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
  String timeStr = now.format(formatter);
  System.out.println("方法执行开始时间：" + timeStr);
}
@After("pointcutCommon()")
public void after(JoinPoint joinPoint) {
    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Pattern);
    String timeStr = now.format(formatter);
    System.out.println("方法执行完成时间：" + timeStr);
  }
  /**
   * @param result：需要与 returning 指定的值保存一致，两者需要同时使用！
   *  result参数的类型需要与目标方法的返回值类型保存一致，
   * 如果两者不一致则不会执行该通知方法！
   * 如果不确定目标方法返回的类型，则可以使用 Object
   */
@AfterReturning(value = "pointcutCommon()", returning = "result")
public void afterReturning(Object result) {
    System.out.println("返回通知：afterReturning = " + result);
  }
  /**
   * @param ex：需要与 throwing 指定的值保存一致，两者需要同时使用！
   */
@AfterThrowing(value = "pointcutCommon()", throwing = "ex")
public void afterThrowing(Throwable ex) {
  if(ex instanceof ArithmeticException) {
    System.out.println("异常通知：afterThrowing");
  }
}
@Around("pointcutCommon()")
public Object around(ProceedingJoinPoint joinPoint) {
  System.out.println("环绕通知前：around");
  try {
    //执行下一个流程
    Object proceed = joinPoint.proceed();
    // proceed 目标方法的返回值
    System.out.println("目标方法的返回值 = " + proceed);
    System.out.println("环绕通知后：around");
    return proceed;
  } catch(Throwable throwable) {
      System.out.println("环绕通知执行下一个流程异常：around"); 
      return null;
  }
}

测试代码，运行结果如下：

环绕通知前：around
方法执行开始时间：2022-04-20 22:41:11
用户查询===
异常通知：afterThrowing
方法执行完成时间：2022-04-20 22:41:11
环绕通知执行下一个流程异常：around
方法返回值为 = null

切入点表达式

切入点表达式有什么作用呢？寻找连接点。

上面只用到了其中一种表达式：execution。

语法结构如下：

execution(权限修饰符匹配? 返回类型匹配 类名匹配? 方法名匹配(参数匹配) 异常匹配?)

结构中带?符号的匹配式都是可选的，也就是说必写的只有三个:

  1. 返回类型匹配
  2. 方法名匹配
  3. 参数匹配

还支持通配符

  1. *：匹配所有字符
  2. ..：匹配多个包或者多个参数
  3. +：表示类及其子类
  4. &&、||、!：运算符

可能比较难以理解，下面举几个例子：

  • 1、对 com.cxyxj.controller.UserController 类里面的 queryUser 方法进行增强 结构：execution(* com.cxyxj.controller.UserController.queryUser(..))
  • 2、对 com.cxyxj.controller.UserController 类里面的所有方法进行增强 结构：execution(* com.cxyxj.controller.UserController.*(..))
  • 3、对 com.cxyxj.controller包中的所有类、所有方法进行增强 结构：execution(* com.cxyxj.controller.*.*(..))
  • 4、对 com.cxyxj.controller.UserController 类里面的 queryUser 方法或者 addUser进行增强 "execution(* com.cxyxj.aopannon.UserController.queryUser(..))" + "|| execution(* com.cxyxj.aopannon.UserController.addUser(..))"
  • 如你对本文有疑问或本文有错误之处，欢迎评论留言指出。如觉得本文对你有所帮助，欢迎点赞和关注。
转载自:https://juejin.cn/post/7088930138385023007
评论
请登录