Exemplos de redirecionamentos e interceptores de encaminhamento em Springmvc

Este artigo apresenta exemplos de redirecionamento e interceptador de encaminhamento no SpringMVC. É compartilhado com você, como segue:

Parâmetros variáveis Ao projetar métodos, use数据类型... para declarar os tipos de parâmetros, por exemplo: public static void function(int... numbers)

Ao implementar o corpo do método, os parâmetros variáveis são processados como uma matriz

 public class Test {public static void main (string [] args) {System.out.println (test.sum (1,2,3)); System.out.println (test.sum (1,2,3,4,54)); } public static int sum (int ... números) {int sum = 0; for (int i = 0; i <números.length; i ++) {sum+= números [i]; } retornar soma; }}

Nota: Em cada método, apenas 1 parâmetro variável é permitido no máximo e, se houver um parâmetro variável, ele deve ser o último parâmetro.

Encaminhamento e redirecionamento

No método de manuseio de solicitações dentro do controlador, o método padrão de retornar uma string está encaminhando. O valor encaminhado é o nome do componente de visualização, como o retorno "Login", que obterá essencialmente a página que é finalmente exibida com base no View Resolver (ViewResolver). A sintaxe do redirecionamento de retorno: o caminho representa o redirecionamento. O conteúdo do lado direito do redirecionamento: é o caminho. Esse caminho geralmente usa um caminho relativo e é referenciado com base no caminho na barra de endereço do cliente atual como padrão. Por exemplo, o endereço atual é: http: // localhost: 8080/projeto/usuário/reg.do e depois retorne "redirecionar: login.do" e depois redirecionar para http: // lochost: 8080/projeto/user/login.do, se você retornar "Redirecion: /min/eth.do" ou Return "ou retornar http: // localhost: 8080/project/main/index.do

avançar:

O método padrão, mas você também pode usar o retorno "para a frente: login"
A visualização devolvida deve ser uma visão, que será encaminhada para a visão especificada após passar pelo analisador de visualização.

Redirecionar:

Redirecionar: Retorne "Redirecionar: Login.do"
Retorna um caminho para o método do controlador, não uma visualização. Isso não passará pelo analisador de visualização, mas pulará diretamente.

Exemplo

 @RequestMapping (value = "/handle_reg.do", método = requestMethod.post) public string handlereg (usuário do usuário, mapa de modelMap) {try {userservice.reg (usuário); System.out.println ("Registrado com sucesso!"); retornar "Redirecionar: login.do"; // redireciona para o método de controle de login.do, login.do corresponde a encaminhamento para login.jsp} catch (usernameConflictException e) {System.out.println (e.getMessage ()); map.put ("errorMessage", e.getMessage ()); retornar "erro"; }} @RequestMapping (value = "login.do") public string handleLogin () {return "login"; }

Interceptor

Conceitos básicos

1. O Interceptor (Interceptor) é um componente no SpringMVC. É executado após o DispatcheserServlet e antes do controlador.
2. Os interceptores podem decidir interceptar ou liberar certas condições qualificadas, portanto, geralmente são usadas para restringir algumas funções com as mesmas condições operacionais.

Usando interceptador

Classe interceptadora personalizada

Crie uma classe de interceptação (Demointerceptor) para implementar a interface HandlerInterceptor

 classe pública Demointerceptimplements HandlerInterception { /*** chamado antes do processador executar* @param solicitar objeto httpServLeTrequest, que pode obter parâmetros de solicitação, etc.* @param Responder HttpServletResponse objeto* @param o controlador interceptor BEIRSTENT* @ @Retorno for revolt, Se o true for retornado, os interceptores e processadores subsequentes serão executados */ Public Boolean Prehandle (solicitação HTTPSERVletRequest, resposta httpSertletResponse, manipulador de objeto) lança exceção {System.out.println ("Execução de pré -manipulador de Demontercetor"); retornar true; } / *** Chamado após a execução do processador e ligue antes de pular para a visualização especificada* @param solicitar httpServletRequest Objeto* @param Resposta HttpServletResponse objeto* @param Resposta @PARAndRevView objeto STORESSPONSE, que é o objeto do controlador do controlador* @paramAndView ModelAndView Postandle (solicitação httpServletRequest, resposta httpServletResponse, manipulador de objetos, modelAndView ModelAndView) lança a exceção { /*** 1. Você pode projetar sua própria lógica, por exemplo, em alguns casos, retornar false, retornará verdadeiro* 2. System.out.println ("Handler:"+Handler); System.out.println ("Execução de Posthandler de Demointerceptor"); // Defina o nome da visualização e, após a conclusão da execução, ele saltará para a página index.jsp // modelandview.setViewName ("index"); } /** * ligue * Após a conclusão do processamento da solicitação, o After comcompleção de vazio público (solicitação de HttPervletRequest, resposta httpServletResponse, manipulador de objetos, exceção ex) lança exceção {System.out.println ("Demointerceptor de exceção de complemização do desconforto"); }}

Configurar no arquivo de configuração Springmvc

1. Configurar o caminho interceptado: <mvc: mapeando path = "" /> você pode usar caracteres curinga* por exemplo: /** corresponde a todos os caminhos, /user /* pode corresponder apenas aos subpaths de /usuário
2. Configurar caminhos que não são interceptados: <mvc: exclua-mapping path = ""/> múltiplo
3. Configure a classe interceptadora (Bean): <Bean>

Configuração

Deve ser configurado na ordem acima, caso contrário, um erro será relatado

 <!-Configure o interceptador, onde vários interceptores podem ser configurados-> <MVC: Interceptores> <MVC: Interceptor> <!-Configure o caminho do interceptador e intercepte todos os mapeamentos do método do processador-por exemplo, http: // lochost: 8080/springmv/user/login.do.do.do.do, http: // lochost: 8080/springmv/user/login.do.do.do.do, http: // lochost: 8080/springmv/user/login.do.do.do.do. <mvc: mappingpath = "/user/*"/> <!-Configure o método do controlador que não é interceptado pelo interceptador, esta é uma configuração opcional, como http: // lochost: 8080/springmvc/user/index.do, isso não será interceptado-> <lvc: exclui-se-mvc/user/index. <mvc: exclude-mapppath = "/user/login.do"/> <!-Configure o feijão do interceptador, especificando o nome completo da classe-> <beansclass = "cn.tedu.spring.intercept.demonterceptor"> </bean> </mvc: interceptor> </mvc:

O método de implementação

Prendle booleana pública (solicitação httpServletRequest, resposta httpServletResponse, manipulador de objetos)

1. Este método é executado antes do controlador lidar com a solicitação
2. Se False for retornado, o fluxo de processamento será interrompido e os interceptores e processadores subsequentes não serão executados. O retorno do True executará interceptores e processadores subsequentes.
3. Você pode projetar sua própria lógica para retornar falsa ou verdadeira

public void PostHandle (solicitação httpServletRequest, resposta httpServletResponse, manipulador de objetos, modelo e modelAndView)

1. Após a execução do processador, o processamento de visualização é chamado antes de ser processado. No momento, os dados e a visualização podem ser processados pelo ModelAndView.
2. Obviamente, o método pré -manipulador precisa retornar verdadeiro antes de ser executado

Public void After compliction (solicitação HTTPSERVLETREQUEST, Resposta HttpServletResponse, manipulador de objetos, Exceção ex)

1. Todas as solicitações são chamadas após serem processadas. Por exemplo, no monitoramento de desempenho, podemos gravar o tempo de término e o tempo de consumo aqui e também podemos executar algum processamento de recursos.
2. Obviamente, o método pré -manipulador precisa retornar verdadeiro antes de ser executado

Verificação de login de demonstração

1. Verificação de login: Quando se trata de modificar as informações do usuário e verificar algo, você deve verificar se deve fazer login, para que você precise projetar um interceptador para verificar o login
2. Defina primeiro os dados de login, ou seja: adicione o botão de login no login.jsp. Após a conclusão do login, você precisa definir uma tag armazenada na sessão, como o ID do usuário ou o objeto do usuário.
3. Usamos o ID do usuário como uma marca para verificar se o login já está dentro. Se o usuário efetuar login com sucesso, um atributo UID será adicionado à sessão
4. Logout do usuário usando session.invalidate (); Limpar sessão e redirecionar para a interface de login

Interceptador personalizado (LoginInterceptor)

O processo específico é escrito muito claramente no método de pré -manipulador

 classe pública LogInInterceptimplements HandlerInterCorpt { / * * chamado antes que o processador seja executado (não-Javadoc) * 1. Obtenha sessão * 2. Leia o valor UID na sessão * Se nulo, significa que não há login e depois redireciona diretamente para a interface de login e retorna false na mesma época. Não há necessidade de executar o processo subsequente*, se não for nulo, significa que ele foi conectado e retornar diretamente true e continuar a executar o interceptador ou processador subsequente*/ public boolean prehandle (httpServletRequest Solicy, httpsLearponsenseport, handler) excepção; // obtenha objeto de sessão uid = session.getAttribute ("uid"); // Leia o objeto na sessão // Se houver uid, você poderá fazer login e concluir se (uid! = Null) {return true; // retorna true, se o login for bem -sucedido, você precisará executar o processo subsequente} Response.sendRedirect (request.getContextPath ()+"/user/login.do"); // redirecionar para a interface de login retornar false; //Return false, the subsequent process does not need to be executed, and it is directly interrupted} public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { } public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { }}

Configurar o Interceptor em Springmvc

Como aqui apenas pula para o centro do usuário e precisa verificar o login, apenas corresponde ao user_center.do

 <!-Configurar interceptores, onde vários interceptores podem ser configurados-> <mvc: interceptores> <mvc: interceptor> <mvc: mappingpath = "/user/user_center.do"/> <BeanClass = "cn.tedu.spring.interc:

Ordem de execução de múltiplos interceptores

Execute de acordo com o pedido configurado no arquivo de configuração Springmvc, ou seja, a ordem dos interceptores configurados em <mvc: interceptores>. Se um interceptador for realizado no mesmo caminho, então o primeiro interceptor de primeira configuração

A diferença entre interceptador e filtro (diferença principal)

1. O Interceptor está no SpringMVC. O interceptador só pode ser usado se o springmvc for usado. O filtro está no sistema Java EE. Os filtros podem ser usados, independentemente da estrutura usada.
2. O interceptador é executado após o DispatcheserServlet, antes do processador, e o filtro é executado antes do DispatcherServlet
3. O filtro será executado antes de todos os servlets (todas as solicitações serão executadas) e o interceptador será executado após o DispatcheServlet no Springmvc, para que o filtro possa filtrar qualquer solicitação no projeto (desde que o caminho correspondente esteja configurado), enquanto o interceptor interceptará apenas as solicitações processadas pelo despachante.

Resumir

Os interceptores podem ser usados quando várias solicitações exigirem as mesmas tarefas ou extremamente semelhantes.

Desenvolva bem um interceptador, então você precisa configurá -lo no arquivo de configuração do springmvc

Em <mvc: interceptores>, se vários <mvc: interceptores> estiverem configurados, vários interceptores formarão uma cadeia interceptores. Se vários interceptores estiverem configurados, eles interceptarão o mesmo caminho e serão executados na ordem dos nós configurados.

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.