6. SpirngBoot + Aop 记录用户的操作日志+具体学习

本是古典何须时尚 2022-09-04 07:58 168阅读 0赞

参考文章 [https://mrbird.cc/Spring-Boot-AOP%20log.html][https_mrbird.cc_Spring-Boot-AOP_20log.html]

### 文章目录 ###

*  1. Aop 是什么？
 *  2. 引依赖
 *  3. 准备工作
 *   *  3.1 建表
     *  3.2 配置文件
     *  3.3 实体类
     *  3.3 mapper
     *  3.4 mapper.xml
 *  4. 记录日志
 *   *  4.1日志方法注解
     *  4.2 日志切面
     *  4.3 其他工具类
     *  4.4 测试
 *  5. Aop学习
 *  6. 实战学习
 *   *  6.1 定义切面类
     *  6.2 定义切入点
     *  6.2 定义通知
     *  6.3 方法测试
     *   *  6.3.1 测试1
         *  6.3.2 测试2
         *  6.3.3 测试3
 *  7. 总结

# 1. Aop 是什么？ #

面试中肯定会问到这个概念 我不喜欢用官网的话来讲述 简单的来说

使用Aop 可以在你不对原先的方法进行改动的情况下 改变方法的参数 返回值 或者是加一些日志记录

比如你可以记录下每个方法用的时间 来筛查是什么原因导致方法调用时间过长

举个生活中的例子

你作为一个冰棍制造商 你要是有aop 可以在不打开包装纸的情况下

往里面加点什么色素啊 香精啊 防腐剂什么的 或者偷工减料 做点什么额外的操作  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDM1MzUwNw_size_16_color_FFFFFF_t_70]

还好你没有Aop 不然可就要违法了 但是在程序中 你就可以使用

# 2. 引依赖 #

重点就是这玩意

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>

其他依赖 看你的需要 自己引入即可

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.4</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.20</version>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.7.7</version>
            </dependency>

# 3. 准备工作 #

## 3.1 建表 ##

建表语句如下 我们采用的是mysql

CREATE TABLE `sys_log` (
      `id` int(20) NOT NULL AUTO_INCREMENT,
      `username` varchar(50) DEFAULT NULL,
      `operator` varchar(50) DEFAULT NULL,
      `time` int(11) DEFAULT NULL,
      `method` varchar(200) DEFAULT NULL,
      `param` varchar(500) DEFAULT NULL,
      `ip` varchar(64) DEFAULT NULL,
      `create_time` datetime DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4;

![在这里插入图片描述][cd3cc2c252fb4675b92ce13d250ebe48.png]  
可以记录对应的用户名 调用方法 调用时间 ip等 其实也可以自己扩展啦

## 3.2 配置文件 ##

这次采用的是yml格式

server:
      port: 8888
    
    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
        driver-class-name: com.mysql.cj.jdbc.Driver
    
    mybatis:
      mapper-locations: classpath:mapper/**.xml
    #mybatis日志
    logging:
      level:
        cn.bb: debug

## 3.3 实体类 ##

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class SysLog implements Serializable { 
        private Integer id;
    
        private String username;
    
        private String operator;
    
        private Integer time;
    
        private String method;
    
        private String param;
    
        private String ip;
    
        private Date createTime;
    
        private static final long serialVersionUID = 1L;
    }

## 3.3 mapper ##

@Mapper
    public interface SysLogMapper { 
    
        int insertSelective(SysLog record);
    
    }

## 3.4 mapper.xml ##

还是复制下吧 知道你们懒 只需要一个插入方法即可 注意改下包名

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.bb.springbootstart.mapper.SysLogMapper">
      <resultMap id="BaseResultMap" type="cn.bb.springbootstart.pojo.SysLog">
        
        
        <id column="id" jdbcType="INTEGER" property="id" />
        <result column="username" jdbcType="VARCHAR" property="username" />
        <result column="operator" jdbcType="VARCHAR" property="operator" />
        <result column="time" jdbcType="INTEGER" property="time" />
        <result column="method" jdbcType="VARCHAR" property="method" />
        <result column="param" jdbcType="VARCHAR" property="param" />
        <result column="ip" jdbcType="VARCHAR" property="ip" />
        <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
      </resultMap>
      <sql id="Base_Column_List">
        
        id, username, `operator`, `time`, `method`, param, ip, create_time
      </sql>
    
      <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="cn.bb.springbootstart.pojo.SysLog" useGeneratedKeys="true">
        
        insert into sys_log
        <trim prefix="(" suffix=")" suffixOverrides=",">
          <if test="username != null">
            username,
          </if>
          <if test="operator != null">
            `operator`,
          </if>
          <if test="time != null">
            `time`,
          </if>
          <if test="method != null">
            `method`,
          </if>
          <if test="param != null">
            param,
          </if>
          <if test="ip != null">
            ip,
          </if>
          <if test="createTime != null">
            create_time,
          </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
          <if test="username != null">
            #{username,jdbcType=VARCHAR},
          </if>
          <if test="operator != null">
            #{operator,jdbcType=VARCHAR},
          </if>
          <if test="time != null">
            #{time,jdbcType=INTEGER},
          </if>
          <if test="method != null">
            #{method,jdbcType=VARCHAR},
          </if>
          <if test="param != null">
            #{param,jdbcType=VARCHAR},
          </if>
          <if test="ip != null">
            #{ip,jdbcType=VARCHAR},
          </if>
          <if test="createTime != null">
            #{createTime,jdbcType=TIMESTAMP},
          </if>
        </trim>
      </insert>
    
    </mapper>

接下来开始实战内容

# 4. 记录日志 #

## 4.1日志方法注解 ##

我们定义一个 @Log 注解 只需一个注解 就可以打印出方法对应的执行时间 参数等 当然单单这个注解是不够的

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log { 
        String value() default "";
    }

## 4.2 日志切面 ##

可以结合这张图理解  
![在这里插入图片描述][fc1af3a243214f2c855a60c5ff8005a8.png]

@Aspect
    @Component
    public class LogAspect { 
    
        @Autowired
        private SysLogMapper sysLogMapper;
    
        /** * 切入点 加了@log注解的方法即为切入点 */
        @Pointcut("@annotation(cn.bb.springbootstart.annotation.Log)")
        public void pointcut() {  }
    
        /** * 环绕通知 最为强大的通知 一般都会用到他 */
        @Around("pointcut()")
        public Object around(ProceedingJoinPoint point) { 
            Object result = null;
            //记录下开始时间
            long beginTime = System.currentTimeMillis();
            try { 
                // 使得方法继续执行 还可以修改目标方法的参数 返回值等
                result = point.proceed();
            } catch (Throwable e) { 
                e.printStackTrace();
            }
            // 执行时长(毫秒)
            long time = System.currentTimeMillis() - beginTime;
            // 保存日志
            saveLog(point, time);
            return result;
        }
    
        /** * 保存日志的方法 * @param joinPoint * @param time */
    	private void saveLog(ProceedingJoinPoint joinPoint, long time) { 
            try { 
                //通过方法签名获取到对应的方法
                MethodSignature signature = (MethodSignature) joinPoint.getSignature();
                Method method = signature.getMethod();
                //创建日志对象
                SysLog sysLog = new SysLog();
                Log logAnnotation = method.getAnnotation(Log.class);
                if (logAnnotation != null) { 
                    // 注解上的描述 会被记录到db
                    sysLog.setOperator(logAnnotation.value());
                }
                // 获取请求的方法名
                String className = joinPoint.getTarget().getClass().getName();
                String methodName = signature.getName();
                //设置进日志对象中 全类名+方法的形式
                sysLog.setMethod(className + "." + methodName + "()");
                // 请求的方法参数值
                Object[] args = joinPoint.getArgs();
                // 请求的方法参数名称
                LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
                String[] paramNames = u.getParameterNames(method);
                //数组不为空时 将参数写入
                if (args != null && paramNames != null) { 
                    String params = "";
                    for (int i = 0; i < args.length; i++) { 
                        params += " " + paramNames[i] + ": " + args[i];
                    }
                    sysLog.setParam(params);
                }
                // 获取request
                HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
                // 设置IP地址
                sysLog.setIp(IPUtils.getIpAddr(request));
                // 模拟一个用户名 真实使用使可以根据某个工具获取用户名
                sysLog.setUsername("bb");
                sysLog.setTime((int) time);
                sysLog.setCreateTime(new Date());
                // 保存系统日志
                sysLogMapper.insertSelective(sysLog);
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    }

## 4.3 其他工具类 ##

获取用户ip地址 当然 如果你引入了`hutool`工具

也可以使用 `ServletUtil.getClientIP(httpServletRequest)`

public class IPUtils { 
    
    	/** * 获取IP地址 * * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址 * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址 */
    	public static String getIpAddr(HttpServletRequest request) { 
    		String ip = request.getHeader("x-forwarded-for");
    		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
    			ip = request.getHeader("Proxy-Client-IP");
    		}
    		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
    			ip = request.getHeader("WL-Proxy-Client-IP");
    		}
    		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { 
    			ip = request.getRemoteAddr();
    		}
    		return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    	}
    
    }

`HttpContextUtils` 工具类获取 `HttpServletRequest`

public class HttpContextUtils { 
    	public static HttpServletRequest getHttpServletRequest() { 
    		return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    	}
    }

## 4.4 测试 ##

