Streben 2 - Abfangjäger

Interceptors sind konzeptionell identisch mit Servlet-Filtern oder der JDKs-Proxy-Klasse. Interceptors ermöglichen die Implementierung von Crosscutting-Funktionen, die sowohl von der Aktion als auch vom Framework getrennt sind. Mit Interceptors können Sie Folgendes erreichen:

Bereitstellen der Vorverarbeitungslogik, bevor die Aktion aufgerufen wird.
Bereitstellen der Nachbearbeitungslogik nach dem Aufruf der Aktion.
Ausnahmen abfangen, damit eine alternative Verarbeitung durchgeführt werden kann.

Viele der Funktionen in der Struts2 Framework werden mit Interceptors implementiert;

Examples Dazu gehören Ausnahmebehandlung, Hochladen von Dateien, Lebenszyklus-Rückrufe usw. Da Struts2 einen Großteil seiner Funktionalität auf Interceptors hervorhebt, ist es unwahrscheinlich, dass pro Aktion 7 oder 8 Interceptors zugewiesen werden.

Struts2 Framework Interceptors

Das Struts 2-Framework bietet eine gute Liste von sofort einsatzbereiten Interceptors, die vorkonfiguriert und einsatzbereit sind. Einige der wichtigen Abfangjäger sind unten aufgeführt -

Sr.Nr.	Abfangjäger & Beschreibung
1	alias Ermöglicht Parametern, unterschiedliche Namensaliasnamen für Anforderungen zu verwenden.
2	checkbox Hilft bei der Verwaltung von Kontrollkästchen, indem für nicht aktivierte Kontrollkästchen der Parameterwert false hinzugefügt wird.
3	conversionError Platziert Fehlerinformationen aus der Konvertierung von Zeichenfolgen in Parametertypen in die Feldfehler der Aktion.
4	createSession Erstellt automatisch eine HTTP-Sitzung, falls noch keine vorhanden ist.
5	debugging Bietet dem Entwickler verschiedene Debugging-Bildschirme.
6	execAndWait Sendet den Benutzer an eine zwischengeschaltete Warteseite, während die Aktion im Hintergrund ausgeführt wird.
7	exception Ordnet Ausnahmen, die von einer Aktion ausgelöst werden, einem Ergebnis zu und ermöglicht so die automatische Ausnahmebehandlung über die Umleitung.
8	fileUpload Erleichtert das Hochladen von Dateien.
9	i18n Verfolgt das ausgewählte Gebietsschema während der Sitzung eines Benutzers.
10	logger Bietet eine einfache Protokollierung durch Ausgabe des Namens der ausgeführten Aktion.
11	params Legt die Anforderungsparameter für die Aktion fest.
12	prepare Dies wird normalerweise für Vorverarbeitungsarbeiten verwendet, z. B. zum Einrichten von Datenbankverbindungen.
13	profile Ermöglicht die Protokollierung einfacher Profilinformationen für Aktionen.
14	scope Speichert und ruft den Status der Aktion im Sitzungs- oder Anwendungsbereich ab.
15	ServletConfig Bietet der Aktion Zugriff auf verschiedene servletbasierte Informationen.
16	timer Bietet einfache Profilinformationen in Form der Ausführungsdauer der Aktion.
17	token Überprüft die Aktion auf ein gültiges Token, um eine doppelte Formularübermittlung zu verhindern.
18	validation Bietet Validierungsunterstützung für Aktionen

Weitere Informationen zu den oben genannten Abfangjägern finden Sie in der Dokumentation zu Struts 2. Aber ich werde Ihnen zeigen, wie Sie einen Interceptor im Allgemeinen in Ihrer Struts-Anwendung verwenden.

Wie benutzt man Interceptors?

Lassen Sie uns sehen, wie Sie einen bereits vorhandenen Interceptor für unser "Hello World" -Programm verwenden. Wir werden die verwendentimerInterceptor, dessen Zweck es ist zu messen, wie lange es gedauert hat, eine Aktionsmethode auszuführen. Zur gleichen Zeit benutze ichparamsInterceptor, dessen Zweck darin besteht, die Anforderungsparameter an die Aktion zu senden. Sie können Ihr Beispiel ausprobieren, ohne diesen Interceptor zu verwenden, und Sie werden das findenname Die Eigenschaft wird nicht festgelegt, da der Parameter die Aktion nicht erreichen kann.

Wir behalten die Dateien HelloWorldAction.java, web.xml, HelloWorld.jsp und index.jsp bei, wie sie erstellt wurden Examples Kapitel, aber lassen Sie uns das ändern struts.xml Datei, um einen Interceptor wie folgt hinzuzufügen -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <constant name = "struts.devMode" value = "true" />
   
   <package name = "helloworld" extends = "struts-default">
      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction"
         method = "execute">
         <interceptor-ref name = "params"/>
         <interceptor-ref name = "timer" />
         <result name = "success">/HelloWorld.jsp</result>
      </action>
   </package>
