Halo（七）

@ControllerAdvice 对Controller进行"切面"环绕

结合方法型注解 @ExceptionHandler

	用于捕获Controller中抛出的指定类型的异常，从而达到不同类型的异常区别处理的目的。

	@ControllerAdvice(basePackages = "mvc")
	public class ControllerAdvice {
		@ExceptionHandler(RuntimeException.class)
		public ModelAndView runtimeException(RuntimeException e) {
			e.printStackTrace();
			return new ModelAndView("error");
		}
	}


结合方法型注解 @InitBinder

	用于request中自定义参数解析方式进行注册，从而达到自定义指定格式参数的目的。

	@ControllerAdvice(basePackages = "mvc")
	public class ControllerAdvice {
		@InitBinder
		public void globalInitBinder(WebDataBinder binder) {
			binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd"));
		}
	}


结合方法型注解 @ModelAttribute

	表示其标注的方法将会在目标Controller方法执行之前执行。

	@ControllerAdvice(basePackages = "mvc")
	public class ControllerAdvice {
		@ModelAttribute(value = "message")	//name或value属性则指定的是返回值的名称
		public String globalModelAttribute() {
			return "ld";
		}
	}

@Valid @Validated 参数校验

@Valid 注解会导致 MethodArgumentNotValidException 验证失败时抛出该异常

	1. 参数前加注解：@Valid

	2. JavaBean属性注解：@NotNull，@Max，@Size


@Validated 导致 ConstraintViolationException 抛出该异常

	@RequestParam或者@PathVariable结合@NotNull进行参数检验

	1. 类上加注解：@Validated

	2. 参数前加注解：@NotBlank(message = "姓名不能为空") @RequestParam("name") String name
	
	3. 给SpringMVC注入org.springframework.validation.beanvalidation.MethodValidationPostProcessor

		@Bean
		public MethodValidationPostProcessor methodValidationPostProcessor() {
			return new MethodValidationPostProcessor();
		}

Controller 异常捕获

@RestControllerAdvice({"run.halo.app.controller.admin.api", "run.halo.app.controller.content.api"})
@Slf4j
public class ControllerExceptionHandler {

    //试图插入或更新数据时引发异常（Dao异常）
    @ExceptionHandler(DataIntegrityViolationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public BaseResponse handleDataIntegrityViolationException(DataIntegrityViolationException e) {
        BaseResponse<?> baseResponse = handleBaseException(e);
        if (e.getCause() instanceof org.hibernate.exception.ConstraintViolationException) {
            baseResponse = handleBaseException(e.getCause());
        }
        baseResponse.setMessage("字段验证错误，请完善后重试！");
        baseResponse.setStatus(HttpStatus.BAD_REQUEST.value());
        return baseResponse;
    }

 
 	//参数校验异常
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public BaseResponse handleConstraintViolationException(ConstraintViolationException e) {
        BaseResponse<Map<String, String>> baseResponse = handleBaseException(e);
        baseResponse.setMessage("字段验证错误，请完善后重试！");
        //违反属性约束的Map（key是变量名，value是错误信息）
        baseResponse.setData(ValidationUtils.mapWithValidError(e.getConstraintViolations()));
        baseResponse.setStatus(HttpStatus.BAD_REQUEST.value());
        return baseResponse;
    }


 	//参数校验异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public BaseResponse handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
        BaseResponse<Map<String, String>> baseResponse = handleBaseException(e);
        baseResponse.setMessage("字段验证错误，请完善后重试！");
        //违反属性约束的Map（key是变量名，value是错误信息）
        baseResponse.setData(ValidationUtils.mapWithFieldError(e.getBindingResult().getFieldErrors()));
        baseResponse.setStatus(HttpStatus.BAD_REQUEST.value());
        return baseResponse;
    }


    //缺少Servlet请求参数异常
    @ExceptionHandler(MissingServletRequestParameterException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public BaseResponse handleMissingServletRequestParameterException(MissingServletRequestParameterException e) {
        BaseResponse<?> baseResponse = handleBaseException(e);
        baseResponse.setMessage(String.format("请求字段缺失，类型为 %s，名称为 %s", e.getParameterType(), e.getParameterName()));
        baseResponse.setStatus(HttpStatus.BAD_REQUEST.value());
        return baseResponse;
    }


    /**
     * 异常处理基础方法
     */
    private <T> BaseResponse<T> handleBaseException(Throwable t) {
        log.error("捕获一个异常：", t);

        //构造响应体BaseResponse
        BaseResponse<T> baseResponse = new BaseResponse<>();
        //设置响应信息Message
        baseResponse.setMessage(t.getMessage());

        if (log.isDebugEnabled()) {
            //设置开发信息（堆栈跟踪信息）
            baseResponse.setDevMessage(ExceptionUtils.getStackTrace(t));
        }

        return baseResponse;
    }
}

参数校验工具类

public class ValidationUtils {

    private static Validator VALIDATOR;

    private ValidationUtils() {
    }

    /** 获取验证器 */
    @NonNull
    public static Validator getValidatorOrCreate() {
        if (VALIDATOR == null) {
            synchronized (ValidationUtils.class) {
                //初始化验证器
                VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();
            }
        }
        return VALIDATOR;
    }


    /**
     * 手动校验Bean
     */
    public static void validate(Object obj, Class<?>... groups) {

        Validator validator = getValidatorOrCreate();

        Set<ConstraintViolation<Object>> constraintViolations = validator.validate(obj, groups);

        if (!CollectionUtils.isEmpty(constraintViolations)) {
            throw new ConstraintViolationException(constraintViolations);
        }
    }


    /**
     * ConstraintViolationException.class
     * 
     * 将字段验证错误转换为标准的map型，key:value = field:message
     */
    @NonNull
    public static Map<String, String> mapWithValidError(Set<ConstraintViolation<?>> constraintViolations) {
        if (CollectionUtils.isEmpty(constraintViolations)) {
            return Collections.emptyMap();
        }

        Map<String, String> errMap = new HashMap<>(4);
        //格式化错误信息
        constraintViolations.forEach(
                constraintViolation ->
                        //key：变量名(constraintViolation.getPropertyPath())，value：错误信息
                        errMap.put(constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage()));
        return errMap;
    }


    /**
     * MethodArgumentNotValidException.class
     * 
     * 将字段验证错误转换为标准的map型，key:value = field:message
     */
    public static Map<String, String> mapWithFieldError(@Nullable List<FieldError> fieldErrors) {
        if (CollectionUtils.isEmpty(fieldErrors)) {
            return Collections.emptyMap();
        }

        Map<String, String> errMap = new HashMap<>(4);

        fieldErrors.forEach(
        		//key：变量名(constraintViolation.getPropertyPath())，value：错误信息
        		filedError -> errMap.put(filedError.getField(), filedError.getDefaultMessage()));
        return errMap;
    }
}

堆栈跟踪信息

public class ExceptionUtils {

    /** 从Throwable获取堆栈跟踪 */
    public static String getStackTrace(final Throwable throwable) {
        final StringWriter sw = new StringWriter();
        final PrintWriter pw = new PrintWriter(sw, true);
        //将异常信息打印到StringWriter中
        throwable.printStackTrace(pw);
        return sw.getBuffer().toString();
    }
}

ResponseBodyAdvice接口 + @ControllerAdvice 处理返回结果

/**
 * 封装请求体body，解决JS跨域请求
 */
@ControllerAdvice("run.halo.app.controller")
public class CommonResultControllerAdvice implements ResponseBodyAdvice<Object> {

    /**
     * 拦截条件：拦截Json数据
     *
     * @param returnType    返回类型
     * @param converterType 转换器类型
     */
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        //拦截转换器 AbstractJackson2HttpMessageConverter子类的Controller方法
        return AbstractJackson2HttpMessageConverter.class.isAssignableFrom(converterType);
    }

    @Override
    @NonNull
    public final Object beforeBodyWrite(@Nullable Object body, MethodParameter returnType,
                                        MediaType contentType, Class<? extends HttpMessageConverter<?>> converterType,
                                        ServerHttpRequest request, ServerHttpResponse response) {
        //将返回体body包装成MappingJacksonValue
        MappingJacksonValue container = getOrCreateContainer(body);
        //处理返回体body，设置状态码
        beforeBodyWriteInternal(container, response);
        return container;
    }

    /**
     * 将返回体body包装成MappingJacksonValue
     */
    private MappingJacksonValue getOrCreateContainer(Object body) {
        //JSONP：JS跨域请求数据的一中解决方案
        return (body instanceof MappingJacksonValue ? (MappingJacksonValue) body : new MappingJacksonValue(body));
    }

    /**
     * 处理返回体body，设置状态码
     */
    private void beforeBodyWriteInternal(MappingJacksonValue bodyContainer,
                                         ServerHttpResponse response) {
        //返回体body
        Object returnBody = bodyContainer.getValue();

        //如果返回体body是BaseResponse及其子类，设置状态码并返回
        if (returnBody instanceof BaseResponse) {
            BaseResponse<?> baseResponse = (BaseResponse) returnBody;
            //HttpStatus.resolve(baseResponse.getStatus()：将给定的状态码解析为HttpStatus
            //response.setStatusCode：设置 response 状态码
            response.setStatusCode(HttpStatus.resolve(baseResponse.getStatus()));
            return;
        }

        //如果返回体body不是BaseResponse及其子类，将返回体包装成BaseResponse，设置状态码并返回
        BaseResponse<?> baseResponse = BaseResponse.ok(returnBody);
        bodyContainer.setValue(baseResponse);
        response.setStatusCode(HttpStatus.valueOf(baseResponse.getStatus()));
    }
}

