Springboot2.x tutorial básico: verificación de parámetros de interfaz jsr303, combinada con intercepción de excepciones unificadas

JSR es la abreviatura de Java Specification Requests, que significa Java Specification Proposal. Es una solicitud formal para agregar una especificación técnica estandarizada a JCP (Java Community Process). Cualquiera puede enviar un JSR para agregar nuevas API y servicios a la plataforma Java. JSR se ha convertido en un estándar importante en el mundo de Java.
JSR-303 es una subespecificación en JAVA EE 6, llamada Bean Validation, Hibernate Validator es la implementación de referencia de Bean Validator. Hibernate Validator proporciona la implementación de todas las restricciones integradas en la especificación JSR 303, además de algunas adicionales restricción. Si desea saber más sobre Hibernate Validator, consulte http://www.hibernate.org/subprojects/validator.html
La interfaz de backend desarrollada por el proyecto SpringBoot a menudo realiza comprobaciones básicas sobre si los parámetros están vacíos y la longitud de los parámetros. Aquí, SpringBoot puede integrar fácilmente JSR303, verificar fácilmente los parámetros de la interfaz a través de anotaciones y puede personalizar las reglas de verificación.

Introducción a la anotación JSR303

JSR303 viene con restricciones

Restricciones adicionales de Hibernate Validator

Integración del proyecto SpringBoot

Dependencia de introducción del proyecto

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

Introducción a Hibernate Validator

El modo de validación de Hibernate Validator tiene dos situaciones

1. Fallo rápido (una verificación falla, el mensaje de error se devuelve rápidamente)
2. Modo normal (de forma predeterminada, se verificarán todos los atributos y luego se devolverá toda la información de falla de verificación)
   Generalmente usamos el primero, SpringBoot necesita habilitar la configuración

/**
 * 配置Jsr303 hibernate validator快速失败模式
 */
@Configuration
public class Jsr303Config {
    @Bean
    public Validator validator(){
        ValidatorFactory validatorFactory = Validation
                .byProvider( HibernateValidator.class )
                .configure()
                .failFast( true )
                .buildValidatorFactory();
        return validatorFactory.getValidator();
    }
}

Uso básico

Use la anotación @Valid en el método para abrir la verificación y use BindingResult para recibir el resultado de la verificación

@Data
public class LoginDTO {
    @Size(min = 8,message = "账号长度大于8")
    String account;
    @NotBlank(message = "密码不能为空")
    String passwd;
}
    @PostMapping("/logon")
    public R logon(@Valid LoginDTO loginDTO, BindingResult result){
        check(result);
        return R.ok("");
    }
    public static void check(BindingResult result){
        StringBuffer sb=new StringBuffer();
        if(result.hasErrors()){
            for (ObjectError error : result.getAllErrors()) {
                sb.append(error.getDefaultMessage());
            }
            ExUtil.throwBusException(sb.toString());
        }
    }

Jsr303 usado con excepción unificada

En el proyecto, normalmente defino una clase de excepción unificada que pertenece a la empresa. Aquí, después de que falla la verificación, se reúne la información de verificación personalizada y se lanza una BusinessException personalizada.

public class BusinessException extends RuntimeException {

    private static final long serialVersionUID = 1L;
    private int code = ApiCommonCodeEnum.FAIL.getCode();
    public BusinessException(String message) {
        super(message);
    }
	//防止篇幅过长省略其他代码
}
//异常工具类
public class ExUtil {
    public static void throwBusException(String msg){
        throw new BusinessException(msg);
    }
	//......
}

Luego, es interceptado por la excepción unificada y regresa a la interfaz previamente definida R. La información de falla está contenida en el campo msg.
Publicar parte del código de interceptación de excepciones unificado

@Component
@Slf4j
public class ExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
        if(ex instanceof BusinessException){
            R result= R.fill(((BusinessException) ex).getCode(),null,ex.getMessage());
            outputJSON(httpServletResponse, Charsets.UTF_8.toString(), JsonUtil.toJson(result));
            return null;
        }else {
            R result=R.failed(ex.getMessage());
            outputJSON(httpServletResponse, Charsets.UTF_8.toString(), JsonUtil.toJson(result));
            return null;
        }
    }
    private void outputJSON(HttpServletResponse response, String charset, String jsonStr) {
        PrintWriter out = null;
        try {
            if (response != null) {
                response.setCharacterEncoding(charset);
                response.setContentType("text/html;charset=" + charset);
                response.setHeader("Pragma", "No-cache");
                response.setHeader("Cache-Control", "no-cache");
                response.setDateHeader("Expires", 0);
                out = response.getWriter();
                out.print(jsonStr);
            }
        } catch (Exception e) {
            log.error(ExUtil.getSimpleMessage(e));
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }
}

Efecto de prueba de interfaz

Mil millas comienzan con un solo paso. Aquí está el cuarto artículo de la serie de tutoriales SpringBoot. Todos los códigos fuente del proyecto se pueden descargar en mi GitHub .
Para obtener más contenido, siga la cuenta oficial de WeChat: