SpringBoot - AOP+自定义注解实现一个日志插件

说在前面

本日志记录涵盖：IP地址(详细)、Header信息、Session信息、方法参数、返回结果、请求方式(POST/GET)、URI等等…
通过自定义注解的思想，根据需求可以添加更多日志字段。
将日志功能做成一个插件，做到即引即用。

插件书写

根据自己的实际需求，对插件代码进行修改。

1、引入相关依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.46</version>
</dependency>

2、创建自定义注解

这个自定义注解作用的作用就是：你可以通过自定义注解来传入一些你想要的记录的日志参数，比如我们调用一个POST类型的Controller接口，我们想记录它的请求方式、它是哪个模块的接口、作用是什么时，我们可以通过这个自定义注解传进去，然后通过在AOP的时候通过反射获取。

// 注解放置的目标位置,METHOD是可注解在方法级别上
@Target(ElementType.METHOD)
//注解在哪个阶段执行 - 运行时
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLog {
    /** 操作模块（如订单模块） */
    String operateModule() default "";
    /** 操作说明（如新增订单） */
    String operateDesc() default "";
    /** 请求类型（GET/POST/PUT/DELETE） */
    String operateType() default "";
    // 更多补充...
}

3、创建两个日志Pojo

创建一个BaseLog

该类主要就是作为正常操作和异常操作日志的基类，即两个日志共有的属性。

@Data
@ToString
public class BaseLog {
    /** 分布式id(自增id) */
    private Long id;
    /** 请求参数 */
    private String requestParam;
    /** 请求头参数 */
    private String headerParam;
    /** 请求方法名 */
    private String operateMethod;
    /** 操作用户ID */
    private Long operateUserId;
    /** 操作用户名 */
    private String operateUserName;
    /** 请求URI(如/test/add) */
    private String operateUri;
    /** 请求IP */
    private String operateIp;
    /** 操作模块 */
    private String operateModule;
    /** 请求类型(GET/POST/PUT/DELETE) */
    private String operateType;
    /** 操作描述 */
    private String operateDesc;
    /** 创建时间 */
    private Date createTime;
}

正常调用记录日志 - OperationLog

@Data
@ToString
public class OperationLog extends BaseLog{
    /** 返回结果 */
    private String operateResponseParam;
}

异常调用记录日志 - ExceptionLog

@Data
@ToString
public class ExceptionLog extends BaseLog{
    /** 异常名 */
    private String excName;
    /** 异常信息 */
    private String excMessage;
}

4、提供两个接口

这两个接口就是对正常操作日志和异常操作日志的处理，把他交给引入我这个插件的人去实现，接口只负责把日志对象信息传过去。
引入我这个插件的，必须要实现这两个接口，且需要将其实现类交给Spring管理（比如使用@Component标记）。

public interface OperationLogService {
    /**
     * 将日志记录到数据库
     * @param operationLog 日志对象
     */
    void recordOperateLog(OperationLog operationLog);
}

@Component
public class ExceptionLogServiceImpl implements ExceptionLogService {
    @Override
    public void recordExceptionLog(ExceptionLog exceptionLog) {
        // 这里再调用一个存储数据库的service即可
        System.out.println("正在记录数据库日志 - 异常");
    }
}

5、创建切面

@Aspect
@Component
@Slf4j
public class OperationLogAspect {
    private static final String COMMA = ",";
    private static final String IP = "127.0.0.1";
    private static final String LOCAL_IP = "0:0:0:0:0:0:0:1";
    /**
     * x-forwarded-for是识别通过HTTP代理或负载均衡方式连接到Web服务器的客户端
     * 最原始的IP地址的HTTP请求头字段
     */
    private static final String HEADER = "x-forwarded-for";
    private static final String UNKNOWN = "unknown";
    /**
     * 经过apache http服务器的请求才会有
     * 用apache http做代理时一般会加上Proxy-Client-IP请求头
     * 而WL-Proxy-Client-IP是它的weblogic插件加上的头。
     */
    private static final String WL_IP = "WL-Proxy-Client-IP";
    private static final Integer IP_LENGTH = 15;

    @Autowired
    private OperationLogService operationLogService;
    @Autowired
    private ExceptionLogService exceptionLogService;

    /**
     * 设置操作日志切入点记录操作日志
     * 在注解的位置切入代码
     */
    @Pointcut("@annotation(pers.liuchengyin.log.OperateLog)")
    public void operateLogPointCut() {

    }

    /**
     * 设置操作异常切入点记录异常日志
     * 扫描所有controller结尾的操作
     * 根据需要修改，一般只需要修改前缀即可，比如你是com.开头的包，将pers改成com即可
     */
    @Pointcut(value = "execution(* pers..*Controller.*.*(..))")
    public void operateExcLogPointCut() {

    }


    /*
     * 1、获取参数问题（Body和Query），通过request.getParameterMap()只能获取到Query参数
     *    无法获取到Body，如果通过流的方式获取Body，会出现 getInputStream() has already been called for this request 异常
     * 2、异常原因：@RequestBody这个注解是以流的形式读取请求，它调用过一次了。（getInputStream()和getReader()只能调用一次）
     *    解决办法：暂不清楚
     * 3、获参解决方案：可以通过request.getParameterMap()获取，但只能获取到query参数，无法获取到body参数
     *    可以考虑通过request.getParameterMap()来判断是否为空，为空，则可能是传的body参数
     *       问题：(@RequestBody User user, String name, Integer age)  无法解决，没办法通过判空来解决
     * 4、最终解决方案：统一采用joinPoint.getArgs()来获取参数
     */


    /**
     * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行，如果连接点抛出异常，则不会执行
     * @param joinPoint 切入点
     * @param keys      返回结果
     */
    @AfterReturning(value = "operateLogPointCut()", returning = "keys")
    public void saveOperationLog(JoinPoint joinPoint, Object keys) {
        OperationLog operationLog = new OperationLog();
        try {
            setBaseLog(joinPoint, operationLog);
            operationLog.setOperateResponseParam(JSON.toJSONString(keys));
            // 插入数据库
            operationLogService.recordOperateLog(operationLog);
            // 打印信息，请删除，做测试使用，请使用log.info做日志
            System.out.println(operationLog);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @AfterThrowing(pointcut = "operateExcLogPointCut()", throwing = "e")
    public void saveExceptionLog(JoinPoint joinPoint, Throwable e) {
        ExceptionLog exceptionLog = new ExceptionLog();
        try {
            setBaseLog(joinPoint, exceptionLog);
            exceptionLog.setExcName(e.getClass().getName());
            exceptionLog.setExcMessage(stackTraceToString(e.getClass().getName(), e.getMessage(), e.getStackTrace()));
            // 插入数据库
            exceptionLogService.recordExceptionLog(exceptionLog);
            // 打印信息，请删除，做测试使用，请使用log.info做日志
            System.out.println(exceptionLog);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


    /**
     * 设置基础的参数
     * @param joinPoint 切入点
     * @param baseLog 基础日志
     */
    private void setBaseLog(JoinPoint joinPoint, BaseLog baseLog) {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
        // 获取Session信息 - 如果你需要的话
//        HttpSession session = (HttpSession) requestAttributes.resolveReference(RequestAttributes.REFERENCE_SESSION);
        baseLog.setId(1L);
        // 从切面织入点通过反射机制获取织入点的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取切入点所在的方法对象
        Method method = signature.getMethod();
        setOpLog(method, baseLog);
        String methodName = getMethodName(joinPoint, method);
        String params = getParams(joinPoint);
        String headerParams = getHeaders(request);
        baseLog.setOperateMethod(methodName);
        baseLog.setRequestParam(params);
        baseLog.setHeaderParam(headerParams);
        // TODO: 参数设置 - 根据自己的需求添加即可
        // 比如请求用户的信息，可以通过一个工具类获取，从ThreadLocal里拿出来
        // 请求用户ID
        baseLog.setOperateUserId(1L);
        // 请求用户名称
        baseLog.setOperateUserName("liuchengyin");
        // 请求IP
        baseLog.setOperateIp(getIpAddr(request));
        // 请求URI
        baseLog.setOperateUri(request.getRequestURI());
        // 创建时间
        baseLog.setCreateTime(new Date());
    }

    /**
     * 设置@OperateLog注解的参数
     * @param method 方法
     * @param baseLog 日志
     */
    private void setOpLog(Method method, BaseLog baseLog){
        // 获取操作信息 - 就是获取@OperateLog里面信息
        OperateLog opLog = method.getAnnotation(OperateLog.class);
        if (null != opLog) {
            // 操作模块 - 如（订单模块）
            baseLog.setOperateModule(opLog.operateModule());
            // 请求类型 - 如（POST）
            baseLog.setOperateType(opLog.operateType());
            // 操作描述 - 如（新增订单）
            baseLog.setOperateDesc(opLog.operateDesc());
        }
    }

    /**
     * 转换异常信息为字符串
     * @param exceptionName    异常名称
     * @param exceptionMessage 异常信息
     * @param elements         堆栈信息
     */
    private String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) {
        StringBuffer strBuff = new StringBuffer();
        for (StackTraceElement stet : elements) {
            strBuff.append(stet + "\n");
        }
        return exceptionName + ":" + exceptionMessage + "\n\t" + strBuff.toString();
    }

    /**
     * 获取方法名
     * @param joinPoint 切入点
     * @param method 方法对象
     * @return 方法名
     */
    private String getMethodName(JoinPoint joinPoint, Method method){
        // 获取请求的类名
        String className = joinPoint.getTarget().getClass().getName();
        // 获取请求的方法名
        String methodName = method.getName();
        // 拼接类名和方法名 - pers.liuchengyin.controller.xxxController
        methodName = className + "." + methodName;
        return methodName;
    }

    /**
     * 获取方法请求参数
     * @param joinPoint 切入点
     * @return 参数JSON字符串
     */
    private String getParams(JoinPoint joinPoint){
        // 获取参数名
        String[] parameterNames = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
        // 参数的JSON字符串
        String params = "";
        if(null != parameterNames && parameterNames.length != 0){
            // 获取参数
            Object[] args = joinPoint.getArgs();
            // 将 <参数名, 参数> 打入map
            HashMap<String, Object> map = new HashMap<>();
            for (int i = 0; i < parameterNames.length; i++){
                map.put(parameterNames[i],args[i]);
            }
            // 使用FastJson将其转换为字符串
            params = JSON.toJSONString(map);
        }
        return params;
    }

    /**
     * 获取Headers，并将其转换成JSON字符串
     * @param request HttpServletRequest
     * @return headers的JSON字符串
     */
    private String getHeaders(HttpServletRequest request) {
        // 获取请求头参数
        Enumeration<String> headerNames = request.getHeaderNames();
        // 请求头的JSON字符串
        String headerParams = "";
        if(null != headerNames){
            HashMap<String, String> headMap = new HashMap<>(7);
            while(headerNames.hasMoreElements()){
                String key = headerNames.nextElement();
                String value = request.getHeader(key);
                headMap.put(key,value);
            }
            // 使用FastJson将其转换为字符串
            headerParams = JSON.toJSONString(headMap);
        }
        return headerParams;
    }

    /**
     * 获取IP地址
     * @param request HttpServletRequest
     * @return IP地址
     */
    private String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader(HEADER);
        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_IP);
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            if (ip.equals(IP) || ip.equals(LOCAL_IP)) {
                // 根据网卡获取本机配置的IP地址
                InetAddress inetAddress = null;
                try {
                    inetAddress = InetAddress.getLocalHost();
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
                if (Objects.nonNull(inetAddress)) {
                    ip = inetAddress.getHostAddress();
                }
            }
        }
        // 对于通过多个代理的情况，第一个IP为客户端真实的IP地址，多个IP按照','分割
        if (null != ip && ip.length() > IP_LENGTH) {
            // "***.***.***.***".length() = 15
            if (ip.indexOf(COMMA) > 0) {
                ip = ip.substring(0, ip.indexOf(COMMA));
            }
        }
        return ip;
    }
    
}

其他工程引入插件方式

1、首先将插件使用maven打到本地仓库

具体操作见百度，下列命令仅作为参考。

// clean install
mvn clean install
// 打包到本地仓库的完整命令，可根据自己需要进行调整
mvn install:install-file -Dfile=target/log-api-1.0.0.jar -DgroupId=pers.liuchengyin.log -DartifactId=log-api -Dversion=1.0.0 -Dpackaging=jar

2、引入插件依赖

<dependency>
    <groupId>pers.liuchengyin.log</groupId>
    <artifactId>log-api</artifactId>
    <version>1.0.0</version>
</dependency>

3、实现接口

@Component
public class LogInfoWriteServiceImpl implements OperationLogService {
    @Override
    public void recordOperateLog(OperationLog operationLog) {
        // 这里再调用一个存储数据库的service即可
        System.out.println("正在记录数据库日志 - 正常");
    }
}

@Component
public class ExceptionLogServiceImpl implements ExceptionLogService {
    @Override
    public void recordExceptionLog(ExceptionLog exceptionLog) {
        // 这里再调用一个存储数据库的service即可
        System.out.println("正在记录数据库日志 - 异常");
    }
}

4、Controller方法加上注解即可

@RequestMapping("/two/test")
@RestController
public class TestTwoController {
    @GetMapping("/info")
    @OperateLog(operateModule = "用户管理", operateType = "GET", operateDesc = "获取用户")
    public Response<User> info(String name, Integer age){
        User user = new User(1L, name,"女", age);
        return new Response<User>(true,"查询成功",user);
    }
}

5、测试

http://localhost:8080/two/test/info?name=liuchengyin&age=18

Github地址：SpringBoot + AOP 实现一个日志记录插件Demo
Gitee地址：SpringBoot + AOP 实现一个日志记录插件Demo
参考博客：参考博文
感谢作者提供的一个自定义注解的思想，代码参照原博客，对代码做了一些优化调整以及一些自己的见解。