Spring Boot AOP面向切面编程使用（定义切入点、前置通知、后置通知、返回通知、异常通知、环绕通知）

迷南。 2022-10-10 04:39 201阅读 0赞

### 1 AOP ###

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

支持5种类型的通知注解：  
（1）@Before:前置通知，在方法执行之前返回  
（2）@After:后置通知，在方法执行后执行  
（3）@AfterRunning:返回通知，在方法返回结果之后执行  
（4）@AfterThrowing:异常通知，在方法抛出异常之后  
（5）@Around:环绕通知，围绕着方法执行

### 2 Maven依赖 ###

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.5.1</version>
            </dependency>

### 3 TestAnnotation ###

测试注解。

package com.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * 测试注解
     */
    @Inherited
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface TestAnnotation {
    }

### 4 TestAspect ###

测试切面。

package com.aspect;
    
    import cn.hutool.core.date.DateUtil;
    import org.aspectj.lang.*;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.util.*;
    
    /**
     * 测试切面
     */
    @Aspect
    @Component
    public class TestAspect {
        /**
         * 指定切面的切入点
         */
        @Pointcut("@annotation(com.annotation.TestAnnotation)")
        public void pointcutAnnotation() {
        }
        /**
         * 前置通知：执行目标方法前 触发
         */
        @Before(value = "pointcutAnnotation()")
        public void methodBefore(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                    + "]前置通知：方法名：" + methodName + "，参数" + Arrays.asList(joinPoint.getArgs()));
        }
    
        /**
         * 后置通知：执行目标方法后触发
         */
        @After(value = "pointcutAnnotation()")
        public void methodAfter(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                    + "]后置通知：方法名：" + methodName + "，参数" + Arrays.asList(joinPoint.getArgs()));
        }
    
        /**
         * 返回通知：目标方法执行完并返回参数后触发。
         */
        @AfterReturning(value = "pointcutAnnotation()", returning = "result")
        public void methodAfterReturning(JoinPoint joinPoint, Object result) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                    + "]返回通知：方法名：" + methodName + "，" +
                    "参数" + Arrays.asList(joinPoint.getArgs()) + "，" +
                    "返回结果：");
            if (result instanceof String[]) {
                Arrays.stream((String[]) result).forEach(System.out::println);
            } else {
                System.out.println(result);
            }
        }
    
        /**
         * 异常通知：目标方法抛出异常后触发
         */
        @AfterThrowing(value = "pointcutAnnotation()", throwing="ex")
        public void methodExceptionOccurred(JoinPoint joinPoint, Exception ex) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                    + "]异常通知：方法名：" + methodName + "，参数" + Arrays.asList(joinPoint.getArgs()) + "，异常信息：" + ex.getMessage());
        }
        /**
         * 环绕通知，围绕着方法执行
         * 环绕通知需要携带ProceedingJoinPoint类型的参数
         * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法。
         * 而且环绕通知必须有返回值，返回值即为目标方法的返回值
         */
        @Around(value = "pointcutAnnotation()")
        public Object methodAround(ProceedingJoinPoint proceedingJoinPoint) {
            Object result = null;
            String methodName = proceedingJoinPoint.getSignature().getName();
            System.out.println("[" + DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                    + "]环绕通知：方法名：" + methodName + "，参数" + Arrays.asList(proceedingJoinPoint.getArgs()));
            //执行目标方法
            try {
                result = proceedingJoinPoint.proceed();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
            return result;
        }
    
    }

### 5 AspectController ###

调试代码。

package com.controller;
    
    import cn.hutool.core.util.StrUtil;
    import com.annotation.TestAnnotation;
    import org.springframework.web.bind.annotation.*;
    
    
    @RestController
    @RequestMapping("/aspect")
    public class AspectController {
    
        /**
         * 测试切面
         *
         * @param key
         * @return
         */
        @GetMapping("/testAspect")
        @TestAnnotation
        public String testAspect(@RequestParam String key) throws Exception {
            if(StrUtil.isBlank(key)){
                throw new Exception("参数为空");
            }
            return key;
        }
    }

### 6 调试结果 ###

正常情况：

![20210626092516736.png][]

报异常情况：

![20210626092623721.png][]

[20210626092516736.png]: /images/20221005/1b97d8f2001a46159c1ac0d3c3427405.png
[20210626092623721.png]: /images/20221005/3d5d6b6b8f5f48e28a258b00d57e9f78.png