Struts Tutorial für Anfänger

Willkommen zum Struts Tutorial für Anfänger. Struts ist eines der ältesten Frameworks zum Erstellen von Java Webanwendungen.

Struts Tutorial

Struts war die erste Implementierung des MVC-Designmusters und hat sich zusammen mit den neuesten Verbesserungen in Java und Java EE-Technologien stark weiterentwickelt. Dieser Struts Tutorial-Artikel soll grundlegende Details von Struts 2 liefern und wie wir unsere erste „Hello World“-Anwendung mit Struts 2 erstellen können.

Struts 2

Apache Struts 2 ist ein offenes, branchenübliches, flexibles und erweiterbares Framework zum Erstellen von Java EE-Webanwendungen. Struts 2 basiert auf dem OpenSymphony WebWork Framework. Struts 2 ist sehr flexibel in Bezug auf Entwicklung und Konfigurationen und wir werden sehen, wie einfach es ist, eine Webanwendung mit dem Struts 2 Framework zu entwickeln.

Struts 2 Architekturdiagramm

Das untenstehende Diagramm zeigt die verschiedenen Komponenten von Struts 2 in einer Webanwendung.

Struts 2 Interceptors

Struts Interceptors sind wie Servlet-Filter, die vor und nach der Verarbeitung der Anfrage ausgeführt werden. Sie werden verwendet, um gemeinsame Operationen für verschiedene Aktionen durchzuführen. Zum Beispiel Logging, Session-Validierung, Hinzufügen gemeinsamer Header zur Antwort usw.

Struts 2 ValueStack und OGNL

ValueStack ist der Speicherbereich, in dem die Anwendungsdaten von Struts 2 zur Verarbeitung einer Clientanfrage gespeichert werden. Die Daten werden in ActionContext-Objekten gespeichert, die ThreadLocal verwenden, um wertespezifisch für den jeweiligen Anfragethread zu sein. Object-Graph Navigation Language (OGNL) ist eine leistungsstarke Ausdruckssprache, die verwendet wird, um Daten zu manipulieren, die auf dem ValueStack gespeichert sind. Wie im Architekturdiagramm zu sehen ist, können sowohl Interceptors als auch Ergebnisseiten auf Daten zugreifen, die auf dem ValueStack mit OGNL gespeichert sind.

Struts 2 Action

Struts 2 Action-Komponenten bearbeiten die Clientanfragen. Struts 2 bietet verschiedene Möglichkeiten, Action-Klassen zu erstellen.

1. Durch Implementierung der com.opensymphony.xwork2.Action-Schnittstelle.
2. Durch Erweiterung der com.opensymphony.xwork2.ActionSupport-Klasse. Normalerweise wird sie verwendet, um leere Aktionsklassen zu erstellen, um Anfragen an eine andere Ressource weiterzuleiten.
3. Annotieren einer Klasse mit der @Action- oder @Actions-Annotation.
4. Einhalten der Namenskonvention für Klassen, der Name sollte mit Action enden und eine execute()-Methode haben.

Struts 2 Ergebnis

Ergebniskomponenten sind normalerweise JSP- oder HTML-Seiten, um eine Ansicht für die Clientantwort zu erstellen. Struts 2 bietet eigene Tags, die wir in JSP-Seiten verwenden können, um Antworten zu erstellen. Struts-Tags sind ein großartiges Beispiel für benutzerdefinierte JSP-Tags.

Struts 2 deklarative Architektur und Verdrahtung

Struts 2 bietet zwei Möglichkeiten, unsere Anwendung für Aktionsklassen und Ergebnisseiten zu konfigurieren.

1. Struts XML-Datei: Wir haben eine struts.xml-Datei im Verzeichnis WEB-INF/classes, wo wir unsere Anwendungsaktionsklassen und Ergebnisseiten konfigurieren können.
2. Annotation: Wir können Java-Annotationen verwenden, um Metadateninformationen über eine Klasse bereitzustellen. Das Struts 2-Konventions-Plugin kann verwendet werden, um Java-Klassen mit @Action- und @Result-Annotationen zu annotieren, um Aktionsklassen und zugehörige Ergebnisseiten zu konfigurieren.

Egal welche Methode wir verwenden, um unsere Anwendung zu konfigurieren, das Endergebnis wird immer gleich sein.

Struts Tutorial – Hello World XML-basierte Anwendung

Sehen wir uns an, wie wir unsere erste Struts 2 Hello World-Anwendung erstellen können. Zunächst benötigen wir die Struts 2 JAR-Dateien, der einfachste Weg ist, sie von der offiziellen Struts 2 Download-Seite herunterzuladen. Aber wenn Sie die Bibliotheken im heruntergeladenen Archiv überprüfen, werden Sie viele JAR-Dateien sehen, die wir für unsere einfache Anwendung nicht benötigen. Daher werde ich ein Maven-Projekt erstellen und nur die struts-core-Abhängigkeit hinzufügen, alle anderen transitiven Abhängigkeits-JARs werden automatisch heruntergeladen und der Anwendung hinzugefügt. Unsere endgültige Projektstruktur wird wie im untenstehenden Bild aussehen.

Erstellen Sie ein neues Dynamisches Webprojekt Struts2XMLHelloWorld in Eclipse und konvertieren Sie es dann wie im untenstehenden Bild in ein Maven-Projekt.

Sie werden feststellen, dass die pom.xml-Datei im Stammverzeichnis des Projekts hinzugefügt wird. Unsere Projekteinrichtung in Eclipse ist bereit, sehen wir uns die verschiedenen Komponenten der Reihe nach an.

pom.xml

