Un tutorial de ejemplo para usar interceptores en el marco Struts2 de Java

1. Introducción al interceptor

La función del interceptor es similar al filtro en el archivo web.xml. Puede interceptar las solicitudes de los usuarios y controlar la página interceptando solicitudes de usuario. El interceptor está configurado en Struts-Core-2.2.3.Jar. El interceptor original está configurado en struts-default.xml, que sella el método de uso básico del interceptor.
La función de interceptor Struts2 es similar a un filtro de servlet. Antes de que Action ejecute el método Ejecutar, STRUTS2 ejecutará primero el interceptor referenciado en Struts.xml. Si hay múltiples interceptores, se ejecutará en orden de arriba y abajo. Después de ejecutar el método interceptor de todos los interceptores, se ejecutará el método de acción de ejecución.
El interceptor Struts2 debe implementar esta interfaz desde com.opensymphoy.xwork2.interceptor.interceptor. Los siguientes tres métodos deben implementarse en el interceptor definido:

 vacío destruir (); vacío init (); String Intercept (ActionInVocation Invocation) arroja excepción;

Los interceptores personalizados deben anular los tres métodos anteriores. Además, el archivo de configuración del interceptor Struts.xml de Struts2 hereda el archivo de archivo original-default.xml, de modo que toda la información de configuración en struts-default.xml se propiedad automáticamente en el correspondiente <compaquet>. El código específico es el siguiente:

 <paquete name = "demo" extends = "struts-default"> ... </paquete>

2. Agregue un interceptor

Para usar un interceptor, debe estar configurado. Struts2 usa el método de mapeo, por lo que si desea usar una función determinada, debe configurarse en el archivo de configuración, y el interceptor no es una excepción. Por lo tanto, el elemento interceptor correspondiente debe agregarse en el paquete, y el interceptor debe estar asociado con el archivo de clase correspondiente, de modo que el interceptor correspondiente se ejecutará antes de ejecutar la acción. El método de uso específico es el siguiente.

(1) Agregue el archivo de configuración Struts.xml y agregue un interceptor al archivo

 <paquete name = "testLogin" namespace = "/" extends = "struts-default"> <!-interceptor-> <interceptor name = "myInterceptore"> </interceptor> </sceptor> <Action name = "demo"> <resultado name = "error" type = "redirect">/error.jsp </ault> <resultado name = "exitoso">/éxito.J dulte name = "checkError">/checksession.jsp </ resultado> <interceptor-ref name = "myInterceptor"> </interceptor-ref> <interceptor-ref name = "defaultstack"> </interceptor-ref> </action> </paquete>

En el paquete anterior, se agregó un interceptor llamado MyInterceptor, y se registró una clase de Java para el interceptor, que se llamó MyInterceptor y se bloqueó en el paquete Com.interceptor. Además, se ha agregado una acción correspondiente al paquete. Antes de ejecutar la acción, el Interceptor MyInterceptor se ejecutará primero.

