HelloWorld
登录

SpringBoot Aop 详解和多种使用场景

kenx

2021-08-02

3000 1 0

前言

aop面向切面编程，是编程中一个很重要的思想本篇文章主要介绍的是SpringBoot切面Aop的使用和案例

什么是aop

AOP（Aspect OrientedProgramming）：面向切面编程，面向切面编程（也叫面向方面编程），是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

使用场景

利用AOP可以对我们边缘业务进行隔离，降低无关业务逻辑耦合性。提高程序的可重用性，同时提高了开发的效率。一般用于日志记录，性能统计，安全控制，权限管理，事务处理，异常处理，资源池管理。使用场景

为什么需要面向切面编程

面向对象编程（OOP）的好处是显而易见的，缺点也同样明显。当需要为多个不具有继承关系的对象添加一个公共的方法的时候，例如日志记录、性能监控等，如果采用面向对象编程的方法，需要在每个对象里面都添加相同的方法，这样就产生了较大的重复工作量和大量的重复代码，不利于维护。面向切面编程（AOP）是面向对象编程的补充，简单来说就是统一处理某一“切面”的问题的编程思想。如果使用AOP的方式进行日志的记录和处理，所有的日志代码都集中于一处，不需要再每个方法里面都去添加，极大减少了重复代码。

技术要点

  1. 通知（Advice）包含了需要用于多个应用对象的横切行为，完全听不懂，没关系，通俗一点说就是定义了“什么时候”和“做什么”。

  2. 连接点（Join Point）是程序执行过程中能够应用通知的所有点。

  3. 切点（Poincut）是定义了在“什么地方”进行切入，哪些连接点会得到通知。显然，切点一定是连接点。

  4. 切面（Aspect）是通知和切点的结合。通知和切点共同定义了切面的全部内容——是什么，何时，何地完成功能。

  5. 引入（Introduction）允许我们向现有的类中添加新方法或者属性。

  6. 织入（Weaving）是把切面应用到目标对象并创建新的代理对象的过程，分为编译期织入、类加载期织入和运行期织入。

整合使用

导入依赖

在springboot中使用aop要导aop依赖

1 <!--aop 切面-->
2        <dependency>
3            <groupId>org.springframework.boot</groupId>
4            <artifactId>spring-boot-starter-aop</artifactId>
5        </dependency>

注意这里版本依赖于spring-boot-start-parent父pom中的spring-boot-dependencies

编写拦截的bean

这里我们定义一个controller用于拦截所有请求的记录

1@RestController
2public class AopController {
3
4    @RequestMapping("/hello")
5    public String sayHello(){
6        System.out.println("hello");
7        return "hello";
8    }
9}

定义切面

SpringBoot在使用切面的时候采用@Aspect注解对POJO进行标注，该注解表明该类不仅仅是一个POJO，还是一个切面容器

定义切点

切点是通过@Pointcut注解和切点表达式定义的。

@Pointcut注解可以在一个切面内定义可重用的切点。

由于Spring切面粒度最小是达到方法级别，而execution表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且实际中，大部分需要使用AOP的业务场景也只需要达到方法级别即可，因而execution表达式的使用是最为广泛的。如图是execution表达式的语法：

execution表示在方法执行的时候触发。以“”开头，表明方法返回值类型为任意类型。然后是全限定的类名和方法名，“”可以表示任意类和任意方法。对于方法参数列表，可以使用“..”表示参数为任意类型。如果需要多个表达式，可以使用“&&”、“||”和“!”完成与、或、非的操作。

定义通知

通知有五种类型，分别是：

  1. 前置通知（@Before）：在目标方法调用之前调用通知
  2. 后置通知（@After）：在目标方法完成之后调用通知
  3. 环绕通知（@Around）：在被通知的方法调用之前和调用之后执行自定义的方法
  4. 返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
  5. 异常通知（@AfterThrowing）：在目标方法抛出异常之后调用通知

代码中定义了三种类型的通知，使用@Before注解标识前置通知，打印“beforeAdvice...”，使用@After注解标识后置通知，打印“AfterAdvice...”，使用@Around注解标识环绕通知，在方法执行前和执行之后分别打印“before”和“after”。这样一个切面就定义好了，代码如下：