@RestController
    public class TesController { 
    
        @Log("执行方法一")
        @GetMapping("/one")
        public void methodOne(String name) { 
        }
    
        @Log("执行方法二")
        @GetMapping("/two")
        public void methodTwo() throws InterruptedException { 
            Thread.sleep(2000);
        }
    
        @Log("执行方法三")
        @GetMapping("/three")
        public void methodThree(String name, String age) {  }
    
    }

分别调用对应的方法 查看数据库 可以发现对应的日志都插入了  
![在这里插入图片描述][445ae0ce60174b1895c670bd353c649d.png]

# 5. Aop学习 #

如果单单是将用户操作日志插入进去 总觉得少了点什么 所以再来学习下Aop吧

概念说一下 我用自己的话阐述了

1.  JoinPoint 连接点 想要在某个方法上增加些功能 那个方法就是连接点
2.  Pointcut 切入点 一个定义要在某个方法上增强的新方法
3.  Advice 通知 说是通知 其实就是对某个方法增强的具体实现 上面的例子应该有体会到
4.  Aspect 切面 上面就 就是切入点+通知的总称 上面@Aspect就用在了类上 那个类就是切面
5.  Target 目标对象 指的是增强的类 上面所有service都属于增强的类

使用的步骤如下  
先定义一个切入点 使用 `@Pointcut注解` 指明要在哪个类或方法上增强  
定义增强的通知 通知分为5种

1.  前置通知 使用 `@Before`在增强方法前执行
2.  后置通知 使用 `@After` 不管是否抛异常都会执行
3.  后置返回通知 使用`@AfterReturning` 在增强方法后执行（抛出异常就不执行）
4.  后置异常通知 使用 `@AfterThrowing` 若抛出异常才执行
5.  环绕通知 使用 `@Around`最为强大 包含上面所有的功能

执行顺序如下

这里借用一下别人的图 如侵权 我就删掉  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDM1MzUwNw_size_16_color_FFFFFF_t_70 1]

# 6. 实战学习 #

我们模拟一个场景 我们想知道某个方法的执行时间 在不改动原有方法的情况下 该怎么做呢？  
这时候就要用到Aop了

## 6.1 定义切面类 ##

只需要一个`@Aspect` 来指定切面

@Aspect
    @Component//声明被Spring容器管理
    @Slf4j
    public class MyAspect { 
    }

## 6.2 定义切入点 ##

切入点表达式学习 请点击下方链接 我也是用到了才查的 太多不好记

[跳转链接][Link 1]

@Aspect
    @Slf4j
    @Component
    public class MyAspect { 
    
        //切入点
        @Pointcut("execution(* cn.bb.springbootstart.service.*.*(..))")
        public void pc1() { 
        }
    }

拿一张原先的图说明下 execution用的是最多的  
![在这里插入图片描述][88e93a734d45451f81f91ee68c908233.png]

## 6.2 定义通知 ##

五个通知都定义了 且需要注意 注解里面需要指定 切入点方法 否则是不生效的

`前置与后置通知`

@Before("pc1()")
        public void before(JoinPoint jp){ 
            Object[] args = jp.getArgs();
            for (Object arg : args) { 
                //打印下被增强方法的参数
                log.info(arg.toString());
            }
            log.info("方法执行前～～～");
        }
        @After("pc1()")
        public void after(JoinPoint jp) { 
            //获取方法签名
            Signature signature = jp.getSignature();
            log.info(signature.getName());
            log.info("方法执行后～～～");
        }

这里我们定义了前置通知和后置通知 且打印一下目标方法的参数 通过`JoinPoint` 类可以获取各种其他参数

如下所示：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Signature getSignature();</td> 
   <td>获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息</td> 
  </tr> 
  <tr> 
   <td>Object[] getArgs();</td> 
   <td>获取传入目标方法的参数对象</td> 
  </tr> 
  <tr> 
   <td>Object getTarget();</td> 
   <td>获取被代理的对象</td> 
  </tr> 
  <tr> 
   <td>Object getThis();</td> 
   <td>获取代理对象</td> 
  </tr> 
 </tbody> 
</table>

`后置返回与异常通知`

@AfterReturning(value = "pc1()", returning = "res")
        public void afterReturning(JoinPoint jp, Object res) { 
            //打印下返回值 注意 当与@Around共存时 无法获取返回值
            log.info("方法返回～～～" + res);
        }
    
        @AfterThrowing(value = "pc1()",throwing = "e")
        public void afterThrowing(JoinPoint jp,Exception e){ 
            log.info("方法出现异常:"+e.getMessage());
        }

这里注解里面多了 `returning`与 `throwing` 与方法里面的参数一一对应

这里有一点需要注意 当`@AfterReturning`与`@Around`共存时 无法获取返回值 等会就能见到效果

