Spring AOP利用切面实现日志保存的示例详解

更新时间：2022年11月17日 09:47:12 作者：陶陶吖

最近领导让写个用切面实现日志保存，经过调研和亲测，以完美解决。在这里分享给大家，给有需要的码友直接使用，希望对大家有所帮助

依赖引入

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

创建表

DROP TABLE IF EXISTS `logger_record`;
CREATE TABLE `logger_record`  (
  `id` varchar(36) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'id',
  `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '描述',
  `package_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作所在的包',
  `class_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作的类名',
  `method_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作的方法名',
  `request_params` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '操作方法的参数',
  `response_params` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '操作方法的出参',
  `running_time` bigint NULL DEFAULT NULL COMMENT '运行时间',
  `created_by` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人ID',
  `date_created` datetime NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

对象实体类

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.**.app.common.util.TimeUtils;
import lombok.Data;
import org.springframework.data.annotation.Id;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * Created by cb on 2022/11/15 10:07
 */
//@Entity
@Data
public class LoggerRecord implements Serializable {
    @Id
    @TableId(value = "id",type = IdType.ID_WORKER_STR)//可不引入注解，UUID生成
    private String id;
    /**
     * 操作方法的描述
     */
    private String description;//实际没用上
    /**
     * 操作所在的包
     */
    private String packageName;
    /**
     * 操作的类名
     */
    private String className;
    /**
     * 操作的方法名
     */
    private String methodName;
    /**
     * 操作方法的参数
     */
    private String requestParams;
    /**
     * 操作方法的出参
     */
    private String responseParams;
    /**
     * 运行时间
     */
    private Long runningTime;
    /** 创建时间 */
    @JsonFormat(pattern = TimeUtils.PATTERN2)
    private LocalDateTime dateCreated;//可以用date

    /** 创建人ID */
    private String createdBy;//实际没用上

}

注解方法

package com.**.app.server.annotation;

import java.lang.annotation.*;

/**
 * Created by cb on 2022/11/15 10:05
 * 日志描述的注解
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LoggerManager {
}

service方法

可根据自己项目去相应改动

/**
 * 日志增删改的接口
 * Created by cb on 2022/11/15 10:11
 */
@Service
public class LoggerRecordRepository extends ServiceImpl<LoggerRecordMapper, LoggerRecord> {
}

工具类

package com.**.app.server.util;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by cb on 2022/11/15 10:24
 */
public class AopUtil {
    /**
     * 获取切点处的方法
     * @param joinPoint
     * @return
     */
    public static Method getMethod(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        return method;
    }

    /**
     //     * 将参数数组转化为字符串
     //     * @param params  参数数组
     //     * @return 参数字符串
     //     */
    public static String getStringOfParams(Object[] params) {
        if (params.length <= 0 || params.length > 1024 || null == params) {
            return "";
        }

        StringBuffer paramString = new StringBuffer("参数:   ");
        for (Object param : params) {
            //将参数转换成字符串
            String s = ToStringBuilder.reflectionToString(param);
            paramString.append(s).append("||");
        }
        return paramString.toString();
    }

    /**
     * 转换request 请求参数
     * @param paramMap request获取的参数数组
     */
    public static Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap<String, String>();
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, paramMap.get(key)[0]);
        }
        return rtnMap;
    }

}

注解实现方法

package com.**.app.server.annotation;

import com.alibaba.fastjson.JSON;
import com.**.app.server.entity.log.LoggerRecord;
import com.**.app.server.service.LoggerRecordRepository;
import com.**.app.server.util.AopUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Map;

/**
 * Created by cb on 2022/11/15 10:19
 */
@Aspect
@Service
@Slf4j
public class LoggerAdvice {
    @Resource
    private LoggerRecordRepository loggerRecordRepository;
   


    /**
     * 切点，在注解处切入
     */
    @Pointcut("@annotation(com.safety.app.server.annotation.LoggerManager)")
    public void AroundPointCut(){
    }

    /**
     * 环绕通知 @Around  ， 当然也可以使用 @Before (前置通知)  @After (后置通知)
     * @param point
     * @return
     * @throws Throwable
     */
    @Around("AroundPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {

        long beginTime = System.currentTimeMillis();
        Object result = point.proceed();
        long time = System.currentTimeMillis() - beginTime;
        try {
            LoggerRecord loggerRecord = saveLog(point, time);
            loggerRecord.setResponseParams(JSON.toJSONString(result));
            loggerRecordRepository.save(loggerRecord);
        } catch (Exception e) {
        }finally {

            return result;
        }

    }


