O interceptador interceptador no SpringMVC também é muito importante e útil. Sua principal função é interceptar solicitações de usuário e executar o processamento correspondente. Por exemplo, ele pode executar a verificação de permissão ou determinar se o usuário está conectado ou determinar se o horário atual é o tempo de compra do ingresso como 12306.
1. Defina a classe de implementação do interceptador
As solicitações de intercepto de interceptor no SpringMVC são implementadas através do HandlerInterceptor. Definir um interceptador no SpringMVC é muito simples. Existem duas maneiras principais. A primeira maneira é definir a classe interceptadora que implementa a interface do manipulador de mola, ou essa classe herda a classe que implementa a interface HandlerInterceptores, como a classe abstrata que a primavera forneceu que implementa a interface HandlerInterceptor, que já é fornecida pela primavera; A segunda maneira é implementar a interface Spring WebRequestInterceptor ou herdar a classe que implementa a interface WebRequestIntercept.
(I) Implementar a interface HandlerInterceptor
Existem três métodos definidos na interface HandlerInterceptor e usamos esses três métodos para interceptar solicitações de usuário.
(1) Prendle (solicitação HttpServletRequest, método HttpServLetResponse, identificador de objeto), como o nome indica, será chamado antes que a solicitação seja processada. O interceptador no SpringMVC é chamado em forma de corrente. Vários interceptores podem existir ao mesmo tempo em um aplicativo ou em uma solicitação. Cada chamada interceptadora será executada em sequência de acordo com sua ordem de declaração, e as primeiras são executadas são o método de pré-manuse no interceptor; portanto, algumas operações de pré-iniciação podem ser realizadas nesse método ou um pré-processamento da solicitação atual, ou alguns julgamentos podem ser feitos neste método para decidir se o pedido deve continuar.
O valor de retorno desse método é do tipo booleano booleano. Quando retornar ao FALSE, significa que a solicitação termina e o interceptador e o controlador subsequentes não serão executados novamente; Quando o valor de retorno for verdadeiro, o método de pré -manuse do próximo interceptador continuará sendo chamado. Se já for o último interceptador, o método do controlador da solicitação atual será chamado.
(2) Postandle (solicitação httpServletRequest, resposta httpServletResponse, identificador de objeto, ModelAndView ModelAndView). A partir da explicação do método de pré -manuse, sabemos que esse método, incluindo o método de pós -conclusão a ser mencionado posteriormente, só pode ser chamado quando o valor de retorno do método de pré -manuse do interceptador atual é verdadeiro.
O método pós -endle, como o nome sugere, é executado após o processamento da solicitação atual, isto é, depois que o método do controlador for chamado, mas será chamado antes que o DispatcheserServlet retorne e torne a visualização, para que possamos operar no objeto ModelAndView após o processo do controlador neste método. A direção da chamada do método pós -endle é o oposto de pré -manuse, o que significa que o método posterior do interceptador declarado primeiro será executado posteriormente, o que é um pouco semelhante ao processo de execução do interceptador no Struts2. O processo de execução do interceptador no STRUTS2 também é encadeado, mas no Struts2, o método de invasão de ação deve ser chamado manualmente para acionar a chamada para o próximo interceptador ou ação. Em seguida, o conteúdo de cada interceptador antes do método Invoke é executado na ordem declarada e o conteúdo após o método de invocar é revertido.
(3) Aftercompleção (solicitação HTTPSERVLETREQUEST, Método HttpServletResponse, identificador de objeto, exceção ex), esse método precisa ser executado quando o valor de retorno do método de pré -manipulação do interceptador correspondente atual é verdadeiro. Como o nome sugere, esse método será executado após a conclusão de toda a solicitação, ou seja, depois que o DispatcheServlet renderiza a visualização correspondente. A principal função desse método é limpar os recursos.
Aqui está uma descrição simples de código:
importar javax.servlet.http.httpServletRequest; importar javax.servlet.http.httpServletResponse; importar org.springframework.web.servlet.HandlerIntercept; importar org.springframework.web.servlet.modelandView; classe pública springmvcintercept implementa HandlerInterceptor { /*** O método Prehandle é usado para a interceptação do processador. Como o nome sugere, esse método será chamado antes do processo do controlador. O interceptador interceptador no SpringMVC é encadeado e vários interceptores podem existir ao mesmo tempo. Em seguida, o SpringMVC executará um por um de acordo com a ordem da declaração, e todos os métodos de pré -manuseio no interceptador serão chamados antes que o método do controlador seja chamado. A estrutura da cadeia interceptores da SpringMVC também pode ser interrompida. Esse método de interrupção faz com que o valor de retorno da pré -manuse seja falso. Quando o valor de retorno do Prehandle é falso, toda a solicitação termina. */ @Override public boolean prehandle (solicitação httpServletRequest, resposta httpSertletResponse, manipulador de objetos) lança exceção {// tlo-gen-generated método stub retornar false; } /*** Este método será executado somente quando o valor de retorno atual do método de pré -manuse do interceptador for verdadeiro. Postandle é usado para interceptação do processador. Seu tempo de execução é após o processador ser processado*, ou seja, depois que o método do controlador for chamado, mas será executado antes que o DispatcheserServlet renderize a visualização, o que significa que, nesse método, você pode operar o ModelAndView*. A estrutura da cadeia desse método é o oposto da direção de acesso normal, ou seja, o método declarado primeiro será chamado posteriormente. Isso é um pouco semelhante ao processo de execução do interceptador no STRUTS2. * Somente no método de interceptação no STRUTS2, o método de invasão de ActionInvocation deve ser chamado manualmente. O método Invoke de ActionInvocation em Struts2 é chamar o próximo interceptador * ou chamar a ação e, em seguida, o conteúdo que precisa ser chamado antes que o interceptador seja escrito antes da chamada para invocar e o conteúdo que precisa ser chamado após o escrito do interceptor após a chamada para o método de invoque. * / @Override public void PostHandle (solicitação httpServletRequest, resposta HTTPERTletResponse, manipulador de objetos, modelAndView ModelAndView) lança a exceção {// TODO Método Auto-Gerado Stubb} / ** *** Esse método também precisa ser executado quando o valor de retorno do precetor correspondente correspondente. Este método será executado após a conclusão de toda a solicitação, ou seja, o DispatcheserServlet renderiza a execução da exibição. * A principal função desse método é limpar os recursos. Obviamente, esse método só pode ser executado quando o valor atual de retorno do método de pré -manuse do interceptador for verdadeiro. */ @Override public void Aftercompletion (solicitação httpServletRequest, resposta httpSertletResponse, manipulador de objetos, exceção ex) lança exceção {// TODO GEERATEADO Método Stub}} (Ii) Implementar a interface WebRequestInterceptor
Existem também três métodos definidos no WebRequestInterceptor, e também usamos esses três métodos para implementar a interceptação. Todos os três métodos passam o mesmo parâmetro WebRequest, então o que é essa WebRequest? Este WebRequest é uma interface definida pela primavera. As definições de método nele são basicamente as mesmas que HttpServletRequest. Todas as operações executadas no WebRequestInterceptor no WebRequestInterceptor serão sincronizadas com HttpServletRequest e depois passadas na solicitação atual.
(1) Método Prehandle (solicitação WebRequest). Esse método será chamado antes que a solicitação seja processada, ou seja, será chamada antes que o método do controlador seja chamado. Este método é diferente do pré -manutenção do HandlerInterceptor. A principal diferença é que o valor de retorno do método é nulo, o que significa que não há valor de retorno. Portanto, geralmente o usamos para preparar recursos. Por exemplo, quando usamos o Hibernate, podemos preparar um objeto de sessão Hibernate neste método e, em seguida, usar o setattribute (nome, valor, escopo) do WebRequest para colocá -lo na propriedade WebRequest. Aqui podemos falar sobre o terceiro escopo do parâmetro do método SetAttribute, que é do tipo inteiro. Três constantes são definidas para a interface da camada pai do WebRequest, requestattributes:
Scope_Request: seu valor é 0, o que significa que é acessível apenas na solicitação.
Scope_session: seu valor é 1. Se o ambiente permitir, representa uma sessão isolada local, caso contrário, representa uma sessão normal e pode ser acessada dentro do escopo da sessão.
Scope_global_session: seu valor é 2. Se o ambiente permitir, representa uma sessão compartilhada globalmente, caso contrário, representa uma sessão normal e pode ser acessada dentro do escopo da sessão.
(2) Método Postanha (Solicitação WebRequest, ModelMap Model). Esse método será chamado após o processamento da solicitação, isto é, após o método do controlador for chamado, mas será chamado antes que as devoluções da visualização sejam renderizadas, para que você possa alterar a exibição dos dados alterando o modelo de modelo de dados nesse método. Este método possui dois parâmetros. O objeto WebRequest é usado para passar por todos os dados da solicitação. Por exemplo, os dados preparados em presandle podem ser passados e acessados através do WebRequest; ModelMap é o objeto modelo retornado após o processo do controlador. Podemos alterar o modelo retornado alterando suas propriedades.
(3) Método de Aftercommission (Solicitação WebRequest, Exceção Ex). Esse método será executado após a processamento de toda a solicitação, ou seja, após a devolução e renderizada. Portanto, neste método, a operação de liberação de recursos pode ser executada. O parâmetro WebRequest pode passar os recursos que preparamos em Prehandle aqui para lançamento. O parâmetro de exceção representa o objeto de exceção atualmente solicitado. Se a exceção lançada no controlador foi processada pelo processador de exceção da mola, o objeto de exceção será nulo.
Aqui está uma descrição simples de código:
importar org.springframework.ui.modelmap; importar org.springframework.web.context.request.webrequest; importar org.springframework.web.context.request.webrequestinterceptor; classe pública AllInterCeptMorptor implementos webRequestIntercept { /*** Executar antes que a solicitação seja processada. Este método é usado principalmente para preparar dados de recursos e, em seguida, eles podem ser colocados no WebRequest, pois os atributos de solicitação*/ @Override public void prehandle (solicitação WebRequest) lança a exceção {// TODO Auto-Generated Method Stub System.out.println ("AllInterceptor .................."); request.setAttribute ("request", "request", webrequest.scope_request); // Isso é colocado dentro do escopo da solicitação, para que você possa apenas obter request.setAttribute ("sessão", "sessão", na solicitação na solicitação atual. Se o ambiente permitir, ele só poderá ser acessado em uma sessão isolada localmente. Caso contrário, ele pode ser acessado na sessão atual normal. Request.setAttribute ("GlobalSession", "GlobalSession", WebRequest.Scope_Global_Session); // Se o ambiente permitir, poderá ser acessado em uma sessão compartilhada globalmente, caso contrário, poderá ser acessado na sessão atual}/*** O ModelMap representa o objeto de modelo retornado depois que o controlador é solicitado para processar o controlador; portanto, as propriedades do mapa do modelo podem ser modificadas nesse método para alcançar o efeito de alterar o modelo retornado. */ @Override public void PostHandle (solicitação WebRequest, ModelMap map) lança exceção {// TODO GEERATEADO AUTOGERATED MECHUB STUB PARA (Chave da String: Map.KeySet ()) System.out.println (chave + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Após a conclusão (solicitação do WebRequest, exceção de exceção) lança a exceção {// TODO Method Auto-Generated Stub System.out.println (Exception + "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= "); }}2. Adicione a classe interceptadora definida ao sistema de interceptação de Springmvc
1. Adicione um esquema que suporta MVC no arquivo de configuração Springmvc
xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: schemalocation = "http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd "
Aqui está um exemplo da minha declaração:
<Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-nstance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd ">
Dessa forma, você pode usar a tag MVC no arquivo de configuração Springmvc. Há um MVC: Interceptores na tag MVC usada para declarar o interceptador do SpringMVC.
(Ii) Use a tag MVC: Interceptores para declarar o interceptador que precisa ser adicionado à cadeia interceptadora Springmvc
<MVC: Interceptores> <!- Use Bean para definir um interceptador. O interceptador definido diretamente sob a raiz do MVC: os interceptores interceptará todas as solicitações-> <bean/> <mvc: interceptor> <mvc: mapeando path = "/test/number.do"/> <!-intercept definido em MVC: interceptor é para interceptar uma solicitação específica-> <Bean/> </MVC:
A partir do exemplo acima, podemos ver que uma série de interceptores pode ser declarada usando a tag MVC: Interceptores e, em seguida, eles podem formar uma cadeia interceptores. A ordem de execução do interceptador é executada na ordem das declarações. O método de pré -manuse no interceptador declarado será executado primeiro, mas seu método pós -endle e o método de aptravação serão executados posteriormente.
Existem duas maneiras principais de declarar interceptador sob a tag MVC: Interceptores:
(1) Defina diretamente um objeto de feijão da classe de implementação do interceptador. O interceptador interceptador declarado dessa maneira interceptará todas as solicitações.
(2) Use a tag MVC: interceptador para declarar. O interceptador declarado dessa maneira pode definir o caminho de solicitação que precisa ser interceptado através do MVC: mapeando a sugestão.
Após as duas etapas acima, o Interceptor definido atuará para interceptar solicitações específicas.
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.