`环绕通知`

@SneakyThrows
        @Around("pc1()")
        public void around(ProceedingJoinPoint pjd){ 
            long start = System.currentTimeMillis();
            //目标方法执行
            pjd.proceed();
            long end = System.currentTimeMillis();
            log.info("方法用时：{} 毫秒",end-start);
        }

我们需要通过 `ProceedingJoinPoint`对象使得目标方法执行 否则我们是不能够计算方法的用时的

## 6.3 方法测试 ##

对应的serive里面新增两个方法

service

@Service
    public class Mysevice { 
    
        //带返回值的方法
        public String test1(String name){ 
            return "success " +name;
        }
        //方法抛出异常
        public void test2(){ 
            throw new RuntimeException("数组越界");
        }
    
    }

同时在test文件夹里新增测试方法

@Test
        void testAop() { 
            mysevice.test1("bb");
    // mysevice.test2();
        }

### 6.3.1 测试1 ###

同时使用5个通知 执行方法1 效果如下

2021-08-19 11:05:00.205  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : bb
    2021-08-19 11:05:00.205  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行前～～～
    2021-08-19 11:05:00.213  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法用时：8 毫秒
    2021-08-19 11:05:00.216  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : test1
    2021-08-19 11:05:00.216  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行后～～～
    2021-08-19 11:05:00.216  INFO 46239 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法返回～～～null

可以看到 方法参数值 方法用时都正确打印了 但是方法返回值为null

### 6.3.2 测试2 ###

那我们注解掉 @Around 再次测试

2021-08-19 11:09:41.657  INFO 46291 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : bb
    2021-08-19 11:09:41.658  INFO 46291 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行前～～～
    2021-08-19 11:09:41.668  INFO 46291 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : test1
    2021-08-19 11:09:41.668  INFO 46291 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行后～～～
    2021-08-19 11:09:41.669  INFO 46291 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法返回～～～success  bb

可以看到 返回值正确的打印了 证明了`@AfterReturning`与`@Around`共存使得返回值为null

### 6.3.3 测试3 ###

最后再测试下异常 打开test2 启用5个通知 运行

2021-08-19 11:12:26.568  INFO 46333 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行前～～～
    2021-08-19 11:12:26.575  INFO 46333 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : test2
    2021-08-19 11:12:26.575  INFO 46333 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法执行后～～～
    2021-08-19 11:12:26.576  INFO 46333 --- [           main] cn.bb.springbootstart.aspect.MyAspect    : 方法出现异常:数组越界
    
    java.lang.RuntimeException: 数组越界

发现环绕通知与后置返回通知都失效了 这也能理解 毕竟方法没有执行完毕 就抛出了异常

# 7. 总结 #

使用Aop 我们首先要理解几个概念

连接点 切入点 切面 增强 目标对象 有了几个概念 就会清晰很多

之后我们要先 定义切面 切入点 通知

切面只需要在类上加 `@Aspect`和`@Component`

切入点 需要加`@Pointcut` 和`切入点表达式` 否则无法确定目标

通知都是指定切入点方法才能生效 什么时候使用什么通知 需要根据具体情况而分析

比如想打印写方法参数 返回值什么的 前几个通知就行了 只需要用到 `JoinPoint`

而如果需要在整个方法执行前后做些什么 就用环绕通知 需要用到 `ProceedingJoinPoint`

但最常用的最强大的还是环绕通知 用它准没错

本期内容就到这里 有点长 拜拜

> 当你学会放手的时候，你会发现你已经拥有。  
> 一念花开，一念花落。这山长水远的人世，终究是要自己走下去。  
> 有的人对你好，是因为你对他好，有的人对你好，是因为懂得你的好。

[https_mrbird.cc_Spring-Boot-AOP_20log.html]: https://mrbird.cc/Spring-Boot-AOP%20log.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDM1MzUwNw_size_16_color_FFFFFF_t_70]: /images/20220829/1433ece7666e40be906bb774137fe516.png
[cd3cc2c252fb4675b92ce13d250ebe48.png]: /images/20220829/8d2c499dcbe64b5f843a895d3229db95.png?
[fc1af3a243214f2c855a60c5ff8005a8.png]: /images/20220829/7e92732392b44932b83c8ea3762cced2.png
[445ae0ce60174b1895c670bd353c649d.png]: /images/20220829/e6ae2f0d6ec649c79e484f627b0189dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDM1MzUwNw_size_16_color_FFFFFF_t_70 1]: /images/20220829/c6c023ad1a294321bd88a26a1fb606fd.png
[Link 1]: https://cloud.tencent.com/developer/article/1497814
[88e93a734d45451f81f91ee68c908233.png]: /images/20220829/75a08f92820e4f31ae4237d7ed8dc5bb.png