Spring-AOP基于@AspectJ注解的切面

Bertha 。 2023-07-18 05:51 62阅读 0赞

### Spring-AOP基于@AspectJ注解的切面 ###

## 该篇博客主要阐述 ##

##### 1、编写切点(@Pointcut) #####

##### 2、基于AspectJ的注解方式实现日志打印 #####

##### 3、环绕通知用法 #####

##### 4、JoinPoint用法 #####

##### 5、在 XML 中声明切面 #####

--------------------

### 一、编写切点(@Pointcut) ###

> @Pointcut需要在切面中使用，如下

![这里写图片描述][70]

> Pointcut定义时，还可以使用&&、||、! 这三个运算

![这里写图片描述][70 1]

#### 编写切点表达式 ####

![这里写图片描述][70 2]

#### AspectJ指示器 ####

> 当我们查看这些Spring支持的指示器时，注意只有execution指示器是唯一的执行匹配，而其他的指示器都是用于限制匹配的。这说明execution指示器是我们在编写切点定义时最主要使用的指示器

![这里写图片描述][70 3]

--------------------

### 二、基于AspectJ的注解方式实现日志打印 ###

#### 1、场景分析 ####

在一个经典的业务逻辑(加减乘除)中需要每次执行某个方法时，打印一些增强该业务逻辑的功能，比如某个方法执行完毕后提示用户执行完毕等日志功能

#### 2、解决方案 ####

使用基于@AspectJ的注解方式来实现日志打印，既不用在核心业务方法中添加一些非核心代码，又能实现自己想要实现的功能,利用前置通知、后置通知、返回通知、异常通知实现

##### 前提：使用AspectJ注解需要依赖于以下几个类库 #####

*  aspectjweaver-1.6.10.jar
 *  spring-aop-4.3.10.RELEASE.jar
 *  spring-aspects-4.3.10.RELEASE.jar

> 当然最省力的办法就是将所有Spring的jar都加到classpath中

#### 3、代码 ####

> Arithmetic.java（核心业务代码）

package com.linjie.aop;
    
    import org.springframework.stereotype.Component;
    /**
    * @author LinJie E-mail:ash-ali@163.com
    * @version 创建时间：2018年5月6日 下午7:53:56
    * @核心业务：基本运算
    */
    @Component("arithmetic")
    public class Arithmetic {
        //add
        public int add(int d,int e) {
            System.out.println("add method END!");
            System.out.println();
            return d+e;
        }
    
        //subtraction
        public int sub(int a,int b) {
            System.out.println("sub method END!");
            System.out.println();
            return a-b;
        }
    
        //multiplicative
        public int mul(int a,int b) {
            System.out.println("mul method END!");
            System.out.println();
            return a*b;
        }
        //division
        public int div(int a,int b) {
            System.out.println("div method END!");
            System.out.println();
            return a/b;
        }
    }

> LogginAspectJ.java（基于AspectJ的注解方式的切面——日志）

package com.linjie.aop;
    
    import java.util.Arrays;
    
    import org.aopalliance.intercept.Joinpoint;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    /**
     * @author LinJie
     * log功能，不影响核心业务
     */
    @Component("logginAspectJ")
    @Aspect
    public class LogginAspectJ {
        /*
         *定义一个方法,用于声明切点表达式,该方法一般没有方法体
         *@Pointcut用来声明切点表达式
         *通知直接使用定义的方法名即可引入当前的切点表达式 
         */
        @Pointcut("execution(* com.linjie.aop.Arithmetic.*(..))")
        public void PointcutDeclaration() {}
    
        //前置通知,方法执行之前执行
        @Before("PointcutDeclaration()")
        public void BeforeMethod(JoinPoint jp) {    
            String methodName = jp.getSignature().getName();
            Object[] args = jp.getArgs();
            System.out.println("BeforeMethod  The method   "+ methodName +"   parameter is  "+ Arrays.asList(args));
            System.out.println("add before");
            System.out.println();
        }
    
        //后置通知,方法执行之后执行(不管是否发生异常)
        @After("PointcutDeclaration()")
        public void AfterMethod(JoinPoint jp) {
            String methodName = jp.getSignature().getName();
            Object[] args = jp.getArgs();
            System.out.println("AfterMethod  The method    "+ methodName +"   parameter is  "+Arrays.asList(args));
            System.out.println();
        }
    
        //返回通知,方法正常执行完毕之后执行
        @AfterReturning(value="PointcutDeclaration()",returning="result")
        public void AfterReturningMethod(JoinPoint jp,Object result) {
            String methodName = jp.getSignature().getName();
            Object[] args = jp.getArgs();
            System.out.println("AfterReturningMethod  The method   "+ methodName +"   parameter is  "+Arrays.asList(args)+" "+result);
            System.out.println();
        } 
    
        //异常通知,在方法抛出异常之后执行
        @AfterThrowing(value="PointcutDeclaration()",throwing="e")
        public void AfterThrowingMethod(JoinPoint jp,Exception e) {
            String methodName = jp.getSignature().getName();
            System.out.println("AfterThrowingMethod  The method   "+ methodName +"exception :"+e);
        }
    }

