• springboot AOP记录操作日志（包含遇到的问题）

    项目上需要对一些重要的接口记录操作日志，便于历史问题追踪、排查。主要记录的字段有操作人、请求ip、操作时间、模块、功能、请求参数、请求结果等。

    记录操作日志基本上都是用AOP，当然我也不例外，需要记录的字段，大部分都很容易获取到，比较难获取的一个字段是请求参数，因为不同的接口参数请求方式不同，有的接口使用@RequestBody传json字符串，有的接口使用@RequestParam传的form参数，有的接口有文件上传@RequestParam("file") MultipartFile file。我们项目中大部分是使用@RequestBody传json字符串，少部分文件上传接口使用@RequestParam("file") MultipartFile file。

    第一次

    使用httpRequest.getInputStream()的方式提取@RequestBody中的json参数，大致代码如下：

    1. ServletInputStream inputStream = httpRequest.getInputStream();
    2. InputStreamReader reader = new InputStreamReader(inputStream,StandardCharsets.UTF_8);
    3. BufferedReader bfReader = new BufferedReader(reader);
    4. StringBuilder sb = new StringBuilder();
    5. String line;
    6. while ((line = bfReader.readLine()) != null){
    7. sb.append(line);
    8. }
    9. System.out.println(sb.toString());

    问题：发现AOP拦截后，controller那里获取到的参数为空。在网上查到问题原因是，“在拦截器中读取请求的JSON数据需要，获取请求中的输入流InputStream is = request.getInputStream();当我们拦截器执行完成后，进入其他拦截器或者控制层参数解析时，也需要获取，当因为我们之前的拦截器已经获取过一次，之后的都获取不到内容，因此报出此错误！”。解决思路就是“通过过滤器，将原始的 HttpServletRequest替换成我们自己的请求包装类，在其中重写 getInputStream()方法”

    第二次

    1. public class BodyReaderRequestWrapper extends HttpServletRequestWrapper {
    2.     // 将流中的内容保存
    3.     private final byte[] buff;
    4.     public BodyReaderRequestWrapper(HttpServletRequest request) throws IOException {
    5.         super(request);
    6.         InputStream is = request.getInputStream();
    7.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    8.         byte[] b = new byte[1024];
    9.         int len;
    10.         while ((len = is.read(b)) != -1) {
    11.             baos.write(b, 0, len);
    12.         }
    13.         buff = baos.toByteArray();
    14.     }
    15.     @Override
    16.     public ServletInputStream getInputStream() throws IOException {
    17.         final ByteArrayInputStream bais = new ByteArrayInputStream(buff);
    18.         return new ServletInputStream() {
    19.             @Override
    20.             public boolean isFinished() {
    21.                 return false;
    22.             }
    23.             @Override
    24.             public boolean isReady() {
    25.                 return false;
    26.             }
    27.             @Override
    28.             public void setReadListener(ReadListener listener) {
    29.             }
    30.             @Override
    31.             public int read() throws IOException {
    32.                 return bais.read();
    33.             }
    34.         };
    35.     }
    36.     @Override
    37.     public BufferedReader getReader() throws IOException {
    38.         return new BufferedReader(new InputStreamReader(getInputStream()));
    39.     }
    40.     public String getRequestBody() {
    41.         return new String(buff);
    42.     }
    43. }
    1. public class AuthFilter implements Filter {
    2.     @Override
    3.     public void init(FilterConfig filterConfig) throws ServletException {
    4.     }
    5.     @Override
    6.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    7.         // 防止流读取一次后就没有了, 所以需要将流继续写出去
    8.         HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
    9.         // 这里将原始request传入，读出流并存储
    10.         ServletRequest requestWrapper = new  BodyReaderRequestWrapper(httpServletRequest);
    11.         // 这里将原始request替换为包装后的request，此后所有进入controller的request均为包装后的
    12.         filterChain.doFilter(requestWrapper, servletResponse);//
    13.     }
    14.     @Override
    15.     public void destroy() {
    16.     }
    17. }
    1. @Configuration
    2. public class FilterOrderConfig {
    3.     @Bean
    4.     public FilterRegistrationBean filterRegistrationBean1(){
    5.         FilterRegistrationBean filterRegistrationBean=new FilterRegistrationBean();
    6.         filterRegistrationBean.setFilter(new AuthFilter());
    7.         filterRegistrationBean.addUrlPatterns("/*");
    8.         //order的数值越小 则优先级越高,这里直接使用的最高优先级
    9.         filterRegistrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE);
    10.         return filterRegistrationBean;
    11.     }
    12. }

    这种方式确实解决了第一次遇到的问题，测了几个普通接口也没问题，后来发现包含@RequestParam("file") MultipartFile file文件上传的接口提示Required request part 'file' is not present

     在网上查了半天也没有查到合适的解决方法。于是准备参考一下一些成熟的springboot项目脚手架怎么处理的，发现若依项目没有出现这个问题，于是参考若依项目，结合自己项目特点，完成了这记录操作日志的功能，目前没发现问题。

    第三次

    直接贴上代码

    操作日志实体类，存储在mongo

    1. @Data
    2. @Builder
    3. @NoArgsConstructor
    4. @AllArgsConstructor
    5. @Document(collection = "op_log")
    6. public class OpLog {
    7.  
    8.     @Id
    9.     private String id;
    10.  
    11.     /**
    12.      * 用户名
    13.      */
    14.     private String username;
    15.  
    16.     /**
    17.      * 方法名
    18.      */
    19.     private String method;
    20.  
    21.     /**
    22.      * 参数
    23.      */
    24.     private String params;
    25.  
    26.     /**
    27.      * ip地址
    28.      */
    29.     private String ip;
    30.  
    31.     /**
    32.      * 请求url
    33.      */
    34.     private String url;
    35.  
    36.     /**
    37.      * //操作类型 :新增、删除等等
    38.      */
    39.     private String type;
    40.  
    41.     /**
    42.      * 模块
    43.      */
    44.     private String model;
    45.  
    46.     /**
    47.      * 操作时间
    48.      */
    49.     private Long createTime;
    50.  
    51.     /**
    52.      * 操作结果
    53.      */
    54.     private String result;
    55.  
    56.     /**
    57.      * 描述
    58.      */
    59.     private String description;
    60. }

    注解定义

    1. import java.lang.annotation.Documented;
    2. import java.lang.annotation.ElementType;
    3. import java.lang.annotation.Retention;
    4. import java.lang.annotation.RetentionPolicy;
    5. import java.lang.annotation.Target;
    6.  
    7. /**
    8.  * 自定义操作日志记录注解
    9.  */
    10. @Target({ ElementType.PARAMETER, ElementType.METHOD })
    11. @Retention(RetentionPolicy.RUNTIME)
    12. @Documented
    13. public @interface OperationLog
    14. {
    15.     /**
    16.      * 模块
    17.      */
    18.     String module() default "";
    19.  
    20.     /**
    21.      * 功能
    22.      * @return
    23.      */
    24.     String function() default "";
    25.  
    26.     /**
    27.      * 操作类型
    28.      */
    29.     BusinessType type() default BusinessType.QUERY;
    30.  
    31. }

    操作日志处理

    1. import cn.hutool.core.date.DateUtil;
    2. import cn.hutool.json.JSONUtil;
    3. import com.alibaba.fastjson.JSON;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.aspectj.lang.JoinPoint;
    6. import org.aspectj.lang.Signature;
    7. import org.aspectj.lang.annotation.AfterReturning;
    8. import org.aspectj.lang.annotation.AfterThrowing;
    9. import org.aspectj.lang.annotation.Aspect;
    10. import org.aspectj.lang.annotation.Pointcut;
    11. import org.aspectj.lang.reflect.MethodSignature;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.security.core.context.SecurityContextHolder;
    14. import org.springframework.stereotype.Component;
    15. import org.springframework.validation.BindingResult;
    16. import org.springframework.web.multipart.MultipartFile;
    17.  
    18. import javax.servlet.http.HttpServletRequest;
    19. import javax.servlet.http.HttpServletResponse;
    20. import java.lang.reflect.Method;
    21. import java.util.Collection;
    22. import java.util.Iterator;
    23. import java.util.Map;
    24.  
    25. /**
    26.  * 操作日志记录处理
    27.  */
    28. @Aspect
    29. @Component
    30. @Slf4j
    31. public class LogAspect {
    32.  
    33.     @Autowired
    34.     private OpLogService opLogService;
    35.  
    36.     // 配置织入点
    37.     @Pointcut("@annotation(com.cq.mysmsmanagerback.annotation.OperationLog)")
    38.     public void logPointCut() {
    39.     }
    40.  
    41.     /**
    42.      * 处理完请求后执行
    43.      *
    44.      * @param joinPoint 切点
    45.      */
    46.     @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    47.     public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
    48.         handleLog(joinPoint, null, jsonResult);
    49.     }
    50.  
    51.     /**
    52.      * 拦截异常操作
    53.      *
    54.      * @param joinPoint 切点
    55.      * @param e         异常
    56.      */
    57.     @AfterThrowing(value = "logPointCut()", throwing = "e")
    58.     public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
    59.         handleLog(joinPoint, e, null);
    60.     }
    61.  
    62.     protected void handleLog(final JoinPoint joinPoint, final Exception e, Object result) {
    63.         try {
    64.             // 获得注解
    65.             OperationLog controllerOperationLog = getAnnotationLog(joinPoint);
    66.             if (controllerOperationLog == null) {
    67.                 return;
    68.             }
    69.  
    70.             OpLog opLog = new OpLog();
    71.             // 从切面织入点处通过反射机制获取织入点处的方法
    72.             MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    73.             //获取切入点所在的方法
    74.             Method method = signature.getMethod();
    75.             //获取操作
    76.             OperationLog annotation = method.getAnnotation(OperationLog.class);
    77.             if (annotation != null) {
    78.                 opLog.setModel(annotation.module());
    79.                 opLog.setDescription(annotation.function());
    80.                 opLog.setType(annotation.type().name());
    81.             }
    82.  
    83.             // 获取请求的类名
    84.             String className = joinPoint.getTarget().getClass().getName();
    85.             // 获取请求的方法名
    86.             String methodName = method.getName();
    87.             methodName = className + "." + methodName;
    88.             opLog.setMethod(methodName);
    89.  
    90.             opLog.setCreateTime(DateUtil.date().getTime());
    91.             //操作用户 --登录时有把用户的信息保存在session中，可以直接取出
    92.             String userName = SecurityContextHolder.getContext().getAuthentication().getName();
    93.             opLog.setUsername(userName);
    94.  
    95.             String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
    96.             opLog.setIp(ip);
    97.             opLog.setUrl(ServletUtils.getRequest().getRequestURI());
    98.  
    99.             // 请求参数
    100.             String params = argsArrayToString(joinPoint.getArgs());
    101.             opLog.setParams(params.length() > 2000 ? params.substring(0, 2000) : params);
    102.  
    103.             opLog.setResult(JSONUtil.toJsonStr(result));
    104.  
    105.             // 插入到mongo
    106.             log.info("opLog: {}", JSONUtil.toJsonStr(opLog));
    107.             opLogService.insertOpLog(opLog);
    108.             // 保存数据库
    109. //            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
    110.         } catch (Exception exp) {
    111.             // 记录本地异常日志
    112.             log.error("==前置通知异常==");
    113.             log.error("异常信息:{}", exp.getMessage());
    114.             exp.printStackTrace();
    115.         }
    116.     }
    117.  
    118.  
    119.     /**
    120.      * 是否存在注解，如果存在就获取
    121.      */
    122.     private OperationLog getAnnotationLog(JoinPoint joinPoint) throws Exception {
    123.         Signature signature = joinPoint.getSignature();
    124.         MethodSignature methodSignature = (MethodSignature) signature;
    125.         Method method = methodSignature.getMethod();
    126.  
    127.         if (method != null) {
    128.             return method.getAnnotation(OperationLog.class);
    129.         }
    130.         return null;
    131.     }
    132.  
    133.     /**
    134.      * 参数拼装
    135.      */
    136.     private String argsArrayToString(Object[] paramsArray) {
    137.         String params = "";
    138.         if (paramsArray != null && paramsArray.length > 0) {
    139.             for (int i = 0; i < paramsArray.length; i++) {
    140.                 if (paramsArray[i] != null && !isFilterObject(paramsArray[i])) {
    141.                     Object jsonObj = JSON.toJSON(paramsArray[i]);
    142.                     params += jsonObj.toString() + " ";
    143.                 }
    144.             }
    145.         }
    146.         return params.trim();
    147.     }
    148.  
    149.     /**
    150.      * 判断是否需要过滤的对象。
    151.      *
    152.      * @param o 对象信息。
    153.      * @return 如果是需要过滤的对象，则返回true；否则返回false。
    154.      */
    155.     @SuppressWarnings("rawtypes")
    156.     public boolean isFilterObject(final Object o) {
    157.         Class clazz = o.getClass();
    158.         if (clazz.isArray()) {
    159.             return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
    160.         } else if (Collection.class.isAssignableFrom(clazz)) {
    161.             Collection collection = (Collection) o;
    162.             for (Iterator iter = collection.iterator(); iter.hasNext(); ) {
    163.                 return iter.next() instanceof MultipartFile;
    164.             }
    165.         } else if (Map.class.isAssignableFrom(clazz)) {
    166.             Map map = (Map) o;
    167.             for (Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) {
    168.                 Map.Entry entry = (Map.Entry) iter.next();
    169.                 return entry.getValue() instanceof MultipartFile;
    170.             }
    171.         }
    172.         return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
    173.                 || o instanceof BindingResult;
    174.     }
    175. }

    业务操作类型

    1. public enum BusinessType
    2. {
    3.     /**
    4.      * 新增
    5.      */
    6.     ADD,
    7.  
    8.     /**
    9.      * 修改
    10.      */
    11.     UPDATE,
    12.  
    13.     /**
    14.      * 删除
    15.      */
    16.     DELETE,
    17.  
    18.     /**
    19.      * 删除查询
    20.      */
    21.     QUERY,
    22. }

    操作日志存储

    1. @Service
    2. @Slf4j
    3. public class OpLogServiceImpl implements OpLogService {
    4.  
    5.     @Resource
    6.     private MongoTemplate mongoTemplate;
    7.  
    8.     /**
    9.      * 插入操作日志到mongo
    10.      *
    11.      * @param opLog
    12.      * @return
    13.      */
    14.     @Override
    15.     public Result insertOpLog(OpLog opLog) {
    16.  
    17.         mongoTemplate.insert(opLog);
    18.  
    19.         return Result.buildSucc();
    20.     }
    21.  
    22. }

    使用方法，在controller方法上加上下面类似注解就好

    @OperationLog(module = "客户管理", function = "创建客户", type = BusinessType.ADD)

    总结

    一些用得比较多的脚手架，里面还是有很多值得我们学习的地方，一些常用功能，可以多参考参考脚手架中怎么实现的，包括功能界面设计和代码实现。

  • 相关阅读:
    P1278 单词游戏 简单搜索+玄学优化
    论文解读（S^3-CL）《Structural and Semantic Contrastive Learning for Self-supervised Node Representation Learning》
    面对工作中的失误：从错误中学习与成长
    Linux之yum安装MySQL
    WPF 单击移动窗口 MouseLeftButtonDown 事件
    设计模式2、抽象工厂模式 Abstract Factory
    100天精通Golang（基础入门篇）——第20天：Golang 接口 深度解析☞从基础到高级
    wpf 命令概述
    RT-Thread内核快速入门，内核实现与应用开发学习随笔记
    审计智能合约的成本是多少？如何审计智能合约？
  • 原文地址：https://blog.csdn.net/maxi1234/article/details/127641722