Springboot中使用AOP统一处理Web请求日志异常

日志

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是Spring框架中的一个重要内容，它通过对既有程序定义一个切入点，然后在其前后切入不同的执行内容，比如常见的有：打开数据库连接/关闭数据库连接、打开事务/关闭事务、记录日志等。

基于AOP不会破坏原来程序逻辑，因此它可以很好的对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hu</groupId>
    <artifactId>spring-boot-aop-logging</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
    </parent>
    <dependencies>
        <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>
    </dependencies>
</project>

配置：

#引入AOP依赖包后，一般来说并不需要去做其他配置。也不用主类中增加@EnableAspectJAutoProxy来启用。
#spring.aop.auto属性默认是开启的，也就是说只要引入了AOP依赖后，默认已经增加了@EnableAspectJAutoProxy。
spring:
  aop:
    auto: true #默认值
    #proxy-target-class: true#CGLIB来实现AOP，不然默认使用的是标准Java的实现。

切面类：

@Aspect //定义切面类
@Component
public class WebLogAspect {

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

    //如果需要统计一个方法处理请求的处理时间消耗，需要在doBefore中记录时间，在doAfterReturning中统计时间
    //就需要一个对象统一处理时间，在两个方法中调用，就会涉及到同步问题，可以通过ThreadLocal来记录
    ThreadLocal<Long> startTime = new ThreadLocal<>();


    //定义一个切入点
    @Pointcut("execution(public * com.hu.controller..*.*(..))")
    public void webLog(){}

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 记录下请求内容
        logger.info(joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName()
                        +">>>URL：" + request.getRequestURL().toString()+">>>HTTP_METHOD：" + request.getMethod()+">>>IP：" + request.getRemoteAddr()
                        + ">>>ARGS：" + Arrays.toString(joinPoint.getArgs()));

    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        logger.info(">>>RESPONSE：" + ret);
        logger.info(">>>SPEND TIME：" + (System.currentTimeMillis() - startTime.get()));

    }
    /*AOP切面的优先级
    由于通过AOP实现，程序得到了很好的解耦，如果涉及有多个切面，会有切面执行顺序问题，就需要定义切面的优先级。
    @Order(i)注解来标识切面的优先级。i的值越小，优先级越高。
    在切入点前的操作，按order的值由小到大执行
    在切入点后的操作，按order的值由大到小执行*/
}

统一异常处理

@ControllerAdvice
public class ControllerExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(ControllerExceptionHandler.class);

    /**
     * 处理不可知的一些异常，包括业务上RuntimeException异常
     * @param e
     * @return
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public RetViewModel handlerException(Exception e, HttpServletRequest request){
        logger.error(e.getMessage(),e);
        return new RetViewModel(HttpStatus.INTERNAL_SERVER_ERROR.value(), Constants.INTERNAL_SERVER_ERROR,null);
    }

    /**
     * 远程请求异常
     */
    @ExceptionHandler(HttpClientErrorException.class)
    @ResponseBody
    public RetViewModel httpClientErrorException(HttpClientErrorException e, HttpServletRequest request){
        logger.error(Constants.REMOTE_R,e.getMessage());
        return new RetViewModel(e.getRawStatusCode(), Constants.REMOTE_R,null);
    }

    /**
     * 不支持当前请求方法
     * @param e
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    @ResponseBody
    public RetViewModel handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
        logger.error(Constants.METHOD_NOT_ALLOWED, e);
        return new RetViewModel(HttpStatus.METHOD_NOT_ALLOWED.value(),Constants.METHOD_NOT_ALLOWED,null);
    }

    /**
     * 不支持当前媒体类型
     * @param e
     * @return
     */
    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    @ResponseBody
    public RetViewModel handleHttpMediaTypeNotSupportedException(Exception e) {
        logger.error(Constants.UNSUPPORTED_MEDIA_TYPE, e);
        return new RetViewModel(HttpStatus.UNSUPPORTED_MEDIA_TYPE.value(),Constants.UNSUPPORTED_MEDIA_TYPE,null);
    }

    /**
     * 数据校验
     */
    @ExceptionHandler(BindException.class)
    @ResponseBody
    public RetViewModel methodArgumentNotValidHandler(BindException e) {
        logger.error(Constants.BAD_REQUEST, e);
        BindingResult bindingResult = e.getBindingResult();
        Map<String, Object> map = getErrors(bindingResult);
        RetViewModel responseResult = new RetViewModel(HttpStatus.BAD_REQUEST.value(),map.values().toString(),null);
        return responseResult;
    }
    /**
     * 参数类型不匹配
     */
    @ExceptionHandler({TypeMismatchException.class})
    @ResponseBody
    public RetViewModel requestTypeMismatch(TypeMismatchException ex){
        logger.error(Constants.BAD_REQUEST, ex);
        return  new RetViewModel(HttpStatus.BAD_REQUEST.value(),"参数类型不匹配,参数" + ex.getValue() + "类型应该为" + ex.getRequiredType(),null);
    }

    /**
     * 缺少参数异常
     */
    @ExceptionHandler({MissingServletRequestParameterException.class})
    @ResponseBody
    public RetViewModel requestMissingServletRequest(MissingServletRequestParameterException ex){
        logger.error(Constants.BAD_REQUEST, ex);
        return new RetViewModel(HttpStatus.BAD_REQUEST.value(), "缺少必要参数,参数名称为" + ex.getParameterName(),null);
    }
    /**
     * 请求参数错误
     * @param e
     * @return
     */
    @ExceptionHandler({HttpMessageNotReadableException.class})
    @ResponseBody
    public RetViewModel handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
        logger.error(Constants.BAD_REQUEST, e);
        return new RetViewModel(HttpStatus.BAD_REQUEST.value(),Constants.BAD_REQUEST,null);
    }

    private Map<String, Object> getErrors(BindingResult result) {
        Map<String, Object> map = new HashMap<>();
        List<FieldError> list = result.getFieldErrors();
        for (FieldError error : list) {
            map.put(error.getField(), error.getDefaultMessage());
        }
        return map;
    }
}

Exception Type	HTTP Status Code
ConversionNotSupportedException	500 (Internal Server Error)
HttpMediaTypeNotSupportedException	406 (Not Acceptable)
HttpMediaTypeNotSupportedException	415 (Unsupported Media Type)
HttpMessageNotReadableException	400 (Bad Request)
HttpMessageNotWritableException	500 (Internal Server Error)
HttpRequestMethodNotSupportedException	405 (Method Not Allowed)
MissingServletRequestParameterException	400 (Bad Request)
NoSuchRequestHandlingMethodException	404 (Not Found)
TypeMismatchException	400 (Bad Request)