El interceptor interceptor en SpringMVC también es muy importante y útil. Su función principal es interceptar las solicitudes de los usuarios y realizar el procesamiento correspondiente. Por ejemplo, puede realizar una verificación de permiso o determinar si el usuario ha iniciado sesión o determinar si la hora actual es el tiempo de compra de boletos como 12306.
1. Defina la clase de implementación del interceptor
Las solicitudes de intercepción de interceptor en SpringMVC se implementan a través de HandlerInterceptor. Definir un interceptor en SpringMVC es muy simple. Hay dos formas principales. La primera forma es definir la clase Interceptor que implementa la interfaz Spring Handlerinterceptor, o esta clase hereda la clase que implementa la interfaz de HandlerInterceptor, como la clase abstracta que Spring ha proporcionado que implementa la interfaz de Handlerinterceptor, que ya proporciona la primavera; La segunda forma es implementar la interfaz Spring WebRequestInterceptor de Spring o heredar la clase que implementa la interfaz WebRequestInterceptor.
(I) Implementación de la interfaz Handlerinterceptor
Hay tres métodos definidos en la interfaz de Handlerinterceptor, y utilizamos estos tres métodos para interceptar las solicitudes de los usuarios.
(1) Prehandle (solicitud httpservletRequest, httpservletreponse respuesta, mango de objeto), como lo indica el nombre, se llamará antes de procesar la solicitud. El interceptor en SpringMVC se llama en forma de cadena. Múltiples interceptores pueden existir al mismo tiempo en una aplicación o en una solicitud. Cada llamada de interceptor se ejecutará en secuencia de acuerdo con su orden de declaración, y las primeras se ejecutan son el método de prehompuesto en el interceptor, por lo que se pueden realizar algunas operaciones de preinicialización en este método o un preprocesamiento de la solicitud actual, o se pueden hacer algunos juicios en este método para decidir si la solicitud debe continuar.
El valor de retorno de este método es de tipo booleano booleano. Cuando vuelve a falso, significa que la solicitud termina, y el posterior interceptor y el controlador no se ejecutarán nuevamente; Cuando el valor de retorno es verdadero, se continuará llamando al método prehandamiento del próximo interceptor. Si ya es el último interceptor, se llamará al método del controlador de la solicitud actual.
(2) Postthandle (HTTPServletRequest Solicitud, respuesta httpservletResponse, mango de objeto, modelandview modelandView). A partir de la explicación del método Prehandle, sabemos que este método, incluido el método AfterComplettion que se mencionará más adelante, solo puede llamarse cuando el valor de retorno del método de prehandilla del interceptor actual es verdadero.
El método posterior, como su nombre indica, se ejecuta después de procesar la solicitud actual, es decir, después de que se llame al método del controlador, pero se llamará antes de que el desplazamiento devuelva y represente la vista, por lo que podemos operar en el objeto ModelAnview después del proceso del controlador en este método. La dirección de la llamada del método posterior es lo opuesto a Prehandle, lo que significa que el método posthandle del interceptor declarado primero se ejecutará más adelante, lo que es algo similar al proceso de ejecución del interceptor en Struts2. El proceso de ejecución del interceptor en Struts2 también está encadenado, pero en Struts2, el método de invocación de ActionInvocation debe ser llamado manualmente para activar la llamada al próximo interceptor o acción. Luego, el contenido en cada interceptor antes de que el método de invocación se ejecute en el orden declarado, y el contenido después del método de Invoke se invierte.
(3) AfterComppletion (HTTPServletRequest Solicitud, respuesta httpservletResponse, manejo del objeto, excepción ex), este método debe ejecutarse cuando el valor de retorno del método de prehansmento del interceptor correspondiente correspondiente es verdadero. Como su nombre indica, este método se ejecutará después de que se complete toda la solicitud, es decir, después de que el despachador ofrece la vista correspondiente. La función principal de este método es limpiar los recursos.
Aquí hay una simple descripción del código:
import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; importar org.springframework.web.servlet.handlerinterceptor; importar org.springframework.web.servlet.modelandview; Public Class SpringMVCinterceptor implementa HandlerInterceptor { /*** El método Prehandle se utiliza para la intercepción del procesador. Como su nombre indica, este método se llamará antes del proceso del controlador. El interceptor interceptor en SpringMVC está encadenado y múltiples interceptores pueden existir al mismo tiempo. Luego, SpringMVC se ejecutará uno por uno de acuerdo con el orden de la declaración, y se llamará a todos los métodos previos al interceptor antes del método del controlador. La estructura de la cadena interceptora de SpringMVC también se puede interrumpir. Este método de interrupción hace que el valor de retorno de PreHandle a False. Cuando el valor de retorno de PreHandle es falso, la solicitud completa finaliza. */ @Override public Boolean PreHandle (HttpServletRequest Solicitud, respuesta httpServletResponse, manejador de objetos) lanza la excepción {// TODO Auto Generado Método STUB Return False; } /*** Este método solo se ejecutará cuando el valor de retorno actual del método prehandil del interceptor sea verdadero. Postthandle se utiliza para la intercepción del procesador. Su tiempo de ejecución es después de que se procese el procesador*, es decir, después de que se llame al método del controlador, pero se ejecutará antes de que el desplazamiento ofrece la vista, lo que significa que en este método puede operar el modelandView*. La estructura de la cadena de este método es lo opuesto a la dirección de acceso normal, es decir, el método declarado primero se llamará más adelante. Esto es un poco similar al proceso de ejecución del interceptor en Struts2. * Solo en el método de intercepción en Struts2, el método de Invoca de ActionInvocation debe llamarse manualmente. El método de invocación de actionInvocation en Struts2 es llamar al siguiente interceptor * o llamar a la acción, y luego los contenidos que deben llamarse antes del interceptor se escriben antes de la llamada para invocar, y el contenido que debe llamarse después del interceptor se escribe después del método de llamada al método de invocación. * / @Override public void postthandle (httpservletRequest solicitud, httpServletResponse Respuesta, Handler de objetos, ModelAndView ModelAndView) lanza la excepción {// TODO Método Generado Autorgenerado} / *** Este método también debe ejecutarse cuando el valor de retorno del método previo del interceptor correspondiente es cierto. Este método se ejecutará después de que se complete toda la solicitud, es decir, el desplazamiento de ventajas ofrece la ejecución de la vista. * La función principal de este método es limpiar los recursos. Por supuesto, este método solo se puede ejecutar cuando el valor de retorno actual del método previo a la mano del interceptor es verdadero. */ @Override public void AfterComppletion (HttpServletRequest Solicitud, respuesta httpServletResponse, Handler de objetos, Excepción ex) lanza la excepción {// TODO Auto Generado Stub}} (Ii) Implementar la interfaz WebRequestInterceptor
También hay tres métodos definidos en WebRequestInterceptor, y también utilizamos estos tres métodos para implementar la intercepción. Los tres métodos pasan el mismo parámetro WebRequest, entonces, ¿qué es este WebRequest? Esta redacción web es una interfaz definida por Spring. Las definiciones del método en él son básicamente las mismas que httpservletRequest. Todas las operaciones realizadas en WebRequestInterceptor en WebRequestInterceptor se sincronizarán con httpservletRequest y luego se pasarán en la solicitud actual.
(1) Método Prehandle (Solicitud de WebRequest). Se llamará a este método antes de que se procese la solicitud, es decir, se llamará antes de llamar al método del controlador. Este método es diferente del prevenir en HandlerInterceptor. La principal diferencia es que el valor de retorno del método es nulo, lo que significa que no hay valor de retorno. Por lo tanto, generalmente lo usamos para preparar recursos. Por ejemplo, cuando usamos Hibernate, podemos preparar un objeto de sesión Hibernate en este método y luego usar el setAttribute (nombre, valor, alcance) de WebRequest para ponerlo en la propiedad WebRequest. Aquí podemos hablar sobre el tercer alcance del parámetro del método SetAttribute, que es de tipo entero. Se definen tres constantes para las solicitudes de interfaz de la capa principal de WebRequest:
Scope_request: su valor es 0, lo que significa que es accesible solo en solicitud.
Scope_session: su valor es 1. Si el entorno lo permite, representa una sesión aislada local, de lo contrario representa una sesión normal y se puede acceder dentro del alcance de la sesión.
Scope_global_session: su valor es 2. Si el entorno lo permite, representa una sesión compartida a nivel mundial, de lo contrario representa una sesión normal y se puede acceder dentro del alcance de la sesión.
(2) Método posthandle (solicitud WebRequest, ModelMap Model). Se llamará a este método después del procesamiento de la solicitud, es decir, después de que se llame al método del controlador, pero se llamará antes de que se rinden las devoluciones de la vista, por lo que puede cambiar la visualización de datos cambiando el modelo de modelo de datos en este método. Este método tiene dos parámetros. El objeto WebRequest se utiliza para pasar todos los datos de solicitud. Por ejemplo, los datos preparados en Prehandle se pueden pasar y acceder a través de WebRequest; ModelMap es el objeto modelo devuelto después del proceso del controlador. Podemos cambiar el modelo de modelo devuelto cambiando sus propiedades.
(3) AfterCompletion (solicitud de requisito web, excepción ex) método. Este método se ejecutará después de procesar toda la solicitud, es decir, después de que la vista se devuelve y se repita. Por lo tanto, en este método, se puede realizar la operación de liberación de recursos. El parámetro WebRequest puede pasar los recursos que preparamos en Prehandle aquí para su lanzamiento. El parámetro de excepción representa el objeto de excepción solicitado actualmente. Si la excepción lanzada en el controlador ha sido procesada por el procesador de excepción de Spring, entonces el objeto de excepción es nulo.
Aquí hay una simple descripción del código:
importar org.springframework.ui.modelmap; importar org.springframework.web.context.request.webrequest; importar org.springframework.web.context.request.webrequestinterceptor; clase pública Allinterceptor implementa WebRequestInterceptor { /*** Ejecutar antes de que se procese la solicitud. Este método se usa principalmente para preparar datos de recursos, y luego se pueden colocar en WebRequest como atributos de solicitud*/ @Override public void prehandle (solicitud webRequest) lanza la excepción {// TODO Auto Generado STUB System.out.Println ("AllIinterceptor .................."); request.setAttribute ("solicitud", "solicitud", webrequest.scope_request); // Esto se coloca dentro del alcance de la solicitud, por lo que solo puede obtener request.setTribute ("sesión", "sesión", en la solicitud en la solicitud actual. WebRequest.scope_session); // Esto se coloca dentro del alcance de la sesión. Si el entorno lo permite, solo se puede acceder en una sesión aislada localmente. De lo contrario, se puede acceder en la sesión actual normal. Request.SetAttribute ("Globalsession", "Globalsession", WebRequest.scope_global_session); // Si el entorno lo permite, se puede acceder en una sesión compartida a nivel mundial, de lo contrario se puede acceder en la sesión actual}/*** Este método se ejecutará después de que el controlador se ejecute y antes de regresar a la vista. ModelMap representa el objeto modelo devuelto después de que se solicite al controlador que procese el controlador, por lo que las propiedades del ModelMap pueden modificarse en este método para lograr el efecto de cambiar el modelo devuelto. */ @Override public void Posthandle (solicitud WebRequest, ModelMap MAP) lanza la excepción {// TODO STUB AUTO GENERADO PAR "--------------------------------------------------------------------------------------------------------------------------------------------------- AfterComplettion (solicitud WebRequest, excepción de excepción) lanza la excepción {// TODO Método Generado automático stub.out.println (excepción + ""-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= "); }}2. Agregue la clase Interceptor definida al sistema de intercepción de SpringMVC
1. Agregue un esquema que admita MVC en el archivo de configuración de 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 "
Aquí hay un ejemplo de mi declaración:
<Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema -instance" xmlns: context = "http://wwww.springframe 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/ContextExt http://wwww.springframe..Org/schema/contextextextextext-3.0.0.xsdddworkWorkwWork http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd ">
De esta manera, puede usar la etiqueta MVC en el archivo de configuración SpringMVC. Hay un MVC: interceptores en la etiqueta MVC que se utiliza para declarar el interceptor de SpringMVC.
(Ii) Use la etiqueta MVC: Interceptores para declarar el interceptor que debe agregarse a la cadena de interceptor SpringMVC
<MVC: Interceptores> <!- Usa el frijol para definir un interceptor. El interceptor definido directamente en la raíz de MVC: Interceptors interceptará todas las solicitudes-> <bean/> <mvc: interceptor> <mvc: mapeing ruta = "/test/number.do"/> <!-La representación definida en MVC: Interceptor es para interceptar una solicitud específica-> <bean/> </mvc: Interceptor> </mvc: interceptor es para interceptar una solicitud específica-> <bean/> </mvc: Interceptor> </mvc: interceptor es para interceptar una solicitud específica-> <bean/> </mvc: interceptor> </mvc: interceptor>
Del ejemplo anterior, podemos ver que una serie de interceptores se pueden declarar utilizando la etiqueta MVC: interceptores, y luego pueden formar una cadena de interceptores. La orden de ejecución del interceptor se ejecuta en orden de declaraciones. El método previo al Interceptor declarado se ejecutará primero, pero su método posterior y el método AfterCompletion se ejecutarán más adelante.
Hay dos formas principales de declarar Interceptor bajo la etiqueta MVC: Interceptores:
(1) Defina directamente un objeto Bean de la clase de implementación del interceptor. Interceptor Interceptor declarado de esta manera interceptará todas las solicitudes.
(2) Use la etiqueta MVC: Interceptor para declarar. El interceptor declarado de esta manera puede definir la ruta de solicitud que debe interceptarse a través del MVC: Mapeo Subtag.
Después de los dos pasos anteriores, el interceptor definido actuará para interceptar solicitudes específicas.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.