Um exemplo de tutorial para usar interceptores na estrutura do Struts2 de Java

1. Introdução ao interceptador

A função do interceptador é semelhante ao filtro no arquivo web.xml. Ele pode interceptar solicitações de usuário e controlar a página interceptando solicitações de usuário. O interceptador está configurado em struts-core-2.2.3.Jar. O interceptador original está configurado no struts-default.xml, que sela o método de uso básico do interceptador.
A função interceptadora STRUTS2 é semelhante a um filtro de servlet. Antes que a ação execute o método Execute, o STRUTS2 primeiro executará o interceptador referenciado em struts.xml. Se houver vários interceptores, ele será executado em ordem para cima e para baixo. Depois de executar o método interceptador de todos os interceptores, o método de ação de execução será executado.
O interceptador STRUTS2 deve implementar essa interface do com.opensymphoy.xwork2.intercept.intercept. Os três métodos a seguir precisam ser implementados no interceptador definido:

 vazio destruído (); vazio init (); Interceptação de string (invocação de ação) lança exceção;

Os interceptores personalizados precisam substituir os três métodos acima. Além disso, o arquivo de configuração do interceptador struts.xml de struts2 herda o arquivo original do arquivo struts-default.xml, para que todas as informações de configuração no struts-default.xml sejam de propriedade automaticamente no <cackage> correspondente. O código específico é o seguinte:

 <pacote name = "Demo" Extends = "Struts-Default"> ... </cackage>

2. Adicione um interceptador

Para usar um interceptador, você deve estar configurado. O STRUTS2 usa o método de mapeamento; portanto, se você deseja usar uma determinada função, deve estar configurado no arquivo de configuração e o interceptador não é exceção. Portanto, o elemento interceptador correspondente deve ser adicionado no pacote, e o interceptador deve estar associado ao arquivo de classe correspondente, para que o interceptor correspondente seja executado antes que a ação seja executada. O método de uso específico é o seguinte.

(1) Adicione o arquivo de configuração

 <package name = "testlogin" namespace = "/" estends = "struts-default"> <!-interceptor-> <interceptor name = "myInterceptor"> </soceptor> </interceptor> <ação name = "Demo"> Result Name = "Error" name = "checkError">/checkSession.jsp </sicult> <interceptor-ref name = "myInterceptor"> </interceptor-ref> <interceptor-ref name = "defaultStack"> </interceptor-ref> </ction> </catury>

No pacote acima, um interceptador chamado MyInterceptor foi adicionado e uma classe Java foi registrada para o interceptador, que foi nomeada MyInterceptor e foi bloqueada no pacote Com.Interceptor. Além disso, uma ação correspondente foi adicionada ao pacote. Antes de executar a ação, o MyInterceptor Interceptor será executado primeiro.

(2) Escreva a classe interceptadora registrada MyInterceptor. Esta classe deve implementar a interface com.opensymphoy.xwork2.intercept.intercept e substituir o método correspondente

 pacote com.Interceptor; importar java.util.map; importação com.entity.User; importação com.opensymphony.xwork2.ActionContext; importação com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.intercept.intercept; classe pública MyIntercept implementa Interceptor {Usuário privado; usuário público getUser () {return user; } public void SetUser (usuário do usuário) {this.User = user; } @Override public void Destroy () {// TODO Method Auto-Gerated Stub System.out.println ("---- Destruir () ----"); } @Override public void init () {// TODO Method Auto-Gerated Stub System.out.println ("------ Init () -------"); } @Override public String Intercept (ACOCHINVocation Invocation) lança exceção {// TODO Method Auto-Gerated Stub System.out.println ("-----------"); Mapa <string, object> session = invocação.getInvocationContext (). GetSession (); if (session.get ("nome de usuário")! = null) {System.out.println ("Login com sucesso!"); //session.put ("nome de usuário", user.getUserName ()); retornar invocação.invoke (); } else {System.out.println ("Login falhou!"); retornar "checkError"; }}}

(3) Após as duas primeiras etapas, o interceptador foi configurado. A última parte é usar o interceptador. Adicione a tag correspondente à página de exibição e especifique a ação denominada Demo criada acima para a tag. Em seguida, execute a página para imprimir o conteúdo interceptador correspondente no console.

 <%@ página linguagem = "java" contentType = "text/html; charset = utf-8" PageEncoding = "utf-8"%> <! <html> <head> <meta http-equiv = "content-type" content = "text/html; charset = utf-8"> <title> insira título aqui </title> </head> <body> <form action = "Demo"> username: <input type = "text" nome = "username"> <br = <br = "> type = "submeter" name = "ok" value = "submeter"> </mand> </body> </html>

Conteúdo de impressão:

Analise os resultados da saída. No estágio de compilação do programa, o arquivo de configuração STRUTS.XML lerá primeiro o arquivo de arquivo de configuração Struts.xml e, na ação do arquivo de configuração, pesquise se o interceptador foi adicionado. Se um interceptador for adicionado, descubra se o interceptador ou a pilha interceptadora é definida em <Interceptores> de acordo com o nome do interceptador. Se for constatado que o interceptador estiver definido, encontre a classe registrada correspondente com base no interceptador e, finalmente, encontre a classe registrada no pacote e execute o método Init () correspondente. O processo geral do estágio de execução do programa é semelhante ao estágio de compilação. Depois que o usuário enviar uma solicitação em primeiro plano, ele procurará a ação correspondente no Struts.xml. Se for encontrado, o interceptador será encontrado. Se não for encontrado, o erro correspondente será lançado. Finalmente, o método de interceptação da classe de registro interceptador é executado.

3. Pilha interceptora

Os interceptores também têm o conceito de pilha. Eles definem os interceptores usados ​​para um estado compartilhado para obter um gerenciamento unificado, para que os interceptores possam ser compartilhados no pacote, facilitando bastante o uso de interceptores. Interceptores repetidos são frequentemente usados ​​em um pacote. Se você adicionar interceptor-ref à ação sempre, será muito problemático. Em seguida, a pilha interceptores é gerada para resolver esse problema. A configuração específica é a seguinte:

 <names do pacote = "testlogin" namespace = "/" estends = "struts-defafult"> <!-interceptador-> <interceptador name = "myIntercept"> </socceptor> <!-Defina uma cadeia de interceptor público. Na etiqueta de ação, apenas a cadeia interceptadora precisa ser referenciada-> <interceptor-stack name = "defaultTStack1"> <interceptor-ref name = "myInterceptor"> </interceptor-ref> </interceptor-name = "defaultstack"> </intercetor-ref> </intercetor-staack> </interceptack> </interceptor "</interceptor" </interceptor) </interceptor "</interceptor" </interceptor) </interceptor "</interceptor) </interceptor" </interceptor "</interceptor) </interceptor" </interceptor) </interceptor) </interceptor "</interceptor) </interceptor" </interceptor) </interceptor) </interceptor "</interceptor) </interceptor) </interceptack> </interceptor") type = "redirect">/error.jsp </resultado> <resultado name = "succcess">/success.jsp </resultado> <name = "checkError">/checkSession.jsp </resultado> <interceptor-ref name = "defaultStack1"> </interceptor-ref> </action> </package>

No exemplo, o interceptador é usado para definir uma pilha interceptadora chamada DefaultTStack1. O interceptador a ser executado é adicionado à pilha, o interceptor é encapsulado e a pilha interceptadora é chamada diretamente na ação, percebendo o compartilhamento da pilha interceptora.

4. Pilha interceptadora padrão

Além disso, a pilha de interceptores padrão pode ser definida, ou seja, se nenhum interceptador for definido em uma ação, ele executará o interceptador público por padrão. Pertence ao mesmo nível que a tag Interceptores e é definido usando-se-interceptor-ref padrão.

 <names do pacote = "testlogin" namespace = "/" estends = "struts-defafult"> <!-interceptador-> <interceptador name = "myIntercept"> </socceptor> <!-Defina uma cadeia de interceptor público. Na etiqueta de ação, apenas a cadeia interceptadora precisa ser referenciada-> <Interceptor-Stack name = "defaultInter"> <interceptor-ref name = "myInterceptor"> </interceptor-ref> <interceptor-ref name = "defaultStack"> </interceptor-bet </interceptor-stack> </interceptores> </interceptores> <! Ação-> <Defult-interceptor-ref name = "defaultInter"> </default-interceptor-ref> <ação name = "Demo"> <resultado name = "error" type = "redirect">/error.jsp </resultado> <resultado name = "success">/success.jsp </resultado> <resultado = "checkerror">/checks>/checkShen>/"CheckShes>/" schester./"success">/success.jsp </resultado> <resultado = "checkerror">

A pilha interceptadora padrão definida executa apenas a pilha de interceptores padrão personalizada se a ação não especificar um interceptador. Se o interceptador for redefinido na ação, ele substituirá a pilha de interceptores padrão personalizada.

5. Nenhuma execução interceptadora