</struts>

Klicken Sie mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WAR Fileum eine War-Datei zu erstellen. Stellen Sie diese WAR dann im Webanwendungsverzeichnis von Tomcat bereit. Starten Sie abschließend den Tomcat-Server und versuchen Sie, auf die URL zuzugreifenhttp://localhost:8080/HelloWorldStruts2/index.jsp. Daraufhin wird der folgende Bildschirm angezeigt:

Geben Sie nun ein beliebiges Wort in das angegebene Textfeld ein und klicken Sie auf die Schaltfläche "Hallo sagen", um die definierte Aktion auszuführen. Wenn Sie nun das generierte Protokoll überprüfen, finden Sie den folgenden Text:

INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM 
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.

Hier wird unter dem Strich wegen generiert timer Interceptor, der mitteilt, dass die Ausführung der Aktion insgesamt 109 ms gedauert hat.

Erstellen Sie benutzerdefinierte Interceptors

Die Verwendung benutzerdefinierter Interceptors in Ihrer Anwendung ist eine elegante Möglichkeit, um übergreifende Anwendungsfunktionen bereitzustellen. Das Erstellen eines benutzerdefinierten Abfangjägers ist einfach. Die Schnittstelle, die erweitert werden muss, ist die folgendeInterceptor Schnittstelle -

public interface Interceptor extends Serializable {
   void destroy();
   void init();
   String intercept(ActionInvocation invocation)
   throws Exception;
}

Wie die Namen andeuten, bietet die init () -Methode eine Möglichkeit, den Interceptor zu initialisieren, und die destroy () -Methode bietet eine Möglichkeit zur Interceptor-Bereinigung. Im Gegensatz zu Aktionen werden Interceptors über Anforderungen hinweg wiederverwendet und müssen threadsicher sein, insbesondere die intercept () -Methode.

Das ActionInvocationObjekt bietet Zugriff auf die Laufzeitumgebung. Es ermöglicht den Zugriff auf die Aktion selbst und Methoden, um die Aktion aufzurufen und festzustellen, ob die Aktion bereits aufgerufen wurde.

Wenn Sie keinen Initialisierungs- oder Bereinigungscode benötigen, wird der AbstractInterceptorKlasse kann erweitert werden. Dies bietet eine standardmäßige Nooperation-Implementierung der Methoden init () und destroy ().

Erstellen Sie eine Interceptor-Klasse

Lassen Sie uns die folgende MyInterceptor.java in erstellen Java Resources > src Ordner -

package com.tutorialspoint.struts2;

import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class MyInterceptor extends AbstractInterceptor {

   public String intercept(ActionInvocation invocation)throws Exception {

      /* let us do some pre-processing */
      String output = "Pre-Processing"; 
      System.out.println(output);

      /* let us call action or next interceptor */
      String result = invocation.invoke();

      /* let us do some post-processing */
      output = "Post-Processing"; 
      System.out.println(output);

      return result;
   }
}

Wie Sie bemerken, wird die eigentliche Aktion mit dem Interceptor von ausgeführt invocation.invoke()Anruf. So können Sie je nach Ihren Anforderungen eine Vorverarbeitung und eine Nachbearbeitung durchführen.

Das Framework selbst startet den Prozess, indem es den ersten Aufruf des actionInvocation-Objekts invoke () ausführt. Jedes Malinvoke()wird aufgerufen, ActionInvocation konsultiert seinen Status und führt den nächsten Interceptor aus. Wenn alle konfigurierten Interceptors aufgerufen wurden, bewirkt die invoke () -Methode, dass die Aktion selbst ausgeführt wird.

Das folgende Diagramm zeigt dasselbe Konzept durch einen Anforderungsfluss -

Aktionsklasse erstellen

Lassen Sie uns eine Java-Datei HelloWorldAction.java unter erstellen Java Resources > src mit einem Paketnamen com.tutorialspoint.struts2 mit den unten angegebenen Inhalten.

package com.tutorialspoint.struts2;

import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport {
   private String name;

   public String execute() throws Exception {
      System.out.println("Inside action....");
      return "success";
   }  

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }
}

Dies ist dieselbe Klasse, die wir in früheren Beispielen gesehen haben. Wir haben Standard-Getter- und Setter-Methoden für die Eigenschaft "name" und eine Ausführungsmethode, die die Zeichenfolge "success" zurückgibt.

Erstellen Sie eine Ansicht

Lassen Sie uns die folgende JSP-Datei erstellen HelloWorld.jsp im WebContent-Ordner in Ihrem Eclipse-Projekt.

<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      Hello World, <s:property value = "name"/>
   </body>
</html>

Hauptseite erstellen

Wir müssen auch schaffen index.jspim WebContent-Ordner. Diese Datei dient als anfängliche Aktions-URL, über die ein Benutzer das Struts 2-Framework anweisen kann, eine definierte Methode der HelloWorldAction-Klasse aufzurufen und die Ansicht HelloWorld.jsp zu rendern.

<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
   pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
   <head>
      <title>Hello World</title>
   </head>
   
   <body>
      <h1>Hello World From Struts2</h1>
      <form action = "hello">
         <label for = "name">Please enter your name</label><br/>
         <input type = "text" name = "name"/>
         <input type = "submit" value = "Say Hello"/>
      </form>
   </body>
</html>

Das hello Die in der obigen Ansichtsdatei definierte Aktion wird der HelloWorldAction-Klasse und ihrer Ausführungsmethode mithilfe der Datei struts.xml zugeordnet.

Konfigurationsdateien

Jetzt müssen wir unseren Interceptor registrieren und ihn dann so aufrufen, wie wir ihn im vorherigen Beispiel als Standard-Interceptor bezeichnet hatten. Um einen neu definierten Interceptor zu registrieren, werden die Tags <interceptors> ... </ interceptors> direkt unter den <package> -Tag-Ins platziertstruts.xmlDatei. Sie können diesen Schritt für einen Standardabfangjäger wie in unserem vorherigen Beispiel überspringen. Aber hier registrieren wir uns und verwenden es wie folgt -

<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
   <constant name = "struts.devMode" value = "true" />
   <package name = "helloworld" extends = "struts-default">

      <interceptors>
         <interceptor name = "myinterceptor"
            class = "com.tutorialspoint.struts2.MyInterceptor" />
      </interceptors>

      <action name = "hello" 
         class = "com.tutorialspoint.struts2.HelloWorldAction" 
         method = "execute">
         <interceptor-ref name = "params"/>
         <interceptor-ref name = "myinterceptor" />
         <result name = "success">/HelloWorld.jsp</result>
      </action>

   </package>
</struts>

Es ist zu beachten, dass Sie mehr als einen Abfangjäger im Inneren registrieren können <package> Tag und gleichzeitig können Sie mehr als einen Interceptor innerhalb der anrufen <action>Etikett. Sie können denselben Interceptor mit den verschiedenen Aktionen aufrufen.

Die Datei web.xml muss wie folgt im Ordner WEB-INF unter WebContent erstellt werden:

<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns = "http://java.sun.com/xml/ns/javaee" 
   xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee 
   http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id = "WebApp_ID" version = "3.0">
   
   <display-name>Struts 2</display-name>
   
   <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <filter>
      <filter-name>struts2</filter-name>
      <filter-class>
         org.apache.struts2.dispatcher.FilterDispatcher
      </filter-class>
   </filter>

   <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
   </filter-mapping>
</web-app>

Pre-Processing
Inside action....
Post-Processing

Mehrere Abfangjäger stapeln

Wie Sie sich vorstellen können, wäre es schnell äußerst unüberschaubar, für jede Aktion mehrere Interceptors konfigurieren zu müssen. Aus diesem Grund werden Interceptors mit Interceptor-Stacks verwaltet. Hier ist ein Beispiel direkt aus der Datei strutsdefault.xml -

<interceptor-stack name = "basicStack">
   <interceptor-ref name = "exception"/>
   <interceptor-ref name = "servlet-config"/>
   <interceptor-ref name = "prepare"/>
   <interceptor-ref name = "checkbox"/>
   <interceptor-ref name = "params"/>
   <interceptor-ref name = "conversionError"/>
</interceptor-stack>

Der oben genannte Einsatz heißt basicStackund kann in Ihrer Konfiguration wie unten gezeigt verwendet werden. Dieser Konfigurationsknoten befindet sich unter dem Knoten <package ... />. Jedes <interceptor-ref ... /> -Tag verweist entweder auf einen Interceptor- oder einen Interceptor-Stapel, der vor dem aktuellen Interceptor-Stapel konfiguriert wurde. Es ist daher sehr wichtig sicherzustellen, dass der Name bei der Konfiguration der anfänglichen Interceptors und Interceptor-Stacks für alle Interceptor- und Interceptor-Stack-Konfigurationen eindeutig ist.

Wir haben bereits gesehen, wie Interceptor auf die Aktion angewendet wird. Das Anwenden von Interceptor-Stacks ist nicht anders. Tatsächlich verwenden wir genau das gleiche Tag -

<action name = "hello" class = "com.tutorialspoint.struts2.MyAction">
   <interceptor-ref name = "basicStack"/>
   <result>view.jsp</result>
</action

Die obige Registrierung von "basicStack" registriert den vollständigen Einsatz aller sechs Abfangjäger mit Hallo-Aktion. Dies ist zu beachten, dass Interceptors in der Reihenfolge ausgeführt werden, in der sie konfiguriert wurden. In dem obigen Fall wird beispielsweise zuerst eine Ausnahme ausgeführt, dann eine Servlet-Konfiguration usw.