> applicationContext.xml（用于配置Bean和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"
        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-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
        
        <context:component-scan base-package="com.linjie.aop"></context:component-scan>  
    
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>

在Spring IoC容器中启动AspectJ注解支持，只要在Bean的配置文件中定义一个空的XML元素

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

> 测试类

package com.linjie.aop;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author LinJie
     * 测试
     */
    public class SpringTest {
        @Test
        public void test() {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            Arithmetic arithmetic = (Arithmetic) context.getBean("arithmetic");
            int result = arithmetic.add(1, 2);
            System.out.println("result: "+result);
    
            System.out.println("--------------");
    
            result = arithmetic.div(8, 1);
            System.out.println("result: "+result);
        }
    }

> 运行结果

![这里写图片描述][70 4]

--------------------

### 三、环绕通知用法 ###

> 环绕通知是最为强大的通知，这里与以上的切面不同以外其他都相同

![这里写图片描述][70 5]

--------------------

### 四、JoinPoint用法 ###

> 可以在上面的切面代码中发现参数JoinPoint，下面就阐述下该参数的用法

JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象.

#### 常用方法 ####

![这里写图片描述][70 6]

#### ProceedingJoinPoint对象 ####

> ProceedingJoinPoint对象是JoinPoint的子接口,该对象用在@Around的切面方法中,常用有以下两个方法

![这里写图片描述][70 7]

# 5：在 XML 中声明切面 #

Spring 的 AOP 配置元素简化了基于 POJO 切面声明

<table> 
 <thead> 
  <tr> 
   <th align="center">AOP 配置元素</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">aop : advisor</td> 
   <td align="center">定义 AOP 通知器</td> 
  </tr> 
  <tr> 
   <td align="center">aop : after</td> 
   <td align="center">定义 AOP 后置通知（不管被通知方法是否执行成功）</td> 
  </tr> 
  <tr> 
   <td align="center">aop : after-returing</td> 
   <td align="center">定义 AOP after-returing 通知</td> 
  </tr> 
  <tr> 
   <td align="center">aop : after-throwing</td> 
   <td align="center">定义 AOP after-throwing 通知</td> 
  </tr> 
  <tr> 
   <td align="center">aop : around</td> 
   <td align="center">定义 AOP 环绕通知</td> 
  </tr> 
  <tr> 
   <td align="center">aop : aspect</td> 
   <td align="center">定义切面</td> 
  </tr> 
  <tr> 
   <td align="center">aop : aspectj-autoproxy</td> 
   <td align="center">启动 @AspectJ 注解驱动的切面</td> 
  </tr> 
  <tr> 
   <td align="center">aop : before</td> 
   <td align="center">定义 AOP 前置通知</td> 
  </tr> 
  <tr> 
   <td align="center">aop : config</td> 
   <td align="center">顶层的 AOP 配置元素，大多数 aop : * 元素必须包含在 元素内</td> 
  </tr> 
  <tr> 
   <td align="center">aop : declare-parents</td> 
   <td align="center">为被通知的对象引入额外接口，并透明的实现</td> 
  </tr> 
  <tr> 
   <td align="center">aop : pointcut</td> 
   <td align="center">定义切点</td> 
  </tr> 
 </tbody> 
</table>

--------------------

**持续更新中…**

**文章参考学习地址：[https://blog.csdn.net/w\_linux/article/details/80230222][https_blog.csdn.net_w_linux_article_details_80230222]**

[70]: /images/20230528/2d81b20a30204747a9838ff156203c00.png
[70 1]: /images/20230528/699375c1914c4240b9cb57841f0b86f8.png
[70 2]: /images/20230528/73fe77b3fefb466487508d793425bae2.png
[70 3]: /images/20230528/f2f4c2714cd04106a2e7d30c5e500213.png
[70 4]: /images/20230528/391b6b82587f44a9880c5f82e8e3253f.png
[70 5]: /images/20230528/e2314c1690b0404a8ff5d23cf6d3bea9.png
[70 6]: /images/20230528/689ddf40978648a9bfd75ddd31ffe4f0.png
[70 7]: /images/20230528/da5d4287dc16417ea1f29c2f43eab8b8.png
[https_blog.csdn.net_w_linux_article_details_80230222]: https://blog.csdn.net/w_linux/article/details/80230222