Há outra situação em que um pacote define o interceptador padrão, mas nenhum interceptador deve ser executado em uma determinada ação escrita. Em seguida, você pode adicionar um interceptador chamado DefaultStack à ação correspondente. É o interceptador padrão do sistema e não haverá operações.

 <names do pacote = "testlogin" namespace = "/" estends = "struts-defafult"> <!-interceptador-> <interceptador name = "myIntercept"> </socceptor> <!-Defina uma cadeia de interceptor público. Na etiqueta de ação, apenas a cadeia interceptadora precisa ser referenciada-> <Interceptor-Stack name = "defaultInter"> <interceptor-ref name = "myInterceptor"> </interceptor-ref> <interceptor-ref name = "defaultStack"> </interceptor-bet </interceptor-stack> </interceptores> </interceptores> <! Ação-> <Defundi-interceptor-ref name = "defaultInter"> </default-interceptor-ref> <ação name = "Demo"> <resultado name = "error" type = "redirect">/error.jsp </result> <burt> <resultado name = "sucessor"/sucess.jsp </resultado> <nome ("! Interceptador não é executado-> <Interceptor-ref name = "DefaultStack"> </socceptor-ref> </ction> </cackage>

6. Método de interceptação

6.1 Uso
O interceptador acima implementa apenas a ação interceptadora interceptora. De fato, o interceptador tem uma função muito poderosa e também pode interceptar o método de ação correspondente. A diferença entre a ação intercepta é que, se você deseja interceptar o método, deverá herdar o MethodFilterInterprector da classe. Esta classe é incluída no XWork-core.jar, que mais uma vez prova que o webwork é o núcleo do Struts2. Além disso, também é necessário adicionar atributos correspondentes ao arquivo de configuração para determinar o método de interceptação e o método de não interceptação. O método de configuração específico é o seguinte:

 <names do pacote = "testlogin" namespace = "/" estends = "struts-defafult"> <!-interceptador-> <interceptador name = "myIntercept"> </socceptor> <!-Defina uma cadeia de interceptor público. Na etiqueta de ação, apenas a cadeia interceptadora precisa ser referenciada-> <Interceptor-Stack name = "defaultInter"> <interceptor-ref name = "myInterceptor"> </interceptor-ref> </interceptor-ref name = "defaultstack"> </interceptor-names> </interceptor-sef) </interceptors> </interceptors> type = "Redirect">/error.jsp </resultado> <resultado name = "succcess">/succcess.jsp </resultado> <resultado name = "checkError">/checkSession.jsp </resultado> <nome do nome = "checkError">/checkSession.jsp </resultado>!- Configure o método intercepting no defraftale, Precisa ser interceptado nos excludemethods-> <interceptor-ref name = "defaultStack"> <param name = "includeMethods"> Adicione o nome do método a ser interceptado </am Param> <!-Método intercepting-> <param name = "excdemeths"> Adicione o nome do método que não requer interceptação </param> <! </package>