(2) Escriba la clase Interceptor registrada MyInterceptor. Esta clase debe implementar el com.opensymphoy.xwork2.interceptor.interceptor interfaz y anular el método correspondiente

 paquete com.interceptor; import java.util.map; import com.entity.user; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.actionInVocation; import com.opensymphony.xwork2.interceptor.interceptor; Clase pública MyInterceptor implementa Interceptor {usuario de usuario privado; Usuario público getUser () {Return User; } public void setUser (usuario de usuario) {this.user = user; } @Override public void destruir () {// TODO Auto Generado Método stub System.out.println ("---- destruye () ----"); } @Override public void init () {// TODO Auto Generado Método stub System.out.println ("------ init () -------"); } @Override public String Intercept (ActionInVocation Invocation) lanza la excepción {// TODO Método Generado automático stub.out.println ("-----------"); Map <string, object> session = invocation.getInVocationContext (). GetSession (); if (session.get ("username")! = null) {system.out.println ("¡Inicie sesión con éxito!"); //session.put ("UserName", user.getUsername ()); return invocation.invoke (); } else {System.out.println ("¡Iniciar sesión!"); devolver "checkError"; }}}

(3) Después de los dos primeros pasos, el interceptor se ha configurado. La última parte es usar el interceptor. Agregue la etiqueta correspondiente a la página de visualización y especifique la acción llamada demo creada anteriormente para la etiqueta. Luego ejecute la página para imprimir el contenido del interceptor correspondiente en la consola.

 <%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" PageEncoding = "utf-8"%> <! DocType html public "-// w3c // dtd html 4.01 transición // en" "http://www.w3.org/tr/html4/loos.dttd <html> <fead> <meta http-equiv = "content-type" content = "text/html; charset = utf-8"> <title> Inserte el título aquí </title> </Etnad> <Body> <Form Action = "Demo"> UserName: <input type = "text" name = "Username"> <Br> contraseña: <input type = "text" name "name" type = "Subt" name = "ok" valor = "enviar"> </form> </body> </html>

Contenido de impresión:

Analice los resultados de la salida. En la etapa de compilación del programa, el archivo de configuración Struts.xml leerá primero el archivo de configuración Struts.xml, y en la acción del archivo de configuración, busque si se ha agregado el interceptor. Si se agrega un interceptor, encuentre si el interceptor o la pila de interceptor se define en <Conceptores> de acuerdo con el nombre del interceptor. Si se encuentra que se define el interceptor, encuentre la clase registrada correspondiente basada en el interceptor y finalmente encuentre la clase registrada en el paquete y ejecute el método init () correspondiente. El proceso general de la etapa de ejecución del programa es similar a la etapa de compilación. Después de que el usuario envíe una solicitud en primer plano, buscará la acción correspondiente en Struts.xml. Si se encuentra, se encontrará el interceptor. Si no se encuentra, se lanzará el error correspondiente. Finalmente, se ejecuta el método de intercepción de la clase de registro de interceptor.

3. Pila de Interceptor

Los interceptores también tienen el concepto de pila. Definen los interceptores usados ​​a un estado compartido para lograr una gestión unificada, de modo que los interceptores se puedan compartir en el paquete, facilitando en gran medida el uso de interceptores. Los interceptores repetidos a menudo se usan en un paquete. Si agrega Interceptor-Ref a la acción cada vez, será muy problemático. Luego se genera la pila de interceptor para resolver este problema. La configuración específica es la siguiente:

 <paquete name = "testLogin" namespace = "/" extends = "struts-default"> <!-Interceptor-> <interceptor name = "myInterceptor"> </interceptor> <!-Defina una cadena pública de interceptores. En la etiqueta de acción, solo se debe hacer referencia a la cadena de interceptor-> <Interceptor-stack name = "Defaulttstack1"> <interceptor-ref name = "myInterceptore"> </interceptor-ref> <interceptor-ref name = "Defaultsack"> </interceptor-ref> </interceptor-stack> </interceptors> <paccion name = "demo"> </"error" error " type = "redirect">/error.jsp </resultado> <resultado name = "éxito">/éxito.jsp </resultado> <resultado name = "checkError">/checksession.jsp </ resultado> <interceptor-ref name = "defaultStack1"> </interceptor-rref> </action> </paquete>

En el ejemplo, Interceptor-stack se usa para definir una pila de interceptor llamado DefaultTtack1. El interceptor que se ejecutará se agrega a la pila, el interceptor se encapsula y la pila del interceptor se llama directamente en la acción, realizando el intercambio de la pila de interceptor.

4. Pila de interceptor predeterminado

Además, se puede definir la pila de interceptor predeterminada, es decir, si no se define ningún interceptor en una acción, ejecutará el interceptor público de forma predeterminada. Pertenece al mismo nivel que la etiqueta Interceptors y se define utilizando el Interceptor-REF predeterminado.

 <paquete name = "testLogin" namespace = "/" extends = "struts-default"> <!-Interceptor-> <interceptor name = "myInterceptor"> </interceptor> <!-Defina una cadena pública de interceptores. In the action tag, only the interceptor chain needs to be referenced --> <interceptor-stack name="defaultinter"> <interceptor-ref name="myInterceptor"></interceptor-ref> <interceptor-ref name="defaultStack"></interceptor-ref> </interceptor-stack> </interceptors> <!-- Define the default interceptor stack and will be automatically registered in the action --> <Default-interceptor-ref name = "Defaultinter"> </default-interceptor-ref> <Action name = "demo"> <resultado name = "error" type = "redirect">/error.jsp </sul> <resultado name = "exitoso">/éxito.jsp </resultado> <resultado name = "checkerror">/chechSesion.jsp </resultado> </paquete>

La pila de interceptor predeterminada definida solo ejecuta la pila de interceptor predeterminada personalizada si la acción no especifica un interceptor. Si el interceptor se redefine en la acción, anulará la pila de interceptor predeterminada personalizada.

5. Sin ejecución del interceptor

Hay otra situación en la que un paquete define el interceptor predeterminado, pero no se requiere que no se ejecute un interceptor en una determinada acción escrita. Luego, puede agregar un interceptor llamado DefaultStack a la acción correspondiente. Es el interceptor predeterminado del sistema y no habrá operaciones.

 <paquete name = "testLogin" namespace = "/" extends = "struts-default"> <!-Interceptor-> <interceptor name = "myInterceptor"> </interceptor> <!-Defina una cadena pública de interceptores. In the action tag, only the interceptor chain needs to be referenced --> <interceptor-stack name="defaultinter"> <interceptor-ref name="myInterceptor"></interceptor-ref> <interceptor-ref name="defaultStack"></interceptor-ref> </interceptor-stack> </interceptors> <!-- Define the default interceptor stack and will be automatically registered in the action --> <Default-interceptor-ref name = "Defaultinter"> </default-interceptor-ref> <Action name = "Demo"> <resultado name = "error" type = "redirect">/error.jsp </resulte> <resultado name = "éxito">/exitoso.jsp </resultado> <resulte name de resultado = "versor"/chequesession.jsp </resulte> <! Resultado-agrega el interforto de la actualidad. <Interceptor-Ref name = "DefaultStack"> </interceptor-ref> </action> </pacle>

6. Método de intercepción

6.1 Uso
El interceptor anterior solo implementa el interceptor de acción de interceptación. De hecho, el interceptor tiene una función muy potente y también puede interceptar el método de acción correspondiente. La diferencia entre la acción de interceptación es que si desea interceptar el método, debe heredar el método de clase Interceptor. Esta clase está encerrada en xwork-core.jar, que una vez más demuestra que la webwork es el núcleo de Struts2. Además, también es necesario agregar los atributos correspondientes al archivo de configuración para determinar el método de intercepción y el método de no interferencia. El método de configuración específico es el siguiente:

 <paquete name = "testLogin" namespace = "/" extends = "struts-default"> <!-Interceptor-> <interceptor name = "myInterceptor"> </interceptor> <!-Defina una cadena pública de interceptores. En la etiqueta de acción, solo se debe hacer referencia a la cadena de interceptor-> <Interceptor-stack name = "Defaultinter"> <interceptor-ref name = "myInterceptore"> </interceptor-ref> <interceptor-ref name = "defaultstack"> </interceptor-ref> </serceptor-stack> </interceptors> <ports name = "damo"> <sed name "error" type = "redirect">/error.jsp </resultado> <resultado nombre = "éxito">/éxito.jsp </resultado> <resultado name = "checkError">/checkSession.jsp </resultado> <resulte name = "checkError">/checkSession.jsp </resultado> <!- Configure el método de interceptación en el orto de valor predeto ser interceptado en excludemethods-> <interceptor-ref name = "defaultStack"> <param name = "includeMethods"> Agregar el nombre del método para interceptarse </param> <!-Intercepting Method-> <Param name = "Excudemethods"> Agregar el nombre del método que no requiere intercepción </param> <!

Código en la clase que hereda el método de interceptor correspondiente de la clase MethodFilterInterceptor:

 paquete com.interceptor; import java.util.map; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.actionInVocation; import com.opensymphony.xwork2.interceptor.methodfilterinterceptor; Public Class Inter extiende MethodFilterInterceptor {@Override public String DoIntercept (ActionVocation Invocation) lanza la excepción {System.out.println ("-Intercept ()-"); // Obtenga el mapa de sesión correspondiente <String, Object> Session = Invocation.GetInVocationContext (). GetSession (); Mapa request = (map) actionContext.getContext (). Get ("request"); String username = (string) request.get ("user.username"); if (session.get ("UserName")! = NULL) {String result = Invocation.Invoke (); System.out.println ("-end ()-"); resultado de retorno; }}}}

6.2 Demo
Veamos un ejemplo de un método de intercepción y analicemos los resultados. El siguiente ejemplo demuestra los resultados de salida del método de intercepción. En el caso, se crea una clase de LoginAction por separado para agregar el método que se ejecutará por acción; La entre clase se anula en el método del interceptor y genera si debe interceptar un cierto método en la consola; El archivo Login.jsp se agrega para demostrar la ejecución de los tres métodos respectivamente.
(1) La definición del Interceptor de método en Struts.xml define un interceptor llamado Inter en el paquete y especifica los parámetros en el interceptor. includeMethods se utiliza para interceptar el método1. El método2 en excludemethods significa que el método de métodos2 no se intercepta. La configuración específica es la siguiente:

 ; <Interceptor name = "inter"> <param name = "includeMethods"> Method1 </marr> <!-Método de Intercept1 Método-> <Param name = "Excudemethods"> Method2 </amamr> </sceptor> <Interceptor-stack name = "myInterceptor"> <interceptor-ref name = "inter" </axterceptor-ref> name = "DefaultStack"> </interceptor-ref> </ interceptor-stack> </interceptor stack> </ interceptors> <action name = "loginaction"> <resultado name = "éxito"> exitoso.jsp </resultado> <resultado name = "error"> error.jsp </sutor> <resultado name = "error"> error.jsp </sul <Interceptor-Ref name = "Inter"> </sceptor-ref> <interceptor-ref name = "DefaultStack"> </interceptor-ref> </action> </paquete> </truts>

(2) Clase de LoginAction, configure la acción en Login.jsp y agregue tres métodos Method1-Method3 a esta clase, respectivamente, el método1 es interceptado, Method2 y Method3 no se interceptan, y finalmente verificamos el resultado de la salida.

 paquete com.action; import com.opensymphony.xwork2.ActionSupport; Public Class LoginAction extiende ActionSupport {@Override public String Execute () lanza la excepción {if (this.username.equals ("admin") && this.password.equals ("admin")) {return "éxito"; } else if (this.username.equals ("cancelar") && this.password.equals ("cancelar")) {return "cancelar"; } else {return "error"; }} public void Method1 () {System.out.println ("Método de ejecución: método1"); } public void Method2 () {System.out.println ("Método de ejecución: método2"); } public void Method3 () {System.out.println ("Método de ejecución: método3"); } nombre de usuario de cadena privada; contraseña de cadena privada; public String getUsername () {return this.Username; } public void setUsername (String UserName) {this.Username = username; } public String getPassword () {return this.password; } public void setPassword (String Password) {this.password = contraseña; }}

(3) Inter Clase, heredar la clase MethodFilterInterceptor, y se utiliza para implementar métodos de interceptación. Reescribe el método Dointercept y agregue la información correspondiente para interceptar al método.

 paquete com.interceptor; import java.util.date; import java.util.map; import com.action.loginaction; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.actionInVocation; import com.opensymphony.xwork2.interceptor.methodfilterinterceptor; Public Class Inter extiende MethodFilterInterceptor {@Override String DoIntercept (ActionInVocation Invocation) lanza la excepción {// TODO Método Generado automático stub System.out.println ("Interceptor Interess antes de la ejecución de la acción"+nueva fecha ()); String result = invocation.invoke (); // Ejecutar el método de acción System.out.println ("Interceptor Intercepts después de la ejecución de la acción"+nueva fecha ()); resultado de retorno; }}

(4) Login.jsp, agregue tres botones en la página JSP, demuestre tres métodos respectivamente y juzga la intercepción del interceptor del método. Las acciones publicadas por los tres botones después de hacer clic se agregan dinámicamente en JavaScript. Esto logra el método de ejecutar diferentes acciones en una forma. Por supuesto, hay otros métodos que se discutirán en el próximo artículo.

 <%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" PageEncoding = "utf-8"%> <! DocType html public "-// w3c // dtd html 4.01 transición // en" "http://www.w3.org/tr/html4/loos.dttd <html> <fead> <meta http-equiv = "content-type" content = "text/html; charset = utf-8"> <title> Insertar título aquí </title> <script type = "text/javaScript" // método 1, defina una instancia de la función de método interceptado método1 () {var formar = document.forms [0]; form.Action = "LoginAction! Method1"; form.subMit (); } // Método 2, agregue un método que no se intercepta para el botón 2 de la función Method2 () {var form = document.forms [0]; form.Action = "LoginAction! Method2"; form.subMit (); } // Método 3, agregue un método que no intercepta para el botón 3 de la función Method3 () {var form = document.forms [0]; form.Action = "LoginAction! Method3"; form.subMit (); } </script> </head> <body> <form> username: <input type = "text" name = "username"> <br> contraseña: <input type = "text" name = "contraseña"> <br> <input type = "envíe" name = "ok" valor = "botón1" itClick = "método1 ()"> <input type = "Subt" name = "ok1" value = "button2" oneClick "oneClick" (") <input type = "subt" name = "ok2" value = "button3" onClick = "método3 ()"> </form> </body> </html>

Vista de página Después de completar la ejecución:

(5) Analice los resultados en ejecución, haga clic en los botones 1, 2 y 3 respectivamente, y obtenga los resultados en la consola. El botón 1 es el método encuadernado1. Este método se intercepta en Struts.xml. Si el resultado es correcto, se mostrará el resultado interceptado. Los botones correspondientes 2 y 3 solo obtienen los resultados de la ejecución porque no se interceptan. Luego mira el diagrama de resultados a continuación:

El diagrama de resultados es exactamente el resultado de nuestro análisis. Se interceptó el botón 1 y se ejecutó el método Dointercept en la intersección. Los botones correspondientes 2 y 3 de los dos no fueron interceptados. En otras palabras, el método1 se coloca en la lista blanca del Interceptor del método, y el método debe interceptarse cuando se ejecuta; Method2 se coloca en la lista negra del interceptor, y no hay necesidad de interceptar el método; Method3 no hace nada.

7. Conclusión

El contenido del interceptor se resume aquí. El interceptor proporciona funciones muy poderosas, lo que permite a los desarrolladores controlar los resultados de la salida en tiempo de ejecución, aumentando la flexibilidad de la programación. Además, no intentes recordar cosas teóricas. Debe analizarlos racionalmente, practicar más y hacer algunos ejemplos para tener una comprensión más profunda de los resultados del análisis.

PS: Descripción funcional del interceptor proporcionado por Struts2 (Xwork)