    /**
     * 保存日志
     * @param joinPoint
     * @param time
     */
    private LoggerRecord saveLog(ProceedingJoinPoint joinPoint, long time) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);

        //获取该切点处的方法
        Method method = AopUtil.getMethod(joinPoint);
        LoggerRecord loggerRecord = new LoggerRecord();
        //获取切点处的注解
        LoggerManager loggerManager = method.getAnnotation(LoggerManager.class);
        if (null == loggerManager) {
            return loggerRecord;
        }
        //获取请求的描述
//        String description = loggerManager.
        //获取请求包名
        Signature signature = joinPoint.getSignature();
        //获取请求的类名
        String className = joinPoint.getTarget().getClass().getName();
        //获取请求的方法名
        String methodName = method.getName();
        //获取请求的参数
        Map<String, String[]> parameterMap = request.getParameterMap();
        Map<String, String> stringStringMap = AopUtil.converMap(parameterMap);

        log.info("执行===" + methodName + "===开始");
        //打印方法名
        log.info("方法名：" + signature.toString());
        //打印方法参数
        log.info("方法参数：" + JSON.toJSONString(stringStringMap));
        log.info("执行===" + methodName + "===结束");
        //将日志保存
//        loggerRecord.setDescription(description);
        loggerRecord.setPackageName(signature.toString());
        loggerRecord.setClassName(className);
        loggerRecord.setMethodName(methodName);
        loggerRecord.setRunningTime(time);
        loggerRecord.setRequestParams(JSON.toJSONString(stringStringMap));
        return loggerRecord;

    }
}

最后只需要在自己的接口上加注解@LoggerManager就可以实现此方法的入参出参日志保存

/**
 * 测试
 */
@GetMapping("/test")
@ResponseBody
@LoggerManager
public ResponseResult test(@RequestParam("userName") String userName) throws BusinessException {
    Map<String, Object> verifyCodeMap = VerifyCodeUtils.verifyCode();
    redisUtils.set(VERIFY_CODE + userName, verifyCodeMap, 60);
    return new ResponseResult(verifyCodeMap);
}

保存数据库后的图片：

注：所有‘**’的地方为自己项目的包名。好了，下期会改版此日志保存方法，在数据库配置接口名称就可以实现日志的打印保存。

到此这篇关于Spring AOP利用切面实现日志保存的示例详解的文章就介绍到这了,更多相关Spring AOP切面实现日志保存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java并发之Phaser的全面解析详解
Phaser是Java中一个灵活的同步工具,其优点在于支持多阶段的任务拆分与同步,并且能够动态地注册与注销参与者,下面我们就来深入了解一下Phaser的应用吧
2024-02-02
Spring实现IoC和DI的方法详解
IoC全称Inversion of Control (控制反转) ,这里的控制其实是控制权的意思,可以理解为对象的获取权力和方式发生了发转,DI依赖注⼊是⼀个过程,是指IoC容器在创建Bean时, 去提供运⾏时所依赖的资源,⽽资源指的就是对象,本文介绍了Spring实现IoC和DI的方法
2024-08-08
新手小白入门必学JAVA面向对象之多态
说到多态,一定离不开其它两大特性:封装和继承,下面这篇文章主要给大家介绍了关于新手小白入门必学JAVA面向对象之多态的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2022-02-02
Spring中Bean创建完后打印语句的两种方法
这篇文章主要介绍了Spring中Bean创建完后打印语句的两种方法，一个是实现InitializingBean接口，另一个使用@Bean注解和initMethod属性，通过代码示例介绍的非常详细，感兴趣的小伙伴可以参考阅读
2023-07-07
mybatis typeAliases 给实体类起别名的方法
这篇文章主要介绍了mybatis typeAliases 给实体类起别名,本文给大家分享两种用法，通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-09-09
如何将eclipse项目导入到idea的方法步骤(图文)
这篇文章主要介绍了如何将eclipse项目导入到idea的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-03-03
mybatis中的多重if 条件判断
这篇文章主要介绍了mybatis中的多重if 条件判断，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-03-03
springboot+redis+lua实现分布式锁的脚本
本文介绍了如何使用Spring Boot、Redis和Lua脚本实现分布式锁,包括实现原理、代码实现和存在的问题,感兴趣的朋友跟随小编一起看看吧
2024-11-11
SpringBoot使用OpenCV示例总结
这篇文章主要介绍了SpringBoot使用OpenCV示例总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-08-08
SpringBoot集成POI导出Execl表格之统一工具类
这篇文章主要为大家详细介绍了SpringBoot集成POI导出Execl表格之统一工具类，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-09-09