Por que:
Por que usar AOP para obter verificação?
responder:
O Spring MVC possui seu próprio mecanismo de verificação @Valid + BindingResult, mas essa implementação padrão deve receber o BindingResult no método do controlador para executar a verificação.
por exemplo:
if (result.haserrors ()) {list <BJecterror> allerrors = resultado.getAllErrors (); List <string> errorLists = new ArrayList <> (); for (objecterror objecterror: allerrors) {errorLists.add (objecterror.getDefaultMessage ()); }}Obtenha listas de erros. Se isso for implementado, cada método que requer verificação deve ser chamado repetidamente, mesmo que encapsulado.
Talvez a declaração acima não possa indicar a implementação do @Valid + BindingResult da Spring. Deixe -me dar uma "castanha".
1. Chestnut (versão antiga)
1.1 camada de interface (idal)
Por exemplo: Solicitação de postagem simples, @Requestbody recebe dados de solicitação, @Valid + BindingResult executa a verificação
@ResponseBody @PostMapping ("Body") Public ResponseVo BodyPost (@RequestBody @Valid testVO Body, BindingResult resultado) {// Verifique o erro se (resultado.haserrors ()) {list <Objecterror> allerrors = resultado.getallerrorrors (); List <String> lists = new ArrayList <> (); para (objecterror objecterror: allerrors) {lists.add (objecterror.getDefaultMessage ()); } retornar new ResponseVo (httpstatus.bad_request.value (), "parâmetro vazio", listas); } Retorne a nova resposta (httpstatus.ok.value (), "bodypost", nulo);}1.2 Conteúdo de verificação da entidade (VO)
@Valid + BindingResult possui muitas anotações de verificação e você pode encontrá -lo assim que tocar on -line!
classe pública Testvo {@getter @setter @min (value = 0, message = "Parâmetro de solicitação Isstring não pode ser menor que 0") INTERGE ISINT; @Getter @setter @NotBlank (message = "Parâmetro de solicitação Isstring não pode estar vazio") Private String Isstring;}1.3 Teste de resultados
2. Verificação AOP (versão atualizada)
Pode -se observar que, se vários corpos precisarem ser verificados como o BodyPost, um pedaço de código deve ser reproduzido continuamente. Mesmo que seja alterado para um método reutilizável da classe pai, ele deve ser chamado. Então, ainda sinto que não é elegante depois de pensar nisso. Portanto, há AOP para a verificação da seção.
2.1 Camada de interface (idal)
Sim! Você leu certo, o código acima se foi e não há necessidade de chamar o método compartilhado da classe pai. Apenas uma anotação é feita: @paramvalid
@Paramvalid@ResponseBody@PostMapping ("Body") Public ResponseVo BodyPost (@RequestBody @Valid testvo Body, BindingResult resultado) {retorna new ResponseVo ("BodyPost", NULL);}2.2 Anotação personalizada
Esta anotação também é uma anotação simples do método.
@Target (elementType.method) @retention (retentionpolicy.runtime) public @interface paramvalid {}2.3 Pontos -chave! Implementação de aspectos
Explicação detalhada da seção:
@Before: use o método de anotação @annotation (xx), esse método será chamado sempre que você usar a anotação desejada (@paramValid).
JONCEPOINT: Obtenha os parâmetros do método através do JONPOint para obter o conteúdo verificado pelo BindingResult
Migrar Pacote de Verificação: Migrar a verificação original para o aspecto: ValidRequestParams
Resultados da verificação de resposta:
@Aspecto@componentpublic classe paramvalidaspect {private static final logger log = loggerfactory.getLogger (paramvalidaspect.class); @Before ("@anotação (paramvalid)") public void paramValid (ponto de junção, paramvalid paramvalid) {object [] paramobj = Point.getargs (); if (paramobj.length> 0) {if (paramobj [1] instanceof bindingResult) {bindingResult resultado = (bindingResult) paramobj [1]; ResponseVo errorMap = this.validRequestParams (resultado); if (errorMap! = null) {servletRequestattributes res = (servletRequestattributes) requestContextholder.getRequestAttributes (); HttpServletResponse resposta = res.getResponse (); Response.Setcharacterencoding ("UTF-8"); Response.SetContentType (MediaType.Application_Json_Utf8_Value); Response.SetStatus (httpstatus.bad_request.value ()); OutputStream Output = NULL; tente {output = Response.getOutputStream (); errorMap.setCode (nulo); Error de string = new GSON (). Tojson (errorMap); log.info ("Parâmetro AOP irregular detectado" + erro); output.Write (Error.getBytes ("UTF-8")); } catch (ioexception e) {log.error (e.getMessage ()); } finalmente {try {if (output! = null) {output.close (); }} catch (ioexception e) {log.error (e.getMessage ()); }}}}}}}} / *** Verificação* / Resposta privada ValidRequestParams (resultado de BindingResult) {if (result.haserrors ()) {list <BJecterror> allerrors = resultado.getAlLERRORS (); List <String> lists = new ArrayList <> (); para (objecterror objecterror: allerrors) {lists.add (objecterror.getDefaultMessage ()); } retornar new ResponseVo (httpstatus.bad_request.value (), "parâmetro vazio", listas); } retornar nulo; }}2.4 Resultados dos testes
Depois de ler os dois resultados acima, você pode comparar as vantagens do uso da Spring AOP com @Valid + BindingResult para verificação:
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.