Código na classe que herda o método interceptador correspondente da classe MethodFilterInterceptor:

 pacote com.Interceptor; importar java.util.map; importação com.opensymphony.xwork2.ActionContext; importação com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.intercept.methodfilterInterceptores; classe pública inter estende o MethodFilterInterceptor {@Override public String DoIntercept (ACTIONVocation Invocation) lança a exceção {System.out.println ("-intercept ()-"); // Obtenha o mapa de sessão correspondente <string, object> session = Invocation.getInvocationContext (). GetSession (); Mapa request = (map) actionContext.getContext (). Get ("request"); String userName = (string) request.get ("user.username"); if (session.get ("nome de usuário")! = null) {string resultado = invocação.invoke (); System.out.println ("-end ()-"); resultado de retorno; }}}}

6.2 Demo
Vejamos um exemplo de um método de interceptação e analisar os resultados. O exemplo a seguir demonstra os resultados de saída do método de interceptação. No caso, uma classe de loginação é criada separadamente para adicionar o método a ser executado pela ação; A classe Inter é substituída no método interceptador e gera para interceptar um determinado método no console; O arquivo login.jsp é adicionado para demonstrar a execução dos três métodos, respectivamente.
(1) A definição do método interceptador em struts.xml define um interceptador chamado inter no pacote e especifica parâmetros no interceptador. IncluirMethods é usado para interceptar o método1. Método2 em excludemethods significa que o método Methods2 não é interceptado. A configuração específica é a seguinte:

 <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.0 // pt" "http://struts.apache.org/dtds/struts-2.0.dtd"> <truts> <constant name = struts.action.extension "valueftd" </constante " <interceptor name = "inter"> <param name = "includeMethods"> método1 </param> <!-intercept método1 Método-> <param name = "excluiMethods"> method2 </param> </interceptor> <interceptor-stack name = "myinterceptor"> <intercetor-ref name = "interceptor-Reptack-staack =" myinterceptor "> <intercetor-ref name =" interceptor- rack-rack-rack = " Nome = "DefaultStack"> </soceptor-ref> </interceptor-sack> </soceptor-Stack> </sociumtors> <ação name = "loginaction"> <resultado name = "succed"> success.jsp </resultado> <Result Name = "Error"> Error.jsp </resultado> <Result Name = Error "> Error. type = "Redirectaction"> Welcome </silft> <interceptor-ref name = "inter"> </soccept-ref> <interceptor-ref name = "defaultStack"> </interceptor-ref> </ction> </catury> </stuts>

(2) Classe de loginação, configure a ação no login.jsp e adicione três métodos Métodos1-Method3 a essa classe, respectivamente, o método1 é interceptado, o método2 e o método3 não são interceptados e, finalmente, verificamos o resultado da saída.

 pacote com.action; importação com.opensymphony.xwork2.actionsupport; public class LoginAction estende o ACTIONSupport {@Override public String Execute () lança a exceção {if (this.username.equals ("admin") && this.password.equals ("admin")) {return "success"; } else if (this.username.equals ("cancel") && this.password.equals ("cancel")) {return "cancel"; } else {return "error"; }} public void method1 () {System.out.println ("Método de execução: método1"); } public void method2 () {System.out.println ("Método de execução: Method2"); } public void method3 () {System.out.println ("Método de execução: Método3"); } nome de usuário de string privado; senha de sequência privada; public string getUserName () {return this.username; } public void setUserName (string userName) {this.username = nome de usuário; } public string getPassword () {return this.password; } public void setPassword (string senha) {this.password = senha; }}

(3) Inter -classe, herdando a classe MethodFilterInterceptor e é usado para implementar métodos de interceptação. Reescreva o método DOIntercept e adicione as informações correspondentes para interceptar ao método.

 pacote com.Interceptor; importar java.util.date; importar java.util.map; importação com.action.loginaction; importação com.opensymphony.xwork2.ActionContext; importação com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.intercept.methodfilterInterceptores; classe pública inter estende o métodoFilterInterceptor {@Override Protected String DoIntercept (ACTIONVocation Invocation) lança exceção {// TODO Method Method Stub System.out.println ("Interceptor Intercepts antes da execução da ação"+new Date ()); String result = Invocation.inVoke (); // execute o método de ação System.out.println ("Interceptores intercepta após a execução da ação"+new Date ()); resultado de retorno; }}

(4) Login.jsp, adicione três botões na página JSP, demonstre três métodos, respectivamente, e julgue a interceptação do Interceptor sobre o método. As ações postadas de volta pelos três botões após o clique são adicionadas dinamicamente no JavaScript. Isso alcança o método de executar ações diferentes de um formulário. Obviamente, existem outros métodos, que serão discutidos no próximo artigo.

 <%@ página linguagem = "java" contentType = "text/html; charset = utf-8" pageEncoding = "utf-8"%> <! Doctype html public "-// w3c // dtd html 4.01 transitório //" <html> <head> <meta http-equiv = "content-type" content = "text/html; charset = utf-8"> <title> insira título aqui </title> <script type = "text/javascript"> // método 1, define uma instância da instituição da função do método da função1 () {vars. form.action = "LoginAction! Method1"; form.subMit (); } // Método 2, adicione um método que não intercepte para o botão 2 função Metod2 () {var form = document.forms [0]; form.action = "LoginAction! Method2"; form.subMit (); } // Método 3, adicione um método que não intercepte para o botão 3 função Method3 () {var form = document.forms [0]; form.action = "LoginAction! Method3"; form.subMit (); } </script> </ad Head> <body> <form> Nome de usuário: <input type = "text" name = "username"> <br> senha: <input type = "text" name = "senha"> <br> <input type = "submit" name = "ok" value = "button1" onclick = ""1 ()"> <input "" ONCLICK = "Method2 ()"> <input type = "submit" name = "ok2" value = "button3" onclick = "method3 ()"> </morm> </body> </html>

Visualização da página após a conclusão da execução:

(5) Analise os resultados em execução, clique em botões 1, 2 e 3, respectivamente, e produza os resultados no console. O botão 1 é o método ligado1. Este método intercepta em struts.xml. Se o resultado estiver correto, o resultado interceptado será exibido. Os botões correspondentes 2 e 3 emitem apenas os resultados em execução porque não são interceptados. Em seguida, olhe para o diagrama de resultados abaixo:

O diagrama de resultados é exatamente o resultado de nossa análise. O botão 1 foi interceptado e o método do DOINTERCECT na classe foi executado. Os botões correspondentes 2 e 3 dos dois não foram interceptados. Em outras palavras, o método1 é colocado na lista de permissões do método interceptador, e o método deve ser interceptado quando executado; O método2 é colocado na lista negra do interceptador e não há necessidade de interceptar o método; Method3 não faz nada.

7. Conclusão

O conteúdo do interceptador está resumido aqui. O interceptador fornece funções muito poderosas, permitindo que os desenvolvedores controlem os resultados da saída em tempo de execução, aumentando a flexibilidade da programação. Além disso, não tente se lembrar de nenhuma coisa teórica. Você deve analisá -los racionalmente, praticar mais e fazer alguns exemplos para ter uma compreensão mais profunda dos resultados da análise.

PS: Descrição funcional do interceptador fornecido pelo Struts2 (XWork)