tutorial básico do springboot2.x: verificação dos parâmetros da interface jsr303, combinada com interceptação de exceção unificada

JSR é a abreviatura de Java Specification Requests, que significa Java Specification Proposal. É uma solicitação formal para adicionar uma especificação técnica padronizada ao JCP (Java Community Process). Qualquer pessoa pode enviar um JSR para adicionar novas APIs e serviços à plataforma Java. JSR se tornou um padrão importante no mundo Java.
JSR-303 é uma subespecificação em JAVA EE 6, chamada Bean Validation, Hibernate Validator é a implementação de referência da Bean Validator. Hibernate Validator fornece a implementação de todas as restrições embutidas na especificação JSR 303, além de algumas limitação. Se você quiser saber mais sobre o Hibernate Validator, por favor verifique http://www.hibernate.org/subprojects/validator.html
A interface de backend desenvolvida pelo projeto SpringBoot freqüentemente faz verificações básicas se os parâmetros estão vazios e o comprimento dos parâmetros. Aqui, o SpringBoot pode integrar facilmente o JSR303, verificar facilmente os parâmetros da interface por meio de anotações e personalizar as regras de verificação.

Introdução à anotação JSR303

JSR303 vem com restrições

Restrições adicionais do Hibernate Validator

Integração do projeto SpringBoot

Dependência de introdução do projeto

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

Introdução ao Hibernate Validator

O modo de validação do Hibernate Validator tem duas situações

1. Falha rápida (uma verificação falha, a mensagem de erro é retornada rapidamente)
2. Modo normal (por padrão, todos os atributos serão verificados e, em seguida, todas as informações de falha de verificação serão retornadas)
   Geralmente usamos o primeiro, SpringBoot precisa habilitar a configuração

/**
 * 配置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 a anotação @Valid no método para abrir a verificação e use BindingResult para receber o resultado da verificação

@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 com exceção unificada

No projeto, geralmente defino uma classe de exceção unificada que pertence ao negócio. Aqui, depois que a verificação falha, as informações de verificação customizadas são montadas e uma BusinessException customizada é lançada.

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);
    }
	//......
}

Em seguida, ele é interceptado pela exceção unificada e retorna à interface anteriormente definida R. As informações de falha estão contidas no campo msg.
Publicar parte do código de interceptação de exceção unificada

@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();
            }
        }
    }
}

Efeito de teste de interface

Mil milhas começam com um único passo. Aqui está o quarto artigo da série de tutoriais SpringBoot. Todos os códigos-fonte do projeto podem ser baixados em meu GitHub .
Para mais conteúdo, siga a conta oficial do WeChat: