AOP日志拦截器

各位读者，大家好！

     我们在开发项目时，要经常输出大量的日志，以便问题的排查。但是写日志又显得特别繁琐，特别是固定的日志内容。

     比如，接口开发时，经常要打印出【入参】、【响应结果】及【异常日志】，那么有没有办法统一管理这些日志呢，答案是可以的。

    下面我们就运用Spring的AOP技术来实现它，我们这里用到了Before（前置通知）、After（后置通知）及Throwable（异常通知）。

   

    思路：要想对不同的方法打印各自的日志，那么就需要开发者提供这个方法的使用说明，在这里我们就自定义一个注解MyLogAdvice，其作用是用于标注需要被日志拦截器管理的方法，及该方法的说明。如下：

 

 

package com.cheng2839.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 日志打印
 * @author cheng2839
 * @date 2018年11月16日
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface CustomLogAdvice {

    //方法作用
    String msg();

}

 

 

    接下来，我们开发日志拦截器LogAdvice

package com.cheng2839.interceptor;

import com.cheng2839.annotation.MyLogAdvice;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Method;

/**
 * 日志AOP拦截
 * @author cheng2839
 * @date 2018年11月16日
 */
@Aspect
@Component
public class LogAdvice {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Pointcut("execution(@(@com.cheng2839.annotation.MyLogAdvice *) * *(..)) " +
            "|| execution(@com.cheng2839.annotation.MyLogAdvice * *(..)) " +
            "|| execution(@(@com.cheng2839.annotation.MyLogAdvice *) * *(..))")
    public void log() {}

    /**
     * 前置 - 入参打印
     * @param joinPoint
     * @author cheng2839
     * @date 2018年11月16日
     */
    @Before("log()")
    public void beforeAspect(JoinPoint joinPoint) {
        try {
            StringBuilder methodMsg = getMethodMsg(joinPoint);
            if (ObjectUtil.isNotNullOrNotEmpty(methodMsg)) {
                Object[] args = joinPoint.getArgs();
                StringBuilder paramToString = new StringBuilder();
                if (args!=null) {
                    for (Object p : args) {
                        paramToString.append(p);
                        paramToString.append(' ');
                    }
                }
                logger.info("{}入参:{}", methodMsg.toString(), paramToString.toString());
            }
        } catch (Exception ex) {
            logger.error("LogAdvice.beforeAspect exception:{}", ex);
        }

    }

    /**
     * 后置通知 - 响应结果打印
     * @param joinPoint
     * @param result
     * @throws Throwable
     * @author cheng2839
     * @date 2018年11月16日
     */
    @AfterReturning(pointcut = "log()", returning = "result")
    public void afterAspect(JoinPoint joinPoint, Object result) {
        try {
            StringBuilder methodMsg = getMethodMsg(joinPoint);
            if (ObjectUtil.isNotNullOrNotEmpty(methodMsg)) {
                logger.info("{}响应结果：{}", methodMsg.toString(), result);
            }
        } catch (Exception ex) {
            logger.error("LogAdvice.afterAspect exception:{}", ex);
        }
    }

    /**
     * 异常捕获 - 异常打印
     * @param joinPoint
     * @author cheng2839
     * @date 2018年11月16日
     */
    @AfterThrowing(value = "log()", throwing = "e")
    public void throwAspect(JoinPoint joinPoint, Exception e) {
        try {
            StringBuilder methodMsg = getMethodMsg(joinPoint);
            if (ObjectUtil.isNotNullOrNotEmpty(methodMsg)) {
                StringWriter sw = new StringWriter();
                e.printStackTrace(new PrintWriter(sw));
                logger.error("{}异常：{}", methodMsg.toString(), sw.toString());
            }
        } catch (Exception ex) {
            logger.error("LogAdvice.throwAspect exception:{}", ex);
        }
    }

    /**
     * 组装方法提示消息
     * @param joinPoint
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    private StringBuilder getMethodMsg(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        Method method = ((MethodSignature) signature).getMethod();
        MyLogAdvice myLogAdvice = method.getAnnotation(MyLogAdvice.class);

        StringBuilder methodMsg = null;
        if (myLogAdvice != null) {
            methodMsg = new StringBuilder();
            methodMsg.append(method.getDeclaringClass().getName()); //class name
            methodMsg.append('.');
            methodMsg.append(method.getName()); //method name
            methodMsg.append(' ');
            methodMsg.append('-');
            methodMsg.append(' ');
            methodMsg.append(myLogAdvice.msg()); //method remark
        }
        return methodMsg;
    }
}

 

    接下来，我们写个测试接口测试一下：

    注意：这里我创建了一个springBoot服务，端口：8392，服务的创建不再这里赘述。

package com.cheng2839.controller;

import com.cheng2839.annotation.MyLogAdvice;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 日志拦截器测试类
 * @author cheng2839
 * @date 2018年11月16日
 */
@RestController
@RequestMapping("/test")
public class TestLogAspectController {

    @MyLogAdvice(msg = "测试日志拦截器")
    @GetMapping(value = "/testLogAspect")
    public String testLogAspect(@RequestParam("name") String param) {
        return "hello，spring aop";
    }

}

 

   在postman或者浏览器地址栏中用GET请求访问：http://127.0.0.1:8392/test/testLogAspect?name=cheng2839

 

 

    日志输出结果如下：

2018-11-16 17:21:09.130 [http-nio-8392-exec-3] [INFO] com.cheng2839.interceptor.LogAdvice:com.cheng2839.controller.TestLogAspectController.testLogAspect - 测试日志拦截器入参:cheng2839 
2018-11-16 17:21:09.132 [http-nio-8392-exec-3] [INFO] com.cheng2839.interceptor.LogAdvice:com.cheng2839.controller.TestLogAspectController.testLogAspect - 测试日志拦截器响应结果：hello，spring aop

 

                                      ——此记