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);

    }

}

巴特西

Halo（七）

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

@Valid @Validated 参数校验

Controller 异常捕获

参数校验工具类

堆栈跟踪信息

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

自定义序列化器

Controller层日志AOP切面类

最新文章

热门文章