Este artigo estuda principalmente a introdução de interceptores no SpringMVC, código de exemplo, configuração e outros conteúdos, como segue.
O interceptador de processador da SpringMVC é semelhante ao filtro de filtro no desenvolvimento do servlet, usado para pré-processar e pós-processo do processador. Este artigo resume principalmente como o interceptador é definido no SpringMVC, bem como a execução e o uso do interceptador.
No SpringMVC, defina o interceptador para implementar a interface HandlerInterceptor e implementar os três métodos fornecidos na interface, como segue:
// Teste interceptor1public Classe HandlerInterceptor1 implementa HandlerInterceptor {@Override public Boolean Prehandle (solicitação httpServletRequest, httpServletResponse resposta, manipulador de objetos) lança excepção {System.out.println "Handlercetor1 .... prehandle); true significa liberação retornar true;}@substituir public void pós -e -resposta (httpServletRequest Solicy, httpServletResponse Resposta, manipulador de objetos, modelAndView ModelAndView) lança a exceção {System.out.println ("HandlerInterceptor1..Posthle");}@Overoid Void Aftertpletnion manipulador, exceção ex) lança Exceção {System.out.println ("HandlerInterceptor1..AfterCompletion");}}Vou fazer uma análise simples para esses três métodos:
No SpringMVC, o interceptador está configurado para o manutenção específica, ou seja, se um interceptador estiver configurado em um manipulamento de manipulação, o manipulador mapeado com sucesso através do manipulação acabará por usar o interceptor. Por exemplo, suponha que o mapeador que configuramos no arquivo de configuração seja org.springframework.web.servlet.handler.beanNameurlHandlerMapping, então podemos configurar o interceptor da seguinte maneira:
<Bean> <propriedade name = "interceptores"> <lista> <ref bean = "handlerInterceptor1"/> <ref bean = "handlerInterceptor2"/> </list> </propriedade> </bean> <bean id = "handlerintercetor1"/> <bean id = "handlercetor2"/>
Então, no SpringMVC, como configurar um interceptador global? Como mencionado acima, os interceptores no SpringMVC são direcionados a mapeadores específicos. Para resolver esse problema, a estrutura Springmvc injeta interceptors globalmente semelhantes em cada handllermping, para que eles possam se tornar interceptores globais. A configuração é a seguinte:
<!-Configurar interceptores-> <mvc: interceptores> <!-múltiplos interceptores, executados em sequência-> <mvc: interceptor> <mvc: mapeando path = "/**"/> <!-indica: interceptor todos os URLs <sv. Path = "/**"/> <bean/> </mvc: interceptor>
Geralmente, usamos essa configuração, basta especificar o URL a ser interceptado em <mvc: mapeando>.
Escreva dois interceptores, HandlerInterceptor2 e HandlerInterceptor3, de acordo com a configuração acima. Em seguida, testaremos a execução dos três interceptores e faremos um resumo relacionado.
Em outras palavras, alteramos o valor de retorno do método de pré -manuse dos três interceptores para true para testar a ordem de execução do interceptador. Os resultados dos testes são os seguintes:
HandlerInterceptor1… .Prehrendle
HandlerInterceptor2… .Prehrendle
HandlerInterceptor3… .PrehrendleHandlerInterceptor3… .Postandle
HandlerInterceptor2… .Postandle
HandlerInterceptor1… .PostandleHandlerInterceptor3… .AsCercompletion
HandlerInterceptor2… .AFtercompletion
HandlerInterceptor1… .AsCercompletion
Um resumo é feito com base nos resultados impressos: quando todos os interceptores são liberados, o método Prehandle é executado na ordem de configuração; enquanto os outros dois métodos são executados na ordem de configuração.
Alteramos o valor de retorno no método de pré -manuse do terceiro interceptador para false, e os dois primeiros ainda são verdadeiros, para testar a ordem de execução do interceptador. Os resultados dos testes são os seguintes:
HandlerInterceptor1… .Prehrendle
HandlerInterceptor2… .Prehrendle
HandlerInterceptor3… .PrehrendleHandlerInterceptor2… .AFtercompletion
HandlerInterceptor1… .AsCercompletion
Faça um resumo com base nos resultados impressos:
1. Como os interceptores 1 e 2 são liberados, o preceptor 3 pode ser executado. Em outras palavras, o interceptador anterior pode ser lançado e o último interceptador pode executar o pré -manuse.
2. O interceptador 3 não o libera, então seus outros dois métodos não são executados. Ou seja, se um interceptador não o liberar, seus outros dois métodos não serão executados.
3. Enquanto houver um interceptador que não seja liberado, o método pós -endle de todos os interceptores não será executado, mas enquanto a pré -manuse for executada e liberada, o método de Aftercommission será executado.
De fato, você pode se referir à situação acima. É um caso especial. Vamos dar uma olhada nos resultados em execução:
HandlerInterceptor1… .Prehrendle
Obviamente, apenas o método de pré -manuseu do primeiro interceptador foi executado. Como nenhum deles foi liberado, nenhum deles executou o método posterior e o método de pós -conclusão.
A partir do segundo caso, por exemplo, se você deseja escrever uma lógica de processamento de exceção unificada, o interceptor deve ser colocado na primeira posição da cadeia interceptores e deve ser liberado, porque somente o pós -conclusão será executado e, se for executado na primeira posição da unidade da cadeia de exceptor, o método de execução será executado por último, que a lógica da lógica da unidade.
Por exemplo, faça login no interceptador de autenticação e coloque -o na primeira posição no link interceptador (se houver manuseio de exceção unificada, ele deve ser colocado atrás do manuseio de exceção unificada). O interceptor de verificação de permissão é colocado após o login no interceptador de autenticação (porque a permissão é verificada apenas após o login).
Aqui está um interceptor de verificação de login para explicar como usar o interceptador do Springmvc.
Primeiro, vejamos os requisitos: o que queremos interceptar, o que queremos fazer quando interceptarmos. A idéia é a seguinte:
1. URL de solicitação do usuário
2. O interceptador executa a verificação de interceptação. Se o URL solicitado for um endereço público (URL que pode ser acessado sem fazer login), seja lançado.
Se a sessão do usuário não existir, entre na página de login.
Se a sessão do usuário existir, libere -a e continue a operação.
// Faça login em @requestMapping ("/login") public String Login (solicitação httpServletRequest, nome de usuário da string, senha da string) lança exceção {//, na verdade, você precisa corresponder ao banco de dados //..//heresett, assume que o login é bem -sucedido "Sessão de uso". "Redirecionar: queryitems.action";} // Login @RequestMapping ("/Logout") public String Logout (solicitação httpServletRequest) lança exceção {httpsession session = request.getSession (); session.invalidate (); return "redirect: queryitems.action";};}; // Test Interceptor 1Public Class LoginInterceptor implementa o HandlerInterceptor {// Execute antes de inserir o método Handler // pode ser usado para autenticação de identidade e autorização de identidade. Se a autenticação não passar, significa que o usuário não está conectado. Esse método precisa interceptá -lo e nenhuma execução adicional. Caso contrário, @Override public boolean Prehandle (solicitação httpServletRequest, resposta httpSertletResponse, manipulador de objetos) lança exceção {// obtém o urlstring de URL solicitado = solicitação. Endereço enviado if (url.indexof ("login.action")> 0) {// Se o envio de login for realizado, libere retorno true;} // juiz sessionhttpsession session = request.getSession (); // busca as informações de identidade do usuário; sessão «userr); Para indicar que a identidade do usuário precisa ser verificada, pule para a página de login request.getRequestDispatcher ("/web-inf/jsp/login.jsp"). Forward (solicitação, resposta); retornar false;} // salvar espaço, omitir os outros dois métodos e não os escrever, e não há necessidade de lidar com eles}Em seguida, configure o interceptador:
<!-Configurar interceptores-> <mvc: interceptores> <!-múltiplos interceptores, executar em sequência-> <mvc: interceptor> <mvc: mapeamento path = "/**"/> <!-interceptroceRect> <!
Dessa forma, quando solicitarmos qualquer URL, seremos capturados pelo interceptador que acabamos de definir e determinaremos se há informações do usuário na sessão. Caso contrário, iremos para a página de login e vamos fazer login:
<Form Action = "$ {PageContext.Request.ContextPath} /Login.Action" Method = "Post"> Nome de usuário: <input type = "text" name = "userrname" /> <br> Senha: <input type = "senha" name = "senha" /> <br> <brut <but type = "sigin" "= name" = "name" name " /" senha " /> <br> <bring <but Type =" submarp "="Esta é basicamente a introdução ao uso de interceptores.
O exposto acima é todo o conteúdo deste artigo sobre a explicação detalhada do interceptador no SpringMVC e dos exemplos de código. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!