1@Aspect
2@Component
3public class AopAdvice {
4
5    @Pointcut("execution (* com.shangguan.aop.controller.*.*(..))")
6    public void test() {
7
8    }
9
10    @Before("test()")
11    public void beforeAdvice() {
12        System.out.println("beforeAdvice...");
13    }
14
15    @After("test()")
16    public void afterAdvice() {
17        System.out.println("afterAdvice...");
18    }
19
20    @Around("test()")
21    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
22        System.out.println("before");
23        try {
24            proceedingJoinPoint.proceed();
25        } catch (Throwable t) {
26            t.printStackTrace();
27        }
28        System.out.println("after");
29    }
30
31}

运行结果

案例场景

这里我们通过一个日志记录场景来完整的使用Aop切面业务层只需关心代码逻辑实现而不用关心请求参数和响应参数的日志记录

那么首先我们需要自定义一个全局日志记录的切面类GlobalLogAspect

然后在该类添加@Aspect注解，然后在定义一个公共的切入点（Pointcut），指向需要处理的包，然后在定义一个前置通知(添加@Before注解)，后置通知(添加@AfterReturning)和环绕通知（添加@Around）方法实现即可

日志信息类

1package cn.soboys.core;
2
3import lombok.Data;
4
5/**
6 * @author kenx
7 * @version 1.0
8 * @date 2021/6/18 18:48
9 * 日志信息
10 */
11@Data
12public class LogSubject {
13    /**
14     * 操作描述
15     */
16    private String description;
17
18    /**
19     * 操作用户
20     */
21    private String username;
22
23    /**
24     * 操作时间
25     */
26    private String startTime;
27
28    /**
29     * 消耗时间
30     */
31    private String spendTime;
32
33    /**
34     * URL
35     */
36    private String url;
37
38    /**
39     * 请求类型
40     */
41    private String method;
42
43    /**
44     * IP地址
45     */
46    private String ip;
47
48    /**
49     * 请求参数
50     */
51    private Object parameter;
52
53    /**
54     * 请求返回的结果
55     */
56    private Object result;
57
58    /**
59     * 城市
60     */
61    private String city;
62
63    /**
64     * 请求设备信息
65     */
66    private String device;
67
68
69
70}
71
72

全局日志拦截

1package cn.soboys.core;
2
3import org.aspectj.lang.ProceedingJoinPoint;
4import org.aspectj.lang.reflect.MethodSignature;
5
6import java.lang.reflect.Method;
7
8/**
9 * @author kenx
10 * @version 1.0
11 * @date 2021/6/18 14:52
12 * 切面
13 */
14public class BaseAspectSupport {
15    public Method resolveMethod(ProceedingJoinPoint point) {
16        MethodSignature signature = (MethodSignature)point.getSignature();
17        Class<?> targetClass = point.getTarget().getClass();
18
19        Method method = getDeclaredMethod(targetClass, signature.getName(),
20                signature.getMethod().getParameterTypes());
21        if (method == null) {
22            throw new IllegalStateException("无法解析目标方法: " + signature.getMethod().getName());
23        }
24        return method;
25    }
26
27    private Method getDeclaredMethod(Class<?> clazz, String name, Class<?>... parameterTypes) {
28        try {
29            return clazz.getDeclaredMethod(name, parameterTypes);
30        } catch (NoSuchMethodException e) {
31            Class<?> superClass = clazz.getSuperclass();
32            if (superClass != null) {
33                return getDeclaredMethod(superClass, name, parameterTypes);
34            }
35        }
36        return null;
37    }
38}
39

GlobalLogAspect类

1package cn.soboys.core;
2
3import cn.hutool.core.date.DateUtil;
4import cn.hutool.core.date.TimeInterval;
5import cn.hutool.json.JSONUtil;
6import cn.soboys.core.utils.HttpContextUtil;
7import io.swagger.annotations.ApiOperation;
8import lombok.extern.slf4j.Slf4j;
9import org.aspectj.lang.ProceedingJoinPoint;
10import org.aspectj.lang.annotation.AfterThrowing;
11import org.aspectj.lang.annotation.Around;
12import org.aspectj.lang.annotation.Aspect;
13import org.aspectj.lang.annotation.Pointcut;
14import org.springframework.stereotype.Component;
15import org.springframework.web.bind.annotation.RequestBody;
16import org.springframework.web.bind.annotation.RequestParam;
17
18import javax.servlet.http.HttpServletRequest;
19import java.lang.reflect.Method;
20import java.lang.reflect.Parameter;
21import java.util.ArrayList;
22import java.util.HashMap;
23import java.util.List;
24import java.util.Map;
25
26/**
27 * @author kenx
28 * @version 1.0
29 * @date 2021/6/18 15:22
30 * 全局日志记录器
31 */
32@Slf4j
33@Aspect
34@Component
35public class GlobalLogAspect extends BaseAspectSupport {
36    /**
37     * 定义切面Pointcut
38     */
39    @Pointcut("execution(public * cn.soboys.mallapi.controller.*.*(..))")
40    public void log() {
41
42    }
43
44
45    /**
46     * 环绕通知
47     *
48     * @param joinPoint
49     * @return
50     */
51    @Around("log()")
52    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
53
54        LogSubject logSubject = new LogSubject();
55        //记录时间定时器
56        TimeInterval timer = DateUtil.timer(true);
57        //执行结果
58        Object result = joinPoint.proceed();
59        logSubject.setResult(result);
60        //执行消耗时间
61        String endTime = timer.intervalPretty();
62        logSubject.setSpendTime(endTime);
63        //执行参数
64        Method method = resolveMethod(joinPoint);
65        logSubject.setParameter(getParameter(method, joinPoint.getArgs()));
66
67        HttpServletRequest request = HttpContextUtil.getRequest();
68        // 接口请求时间
69        logSubject.setStartTime(DateUtil.now());
70        //请求链接
71        logSubject.setUrl(request.getRequestURL().toString());
72        //请求方法GET,POST等
73        logSubject.setMethod(request.getMethod());
74        //请求设备信息
75        logSubject.setDevice(HttpContextUtil.getDevice());
76        //请求地址
77        logSubject.setIp(HttpContextUtil.getIpAddr());
78        //接口描述
79        if (method.isAnnotationPresent(ApiOperation.class)) {
80            ApiOperation apiOperation = method.getAnnotation(ApiOperation.class);
81            logSubject.setDescription(apiOperation.value());
82        }
83
84        String a = JSONUtil.toJsonPrettyStr(logSubject);
85        log.info(a);
86        return result;
87
88    }
89
90
91    /**
92     * 根据方法和传入的参数获取请求参数
93     */
94    private Object getParameter(Method method, Object[] args) {
95        List<Object> argList = new ArrayList<>();
96        Parameter[] parameters = method.getParameters();
97        Map<String, Object> map = new HashMap<>();
98        for (int i = 0; i < parameters.length; i++) {
99            //将RequestBody注解修饰的参数作为请求参数
100            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
101            //将RequestParam注解修饰的参数作为请求参数
102            RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);
103            String key = parameters[i].getName();
104            if (requestBody != null) {
105                argList.add(args[i]);
106            } else if (requestParam != null) {
107                map.put(key, args[i]);
108            } else {
109                map.put(key, args[i]);
110            }
111        }
112        if (map.size() > 0) {
113            argList.add(map);
114        }
115        if (argList.size() == 0) {
116            return null;
117        } else if (argList.size() == 1) {
118            return argList.get(0);
119        } else {
120            return argList;
121        }
122    }
123}
124
点赞
收藏

评论区

加载中...

相关推荐

手写Java HashMap源码

HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22

推荐学java——Spring之AOP

tips：本文首发在公众号逆锋起笔，本文源代码在公众号回复aop即可查看。什么是AOP？AOP（AspectOrientProgramming）,直译过来就是面向切面编程。AOP是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。为什么需要AOP？实际开发中我们应

Spring 学习笔记（四）：Spring AOP

@\TOC\1概述本文主要讲述了AOP的基本概念以及在Spring中AOP的几种实现方式。2AOPAOP，即AspectOrientedProgramming，面向切面编程，与OOP相辅相成。类似的，在OOP中，以类为程序的基本单元，在AOP中的基本单元是Aspect

SpringBoot2.0 基础案例(11)：配置AOP切面编程，解决日志记录业务

本文源码GitHub地址：知了一笑https://github.com/cicadasmile/springbootbase一、AOP切面编程1、什么是AOP编程在软件业，AOP为AspectOrientedProgramming的缩写，意为：面向切面编程，通

AOP相关概念

1.AOP(面向切面编程)在软件业,AOP为AspectOrientedProgramming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,在软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生泛型.利用AOP

69道Spring面试题和答案

目录Spring概述依赖注入SpringbeansSpring注解Spring数据访问Spring面向切面编程（AOP）SpringMVCSpring 概述1. 什么是spring?Spring 是个java企业