自定义序列化器

/**
 * 分页对象的序列化
 */
public class PageJacksonSerializer extends JsonSerializer<Page> {

    @Override
    public void serialize(Page page, JsonGenerator generator, SerializerProvider serializers) throws IOException {
        //写开始标记：'{'
        generator.writeStartObject();

        //写内容：属性是"content"，值是page.getContent()
        generator.writeObjectField("content", page.getContent());
        generator.writeNumberField("pages", page.getTotalPages());  //总页数
        generator.writeNumberField("total", page.getTotalElements());   //总元素数
        generator.writeNumberField("page", page.getNumber());   //第几页
        generator.writeNumberField("rpp", page.getSize());  //当前页元素数
        generator.writeBooleanField("hasNext", page.hasNext()); //是否后面还有页
        generator.writeBooleanField("hasPrevious", page.hasPrevious()); //是否前面还有页
        generator.writeBooleanField("isFirst", page.isFirst()); //是否是第一页
        generator.writeBooleanField("isLast", page.isLast());   //是否是最后一页
        generator.writeBooleanField("isEmpty", page.isEmpty()); //当前页内容是否为空
        generator.writeBooleanField("hasContent", page.hasContent());   //当前页是否有内容

        //处理评论页
        if (page instanceof CommentPage) {
            CommentPage commentPage = (CommentPage) page;
            generator.writeNumberField("commentCount", commentPage.getCommentCount());  //总评论数（包含子评论）
        }

        //写结束标记：'}'
        generator.writeEndObject();
    }
}


使用1

	@JsonSerialize(using = Date2LongSerialize.class)
	private Date time;

使用2

	/**
     * Http请求和响应报文本质上都是一串字符串（有格式文本）。
     * 
     * Spring Boot底层通过HttpMessageConverter（消息转换器）将请求报文与响应报文转换为对象。
     *
     * MappingJackson2HttpMessageConverter处理application/json。
     */
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.stream()
                .filter(c -> c instanceof MappingJackson2HttpMessageConverter)
                .findFirst().ifPresent(converter -> {
            MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = (MappingJackson2HttpMessageConverter) converter;
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json();
            // JsonComponentModule 来扫描被 @JsonComponent 注解的类
            // 并自动注册 JsonSerializer 和 JsonDeserializer。
            JsonComponentModule module = new JsonComponentModule();
            //指定PageImpl类型字段使用自定义的PageJacksonSerializer序列化器
            module.addSerializer(PageImpl.class, new PageJacksonSerializer());
            ObjectMapper objectMapper = builder.modules(module).build();
            mappingJackson2HttpMessageConverter.setObjectMapper(objectMapper);
        });
    }

Controller层日志AOP切面类

@Aspect
@Component
@Slf4j
public class ControllerLogAop {

	//所有Controller方法
    @Pointcut("execution(* *..controller..*.*(..))")
    public void controller() {
    }

    @Around("controller()")
    public Object controller(ProceedingJoinPoint joinPoint) throws Throwable {
        //类名
        String className = joinPoint.getTarget().getClass().getSimpleName();
        //方法名
        String methodName = joinPoint.getSignature().getName();
        //参数数组
        Object[] args = joinPoint.getArgs();

        //获取HttpServletRequest对象
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = Objects.requireNonNull(requestAttributes).getRequest();

        //打印请求日志
        printRequestLog(request, className, methodName, args);
        long start = System.currentTimeMillis();
        //处理目标方法
        Object returnObj = joinPoint.proceed();
        //打印响应日志
        printResponseLog(className, methodName, returnObj, System.currentTimeMillis() - start);
        return returnObj;
    }


    private void printRequestLog(HttpServletRequest request, String clazzName, String methodName, Object[] args) throws JsonProcessingException {
        log.info("打印请求信息-----Request URL：[{}], URI：[{}], Request Method：[{}], IP：[{}]",
                request.getRequestURL(),
                request.getRequestURI(),
                request.getMethod(),
                ServletUtil.getClientIP(request));

        //将参数转为Json字符串
        String requestBody = JsonUtils.objectToJson(args);
        log.info("打印请求参数信息-----{}.{}的请求体：[{}]", clazzName, methodName, requestBody);
    }

    private void printResponseLog(String className, String methodName, Object returnObj, long usage) throws JsonProcessingException {
        String returningData = null;
        if (returnObj != null) {
            if (returnObj.getClass().isAssignableFrom(byte[].class)) {
                returningData = "byte[]二进制数据";
            } else {
                returningData = JsonUtils.objectToJson(returnObj);
            }
        }
        log.info("打印响应信息-----{}.{}的响应体：[{}], 处理时长：[{}]ms", className, methodName, returningData, usage);
    }
}