Öffnen Sie die pom.xml Datei und fügen Sie die Struts-Core-Abhängigkeit hinzu. Die endgültige pom.xml sieht wie folgt aus.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>Struts2XMLHelloWorld</groupId>
    <artifactId>Struts2XMLHelloWorld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.15.1</version>
        </dependency>
    </dependencies>
    <build>
        <sourceDirectory>src</sourceDirectory>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <warSourceDirectory>WebContent</warSourceDirectory>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>
        <finalName>${project.artifactId}</finalName>
    </build>
</project>

Beachten Sie, dass ich das Element finalName überschrieben habe, um zu verhindern, dass die Versionsnummer der WAR-Datei beim Maven-Build hinzugefügt wird. Andere Teile wurden von Eclipse selbst hinzugefügt, die einzige Abhängigkeit, die wir benötigen, ist struts2-core, deren aktuelle Version 2.3.15.1 ist (Stand 10-Sep-2013). Führen Sie einfach einen Maven-Build der Anwendung durch und Sie werden sehen, dass viele Jars dem Anwendungslib-Verzeichnis hinzugefügt und im Maven-Abhängigkeitenbereich des Projekts wie im folgenden Bild angezeigt werden.

Struts 2 web.xml Konfiguration

Wir müssen den Filter `org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter` zur Webanwendung hinzufügen und das URL-Muster angeben, bei dem wir möchten, dass Struts die Clientanfrage bearbeitet. Unsere `web.xml` sieht wie folgt aus;

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xmlns="https://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name>Struts2XMLHelloWorld</display-name>
    
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>

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

Für Struts 2 Versionen unter 2.1.3 war die Filter-Klasse org.apache.struts2.dispatcher.FilterDispatcher.

Struts Tutorial – Ergebnisseiten

Wir haben drei JSP-Seiten, die von der Anwendung verwendet werden, wir verwenden Struts 2 Tags, um unsere JSP-Seiten zu erstellen. `login.jsp`

<%@ page language="java" contentType="text/html; charset=US-ASCII"
    pageEncoding="US-ASCII"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<%-- Using Struts2 Tags in JSP --%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Login Page</title>
</head>
<body>
<h3>Willkommen Benutzer, bitte melden Sie sich unten an</h3>
<s:form action="login">
    <s:textfield name="name" label="Benutzername"></s:textfield>
    <s:textfield name="pwd" label="Passwort" type="password"></s:textfield>
    <s:submit value="Login"></s:submit>
</s:form>
</body>
</html>

Beachten Sie, dass die Formularfeldnamen name und pwd sind, wir werden sehen, wie sie in Aktionsklassen verwendet werden. welcome.jsp

<%@ page language="java" contentType="text/html; charset=US-ASCII"
    pageEncoding="US-ASCII"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Willkommensseite</title>
</head>
<body>
<h3>Willkommen <s:property value="name"></s:property></h3>
</body>
</html>

Beachten Sie das Struts-Tag s:property, das wir verwenden können, um Anfrageattribute zu erhalten, der Name ist derselbe wie in login.jsp. error.jsp

<%@ page language="java" contentType="text/html; charset=US-ASCII"
    pageEncoding="US-ASCII"%>
<%@ taglib uri="/struts-tags" prefix="s"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Fehlerseite</title>
</head>
<body>
<h4>Benutzername oder Passwort ist falsch</h4>
<s:include value="login.jsp"></s:include>
</body>
</html>

Dies ist eine einfache JSP-Seite, auf der wir eine Fehlermeldung hinzufügen und die Login-Seite in die Antwort einbeziehen.

Struts Tutorial – Aktionsklassen

Unsere Anwendung hat nur eine Aktionsklasse, in der wir die Struts 2 Action-Schnittstelle implementieren. `LoginAction.java`

Beachten Sie, dass die Aktionsklasse auch ein Java-Bean mit denselben Variablen wie login.jsp und deren Getter- und Setter-Methoden ist. Struts wird sich um die Zuordnung der Anfrageparameter zu den Variablen der Aktionsklasse kümmern.

Struts Tutorial – Konfigurationsdatei

Da wir eine auf XML basierende Konfiguration verwenden, um unsere Anwendung zu verdrahten, müssen wir eine Struts-Konfigurationsdatei erstellen, die als `struts.xml` benannt sein sollte und sich im Verzeichnis `WEB-INF/classes` befindet. `struts.xml`

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "https://struts.apache.org/dtds/struts-2.3.dtd">
<struts>

<package name="user" namespace="/User" extends="struts-default">
    <action name="home">
        <result>/login.jsp</result>
    </action>
    <action name="login" class="com.journaldev.struts2.action.LoginAction">
    <result name="SUCCESS">/welcome.jsp</result>
    <result name="ERROR">/error.jsp</result>
    </action>

</package>

</struts>

Für die Aktion „home“ gibt es keine Aktionsklasse und nur ein Ergebnis, daher wird die Anfrage an die Seite login.jsp weitergeleitet. Für die Aktion „login“ ist LoginAction die Aktionsklasse und wenn die execute-Methode „SUCCESS“ zurückgibt, wird die Anfrage von welcome.jsp verarbeitet und bei „ERROR“ wird sie an die Seite error.jsp weitergeleitet. Der namespace=“/User“ ist wichtig und wird in der URL verwendet, um auf die Aktionsklassen zuzugreifen, er wird bereitgestellt, um verschiedene Module zu erstellen. So können wir auf unsere Anwendung mit der URL https://localhost:8080/Struts2XMLHelloWorld/User/home.action zugreifen. Beachten Sie, dass die URL mit .action endet, das ist die Standardendung für Struts 2 Aktionen, wie es .do für Struts 1 ist.

Struts Tutorial – Struts 2 Hello World Test

Wenn wir unsere Anwendung ausführen, erhalten wir die folgenden Antwortseiten.