Spring中AOP使用小结

在开发中经常需要对调用链路进行日志记录，如果只是简单的在调用方法中打印日志，显然无法达到效果。所以需要有一种更好的方式统一管理。而Spring中提供的aop就可以很好的解决此问题。

参考学习网站：https://www.cnblogs.com/bigben0123/p/7779357.html

需求：① 调用链路 ② 日志统一整合

/**
 * @author betterLearning
 */
@Aspect
@Component
public class LogAspect {

    private static final Logger LOGGER = LoggerFactory.getLogger(LogAspect.class);

    /** 定义被切包及其子包内的方法 */
    @Pointcut(value = "execution(* com.it.betterlearn.controller..*.*(..))")
    public void controllerPointcut(){}

    @Around("controllerPointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 接收请求
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录请求内容
        LOGGER.info("URL:{}",request.getRequestURL().toString());
        LOGGER.info("IP:{}",request.getRemoteAddr());
        String classMethod = pjp.getSignature().getDeclaringTypeName() + "." + pjp.getSignature().getName();
        LOGGER.info("CLASS_METHOD:{}", classMethod);
        // 记录请求入参
        Object[] args = pjp.getArgs();
        if (args.length > 0) {
            StringBuilder sb = new StringBuilder();
            for (Object arg : args) {
                sb.append(JSON.toJSONString(arg));
            }
            LOGGER.info("classMethod:{}|params:{}", classMethod, sb.toString());
        }
        // 获取调用链路号(全局唯一)，约定俗称key:traceId。value:全局唯一号
        String traceId = MDC.get("traceId");
        // 如果没有,自身产生一个。比如当前服务属于调用链路中的第一个。
        if (traceId == null) {
            MDC.put("traceId", UUID.randomUUID().toString().replace("-", ""));
        }
        Exception exception = null;
        Object result = null;
        long begin = System.currentTimeMillis();
        try {
            return result = pjp.proceed();
        } catch (Exception ex) {
            exception = ex;
            throw ex;
        } finally {
            long spendTime = System.currentTimeMillis()-begin;
            if (exception != null) {
                LOGGER.info("classMethod:{}|spendTime:{}|exception:{}", classMethod, spendTime, JSON.toJSONString(exception));
            } else {
                LOGGER.info("classMethod:{}|spendTime:{}|result:{}", classMethod, spendTime, JSON.toJSONString(result));
            }
            // 从MDC删除调用链路号
            if (traceId != null) {
                MDC.remove(traceId);
            }
            MDC.clear();
        }
    }
}

最后还需要在日志格式中添加traceId的打印:

<property name="pattern">[TRACEID:%X{traceId}] %d{HH:mm:ss.SSS} %-5level %class{-1}.%M()/%L - %msg%xEx%n</property>

---

基于上面的方式，代码看起来还是有点凌乱，而且打印的内容没有做封装，不好管理和迭代，甚至在高并发情况下，日志出现串行（虽然有链路号，可以判断），所以下面继续优化。

封装正常请求信息头和错误信息头

/**
 * @author betterLearning
 */
@Data
public class RequestInfo {
    private String ip;
    private String url;
    private String httpMethod;
    private String classMethod;
    private Object requestParams;
    private Object result;
    private Long timeCost;
}

/**
 * @author betterLearning
 */
@Data
public class RequestErrorInfo {
    private String ip;
    private String url;
    private String httpMethod;
    private String classMethod;
    private Object requestParams;
    private RuntimeException exception;
}

切面代码，注：此处没有把traceId加上。

/**
 * @author betterLearning
 */
@Aspect
@Component
public class LogAspect {
    private final static Logger LOGGER = LoggerFactory.getLogger(LogAspect.class);

    @Pointcut("execution(* com.it.demo.controller..*(..))")
    public void controllerPointcut(){};

    /**
     * 正常通知环绕体
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around("controllerPointcut()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 封装请求
        RequestInfo requestInfo = new RequestInfo();
        requestInfo.setIp(request.getRemoteAddr());
        requestInfo.setUrl(request.getRequestURL().toString());
        requestInfo.setHttpMethod(request.getMethod());
        requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                proceedingJoinPoint.getSignature().getName()));
        requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));
        // 执行目标方法
        Object result = proceedingJoinPoint.proceed();
        // 封装执行结果
        requestInfo.setResult(result);
        // 答应请求耗时
        requestInfo.setTimeCost(System.currentTimeMillis() - start);
        LOGGER.info("Request Info: {}", JSON.toJSONString(requestInfo));
        return result;
    }

    /**
     * 异常通知。区别于正常环绕，不打印耗时；
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "controllerPointcut()", throwing = "e")
    public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        RequestErrorInfo requestErrorInfo = new RequestErrorInfo();
        requestErrorInfo.setIp(request.getRemoteAddr());
        requestErrorInfo.setUrl(request.getRequestURL().toString());
        requestErrorInfo.setHttpMethod(request.getMethod());
        requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName()));
        requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));
        requestErrorInfo.setException(e);
        LOGGER.info("Error Request Info: {}", JSON.toJSONString(requestErrorInfo));
    }
    /**
     * 获取请求参数。注：对于@PathVariable以及@RequestParam注解传递的参数无法打印出参数名
     * @param proceedingJoinPoint
     * @return
     */
    private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {
        //参数名
        String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
        //参数值
        Object[] paramValues = proceedingJoinPoint.getArgs();
        return buildRequestParam(paramNames, paramValues);
    }

    private Map<String, Object> getRequestParamsByJoinPoint(JoinPoint joinPoint) {
        //参数名
        String[] paramNames = ((MethodSignature)joinPoint.getSignature()).getParameterNames();
        //参数值
        Object[] paramValues = joinPoint.getArgs();
        return buildRequestParam(paramNames, paramValues);
    }

    /**
     * 封装参数名和参数值，一一对应。注：此处对于文件对象做了特殊处理
     * @param paramNames
     * @param paramValues
     * @return
     */
    private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {
        Map<String, Object> requestParams = new HashMap<>(16);
        for (int i = 0; i < paramNames.length; i++) {
            Object value = paramValues[i];
            //如果是文件对象
            if (value instanceof MultipartFile) {
                MultipartFile file = (MultipartFile) value;
                //获取文件名
                value = file.getOriginalFilename();
            }
            requestParams.put(paramNames[i], value);
        }
        return requestParams;
    }
}