Streben 2 - Kurzanleitung
Model View Controller oder MVCwie es im Volksmund genannt wird, ist ein Software-Design-Muster für die Entwicklung von Webanwendungen. Ein Model View Controller-Muster besteht aus den folgenden drei Teilen:
Model - Die niedrigste Ebene des Musters, die für die Pflege der Daten verantwortlich ist.
View - Dies ist dafür verantwortlich, dem Benutzer alle oder einen Teil der Daten anzuzeigen.
Controller - Software-Code, der die Interaktionen zwischen Modell und Ansicht steuert.
MVC ist beliebt, da es die Anwendungslogik von der Benutzeroberflächenschicht isoliert und die Trennung von Bedenken unterstützt. Hier empfängt der Controller alle Anforderungen für die Anwendung und arbeitet dann mit dem Modell zusammen, um alle von der Ansicht benötigten Daten vorzubereiten. Die Ansicht verwendet dann die vom Controller vorbereiteten Daten, um eine endgültige vorzeigbare Antwort zu generieren. Die MVC-Abstraktion kann wie folgt grafisch dargestellt werden.
Das Model
Das Modell ist für die Verwaltung der Daten der Anwendung verantwortlich. Es reagiert auf die Anforderung aus der Ansicht und auf Anweisungen des Controllers, sich selbst zu aktualisieren.
Die Aussicht
Dies bedeutet die Darstellung von Daten in einem bestimmten Format, ausgelöst durch die Entscheidung eines Controllers, die Daten zu präsentieren. Sie sind skriptbasierte Template-Systeme wie JSP, ASP, PHP und sehr einfach in die AJAX-Technologie zu integrieren.
Der Controller
Die Steuerung ist dafür verantwortlich, auf Benutzereingaben zu reagieren und Interaktionen mit den Datenmodellobjekten durchzuführen. Der Controller empfängt die Eingabe, validiert die Eingabe und führt dann den Geschäftsvorgang aus, der den Status des Datenmodells ändert.
Struts2ist ein MVC-basiertes Framework. Lassen Sie uns in den kommenden Kapiteln sehen, wie wir die MVC-Methodik in Struts2 verwenden können.
Struts2ist ein beliebtes und ausgereiftes Webanwendungsframework, das auf dem MVC-Entwurfsmuster basiert. Struts2 ist nicht nur eine neue Version von Struts 1, sondern eine vollständige Neufassung der Struts-Architektur.
Das Webwork-Framework begann ursprünglich mit dem Struts-Framework als Basis. Ziel war es, ein erweitertes und verbessertes Framework anzubieten, das auf Struts basiert, um den Entwicklern die Webentwicklung zu erleichtern.
Nach einer Weile schlossen sich das Webwork-Framework und die Struts-Community zusammen, um das berühmte Struts2-Framework zu erstellen.
Struts 2 Framework-Funktionen
Hier sind einige der großartigen Funktionen, die Sie dazu zwingen können, Struts2 in Betracht zu ziehen:
POJO Forms and POJO Actions- Struts2 hat die Aktionsformulare entfernt, die ein wesentlicher Bestandteil des Struts-Frameworks waren. Mit Struts2 können Sie jedes POJO verwenden, um die Formulareingabe zu erhalten. Ebenso können Sie jetzt jedes POJO als Aktionsklasse anzeigen.
Tag Support - Struts2 hat die Formular-Tags und die neuen Tags verbessert, mit denen die Entwickler weniger Code schreiben können.
AJAX Support - Struts2 hat die Übernahme durch Web2.0-Technologien erkannt und die AJAX-Unterstützung durch das Erstellen von AJAX-Tags in das Produkt integriert. Diese Funktion ist den Standard-Struts2-Tags sehr ähnlich.
Easy Integration - Die Integration mit anderen Frameworks wie Spring, Tiles und SiteMesh ist jetzt mit einer Vielzahl von Integrationen, die mit Struts2 verfügbar sind, einfacher.
Template Support - Unterstützung für das Generieren von Ansichten mithilfe von Vorlagen.
Plugin Support- Das Kernverhalten von Struts2 kann durch die Verwendung von Plugins verbessert und erweitert werden. Für Struts2 stehen eine Reihe von Plugins zur Verfügung.
Profiling- Struts2 bietet eine integrierte Profilerstellung zum Debuggen und Profilieren der Anwendung. Darüber hinaus bietet Struts ein integriertes Debugging mit Hilfe integrierter Debugging-Tools.
Easy to Modify Tags- Tag-Markups in Struts2 können mithilfe von Freemarker-Vorlagen optimiert werden. Dies erfordert keine JSP- oder Java-Kenntnisse. Grundlegende HTML-, XML- und CSS-Kenntnisse reichen aus, um die Tags zu ändern.
Promote Less configuration- Struts2 fördert weniger Konfiguration mit Hilfe von Standardwerten für verschiedene Einstellungen. Sie müssen nichts konfigurieren, es sei denn, es weicht von den von Struts2 festgelegten Standardeinstellungen ab.
View Technologies - Struts2 bietet eine hervorragende Unterstützung für mehrere Ansichtsoptionen (JSP, Freemarker, Velocity und XSLT).
Oben sind die Top 10 Funktionen von aufgeführt Struts 2 Das macht es zu einem Enterprise-fähigen Framework.
Streben 2 Nachteile
Obwohl Struts 2 eine Liste großartiger Funktionen enthält, gibt es einige Einschränkungen der aktuellen Version - Struts 2, die weiter verbessert werden müssen. Aufgeführt sind einige der wichtigsten Punkte -
Bigger Learning Curve - Um MVC mit Struts verwenden zu können, müssen Sie mit der Standard-JSP, den Servlet-APIs und einem großen und ausgeklügelten Framework vertraut sein.
Poor Documentation - Im Vergleich zu den Standard-Servlet- und JSP-APIs verfügt Struts über weniger Online-Ressourcen, und viele Erstbenutzer finden die Online-Apache-Dokumentation verwirrend und schlecht organisiert.
Less Transparent - Bei Struts-Anwendungen ist hinter den Kulissen viel mehr los als bei normalen Java-basierten Webanwendungen, was das Verständnis des Frameworks erschwert.
Abschließend sei angemerkt, dass ein gutes Framework ein allgemeines Verhalten bieten sollte, das von vielen verschiedenen Arten von Anwendungen verwendet werden kann.
Struts 2 ist eines der besten Web-Frameworks und wird häufig für die Entwicklung von Rich Internet Applications (RIA) verwendet.
Unsere erste Aufgabe ist es, eine minimale Struts 2-Anwendung zum Laufen zu bringen. In diesem Kapitel erfahren Sie, wie Sie eine Entwicklungsumgebung für den Beginn Ihrer Arbeit mit Struts 2 vorbereiten.
Ich gehe davon aus, dass Sie bereits JDK (5+), Tomcat und Eclipse auf Ihrem Computer installiert haben. Wenn Sie diese Komponenten nicht installiert haben, befolgen Sie die angegebenen Schritte auf der Überholspur -
Schritt 1 - Java Development Kit (JDK) einrichten
Sie können die neueste Version des SDK von der Java-Site von Oracle herunterladen - Java SE Downloads . Anweisungen zum Installieren von JDK finden Sie in heruntergeladenen Dateien. Befolgen Sie die Anweisungen zum Installieren und Konfigurieren des Setups. Stellen Sie abschließend die Umgebungsvariablen PATH und JAVA_HOME so ein, dass sie auf das Verzeichnis verweisen, das Java und Javac enthält, normalerweise java_install_dir / bin bzw. java_install_dir.
Wenn Sie Windows ausführen und das SDK in C: \ jdk1.5.0_20 installiert haben, sollten Sie die folgende Zeile in Ihre Datei C: \ autoexec.bat eingeben.
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20Alternativ unter Windows NT / 2000 / XP -
Sie können mit der rechten Maustaste auf Arbeitsplatz klicken, Eigenschaften auswählen, dann Erweitert und dann Umgebungsvariablen. Dann würden Sie den PATH-Wert aktualisieren und die OK-Taste drücken.
Wenn unter Unix (Solaris, Linux usw.) das SDK in /usr/local/jdk1.5.0_20 installiert ist und Sie die C-Shell verwenden, fügen Sie Folgendes in Ihre .cshrc-Datei ein.
Wenn unter Unix (Solaris, Linux usw.) das SDK in /usr/local/jdk1.5.0_20 installiert ist und Sie die C-Shell verwenden, fügen Sie Folgendes in Ihre .cshrc-Datei ein.
setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20Wenn Sie alternativ eine integrierte Entwicklungsumgebung (IDE) wie Borland JBuilder, Eclipse, IntelliJ IDEA oder Sun ONE Studio verwenden, kompilieren Sie ein einfaches Programm und führen Sie es aus, um zu bestätigen, dass die IDE weiß, wo Sie Java installiert haben gegebenes Dokument der IDE.
Schritt 2 - Apache Tomcat einrichten
Sie können die neueste Version von Tomcat von herunterladen https://tomcat.apache.org/. Nachdem Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort.
Zum Beispiel in C: \ apache-tomcat-6.0.33 unter Windows oder /usr/local/apachetomcat-6.0.33 unter Linux / Unix und erstellen Sie die Umgebungsvariable CATALINA_HOME, die auf diese Speicherorte verweist.
Sie können Tomcat starten, indem Sie die folgenden Befehle auf einem Windows-Computer ausführen, oder Sie doppelklicken einfach auf startup.bat
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batTomcat kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden:
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.shNach einem erfolgreichen Start sind die in Tomcat enthaltenen Standard-Webanwendungen unter verfügbar http://localhost:8080/. Wenn alles in Ordnung ist, sollte das folgende Ergebnis angezeigt werden:
Weitere Informationen zum Konfigurieren und Ausführen von Tomcat finden Sie in der hier enthaltenen Dokumentation sowie auf der Tomcat-Website: https://tomcat.apache.org/
Tomcat kann gestoppt werden, indem die folgenden Befehle auf einem Windows-Computer ausgeführt werden:
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownTomcat kann gestoppt werden, indem die folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) ausgeführt werden:
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shSchritt 3 - Eclipse (IDE) einrichten
Alle Beispiele in diesem Tutorial wurden mit der Eclipse-IDE geschrieben. Ich schlage vor, dass Sie die neueste Version von Eclipse auf Ihrem Computer installiert haben.
So installieren Sie Eclipse Laden Sie die neuesten Eclipse-Binärdateien von herunter https://www.eclipse.org/downloads/. Wenn Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort.
Zum Beispiel in C: \ eclipse unter Windows oder / usr / local / eclipse unter Linux / Unix und setzen Sie schließlich die Variable PATH entsprechend. Eclipse kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden, oder Sie können einfach auf eclipse.exe doppelklicken
%C:\eclipse\eclipse.exeEclipse kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden:
$/usr/local/eclipse/eclipseWenn nach einem erfolgreichen Start alles in Ordnung ist, sollte das folgende Ergebnis angezeigt werden:
Schritt 4 - Einrichten der Struts2-Bibliotheken
Wenn nun alles in Ordnung ist, können Sie mit dem Einrichten Ihres Struts2-Rahmenwerks fortfahren. Im Folgenden finden Sie die einfachen Schritte zum Herunterladen und Installieren von Struts2 auf Ihrem Computer.
Treffen Sie eine Auswahl, ob Sie Struts2 unter Windows oder Unix installieren möchten, und fahren Sie dann mit dem nächsten Schritt fort, um die ZIP-Datei für Windows und die ZZ-Datei für Unix herunterzuladen.
Laden Sie die neueste Version der Struts2-Binärdateien von herunter https://struts.apache.org/download.cgi.
Zum Zeitpunkt des Schreibens dieses Tutorials habe ich heruntergeladen struts-2.0.14-all.zip Wenn Sie die heruntergeladene Datei entpacken, erhalten Sie die Verzeichnisstruktur in C: \ struts-2.2.3 wie folgt.
Der zweite Schritt besteht darin, die Zip-Datei an einem beliebigen Ort zu extrahieren, den ich heruntergeladen und extrahiert habe struts-2.2.3-all.zip im c:\ Ordner auf meinem Windows 7-Computer, damit ich alle JAR-Dateien in habe C:\struts-2.2.3\lib. Stellen Sie sicher, dass Sie Ihre CLASSPATH-Variable richtig eingestellt haben, da sonst beim Ausführen Ihrer Anwendung Probleme auftreten.
Struts2 ist ein Pull-MVC-Framework (oder MVC2-Framework). Das Model-ViewController-Muster in Struts2 wird mit den folgenden fünf Kernkomponenten implementiert:
- Actions
- Interceptors
- Wertestapel / OGNL
- Ergebnisse / Ergebnistypen
- Technologien anzeigen
Struts 2 unterscheidet sich geringfügig von einem herkömmlichen MVC-Framework, bei dem die Aktion eher die Rolle des Modells als des Controllers übernimmt, obwohl es einige Überschneidungen gibt.
Das obige Diagramm zeigt die Model, View und CEin Controller für die Struts2-High-Level-Architektur. Die Steuerung ist mit a implementiertStruts2Dispatch-Servlet-Filter sowie Interceptors. Dieses Modell wird mit Aktionen implementiert. Die Ansicht ist eine Kombination aus Ergebnistypen und Ergebnissen. Der Wertestapel und OGNL bieten einen gemeinsamen Thread, der die Integration zwischen den anderen Komponenten verknüpft und ermöglicht.
Abgesehen von den oben genannten Komponenten gibt es viele Informationen, die sich auf die Konfiguration beziehen. Konfiguration für die Webanwendung sowie Konfiguration für Aktionen, Interceptors, Ergebnisse usw.
Dies ist die Architekturübersicht des Struts 2 MVC-Musters. Wir werden jede Komponente in den folgenden Kapiteln genauer durchgehen.
Lebenszyklus anfordern
Anhand des obigen Diagramms können Sie den Arbeitsablauf über den Anforderungslebenszyklus des Benutzers in verstehen Struts 2 wie folgt -
Der Benutzer sendet eine Anforderung an den Server, um eine Ressource (dh Seiten) anzufordern.
Der Filter Dispatcher überprüft die Anforderung und ermittelt dann die entsprechende Aktion.
Es gelten konfigurierte Interceptor-Funktionen wie Validierung, Datei-Upload usw.
Die ausgewählte Aktion wird basierend auf der angeforderten Operation ausgeführt.
Auch hier werden konfigurierte Interceptors angewendet, um bei Bedarf eine Nachbearbeitung durchzuführen.
Schließlich wird das Ergebnis von der Ansicht vorbereitet und gibt das Ergebnis an den Benutzer zurück.
Wie Sie bereits aus der Struts 2-Architektur gelernt haben, wird die Eingabe beim Klicken auf einen Hyperlink oder beim Senden eines HTML-Formulars in einer Struts 2-Webanwendung vom Controller gesammelt und an eine Java-Klasse namens Actions gesendet. Nachdem die Aktion ausgeführt wurde, wählt ein Ergebnis eine Ressource aus, um die Antwort zu rendern. Die Ressource ist im Allgemeinen eine JSP, kann aber auch eine PDF-Datei, eine Excel-Tabelle oder ein Java-Applet-Fenster sein.
Angenommen, Sie haben Ihre Entwicklungsumgebung bereits erstellt. Lassen Sie uns nun mit dem Bau unseres ersten fortfahrenHello World Struts2Projekt. Ziel dieses Projekts ist es, eine Webanwendung zu erstellen, die den Benutzernamen sammelt und "Hello World" gefolgt vom Benutzernamen anzeigt.
Wir müssten für jedes Struts 2-Projekt die folgenden vier Komponenten erstellen:
| Sr.Nr. | Komponenten & Beschreibung |
|---|---|
| 1 | Action Erstellen Sie eine Aktionsklasse, die die vollständige Geschäftslogik enthält, und steuern Sie die Interaktion zwischen dem Benutzer, dem Modell und der Ansicht. |
| 2 | Interceptors Erstellen Sie bei Bedarf Interceptors oder verwenden Sie vorhandene Interceptors. Dies ist Teil von Controller. |
| 3 | View Erstellen Sie JSPs, um mit dem Benutzer zu interagieren, Eingaben vorzunehmen und die endgültigen Nachrichten zu präsentieren. |
| 4 | Configuration Files Erstellen Sie Konfigurationsdateien, um die Aktion, Ansicht und Controller zu koppeln. Diese Dateien sind struts.xml, web.xml, struts.properties. |
Ich werde Eclipse IDE verwenden, damit alle erforderlichen Komponenten unter einem dynamischen Webprojekt erstellt werden. Beginnen wir nun mit der Erstellung eines dynamischen Webprojekts.
Erstellen Sie ein dynamisches Webprojekt
Starten Sie Ihre Eclipse und gehen Sie dann mit File > New > Dynamic Web Project und geben Sie den Projektnamen als ein HelloWorldStruts2 und stellen Sie den Rest der Optionen wie im folgenden Bildschirm angegeben ein -
Wählen Sie in den nächsten Bildschirmen alle Standardoptionen aus und überprüfen Sie sie schließlich Generate Web.xml deployment descriptorMöglichkeit. Dadurch wird in Eclipse ein dynamisches Webprojekt für Sie erstellt. Jetzt geh mitWindows > Show View > Project Explorer, und Sie werden Ihr Projektfenster wie folgt sehen -
Kopieren Sie nun die folgenden Dateien aus dem Ordner struts 2 lib C:\struts-2.2.3\lib zu unseren Projekten WEB-INF\libMappe. Dazu können Sie einfach alle folgenden Dateien in den Ordner WEB-INF \ lib ziehen und dort ablegen.
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Aktionsklasse erstellen
Die Aktionsklasse ist der Schlüssel zur Struts 2-Anwendung, und wir implementieren den größten Teil der Geschäftslogik in die Aktionsklasse. Erstellen wir also eine Java-Datei HelloWorldAction.java unterJava Resources > src mit einem Paketnamen com.tutorialspoint.struts2 mit den unten angegebenen Inhalten.
Die Action-Klasse reagiert auf eine Benutzeraktion, wenn der Benutzer auf eine URL klickt. Eine oder mehrere Methoden der Action-Klasse werden ausgeführt und ein String-Ergebnis zurückgegeben. Basierend auf dem Wert des Ergebnisses wird eine bestimmte JSP-Seite gerendert.
package com.tutorialspoint.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Dies ist eine sehr einfache Klasse mit einer Eigenschaft namens "Name". Wir haben Standard-Getter- und Setter-Methoden für die Eigenschaft "name" und eine Ausführungsmethode, die die Zeichenfolge "success" zurückgibt.
Das Struts 2-Framework erstellt ein Objekt des HelloWorldActionKlasse und rufen Sie die ausgeführte Methode als Antwort auf die Aktion eines Benutzers auf. Sie fügen Ihre Geschäftslogik in diese Methode ein, die schließlich die String-Konstante zurückgibt. Mit anderen Worten, für jede URL müssten Sie eine Aktionsklasse implementieren. Entweder können Sie diesen Klassennamen direkt als Aktionsnamen verwenden oder Sie können mithilfe der Datei struts.xml einem anderen Namen zuordnen, wie unten gezeigt.
Erstellen Sie eine Ansicht
Wir benötigen eine JSP, um die endgültige Nachricht zu präsentieren. Diese Seite wird vom Struts 2-Framework aufgerufen, wenn eine vordefinierte Aktion ausgeführt wird, und diese Zuordnung wird in der Datei struts.xml definiert. Lassen Sie uns also die folgende JSP-Datei erstellenHelloWorld.jspim WebContent-Ordner in Ihrem Eclipse-Projekt. Klicken Sie dazu im Projektexplorer mit der rechten Maustaste auf den Ordner WebContent und wählen SieNew >JSP File.
<%@ 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>Die taglib-Direktive teilt dem Servlet-Container mit, dass diese Seite das verwendet Struts 2 Tags und dass diesen Tags vorangestellt werden s.
Das s: property-Tag zeigt den Wert der Aktionsklasseneigenschaft "name>" an, der von der Methode zurückgegeben wird getName() der HelloWorldAction-Klasse.
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 helloDie in der obigen Ansichtsdatei definierte Aktion wird der HelloWorldAction-Klasse und ihrer Ausführungsmethode mithilfe der Datei struts.xml zugeordnet. Wenn ein Benutzer auf die Schaltfläche Senden klickt, führt das Struts 2-Framework die in der HelloWorldAction-Klasse definierte Ausführungsmethode aus. Basierend auf dem zurückgegebenen Wert der Methode wird eine entsprechende Ansicht ausgewählt und als Antwort gerendert.
Konfigurationsdateien
Wir benötigen eine Zuordnung, um die URL, die HelloWorldAction-Klasse (Modell) und die HelloWorld.jsp (die Ansicht) miteinander zu verknüpfen. Die Zuordnung teilt dem Struts 2-Framework mit, welche Klasse auf die Aktion des Benutzers (die URL) reagiert, welche Methode dieser Klasse ausgeführt wird und welche Ansicht basierend auf dem von dieser Methode zurückgegebenen String-Ergebnis gerendert werden soll.
Lassen Sie uns also eine Datei namens erstellen struts.xml. Da Struts 2 erfordert, dass struts.xml im Klassenordner vorhanden ist. Erstellen Sie daher die Datei struts.xml im Ordner WebContent / WEB-INF / classes. Eclipse erstellt standardmäßig nicht den Ordner "Klassen", daher müssen Sie dies selbst tun. Klicken Sie dazu im Projektexplorer mit der rechten Maustaste auf den Ordner WEB-INF und wählen SieNew > Folder. Ihre struts.xml sollte aussehen wie -
<?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">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Einige Wörter, die in Bezug auf die obige Konfigurationsdatei verstanden werden müssen. Hier setzen wir die Konstantestruts.devMode zu true, weil wir in einer Entwicklungsumgebung arbeiten und einige nützliche Protokollmeldungen sehen müssen. Dann definieren wir ein Paket namenshelloworld.
Das Erstellen eines Pakets ist nützlich, wenn Sie Ihre Aktionen zusammenfassen möchten. In unserem Beispiel haben wir unsere Aktion als "Hallo" bezeichnet, was der URL entspricht/hello.action und wird von der gesichertHelloWorldAction.class. Dasexecute Methode von HelloWorldAction.class ist die Methode, die ausgeführt wird, wenn die URL /hello.actionwird aufgerufen. Wenn das Ergebnis der Methode execute "success" zurückgibt, führen wir den Benutzer zuHelloWorld.jsp.
Der nächste Schritt ist das Erstellen eines web.xmlDatei, die ein Einstiegspunkt für jede Anforderung an Struts 2 ist. Der Einstiegspunkt der Struts2-Anwendung ist ein Filter, der im Deployment Descriptor (web.xml) definiert ist. Daher definieren wir einen Eintrag der Klasse org.apache.struts2.dispatcher.FilterDispatcher in web.xml. Die Datei web.xml muss im Ordner WEB-INF unter WebContent erstellt werden. Eclipse hat bereits beim Erstellen des Projekts eine Skelett-Datei web.xml für Sie erstellt. Ändern wir es also einfach wie folgt:
<?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>Wir haben index.jsp als unsere Begrüßungsdatei angegeben. Dann haben wir den Struts2-Filter so konfiguriert, dass er auf allen URLs ausgeführt wird (dh auf jeder URL, die dem Muster / * entspricht).
So aktivieren Sie das detaillierte Protokoll
Sie können die vollständige Protokollierungsfunktion während der Arbeit mit Struts 2 durch Erstellen aktivieren logging.properties Datei unter WEB-INF/classesMappe. Behalten Sie die folgenden zwei Zeilen in Ihrer Eigenschaftendatei bei -
org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandlerDie Standardeinstellung logging.properties gibt einen ConsoleHandler zum Weiterleiten der Protokollierung an stdout sowie einen FileHandler an. Der Schwellenwert für die Protokollstufe eines Handlers kann mit SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST oder ALL festgelegt werden.
Das ist es. Wir sind bereit, unsere Hello World-Anwendung mit dem Struts 2-Framework auszuführen.
Vorgehensweise zum Ausführen der Anwendung
Klicken Sie mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WAR File um 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 zuzugreifen http://localhost:8080/HelloWorldStruts2/index.jsp. Dies gibt Ihnen folgenden Bildschirm -
Geben Sie einen Wert "Struts2" ein und senden Sie die Seite. Sie sollten die nächste Seite sehen
Beachten Sie, dass Sie definieren können index als Aktion in der Datei struts.xml und in diesem Fall können Sie die Indexseite als aufrufen http://localhost:8080/HelloWorldStruts2/index.action. Überprüfen Sie unten, wie Sie den Index als Aktion definieren können.
<?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 = "index">
<result >/index.jsp</result>
</action>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Dieses Kapitel führt Sie durch die Grundkonfiguration, die für a erforderlich ist Struts 2Anwendung. Hier sehen wir, was mit Hilfe einiger wichtiger Konfigurationsdateien wie konfiguriert werden kannweb.xml, struts.xml, strutsconfig.xml und struts.properties
Ehrlich gesagt können Sie mit der Arbeit beginnen, indem Sie einfach verwenden web.xml und struts.xmlKonfigurationsdateien (wie Sie bereits in unserem vorherigen Kapitel gesehen haben, in dem unser Beispiel mit diesen beiden Dateien gearbeitet hat). Nach Ihrem Wissen werden wir jedoch auch andere Dateien erläutern.
Die Datei web.xml
Die Konfigurationsdatei web.xml ist eine J2EE-Konfigurationsdatei, die bestimmt, wie Elemente der HTTP-Anforderung vom Servlet-Container verarbeitet werden. Es handelt sich nicht ausschließlich um eine Struts2-Konfigurationsdatei, sondern um eine Datei, die konfiguriert werden muss, damit Struts2 funktioniert.
Wie bereits erwähnt, bietet diese Datei einen Einstiegspunkt für jede Webanwendung. Der Einstiegspunkt der Struts2-Anwendung ist ein Filter, der im Deployment-Deskriptor (web.xml) definiert ist. Daher definieren wir einen Eintrag der FilterDispatcher- Klasse in web.xml. Die Datei web.xml muss unter dem Ordner erstellt werdenWebContent/WEB-INF.
Dies ist die erste Konfigurationsdatei, die Sie konfigurieren müssen, wenn Sie ohne die Hilfe einer Vorlage oder eines Tools starten, das sie generiert (z. B. Eclipse oder Maven2).
Im Folgenden finden Sie den Inhalt der Datei web.xml, die wir in unserem letzten Beispiel verwendet haben.
<?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>Beachten Sie, dass wir den Filter Struts 2 zuordnen /*und nicht zu /*.actionDies bedeutet, dass alle URLs vom Struts-Filter analysiert werden. Wir werden dies behandeln, wenn wir das Kapitel Anmerkungen durchgehen.
Die Struts.xml-Datei
Das struts.xmlDie Datei enthält die Konfigurationsinformationen, die Sie bei der Entwicklung von Aktionen ändern werden. Diese Datei kann verwendet werden, um Standardeinstellungen für eine Anwendung zu überschreiben, z. B. struts.devMode = false und andere Einstellungen, die in der Eigenschaftendatei definiert sind. Diese Datei kann unter dem Ordner erstellt werdenWEB-INF/classes.
Werfen wir einen Blick auf die Datei struts.xml, die wir im im vorherigen Kapitel erläuterten Hello World-Beispiel erstellt haben.
<?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">
<result name = "success">/HelloWorld.jsp</result>
</action>
<-- more actions can be listed here -->
</package>
<-- more packages can be listed here -->
</struts>Das erste, was zu beachten ist, ist das DOCTYPE. Alle Struts-Konfigurationsdateien müssen den richtigen Doctype haben, wie in unserem kleinen Beispiel gezeigt. <struts> ist das Root-Tag-Element, unter dem wir verschiedene Pakete mit <package> -Tags deklarieren. Hier ermöglicht <Paket> die Trennung und Modularisierung der Konfiguration. Dies ist sehr nützlich, wenn Sie ein großes Projekt haben und das Projekt in verschiedene Module unterteilt ist.
Wenn Ihr Projekt beispielsweise drei Domänen hat - business_application, customer_application und staff_application, können Sie drei Pakete erstellen und zugehörige Aktionen im entsprechenden Paket speichern.
Das Paket-Tag hat die folgenden Attribute:
| Sr.Nr. | Attribut & Beschreibung |
|---|---|
| 1 | name (required) Die eindeutige Kennung für das Paket |
| 2 | extends Von welchem Paket erstreckt sich dieses Paket? Standardmäßig verwenden wir struts-default als Basispaket. |
| 3 | abstract Wenn dies als wahr markiert ist, ist das Paket nicht für den Endbenutzerverbrauch verfügbar. |
| 4 | namespace Eindeutiger Namespace für die Aktionen |
Das constant Tag zusammen mit Namens- und Wertattributen sollten verwendet werden, um eine der folgenden Eigenschaften zu überschreiben, die in definiert sind default.properties, wie wir gerade eingestellt haben struts.devModeEigentum. Rahmenstruts.devMode Mit dieser Eigenschaft können wir mehr Debug-Meldungen in der Protokolldatei anzeigen.
Wir definieren action Tags entsprechen jeder URL, auf die wir zugreifen möchten, und wir definieren eine Klasse mit der Methode execute (), auf die zugegriffen wird, wenn auf die entsprechende URL zugegriffen wird.
Die Ergebnisse bestimmen, was nach Ausführung einer Aktion an den Browser zurückgegeben wird. Die von der Aktion zurückgegebene Zeichenfolge sollte der Name eines Ergebnisses sein. Die Ergebnisse werden pro Aktion wie oben oder als "globales" Ergebnis konfiguriert, das für jede Aktion in einem Paket verfügbar ist. Ergebnisse sind optionalname und typeAttribute. Der Standardwert für den Namen ist "Erfolg".
Die Struts.xml-Datei kann mit der Zeit sehr groß werden. Das Aufteilen nach Paketen ist daher eine Möglichkeit, sie zu modularisieren Strutsbietet eine andere Möglichkeit, die Datei struts.xml zu modularisieren. Sie können die Datei in mehrere XML-Dateien aufteilen und auf folgende Weise importieren.
<?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>
<include file="my-struts1.xml"/>
<include file="my-struts2.xml"/>
</struts>Die andere Konfigurationsdatei, die wir nicht behandelt haben, ist die Datei struts-default.xml. Diese Datei enthält die Standardkonfigurationseinstellungen für Struts, und Sie müssten diese Einstellungen für 99,99% Ihrer Projekte nicht berühren. Aus diesem Grund gehen wir in dieser Datei nicht zu sehr ins Detail. Wenn Sie interessiert sind, werfen Sie einen Blick in diedefault.properties Datei verfügbar in der Datei struts2-core-2.2.3.jar.
Die Datei Struts-config.xml
Die Konfigurationsdatei struts-config.xml ist eine Verknüpfung zwischen den Komponenten Ansicht und Modell im Webclient, aber Sie müssten diese Einstellungen für 99,99% Ihrer Projekte nicht berühren.
Die Konfigurationsdatei enthält im Wesentlichen folgende Hauptelemente:
| Sr.Nr. | Abfangjäger & Beschreibung |
|---|---|
| 1 | struts-config Dies ist der Stammknoten der Konfigurationsdatei. |
| 2 | form-beans Hier ordnen Sie Ihre ActionForm-Unterklasse einem Namen zu. Sie verwenden diesen Namen als Alias für Ihre ActionForm im Rest der Datei strutsconfig.xml und sogar auf Ihren JSP-Seiten. |
| 3 | global forwards In diesem Abschnitt wird eine Seite in Ihrer Webanwendung einem Namen zugeordnet. Mit diesem Namen können Sie auf die aktuelle Seite verweisen. Dadurch wird vermieden, dass URLs auf Ihren Webseiten fest codiert werden. |
| 4 | action-mappings Hier deklarieren Sie Formularhandler, die auch als Aktionszuordnungen bezeichnet werden. |
| 5 | controller In diesem Abschnitt werden Struts-Interna konfiguriert und in praktischen Situationen nur selten verwendet. |
| 6 | plug-in In diesem Abschnitt erfahren Sie von Struts, wo sich Ihre Eigenschaftendateien befinden, die Eingabeaufforderungen und Fehlermeldungen enthalten |
Es folgt die Beispieldatei struts-config.xml -
<?xml version = "1.0" Encoding = "ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
<struts-config>
<!-- ========== Form Bean Definitions ============ -->
<form-beans>
<form-bean name = "login" type = "test.struts.LoginForm" />
</form-beans>
<!-- ========== Global Forward Definitions ========= -->
<global-forwards>
</global-forwards>
<!-- ========== Action Mapping Definitions ======== -->
<action-mappings>
<action
path = "/login"
type = "test.struts.LoginAction" >
<forward name = "valid" path = "/jsp/MainMenu.jsp" />
<forward name = "invalid" path = "/jsp/LoginView.jsp" />
</action>
</action-mappings>
<!-- ========== Controller Definitions ======== -->
<controller contentType = "text/html;charset = UTF-8"
debug = "3" maxFileSize = "1.618M" locale = "true" nocache = "true"/>
</struts-config>Weitere Informationen zur Datei struts-config.xml finden Sie in der Dokumentation zu struts.
Die Struts.properties-Datei
Diese Konfigurationsdatei bietet einen Mechanismus zum Ändern des Standardverhaltens des Frameworks. Eigentlich sind alle Eigenschaften in derstruts.properties Konfigurationsdatei kann auch in der konfiguriert werden web.xml Verwendung der init-param, auch mit dem konstanten Tag in der struts.xmlKonfigurationsdatei. Wenn Sie jedoch die Dinge getrennt und die Streben spezifischer halten möchten, können Sie diese Datei unter dem Ordner erstellenWEB-INF/classes.
Die in dieser Datei konfigurierten Werte überschreiben die in konfigurierten Standardwerte default.propertieswelches in der struts2-core-xyzjar-Distribution enthalten ist. Es gibt einige Eigenschaften, die Sie möglicherweise mit ändern könnenstruts.properties Datei -
### When set to true, Struts will act much more friendly for developers
struts.devMode = true
### Enables reloading of internationalization files
struts.i18n.reload = true
### Enables reloading of XML configuration files
struts.configuration.xml.reload = true
### Sets the port that the server is run on
struts.url.http.port = 8080Hier jede Zeile beginnend mit hash (#) wird als Kommentar angenommen und von ignoriert Struts 2.
Actionssind der Kern des Struts2-Frameworks, wie sie für jedes MVC-Framework (Model View Controller) gelten. Jede URL ist einer bestimmten Aktion zugeordnet, die die Verarbeitungslogik bereitstellt, die zum Bearbeiten der Anforderung vom Benutzer erforderlich ist.
Die Aktion dient aber auch zwei anderen wichtigen Funktionen. Erstens spielt die Aktion eine wichtige Rolle bei der Übertragung von Daten von der Anforderung bis zur Ansicht, unabhängig davon, ob es sich um eine JSP oder eine andere Art von Ergebnis handelt. Zweitens muss die Aktion das Framework bei der Bestimmung unterstützen, welches Ergebnis die Ansicht wiedergeben soll, die in der Antwort auf die Anforderung zurückgegeben wird.
Aktion erstellen
Die einzige Voraussetzung für Aktionen in Struts2ist, dass es eine noargument-Methode geben muss, die entweder ein String- oder ein Result-Objekt zurückgibt und ein POJO sein muss. Wenn die Methode ohne Argumente nicht angegeben ist, wird standardmäßig die Methode execute () verwendet.
Optional können Sie die erweitern ActionSupport Klasse, die sechs Schnittstellen implementiert, einschließlich ActionSchnittstelle. Die Aktionsoberfläche ist wie folgt:
public interface Action {
public static final String SUCCESS = "success";
public static final String NONE = "none";
public static final String ERROR = "error";
public static final String INPUT = "input";
public static final String LOGIN = "login";
public String execute() throws Exception;
}Werfen wir einen Blick auf die Aktionsmethode im Hello World-Beispiel -
package com.tutorialspoint.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Um den Punkt zu veranschaulichen, an dem die Aktionsmethode die Ansicht steuert, nehmen wir die folgende Änderung an der vor execute Methode und erweitern Sie die Klasse ActionSupport wie folgt:
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
if ("SECRET".equals(name)) {
return SUCCESS;
} else {
return ERROR;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}In diesem Beispiel haben wir eine Logik in der Methode execute, um das Namensattribut zu untersuchen. Wenn das Attribut der Zeichenfolge entspricht"SECRET", wir kehren zurück SUCCESS sonst kehren wir zurück ERRORals Ergebnis. Da wir ActionSupport erweitert haben, können wir String-Konstanten verwendenSUCCESSund FEHLER. Lassen Sie uns nun unsere Datei struts.xml wie folgt ändern:
<?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">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Erstellen Sie eine Ansicht
Lassen Sie uns die folgende JSP-Datei erstellen HelloWorld.jspim WebContent-Ordner in Ihrem Eclipse-Projekt. Klicken Sie dazu im Projektexplorer mit der rechten Maustaste auf den Ordner WebContent und wählen SieNew >JSP File. Diese Datei wird aufgerufen, falls das Rückgabeergebnis SUCCESS ist. Dies ist eine String-Konstante "success", wie in der Aktionsschnittstelle definiert.
<%@ 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>Das Folgende ist die Datei, die vom Framework aufgerufen wird, falls das Aktionsergebnis ERROR ist, was der String-Konstante "error" entspricht. Es folgt der Inhalt vonAccessDenied.jsp
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Access Denied</title>
</head>
<body>
You are not authorized to view this page.
</body>
</html>Wir müssen auch schaffen index.jspim WebContent-Ordner. Diese Datei dient als erste Aktions-URL, auf die der Benutzer klicken kann, um das Struts 2-Framework anzuweisen, das aufzurufenexecuteMethode der HelloWorldAction-Klasse und rendern Sie die Ansicht HelloWorld.jsp.
<%@ 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 war's, es ist keine Änderung für die Datei web.xml erforderlich. Verwenden wir also dieselbe web.xml, in der wir erstellt haben ExamplesKapitel. Jetzt sind wir bereit, unsere zu betreibenHello World Anwendung mit Struts 2 Framework.
Führen Sie die Anwendung aus
Klicken Sie mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WARDatei zum Erstellen einer War-Datei. 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. Dies gibt Ihnen folgenden Bildschirm -
Geben Sie ein Wort als "SECRET" ein und Sie sollten die folgende Seite sehen -
Geben Sie nun ein anderes Wort als "SECRET" ein und Sie sollten die folgende Seite sehen -
Erstellen Sie mehrere Aktionen
Sie definieren häufig mehr als eine Aktion, um unterschiedliche Anforderungen zu verarbeiten und den Benutzern unterschiedliche URLs bereitzustellen. Dementsprechend definieren Sie verschiedene Klassen wie unten definiert.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
class MyAction extends ActionSupport {
public static String GOOD = SUCCESS;
public static String BAD = ERROR;
}
public class HelloWorld extends ActionSupport {
...
public String execute() {
if ("SECRET".equals(name)) return MyAction.GOOD;
return MyAction.BAD;
}
...
}
public class SomeOtherClass extends ActionSupport {
...
public String execute() {
return MyAction.GOOD;
}
...
}Sie konfigurieren diese Aktionen in der Datei struts.xml 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">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorld"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
<action name = "something"
class = "com.tutorialspoint.struts2.SomeOtherClass"
method = "execute">
<result name = "success">/Something.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>Wie Sie im obigen hypothetischen Beispiel sehen können, ergibt sich die Aktion SUCCESS und ERROR’s sind dupliziert.
Um dieses Problem zu umgehen, wird empfohlen, eine Klasse zu erstellen, die die Ergebnisergebnisse enthält.
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 vermuten lassen, bietet die Methode init () eine Möglichkeit, den Interceptor zu initialisieren, und die Methode destroy () bietet eine Möglichkeit zur Bereinigung des Interceptors. 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 von invoke () des ActionInvocation-Objekts 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 Methode invoke (), 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, auf die ein Benutzer klicken kann, um das Struts 2-Framework anzuweisen, 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>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 unten den folgenden Text:
Pre-Processing
Inside action....
Post-ProcessingMehrere 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>
</actionDie 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.
Wie bereits erwähnt, ist die <results> Tag spielt die Rolle eines viewim Struts2 MVC-Framework. Die Aktion ist für die Ausführung der Geschäftslogik verantwortlich. Der nächste Schritt nach dem Ausführen der Geschäftslogik besteht darin, die Ansicht mit dem anzuzeigen<results> Etikett.
Oft sind den Ergebnissen einige Navigationsregeln beigefügt. Wenn die Aktionsmethode beispielsweise darin besteht, einen Benutzer zu authentifizieren, gibt es drei mögliche Ergebnisse.
- Erfolgreicher Login
- Nicht erfolgreiche Anmeldung - Falscher Benutzername oder falsches Passwort
- Konto gesperrt
In diesem Szenario wird die Aktionsmethode mit drei möglichen Ergebniszeichenfolgen und drei verschiedenen Ansichten konfiguriert, um das Ergebnis zu rendern. Wir haben dies bereits in den vorherigen Beispielen gesehen.
Struts2 ist jedoch nicht mit der Verwendung von JSP als Ansichtstechnologie verbunden. Schließlich besteht der gesamte Zweck des MVC-Paradigmas darin, die Ebenen getrennt und hochgradig konfigurierbar zu halten. Beispielsweise möchten Sie für einen Web2.0-Client möglicherweise XML oder JSON als Ausgabe zurückgeben. In diesem Fall können Sie einen neuen Ergebnistyp für XML oder JSON erstellen und dies erreichen.
Streben kommt mit einer Reihe von vordefinierten result types und was auch immer wir bereits gesehen haben, das war der Standardergebnis-Typ dispatcher, wird zum Versenden an JSP-Seiten verwendet. Mit Struts können Sie andere Markup-Sprachen für die Ansichtstechnologie verwenden, um die Ergebnisse zu präsentierenVelocity, Freemaker, XSLT und Tiles.
Der Dispatcher-Ergebnistyp
Das dispatcherDer Ergebnistyp ist der Standardtyp und wird verwendet, wenn kein anderer Ergebnistyp angegeben ist. Es wird verwendet, um an ein Servlet, eine JSP, eine HTML-Seite usw. auf dem Server weiterzuleiten. Es verwendet die RequestDispatcher.forward () -Methode.
Wir haben die "Kurzschrift" -Version in unseren früheren Beispielen gesehen, in denen wir einen JSP-Pfad als Hauptteil des Ergebnis-Tags angegeben haben.
<result name = "success">
/HelloWorld.jsp
</result>Wir können die JSP-Datei auch mit einem <param name = "location"> -Tag im <result ...> -Element wie folgt angeben:
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>Wir können auch eine liefern parseParameter, der standardmäßig wahr ist. Der Analyseparameter bestimmt, ob der Standortparameter für OGNL-Ausdrücke analysiert wird oder nicht.
Der FreeMaker-Ergebnistyp
In diesem Beispiel werden wir sehen, wie wir verwenden können FreeMakerals die Ansichtstechnologie. Freemaker ist eine beliebte Vorlagen-Engine, mit der mithilfe vordefinierter Vorlagen Ausgaben generiert werden. Lassen Sie uns nun eine Freemaker-Vorlagendatei mit dem Namen erstellenhello.fm mit folgenden Inhalten -
Hello World ${name}Die obige Datei ist eine Vorlage wo nameist ein Parameter, der mit der definierten Aktion von außen übergeben wird. Sie behalten diese Datei in Ihrem CLASSPATH.
Als nächstes ändern wir die struts.xml um das Ergebnis wie folgt anzugeben -
<?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">
<result name = "success" type = "freemarker">
<param name = "location">/hello.fm</param>
</result>
</action>
</package>
</struts>Lassen Sie uns unsere Dateien HelloWorldAction.java, HelloWorldAction.jsp und index.jsp so behalten, wie wir sie im Beispielkapitel erstellt haben.
Klicken Sie nun mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WAR File um 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. Dadurch wird der folgende Bildschirm angezeigt.
Geben Sie einen Wert "Struts2" ein und senden Sie die Seite. Sie sollten die nächste Seite sehen.
Wie Sie sehen können, entspricht dies genau der JSP-Ansicht, außer dass wir nicht an die Verwendung von JSP als Ansichtstechnologie gebunden sind. In diesem Beispiel haben wir Freemaker verwendet.
Der Redirect-Ergebnistyp
Das redirectDer Ergebnistyp ruft die Standardmethode response.sendRedirect () auf , wodurch der Browser eine neue Anforderung an den angegebenen Speicherort erstellt.
Wir können die Position entweder im Hauptteil des <result ...> -Elements oder als <param name = "location"> -Element angeben. Redirect unterstützt auch dieparseParameter. Hier ist ein Beispiel, das mit XML konfiguriert wurde:
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>Ändern Sie einfach Ihre struts.xml-Datei, um den Umleitungstyp wie oben erwähnt zu definieren, und erstellen Sie eine neue Datei NewWorld.jpg, in der Sie umgeleitet werden, wenn die Hallo-Aktion den Erfolg zurückgibt. Sie können das Beispiel Struts 2 Redirect Action zum besseren Verständnis überprüfen .
Der Wertestapel
Der Wertestapel besteht aus mehreren Objekten, die die folgenden Objekte in der angegebenen Reihenfolge halten:
| Sr.Nr. | Objekte & Beschreibung |
|---|---|
| 1 | Temporary Objects Es gibt verschiedene temporäre Objekte, die während der Ausführung einer Seite erstellt werden. Beispiel: Der aktuelle Iterationswert für eine Sammlung, die in einem JSP-Tag durchlaufen wird. |
| 2 | The Model Object Wenn Sie in Ihrer Struts-Anwendung Modellobjekte verwenden, wird das aktuelle Modellobjekt vor der Aktion auf dem Wertestapel platziert. |
| 3 | The Action Object Dies ist das aktuelle Aktionsobjekt, das ausgeführt wird. |
| 4 | Named Objects Diese Objekte umfassen #application, #session, #request, #attr und #parameters und verweisen auf die entsprechenden Servlet-Bereiche. |
Auf den Wertestapel kann über die für JSP, Velocity oder Freemarker bereitgestellten Tags zugegriffen werden. Es gibt verschiedene Tags, die wir in separaten Kapiteln untersuchen werden, um den Wertestapel für Streben 2.0 zu erhalten und festzulegen. Sie können das valueStack-Objekt wie folgt in Ihre Aktion aufnehmen:
ActionContext.getContext().getValueStack()Sobald Sie ein ValueStack-Objekt haben, können Sie dieses Objekt mit den folgenden Methoden bearbeiten:
| Sr.Nr. | ValueStack-Methoden und Beschreibung |
|---|---|
| 1 | Object findValue(String expr) Suchen Sie einen Wert, indem Sie den angegebenen Ausdruck anhand des Stapels in der Standardsuchreihenfolge auswerten. |
| 2 | CompoundRoot getRoot() Holen Sie sich den CompoundRoot, der die auf den Stapel geschobenen Objekte enthält. |
| 3 | Object peek() Holen Sie sich das Objekt oben auf den Stapel, ohne den Stapel zu ändern. |
| 4 | Object pop() Holen Sie sich das Objekt oben auf den Stapel und entfernen Sie es vom Stapel. |
| 5 | void push(Object o) Legen Sie dieses Objekt oben auf den Stapel. |
| 6 | void set(String key, Object o) Legt ein Objekt auf dem Stapel mit dem angegebenen Schlüssel fest, damit es von findValue (Schlüssel, ...) abgerufen werden kann. |
| 7 | void setDefaultType(Class defaultType) Legt den Standardtyp fest, in den konvertiert werden soll, wenn beim Abrufen eines Werts kein Typ angegeben wird. |
| 8 | void setValue(String expr, Object value) Es wird versucht, eine Eigenschaft für eine Bean im Stapel mit dem angegebenen Ausdruck in der Standardsuchreihenfolge festzulegen. |
| 9 | int size() Ermitteln Sie die Anzahl der Objekte im Stapel. |
Die OGNL
Das Object-Graph Navigation Language(OGNL) ist eine leistungsstarke Ausdruckssprache, mit der Daten auf dem ValueStack referenziert und bearbeitet werden. OGNL hilft auch bei der Datenübertragung und Typkonvertierung.
Die OGNL ist der JSP-Ausdruckssprache sehr ähnlich. OGNL basiert auf der Idee, ein Stamm- oder Standardobjekt im Kontext zu haben. Auf die Eigenschaften des Standard- oder Stammobjekts kann mithilfe der Markup-Notation verwiesen werden, bei der es sich um das Pfund-Symbol handelt.
Wie bereits erwähnt, basiert OGNL auf einem Kontext und Struts erstellt eine ActionContext-Map zur Verwendung mit OGNL. Die ActionContext-Map besteht aus folgenden Elementen:
Application - Variablen mit Anwendungsbereich
Session - Variablen mit Sitzungsbereich
Root / value stack - Alle Ihre Aktionsvariablen werden hier gespeichert
Request - Gültigkeitsbereichsvariablen anfordern
Parameters - Parameter anfordern
Atributes - Die in Seiten-, Anforderungs-, Sitzungs- und Anwendungsbereich gespeicherten Attribute
Es ist wichtig zu verstehen, dass das Action-Objekt immer im Wertestapel verfügbar ist. Also, wenn Ihr Action-Objekt Eigenschaften hat“x” und “y” Es stehen Ihnen diese zur Verfügung.
Objekte im ActionContext werden mit dem Pfund-Symbol referenziert. Die Objekte im Wertestapel können jedoch direkt referenziert werden.
Zum Beispiel, wenn employee ist eine Eigenschaft einer Aktionsklasse, auf die wie folgt verwiesen werden kann:
<s:property value = "name"/>Anstatt von
<s:property value = "#name"/>Wenn Sie in der Sitzung ein Attribut namens "Login" haben, können Sie es wie folgt abrufen:
<s:property value = "#session.login"/>OGNL unterstützt auch den Umgang mit Sammlungen - nämlich Map, List und Set. Um beispielsweise eine Dropdown-Liste mit Farben anzuzeigen, können Sie Folgendes tun:
<s:select name = "color" list = "{'red','yellow','green'}" />Der OGNL-Ausdruck ist klug, um "Rot", "Gelb", "Grün" als Farben zu interpretieren und darauf basierend eine Liste zu erstellen.
Die OGNL-Ausdrücke werden in den nächsten Kapiteln ausführlich verwendet, wenn wir verschiedene Tags untersuchen. Betrachten wir sie also nicht isoliert, sondern anhand einiger Beispiele im Abschnitt Formular-Tags / Steuer-Tags / Daten-Tags und Ajax-Tags.
ValueStack / OGNL-Beispiel
Aktion erstellen
Betrachten wir die folgende Aktionsklasse, in der wir auf valueStack zugreifen und dann einige Schlüssel festlegen, auf die wir in unserer Ansicht mit OGNL zugreifen, dh auf der JSP-Seite.
package com.tutorialspoint.struts2;
import java.util.*;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
Map<String, Object> context = new HashMap<String, Object>();
context.put("key1", new String("This is key1"));
context.put("key2", new String("This is key2"));
stack.push(context);
System.out.println("Size of the valueStack: " + stack.size());
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Tatsächlich fügt Struts 2 Ihre Aktion bei der Ausführung oben im valueStack hinzu. Die übliche Methode, um Inhalte auf den Wertestapel zu legen, besteht darin, Ihrer Aktionsklasse Getter / Setter für die Werte hinzuzufügen und dann mit dem Tag <s: property> auf die Werte zuzugreifen. Aber ich zeige Ihnen, wie genau ActionContext und ValueStack in Streben funktionieren.
Ansichten erstellen
Lassen Sie uns die folgende JSP-Datei erstellen HelloWorld.jspim WebContent-Ordner in Ihrem Eclipse-Projekt. Diese Ansicht wird angezeigt, falls die Aktion erfolgreich ist.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Entered value : <s:property value = "name"/><br/>
Value of key 1 : <s:property value = "key1" /><br/>
Value of key 2 : <s:property value = "key2" /> <br/>
</body>
</html>Wir müssen auch schaffen index.jsp im WebContent-Ordner, dessen Inhalt wie folgt lautet:
<%@ 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>Konfigurationsdateien
Es folgt der Inhalt von struts.xml Datei -
<?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">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Es folgt der Inhalt von web.xml Datei -
<?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>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 zuzugreifen http://localhost:8080/HelloWorldStruts2/index.jsp. Dadurch 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 unten den folgenden Text:
Size of the valueStack: 3Daraufhin wird der folgende Bildschirm angezeigt, in dem der von Ihnen eingegebene Wert und der Wert von Schlüssel1 und Schlüssel2 angezeigt werden, den wir auf ValueStack gesetzt haben.
Das Struts 2-Framework bietet integrierte Unterstützung für die Verarbeitung des Hochladens von Dateien mithilfe von "Formularbasiertes Hochladen von Dateien in HTML". Wenn eine Datei hochgeladen wird, wird sie normalerweise in einem temporären Verzeichnis gespeichert und sollte von Ihrer Action-Klasse verarbeitet oder in ein permanentes Verzeichnis verschoben werden, um sicherzustellen, dass die Daten nicht verloren gehen.
Note - Auf Servern ist möglicherweise eine Sicherheitsrichtlinie vorhanden, die es Ihnen verbietet, in andere Verzeichnisse als das temporäre Verzeichnis und die Verzeichnisse zu schreiben, die zu Ihrer Webanwendung gehören.
Das Hochladen von Dateien in Struts ist über einen vordefinierten Interceptor möglich FileUpload Interceptor, der über die Klasse org.apache.struts2.interceptor.FileUploadInterceptor verfügbar ist und als Teil der Klasse enthalten istdefaultStack. Trotzdem können Sie dies in Ihrer struts.xml verwenden, um verschiedene Parameter festzulegen, wie wir unten sehen werden.
Ansichtsdateien erstellen
Beginnen wir mit der Erstellung unserer Ansicht, die zum Durchsuchen und Hochladen einer ausgewählten Datei erforderlich ist. Also lasst uns eine erstellenindex.jsp mit einem einfachen HTML-Upload-Formular, mit dem der Benutzer eine Datei hochladen kann -
<%@ 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>File Upload</title>
</head>
<body>
<form action = "upload" method = "post" enctype = "multipart/form-data">
<label for = "myFile">Upload your file</label>
<input type = "file" name = "myFile" />
<input type = "submit" value = "Upload"/>
</form>
</body>
</html>Im obigen Beispiel sind einige Punkte zu beachten. Zunächst wird der Enctype des Formulars auf gesetztmultipart/form-data. Dies sollte so eingestellt sein, dass Datei-Uploads vom Datei-Upload-Interceptor erfolgreich verarbeitet werden. Der nächste Punkt ist die Aktionsmethode des Formularsupload und den Namen des Datei-Upload-Feldes - das ist myFile. Wir benötigen diese Informationen, um die Aktionsmethode und die Strebenkonfiguration zu erstellen.
Als nächstes erstellen wir eine einfache JSP-Datei success.jsp um das Ergebnis unseres Datei-Uploads anzuzeigen, falls es erfolgreich wird.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Success</title>
</head>
<body>
You have successfully uploaded <s:property value = "myFileFileName"/>
</body>
</html>Es folgt die Ergebnisdatei error.jsp falls beim Hochladen der Datei ein Fehler auftritt -
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Error</title>
</head>
<body>
There has been an error in uploading the file.
</body>
</html>Aktionsklasse erstellen
Als nächstes erstellen wir eine Java-Klasse namens uploadFile.java die sich um das Hochladen der Datei und das Speichern dieser Datei an einem sicheren Ort kümmert -
package com.tutorialspoint.struts2;
import java.io.File;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
import com.opensymphony.xwork2.ActionSupport;
public class uploadFile extends ActionSupport {
private File myFile;
private String myFileContentType;
private String myFileFileName;
private String destPath;
public String execute() {
/* Copy file to a safe location */
destPath = "C:/apache-tomcat-6.0.33/work/";
try {
System.out.println("Src File name: " + myFile);
System.out.println("Dst File name: " + myFileFileName);
File destFile = new File(destPath, myFileFileName);
FileUtils.copyFile(myFile, destFile);
} catch(IOException e) {
e.printStackTrace();
return ERROR;
}
return SUCCESS;
}
public File getMyFile() {
return myFile;
}
public void setMyFile(File myFile) {
this.myFile = myFile;
}
public String getMyFileContentType() {
return myFileContentType;
}
public void setMyFileContentType(String myFileContentType) {
this.myFileContentType = myFileContentType;
}
public String getMyFileFileName() {
return myFileFileName;
}
public void setMyFileFileName(String myFileFileName) {
this.myFileFileName = myFileFileName;
}
}Das uploadFile.javaist eine sehr einfache Klasse. Das Wichtigste ist, dass der FileUpload-Interceptor zusammen mit dem Parameters Interceptor das ganze schwere Heben für uns erledigt.
Der FileUpload-Interceptor stellt Ihnen standardmäßig drei Parameter zur Verfügung. Sie werden im folgenden Muster benannt -
[your file name parameter] - Dies ist die tatsächliche Datei, die der Benutzer hochgeladen hat. In diesem Beispiel ist es "myFile".
[your file name parameter]ContentType- Dies ist der Inhaltstyp der Datei, die hochgeladen wurde. In diesem Beispiel ist es "myFileContentType".
[your file name parameter]FileName- Dies ist der Name der Datei, die hochgeladen wurde. In diesem Beispiel ist es "myFileFileName".
Die drei Parameter stehen uns dank der Struts Interceptors zur Verfügung. Wir müssen lediglich drei Parameter mit den richtigen Namen in unserer Action-Klasse erstellen und diese Variablen werden automatisch für uns automatisch verdrahtet. Im obigen Beispiel haben wir drei Parameter und eine Aktionsmethode, die einfach "Erfolg" zurückgibt, wenn alles gut geht, andernfalls "Fehler" zurückgibt.
Konfigurationsdateien
Im Folgenden sind die Struts2-Konfigurationseigenschaften aufgeführt, die den Prozess des Hochladens von Dateien steuern:
| Sr.Nr. | Eigenschaften & Beschreibung |
|---|---|
| 1 | struts.multipart.maxSize Die maximale Größe (in Byte) einer Datei, die als Datei-Upload akzeptiert werden soll. Standard ist 250M. |
| 2 | struts.multipart.parser Die Bibliothek, die zum Hochladen des mehrteiligen Formulars verwendet wurde. Standardmäßig istjakarta |
| 3 | struts.multipart.saveDir Der Speicherort für die temporäre Datei. Standardmäßig ist javax.servlet.context.tempdir. |
Um eine dieser Einstellungen zu ändern, können Sie verwenden constant Tag in Ihrer Anwendung struts.xml-Datei, wie ich es getan habe, um die maximale Größe einer hochzuladenden Datei zu ändern.
Lassen Sie uns unsere haben struts.xml 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" />
<constant name = "struts.multipart.maxSize" value = "1000000" />
<package name = "helloworld" extends = "struts-default">
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Schon seit, FileUploadInterceptor ist ein Teil des Standardstapels von Interceptors. Wir müssen ihn nicht explizit konfigurieren. Sie können jedoch das <interceptor-ref> -Tag in <action> hinzufügen. Der fileUpload-Interceptor akzeptiert zwei Parameter(a) maximumSize und (b) allowedTypes.
Der Parameter maximumSize legt die maximal zulässige Dateigröße fest (der Standardwert beträgt ca. 2 MB). Der Parameter allowTypes ist eine durch Kommas getrennte Liste akzeptierter Inhaltstypen (MIME) (siehe unten).
<action name = "upload" class = "com.tutorialspoint.struts2.uploadFile">
<interceptor-ref name = "basicStack">
<interceptor-ref name = "fileUpload">
<param name = "allowedTypes">image/jpeg,image/gif</param>
</interceptor-ref>
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>Es folgt der Inhalt von web.xml Datei -
<?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>Klicken Sie nun 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/upload.jsp. Daraufhin wird der folgende Bildschirm angezeigt:
Wählen Sie nun eine Datei "Contacts.txt" mit der Schaltfläche "Durchsuchen" aus und klicken Sie auf die Schaltfläche "Hochladen", um die Datei auf Ihren Aufschlag hochzuladen. Die nächste Seite sollte angezeigt werden. Sie können überprüfen, ob die hochgeladene Datei in C: \ apache-tomcat-6.0.33 \ work gespeichert werden soll.
Beachten Sie, dass der FileUpload Interceptor die hochgeladene Datei automatisch löscht, sodass Sie die hochgeladene Datei programmgesteuert an einem bestimmten Ort speichern müssen, bevor sie gelöscht wird.
Fehlermeldungen
Der fileUplaod-Interceptor verwendet mehrere Standardfehlermeldeschlüssel -
| Sr.Nr. | Fehlermeldung Schlüssel & Beschreibung |
|---|---|
| 1 | struts.messages.error.uploading Ein allgemeiner Fehler, der auftritt, wenn die Datei nicht hochgeladen werden konnte. |
| 2 | struts.messages.error.file.too.large Tritt auf, wenn die hochgeladene Datei zu groß ist, wie von maximumSize angegeben. |
| 3 | struts.messages.error.content.type.not.allowed Tritt auf, wenn die hochgeladene Datei nicht mit den angegebenen erwarteten Inhaltstypen übereinstimmt. |
Sie können den Text dieser Nachrichten in überschreiben WebContent/WEB-INF/classes/messages.properties Ressourcendateien.
In diesem Kapitel erfahren Sie, wie Sie mit Struts 2 in einfachen Schritten auf eine Datenbank zugreifen. Struts ist ein MVC-Framework und kein Datenbank-Framework, bietet jedoch eine hervorragende Unterstützung für die JPA / Hibernate-Integration. Wir werden uns die Integration im Ruhezustand in einem späteren Kapitel ansehen, aber in diesem Kapitel werden wir einfaches altes JDBC verwenden, um auf die Datenbank zuzugreifen.
Der erste Schritt in diesem Kapitel besteht darin, unsere Datenbank einzurichten und vorzubereiten. Ich verwende MySQL als Datenbank für dieses Beispiel. Ich habe MySQL auf meinem Computer installiert und eine neue Datenbank mit dem Namen "struts_tutorial" erstellt. Ich habe eine Tabelle namens erstelltloginund füllte es mit einigen Werten. Unten finden Sie das Skript, mit dem ich die Tabelle erstellt und gefüllt habe.
Meine MYSQL-Datenbank hat den Standardbenutzernamen "root" und das Passwort "root123"
CREATE TABLE `struts_tutorial`.`login` (
`user` VARCHAR( 10 ) NOT NULL ,
`password` VARCHAR( 10 ) NOT NULL ,
`name` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `user` )
) ENGINE = InnoDB;
INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');Der nächste Schritt besteht darin, die MySQL Connector- JAR-Datei herunterzuladen und diese Datei im Ordner WEB-INF \ lib Ihres Projekts abzulegen. Nachdem wir dies getan haben, können wir jetzt die Aktionsklasse erstellen.
Aktion erstellen
Die Aktionsklasse verfügt über die Eigenschaften, die den Spalten in der Datenbanktabelle entsprechen. Wir habenuser, password und nameals String-Attribute. Bei der Aktionsmethode verwenden wir die Benutzer- und Kennwortparameter, um zu überprüfen, ob der Benutzer vorhanden ist. In diesem Fall wird der Benutzername im nächsten Bildschirm angezeigt.
Wenn der Benutzer falsche Informationen eingegeben hat, senden wir diese erneut an den Anmeldebildschirm.
Es folgt der Inhalt von LoginAction.java Datei -
package com.tutorialspoint.struts2;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String user;
private String password;
private String name;
public String execute() {
String ret = ERROR;
Connection conn = null;
try {
String URL = "jdbc:mysql://localhost/struts_tutorial";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, "root", "root123");
String sql = "SELECT name FROM login WHERE";
sql+=" user = ? AND password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, user);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
name = rs.getString(1);
ret = SUCCESS;
}
} catch (Exception e) {
ret = ERROR;
} finally {
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
}
}
}
return ret;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Hauptseite erstellen
Lassen Sie uns nun eine JSP-Datei erstellen index.jspum den Benutzernamen und das Passwort zu sammeln. Dieser Benutzername und dieses Passwort werden mit der Datenbank verglichen.
<%@ 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>Login</title>
</head>
<body>
<form action = "loginaction" method = "post">
User:<br/><input type = "text" name = "user"/><br/>
Password:<br/><input type = "password" name = "password"/><br/>
<input type = "submit" value = "Login"/>
</form>
</body>
</html>Ansichten erstellen
Lassen Sie uns jetzt erstellen success.jsp Datei, die aufgerufen wird, falls die Aktion ERFOLGREICH zurückgibt, aber wir haben eine andere Ansichtsdatei, falls ein FEHLER von der Aktion zurückgegeben wird.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Successful Login</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>Es folgt die Ansichtsdatei error.jsp im Falle eines Fehlers wird von der Aktion zurückgegeben.
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Invalid User Name or Password</title>
</head>
<body>
Wrong user name or password provided.
</body>
</html>Konfigurationsdateien
Lassen Sie uns abschließend alles mithilfe der Konfigurationsdatei struts.xml wie folgt zusammenstellen:
<?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 = "loginaction"
class = "com.tutorialspoint.struts2.LoginAction"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Es folgt der Inhalt von web.xml Datei -
<?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>Klicken Sie nun 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 einen falschen Benutzernamen und ein falsches Passwort ein. Sie sollten die nächste Seite sehen.
Nun eintreten scott als Benutzername und navyals Passwort. Sie sollten die nächste Seite sehen.
In diesem Kapitel wird erläutert, wie Sie mit Ihrer Struts 2-Anwendung eine E-Mail senden können.
Für diese Übung müssen Sie die Datei mail.jar von der JavaMail-API 1.4.4 herunterladen und installieren und die Datei platzierenmail.jar Datei in Ihrem Ordner WEB-INF \ lib und befolgen Sie dann die Standardschritte zum Erstellen von Aktions-, Ansichts- und Konfigurationsdateien.
Aktion erstellen
Der nächste Schritt besteht darin, eine Aktionsmethode zu erstellen, die sich um das Senden der E-Mail kümmert. Lassen Sie uns eine neue Klasse namens erstellenEmailer.java mit folgenden Inhalten.
package com.tutorialspoint.struts2;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import com.opensymphony.xwork2.ActionSupport;
public class Emailer extends ActionSupport {
private String from;
private String password;
private String to;
private String subject;
private String body;
static Properties properties = new Properties();
static {
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
}
public String execute() {
String ret = SUCCESS;
try {
Session session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication
getPasswordAuthentication() {
return new
PasswordAuthentication(from, password);
}
}
);
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
message.setSubject(subject);
message.setText(body);
Transport.send(message);
} catch(Exception e) {
ret = ERROR;
e.printStackTrace();
}
return ret;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public static Properties getProperties() {
return properties;
}
public static void setProperties(Properties properties) {
Emailer.properties = properties;
}
}Wie im obigen Quellcode zu sehen ist, ist die Emailer.javahat Eigenschaften, die den Formularattributen auf der unten angegebenen Seite email.jsp entsprechen. Diese Attribute sind -
From- Die E-Mail-Adresse des Absenders. Da wir Googles SMTP verwenden, benötigen wir eine gültige gtalk-ID
Password - Das Passwort des oben genannten Kontos
To - An wen soll die E-Mail gesendet werden?
Subject - Betreff der E-Mail
Body - Die eigentliche E-Mail-Nachricht
Wir haben keine Validierungen für die oben genannten Felder berücksichtigt. Validierungen werden im nächsten Kapitel hinzugefügt. Betrachten wir nun die Methode execute (). Die Methode execute () verwendet die javax Mail-Bibliothek, um eine E-Mail mit den angegebenen Parametern zu senden. Wenn die E-Mail erfolgreich gesendet wurde, gibt die Aktion SUCCESS zurück, andernfalls wird ERROR zurückgegeben.
Hauptseite erstellen
Lassen Sie uns die Hauptseite der JSP-Datei schreiben index.jsp, die zum Sammeln der oben genannten E-Mail-Informationen verwendet werden -
<%@ 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>Email Form</title>
</head>
<body>
<em>The form below uses Google's SMTP server.
So you need to enter a gmail username and password
</em>
<form action = "emailer" method = "post">
<label for = "from">From</label><br/>
<input type = "text" name = "from"/><br/>
<label for = "password">Password</label><br/>
<input type = "password" name = "password"/><br/>
<label for = "to">To</label><br/>
<input type = "text" name = "to"/><br/>
<label for = "subject">Subject</label><br/>
<input type = "text" name = "subject"/><br/>
<label for = "body">Body</label><br/>
<input type = "text" name = "body"/><br/>
<input type = "submit" value = "Send Email"/>
</form>
</body>
</html>Ansichten erstellen
Wir werden JSP-Datei verwenden success.jsp Dies wird aufgerufen, wenn die Aktion ERFOLGREICH zurückgibt. Wir haben jedoch eine andere Ansichtsdatei, falls ein FEHLER von der Aktion zurückgegeben wird.
<%@ 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>Email Success</title>
</head>
<body>
Your email to <s:property value = "to"/> was sent successfully.
</body>
</html>Es folgt die Ansichtsdatei error.jsp im Falle eines Fehlers wird von der Aktion zurückgegeben.
<%@ 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>Email Error</title>
</head>
<body>
There is a problem sending your email to <s:property value = "to"/>.
</body>
</html>Konfigurationsdateien
Lassen Sie uns nun alles mit der Konfigurationsdatei struts.xml wie folgt zusammenstellen:
<?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 = "emailer"
class = "com.tutorialspoint.struts2.Emailer"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>Es folgt der Inhalt von web.xml Datei -
<?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>Klicken Sie nun 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 die erforderlichen Informationen ein und klicken Sie auf Send EmailTaste. Wenn alles gut geht, sollten Sie die folgende Seite sehen.
In diesem Kapitel werden wir uns eingehender mit dem Validierungsrahmen für Struts befassen. Im Struts-Kern verfügen wir über das Validierungsframework, das die Anwendung beim Ausführen der Regeln zur Durchführung der Validierung unterstützt, bevor die Aktionsmethode ausgeführt wird.
Die clientseitige Validierung erfolgt normalerweise mit Javascript. Man sollte sich jedoch nicht nur auf die clientseitige Validierung verlassen. Die Best Practices empfehlen, die Validierung auf allen Ebenen Ihres Anwendungsframeworks einzuführen. Lassen Sie uns nun zwei Möglichkeiten betrachten, wie Sie unserem Struts-Projekt eine Validierung hinzufügen können.
Hier nehmen wir ein Beispiel für eine Employee deren Name und Alter auf einer einfachen Seite erfasst werden sollen, und wir werden diese beiden Validierungen durchführen, um sicherzustellen, dass der Benutzer immer einen Namen und ein Alter eingibt, die in einem Bereich zwischen 28 und 65 liegen sollten.
Beginnen wir mit der JSP-Hauptseite des Beispiels.
Hauptseite erstellen
Lassen Sie uns die Hauptseite der JSP-Datei schreiben index.jsp, die zum Sammeln der oben genannten mitarbeiterbezogenen Informationen verwendet werden.
<%@ 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>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>Die index.jsp verwendet das Struts-Tag, das wir noch nicht behandelt haben, aber wir werden sie in Tags-bezogenen Kapiteln untersuchen. Nehmen wir zunächst an, dass das Tag s: textfield ein Eingabefeld und das Tag s: submit eine Schaltfläche zum Senden druckt. Wir haben die Label-Eigenschaft für jedes Tag verwendet, wodurch ein Label für jedes Tag erstellt wird.
Ansichten erstellen
Wir werden die JSP-Datei success.jsp verwenden, die aufgerufen wird, falls eine definierte Aktion SUCCESS zurückgibt.
<%@ 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>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Aktion erstellen
Definieren wir also eine kleine Aktionsklasse Employeeund fügen Sie dann eine Methode mit dem Namen hinzu validate() wie unten in gezeigt Employee.javaDatei. Stellen Sie sicher, dass Ihre Aktionsklasse die erweitertActionSupport Klasse, andernfalls wird Ihre Validierungsmethode nicht ausgeführt.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport {
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void validate() {
if (name == null || name.trim().equals("")) {
addFieldError("name","The name is required");
}
if (age < 28 || age > 65) {
addFieldError("age","Age must be in between 28 and 65");
}
}
}Wie im obigen Beispiel gezeigt, prüft die Validierungsmethode, ob das Feld 'Name' einen Wert hat oder nicht. Wenn kein Wert angegeben wurde, fügen wir einen Feldfehler für das Feld 'Name' mit einer benutzerdefinierten Fehlermeldung hinzu. Zweitens prüfen wir, ob der eingegebene Wert für das Feld 'Alter' zwischen 28 und 65 liegt oder nicht. Wenn diese Bedingung nicht erfüllt ist, fügen wir einen Fehler über dem validierten Feld hinzu.
Konfigurationsdateien
Lassen Sie uns zum Schluss alles mit dem zusammenstellen struts.xml Konfigurationsdatei 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">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
</package>
</struts>Es folgt der Inhalt von web.xml Datei -
<?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>Klicken Sie nun 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 jetzt keine erforderlichen Informationen ein, klicken Sie einfach auf SubmitTaste. Sie sehen folgendes Ergebnis:
Geben Sie die erforderlichen Informationen ein, aber geben Sie ein falsches From-Feld ein. Sagen Sie den Namen als "Test" und das Alter als 30 und klicken Sie schließlich auf SubmitTaste. Sie sehen folgendes Ergebnis:
Wie funktioniert diese Validierung?
Wenn der Benutzer die Senden-Taste drückt, führt Struts 2 automatisch die Validierungsmethode aus und falls eine der “if”Anweisungen, die in der Methode aufgeführt sind, sind wahr. Struts 2 ruft seine addFieldError-Methode auf. Wenn Fehler hinzugefügt wurden, ruft Struts 2 die Ausführungsmethode nicht auf. Vielmehr wird das Struts 2-Framework zurückkehreninput als Ergebnis des Aufrufs der Aktion.
Wenn die Validierung fehlschlägt und Struts 2 zurückkehrt inputDas Struts 2-Framework zeigt die Datei index.jsp erneut an. Da wir Struts 2-Formular-Tags verwendet haben, fügt Struts 2 automatisch die Fehlermeldungen direkt über dem eingereichten Formular hinzu.
Diese Fehlermeldungen haben wir im Methodenaufruf addFieldError angegeben. Die addFieldError-Methode akzeptiert zwei Argumente. Der erste ist derform Der Feldname, für den der Fehler gilt, und der zweite ist die Fehlermeldung, die über diesem Formularfeld angezeigt wird.
addFieldError("name","The name is required");Um den Rückgabewert von zu behandeln input Wir müssen das folgende Ergebnis zu unserem Aktionsknoten in hinzufügen struts.xml.
<result name = "input">/index.jsp</result>XML-basierte Validierung
Die zweite Methode zur Validierung besteht darin, eine XML-Datei neben der Aktionsklasse zu platzieren. Die XML-basierte Struts2-Validierung bietet weitere Validierungsoptionen wie E-Mail-Validierung, Ganzzahlbereichsvalidierung, Formularvalidierungsfeld, Ausdrucksvalidierung, Regex-Validierung, erforderliche Validierung, erforderliche String-Validierung, Stringlängen-Validierung usw.
Die XML-Datei muss benannt werden '[action-class]'-validation.xml. In unserem Fall erstellen wir also eine Datei mit dem NamenEmployee-validation.xml mit folgenden Inhalten -
<!DOCTYPE validators PUBLIC
"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name = "name">
<field-validator type = "required">
<message>
The name is required.
</message>
</field-validator>
</field>
<field name = "age">
<field-validator type = "int">
<param name = "min">29</param>
<param name = "max">64</param>
<message>
Age must be in between 28 and 65
</message>
</field-validator>
</field>
</validators>Die oben genannte XML-Datei wird idealerweise zusammen mit der Klassendatei in Ihrem CLASSPATH gespeichert. Lassen Sie uns unsere Mitarbeiter-Aktionsklasse wie folgt haben, ohne sie zu habenvalidate() Methode -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Der Rest des Setups bleibt wie im vorherigen Beispiel erhalten. Wenn Sie nun die Anwendung ausführen, wird das gleiche Ergebnis erzielt, das wir im vorherigen Beispiel erhalten haben.
Der Vorteil einer XML-Datei zum Speichern der Konfiguration ermöglicht die Trennung der Validierung vom Anwendungscode. Sie könnten einen Entwickler dazu bringen, den Code zu schreiben, und einen Geschäftsanalysten, um die XML-Validierungsdateien zu erstellen. Beachten Sie auch die standardmäßig verfügbaren Validatortypen.
Es gibt viel mehr Validatoren, die standardmäßig mit Struts geliefert werden. Zu den allgemeinen Validatoren gehören der Datumsvalidator, der Regex-Validator und der Stringlängenvalidator. Weitere Informationen finden Sie unter folgendem Link. Struts - XML Based Validators .
Internationalisierung (i18n) ist der Prozess der Planung und Implementierung von Produkten und Dienstleistungen, damit diese leicht an bestimmte lokale Sprachen und Kulturen angepasst werden können. Dieser Prozess wird als Lokalisierung bezeichnet. Der Internationalisierungsprozess wird als Übersetzungs- oder Lokalisierungsaktivierung bezeichnet.
Internationalisierung wird abgekürzt i18n weil das Wort mit dem Buchstaben beginnt “i” und endet mit “n”und es gibt 18 Zeichen zwischen dem ersten i und dem letzten n.
Struts2 bietet Lokalisierung, dh Unterstützung für Internationalisierung (i18n) durch Ressourcenpakete, Interceptors und Tag-Bibliotheken an folgenden Stellen:
Die UI-Tags
Meldungen und Fehler.
Innerhalb von Aktionsklassen.
Ressourcenpakete
Struts2 verwendet Ressourcenpakete, um den Benutzern der Webanwendung mehrere Sprach- und Gebietsschemaoptionen bereitzustellen. Sie müssen sich keine Gedanken über das Schreiben von Seiten in verschiedenen Sprachen machen. Sie müssen lediglich ein Ressourcenpaket für jede gewünschte Sprache erstellen. Die Ressourcenpakete enthalten Titel, Nachrichten und anderen Text in der Sprache Ihres Benutzers. Ressourcenpakete sind die Datei, die die Schlüssel / Wert-Paare für die Standardsprache Ihrer Anwendung enthält.
Das einfachste Namensformat für eine Ressourcendatei ist -
bundlename_language_country.propertiesHier, bundlenameDies können ActionClass-, Interface-, SuperClass-, Modell-, Paket- und globale Ressourceneigenschaften sein. Nächster Teillanguage_country stellt beispielsweise das Gebietsschema des Landes dar, das Gebietsschema Spanisch (Spanien) wird durch es_ES dargestellt, und das Gebietsschema Englisch (USA) wird durch en_US usw. dargestellt, wobei Sie den optionalen Landesteil überspringen können.
Wenn Sie ein Nachrichtenelement anhand seines Schlüssels referenzieren, sucht das Struts-Framework nach einem entsprechenden Nachrichtenpaket in der folgenden Reihenfolge:
- ActionClass.properties
- Interface.properties
- SuperClass.properties
- model.properties
- package.properties
- struts.properties
- global.properties
Um Ihre Anwendung in mehreren Sprachen zu entwickeln, sollten Sie mehrere Eigenschaftendateien verwalten, die diesen Sprachen / Gebietsschemas entsprechen, und den gesamten Inhalt in Form von Schlüssel / Wert-Paaren definieren.
Wenn Sie beispielsweise Ihre Anwendung für US-Englisch (Standard), Spanisch und Französisch entwickeln möchten, müssen Sie drei Eigenschaftendateien erstellen. Hier werde ich verwendenglobal.properties Nur Datei, Sie können auch verschiedene Eigenschaftendateien verwenden, um verschiedene Arten von Nachrichten zu trennen.
global.properties - Standardmäßig wird Englisch (USA) angewendet
global_fr.properties - Dies wird für das Gebietsschema Franch verwendet.
global_es.properties - Dies wird für das spanische Gebietsschema verwendet.
Greifen Sie auf die Nachrichten zu
Es gibt verschiedene Möglichkeiten, auf die Nachrichtenressourcen zuzugreifen, darunter getText, das Text-Tag, das Schlüsselattribut der UI-Tags und das i18n-Tag. Lassen Sie uns sie kurz sehen -
Anzeigen i18n Text, verwenden Sie einen Anruf an getText im Eigenschaftstag oder einem anderen Tag, z. B. den UI-Tags, wie folgt:
<s:property value = "getText('some.key')" />Das text tag Ruft eine Nachricht aus dem Standardressourcenpaket ab, dh struts.properties
<s:text name = "some.key" />Das i18n tagschiebt ein beliebiges Ressourcenbündel auf den Wertestapel. Andere Tags im Bereich des i18n-Tags können Nachrichten aus diesem Ressourcenpaket anzeigen
<s:i18n name = "some.package.bundle">
<s:text name = "some.key" />
</s:i18n>Das key Das Attribut der meisten UI-Tags kann verwendet werden, um eine Nachricht aus einem Ressourcenpaket zu generieren.
<s:textfield key = "some.key" name = "textfieldName"/>Lokalisierungsbeispiel
Lassen Sie uns zielen, um zu schaffen index.jspaus dem vorherigen Kapitel in mehreren Sprachen. Dieselbe Datei würde wie folgt geschrieben werden:
<%@ 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>Employee Form with Multilingual Support</title>
</head>
<body>
<h1><s:text name = "global.heading"/></h1>
<s:url id = "indexEN" namespace="/" action = "locale" >
<s:param name = "request_locale" >en</s:param>
</s:url>
<s:url id = "indexES" namespace="/" action = "locale" >
<s:param name = "request_locale" >es</s:param>
</s:url>
<s:url id = "indexFR" namespace="/" action = "locale" >
<s:param name = "request_locale" >fr</s:param>
</s:url>
<s:a href="%{indexEN}" >English</s:a>
<s:a href="%{indexES}" >Spanish</s:a>
<s:a href="%{indexFR}" >France</s:a>
<s:form action = "empinfo" method = "post" namespace = "/">
<s:textfield name = "name" key = "global.name" size = "20" />
<s:textfield name = "age" key = "global.age" size = "20" />
<s:submit name = "submit" key = "global.submit" />
</s:form>
</body>
</html>Wir werden schaffen success.jsp Datei, die aufgerufen wird, falls eine definierte Aktion zurückgegeben wird SUCCESS.
<%@ 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>Success</title>
</head>
<body>
<s:property value = "getText('global.success')" />
</body>
</html>Hier müssten wir die folgenden zwei Aktionen erstellen. (a) Erste Aktion a, um sich um das Gebietsschema zu kümmern und dieselbe index.jsp-Datei in einer anderen Sprache anzuzeigen. (b) Eine weitere Aktion besteht darin, sich um das Absenden des Formulars selbst zu kümmern. Beide Aktionen geben SUCCESS zurück, aber wir werden unterschiedliche Aktionen basierend auf den Rückgabewerten ausführen, da unser Zweck für beide Aktionen unterschiedlich ist
Aktion zur Pflege des Gebietsschemas
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}Aktion zum Senden des Formulars
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Lassen Sie uns nun die folgenden drei erstellen global.properties Dateien und setzen Sie die in CLASSPATH - -
global.properties
global.name = Name
global.age = Age
global.submit = Submit
global.heading = Select Locale
global.success = Successfully authenticatedglobal_fr.properties
global.name = Nom d'utilisateur
global.age = l'âge
global.submit = Soumettre des
global.heading = Sé lectionnez Local
global.success = Authentifi é avec succèsglobal_es.properties
global.name = Nombre de usuario
global.age = Edad
global.submit = Presentar
global.heading = seleccionar la configuracion regional
global.success = Autenticado correctamenteWir werden unsere schaffen struts.xml mit zwei Aktionen 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" />
<constant name = "struts.custom.i18n.resources" value = "global" />
<package name = "helloworld" extends = "struts-default" namespace="/">
<action name = "empinfo"
class = "com.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
<action name = "locale"
class = "com.tutorialspoint.struts2.Locale"
method = "execute">
<result name = "success">/index.jsp</result>
</action>
</package>
</struts>Es folgt der Inhalt von web.xml Datei -
<?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>Klicken Sie nun 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:
Wählen Sie nun eine der Sprachen aus, sagen wir, wir wählen Spanishwürde es das folgende Ergebnis anzeigen -
Sie können es auch mit französischer Sprache versuchen. Lassen Sie uns zum Schluss versuchen, zu klickenSubmit Wenn wir uns im spanischen Gebietsschema befinden, wird der folgende Bildschirm angezeigt:
Herzlichen Glückwunsch, jetzt haben Sie eine mehrsprachige Webseite, auf der Sie Ihre Website global starten können.
Alles in einer HTTP-Anfrage wird als behandelt Stringdurch das Protokoll. Dies umfasst Zahlen, Boolesche Werte, Ganzzahlen, Datumsangaben, Dezimalstellen und alles andere. In der Struts-Klasse können Sie jedoch Eigenschaften für beliebige Datentypen haben.
Wie verdrahtet Struts die Eigenschaften automatisch für Sie?
Struts verwendet eine Vielzahl von Konvertern unter der Abdeckung, um das schwere Heben durchzuführen.
Wenn Ihre Action-Klasse beispielsweise ein Integer-Attribut enthält, konvertiert Struts den Anforderungsparameter automatisch in das Integer-Attribut, ohne dass Sie etwas unternehmen. Standardmäßig wird Struts mit einer Reihe von Typkonvertern geliefert
Wenn Sie einen der unten aufgeführten Konverter verwenden, müssen Sie sich keine Sorgen machen -
- Integer, Float, Double, Decimal
- Datum und Uhrzeit
- Arrays und Sammlungen
- Enumerations
- Boolean
- BigDecimal
In Zeiten, in denen Sie Ihren eigenen Datentyp verwenden, müssen Sie eigene Konverter hinzufügen, damit Struts vor der Anzeige weiß, wie diese Werte konvertiert werden. Betrachten Sie die folgende POJO-KlasseEnvironment.java.
package com.tutorialspoint.struts2;
public class Environment {
private String name;
public Environment(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Dies ist eine sehr einfache Klasse mit einem Attribut namens name, also nichts besonderes an dieser Klasse. Erstellen wir eine weitere Klasse, die Informationen zum System enthält -SystemDetails.java.
Für diese Übung habe ich die Umgebung auf "Entwicklung" und das Betriebssystem auf "Windows XP SP3" fest codiert.
In einem Echtzeitprojekt würden Sie diese Informationen aus der Systemkonfiguration erhalten.
Lassen Sie uns die folgende Aktionsklasse haben -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class SystemDetails extends ActionSupport {
private Environment environment = new Environment("Development");
private String operatingSystem = "Windows XP SP3";
public String execute() {
return SUCCESS;
}
public Environment getEnvironment() {
return environment;
}
public void setEnvironment(Environment environment) {
this.environment = environment;
}
public String getOperatingSystem() {
return operatingSystem;
}
public void setOperatingSystem(String operatingSystem) {
this.operatingSystem = operatingSystem;
}
}Als nächstes erstellen wir eine einfache JSP-Datei System.jsp um die Umgebungs- und Betriebssysteminformationen anzuzeigen.
<%@ 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>System Details</title>
</head>
<body>
Environment: <s:property value = "environment"/><br/>
Operating System:<s:property value = "operatingSystem"/>
</body>
</html>Lassen Sie uns die verdrahten system.jsp und die SystemDetails.java Klasse zusammen mit struts.xml.
Die SystemDetails-Klasse verfügt über eine einfache execute () -Methode, die die Zeichenfolge "SUCCESS".
<?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 = "system"
class = "com.tutorialspoint.struts2.SystemDetails"
method = "execute">
<result name = "success">/System.jsp</result>
</action>
</package>
</struts>Klicken Sie mit der rechten Maustaste auf den Projektnamen und klicken Sie auf Export > WAR File um 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 zuzugreifen http://localhost:8080/HelloWorldStruts2/system.action. Daraufhin wird der folgende Bildschirm angezeigt:
Was ist falsch an der obigen Ausgabe? Struts weiß, wie die Zeichenfolge "Windows XP SP3" und andere integrierte Datentypen angezeigt und konvertiert werden, weiß jedoch nicht, was mit der Eigenschaft von zu tun istEnvironmentArt. Es heißt einfachtoString() Methode für die Klasse
Um dieses Problem zu beheben, erstellen und registrieren wir jetzt eine einfache TypeConverter für die Klasse Umwelt.
Erstellen Sie eine Klasse namens EnvironmentConverter.java mit den folgenden.
package com.tutorialspoint.struts2;
import java.util.Map;
import org.apache.struts2.util.StrutsTypeConverter;
public class EnvironmentConverter extends StrutsTypeConverter {
@Override
public Object convertFromString(Map context, String[] values, Class clazz) {
Environment env = new Environment(values[0]);
return env;
}
@Override
public String convertToString(Map context, Object value) {
Environment env = (Environment) value;
return env == null ? null : env.getName();
}
}Das EnvironmentConverter erweitert die StrutsTypeConverter Klasse und teilt Struts mit, wie die Umgebung in einen String konvertiert werden soll und umgekehrt, indem zwei Methoden überschrieben werden convertFromString() und convertToString().
Lassen Sie uns diesen Konverter jetzt registrieren, bevor wir ihn in unserer Anwendung verwenden. Es gibt zwei Möglichkeiten, einen Konverter zu registrieren.
Wenn der Konverter nur in einer bestimmten Aktion verwendet wird, müssen Sie eine Eigenschaftendatei erstellen, die als benannt werden muss '[action-class]'converstion.properties.
In unserem Fall erstellen wir eine Datei mit dem Namen SystemDetails-converstion.properties mit folgendem Registrierungseintrag -
environment = com.tutorialspoint.struts2.EnvironmentConverterIm obigen Beispiel ist "Umgebung" der Name der Eigenschaft in der SystemDetails.java Klasse und wir sagen Struts, die zu verwenden EnvironmentConverter zum Konvertieren von und zu dieser Eigenschaft.
Wir werden dies jedoch nicht tun. Stattdessen werden wir diesen Konverter global registrieren, damit er in der gesamten Anwendung verwendet werden kann. Erstellen Sie dazu eine Eigenschaftendatei mit dem Namenxwork-conversion.properties in dem WEBINF/classes Ordner mit der folgenden Zeile
com.tutorialspoint.struts2.Environment = \
com.tutorialspoint.struts2.EnvironmentConverterDadurch wird der Konverter einfach global registriert, so dass Strutskann die Konvertierung jedes Mal automatisch durchführen, wenn sie auf ein Objekt vom Typ Umgebung stößt. Wenn Sie das Programm neu kompilieren und erneut ausführen, erhalten Sie eine bessere Ausgabe wie folgt:
Offensichtlich ist das Ergebnis jetzt besser, was bedeutet, dass unser Struts-Konverter einwandfrei funktioniert.
Auf diese Weise können Sie mehrere Konverter erstellen und registrieren, um sie gemäß Ihren Anforderungen zu verwenden.
Bevor wir mit dem eigentlichen Tutorial für dieses Kapitel beginnen, wollen wir uns einige Definitionen ansehen, die von gegeben sind https://struts.apache.org- -
| Sr.Nr. | Begriff & Beschreibung |
|---|---|
| 1 | TAG Ein kleiner Code, der in JSP, FreeMarker oder Velocity ausgeführt wird. |
| 2 | TEMPLATE Ein bisschen Code, normalerweise in FreeMarker geschrieben, der von bestimmten Tags (HTML-Tags) gerendert werden kann. |
| 3 | THEME Eine Sammlung von Vorlagen, die zusammen gepackt sind, um allgemeine Funktionen bereitzustellen. |
Ich würde auch vorschlagen, das Kapitel Struts2-Lokalisierung durchzugehen, da wir dasselbe Beispiel noch einmal nehmen werden, um unsere Übung durchzuführen.
Wenn Sie eine verwenden Struts 2Tags wie <s: submit ...>, <s: textfield ...> usw. auf Ihrer Webseite generiert das Struts 2-Framework HTML-Code mit einem vorkonfigurierten Stil und Layout. Struts 2 enthält drei integrierte Themen:
| Sr.Nr. | Thema & Beschreibung |
|---|---|
| 1 | SIMPLE theme Ein minimales Thema ohne "Schnickschnack". Das Textfeld-Tag rendert beispielsweise das HTML-Tag <input /> ohne Beschriftung, Validierung, Fehlerberichterstattung oder andere Formatierungen oder Funktionen. |
| 2 | XHTML theme Dies ist das Standardthema, das von Struts 2 verwendet wird. Es bietet alle Grundlagen, die das einfache Design bietet, und fügt verschiedene Funktionen hinzu, z. B. ein zweispaltiges Standardtabellenlayout für HTML, Beschriftungen für HTML, Validierung und Fehlerberichterstattung usw. |
| 3 | CSS_XHTML theme Dieses Thema bietet alle Grundlagen des einfachen Themas und fügt verschiedene Funktionen wie das standardmäßige zweispaltige CSS-basierte Layout hinzu, wobei <div> für die HTML-Struts-Tags und Beschriftungen für jedes der HTML-Struts-Tags verwendet werden, die gemäß dem CSS-Stylesheet platziert werden . |
Wie oben erwähnt, verwendet Struts 2 standardmäßig das xhtml-Thema, wenn Sie kein Thema angeben. Zum Beispiel dieses Struts 2-Auswahl-Tag -
<s:textfield name = "name" label = "Name" />generiert folgendes HTML-Markup -
<tr>
<td class="tdLabel">
<label for = "empinfo_name" class="label">Name:</label>
</td>
<td>
<input type = "text" name = "name" value = "" id = "empinfo_name"/>
</td>
</tr>Hier empinfo ist der in der Datei struts.xml definierte Aktionsname.
Themen auswählen
Sie können das Thema gemäß Struts 2 auf Tag-Basis angeben oder eine der folgenden Methoden verwenden, um anzugeben, welches Thema Struts 2 verwenden soll.
Das Themenattribut für das jeweilige Tag
Das Themenattribut auf dem umgebenden Formular-Tag eines Tags
Das seitenbezogene Attribut mit dem Namen "theme"
Das Attribut mit Anforderungsbereich mit dem Namen "theme"
Das Attribut mit Sitzungsbereich mit dem Namen "theme"
Das anwendungsbezogene Attribut mit dem Namen "theme"
Die Eigenschaft struts.ui.theme in struts.properties (standardmäßig xhtml)
Im Folgenden finden Sie die Syntax, um sie auf Tag-Ebene anzugeben, wenn Sie bereit sind, unterschiedliche Themen für unterschiedliche Tags zu verwenden.
<s:textfield name = "name" label = "Name" theme="xhtml"/>Da es nicht sehr praktisch ist, Themen pro Tag zu verwenden, können wir die Regel einfach in angeben struts.properties Datei mit den folgenden Tags -
# Standard UI theme
struts.ui.theme = xhtml
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the default template type. Either ftl, vm, or jsp
struts.ui.templateSuffix = ftlDas folgende Ergebnis haben wir aus dem Kapitel zur Lokalisierung übernommen, in dem wir das Standardthema mit einer Einstellung verwendet haben struts.ui.theme = xhtml im struts-default.properties Datei, die standardmäßig in der Datei struts2-core.xy.z.jar enthalten ist.
Wie funktioniert ein Thema?
Für ein bestimmtes Thema hat jedes Struts-Tag eine Vorlage wie s:textfield → text.ftl und s:password → password.ftl usw.
Diese Vorlagendateien werden in der Datei struts2-core.xy.z.jar komprimiert. Diese Vorlagendateien behalten für jedes Tag ein vordefiniertes HTML-Layout bei.
Auf diese Weise, Struts 2 Das Framework generiert den endgültigen HTML-Markup-Code mithilfe von Sturts-Tags und zugehörigen Vorlagen.
Struts 2 tags + Associated template file = Final HTML markup code.Standardvorlagen sind in FreeMarker geschrieben und haben eine Erweiterung .ftl.
Sie können Ihre Vorlagen auch mit Velocity oder JSP entwerfen und die Konfiguration in struts.properties mit entsprechend festlegen struts.ui.templateSuffix und struts.ui.templateDir.
Neue Themen erstellen
Der einfachste Weg, ein neues Thema zu erstellen, besteht darin, eine der vorhandenen Themen- / Vorlagendateien zu kopieren und die erforderlichen Änderungen vorzunehmen.
Beginnen wir mit der Erstellung eines Ordners namens templatein WebContent / WEBINF / classes und einem Unterordner mit dem Namen unseres neuen Themas. Zum Beispiel WebContent / WEB-INF / classes / template / mytheme .
Von hier aus können Sie Vorlagen von Grund auf neu erstellen oder die Vorlagen auch aus dem kopieren Struts2 distribution Hier können Sie sie in Zukunft nach Bedarf ändern.
Wir werden die vorhandene Standardvorlage ändern xhtmlzum Lernen. Kopieren wir nun den Inhalt von struts2-core-xyzjar / template / xhtml in unser Themenverzeichnis und ändern Sie nur die .ftl-Datei WebContent / WEBINF / classes / template / mytheme / control . Wenn wir control.ftl öffnen, werden die folgenden Zeilen angezeigt:
<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>Lassen Sie uns die obige Datei ändern control.ftl folgenden Inhalt haben -
<table style = "border:1px solid black;">Wenn Sie überprüfen werden form.ftl dann wirst du das finden control.ftlwird in dieser Datei verwendet, aber form.ftl verweist auf diese Datei aus dem xhtml-Thema. Ändern wir es also wie folgt:
<#include "/${parameters.templateDir}/xhtml/form-validate.ftl" />
<#include "/${parameters.templateDir}/simple/form-common.ftl" /> <#if (parameters.validate?default(false))> onreset = "${parameters.onreset?default('clearErrorMessages(this);\
clearErrorLabels(this);')}"
<#else>
<#if parameters.onreset??>
onreset="${parameters.onreset?html}" </#if> </#if> #include "/${parameters.templateDir}/mytheme/control.ftl" />Ich gehe davon aus, dass Sie nicht viel Verständnis für das haben würden FreeMarker Vorlagensprache, dennoch können Sie eine gute Vorstellung davon bekommen, was zu tun ist, indem Sie sich die .ftl-Dateien ansehen.
Lassen Sie uns jedoch die obigen Änderungen speichern und zu unserem Lokalisierungsbeispiel zurückkehren und das erstellen WebContent/WEB-INF/classes/struts.properties Datei mit folgendem Inhalt
# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftlKlicken Sie nun nach dieser Änderung 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. Daraufhin wird der folgende Bildschirm angezeigt:
Sie können einen Rahmen um die Formularkomponente sehen, der das Ergebnis der Änderung ist, die wir an unserem Thema vorgenommen haben, nachdem wir es aus dem xhtml-Thema kopiert haben. Wenn Sie wenig Aufwand beim Erlernen von FreeMarker betreiben, können Sie Ihre Themen sehr einfach erstellen oder ändern.
Ich hoffe, dass Sie jetzt ein grundlegendes Verständnis haben Sturts 2 Themen und Vorlagen, nicht wahr?
StrutsBietet eine einfachere Möglichkeit, nicht erfasste Ausnahmen zu behandeln und Benutzer auf eine dedizierte Fehlerseite umzuleiten. Sie können Struts einfach so konfigurieren, dass für verschiedene Ausnahmen unterschiedliche Fehlerseiten vorhanden sind.
Struts erleichtert die Ausnahmebehandlung durch die Verwendung des Interceptors "Ausnahme". Der Interceptor "Ausnahme" ist Teil des Standardstapels, sodass Sie keine zusätzlichen Schritte ausführen müssen, um ihn zu konfigurieren. Es ist sofort einsatzbereit und kann verwendet werden.
Sehen wir uns ein einfaches Hello World-Beispiel mit einigen Änderungen in der Datei HelloWorldAction.java an. Hier haben wir bewusst eine NullPointer-Ausnahme in unsere eingeführtHelloWorldAction Aktionscode.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport{
private String name;
public String execute(){
String x = null;
x = x.substring(0);
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Lassen Sie uns den Inhalt von behalten HelloWorld.jsp wie folgt -
<%@ 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>Es folgt der Inhalt von index.jsp - -
<%@ 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>Ihre struts.xml sollte aussehen wie -
<?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">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Klicken Sie nun 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 einen Wert "Struts2" ein und senden Sie die Seite. Sie sollten die folgende Seite sehen -
Wie im obigen Beispiel gezeigt, leistet der Standardausnahmeabfangjäger hervorragende Arbeit bei der Behandlung der Ausnahme.
Lassen Sie uns jetzt eine eigene Fehlerseite für unsere Ausnahme erstellen. Erstellen Sie eine Datei mit dem NamenError.jsp mit folgenden Inhalten -
<%@ 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></title>
</head>
<body>
This is my custom error page
</body>
</html>Lassen Sie uns nun Struts so konfigurieren, dass diese Fehlerseite im Falle einer Ausnahme verwendet wird. Lassen Sie uns das ändernstruts.xml 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">
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Wie im obigen Beispiel gezeigt, haben wir Struts jetzt so konfiguriert, dass die dedizierte Datei Error.jsp für die NullPointerException verwendet wird. Wenn Sie das Programm jetzt erneut ausführen, wird nun die folgende Ausgabe angezeigt:
Darüber hinaus verfügt das Struts2-Framework über einen Interceptor zum Protokollieren der Ausnahmen. Indem der Logger die nicht erfassten Ausnahmen protokollieren kann, können wir die Stapelverfolgung einfach überprüfen und herausfinden, was schief gelaufen ist
Globale Ausnahmezuordnungen
Wir haben gesehen, wie wir mit aktionsspezifischen Ausnahmen umgehen können. Wir können global eine Ausnahme festlegen, die für alle Aktionen gilt. Um beispielsweise dieselben NullPointerException-Ausnahmen abzufangen, könnten wir hinzufügen<global-exception-mappings...> Das Tag im Tag <package ...> und das Tag <result ...> sollten wie folgt im Tag <action ...> in der Datei struts.xml hinzugefügt werden.
<?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">
<global-exception-mappings>
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
</global-exception-mappings>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Wie bereits erwähnt, bietet Struts zwei Konfigurationsformen. Der traditionelle Weg ist die Verwendung derstruts.xmlDatei für alle Konfigurationen. Wir haben bisher so viele Beispiele dafür im Tutorial gesehen. Die andere Möglichkeit zum Konfigurieren von Struts ist die Verwendung der Java 5 Annotations-Funktion. Mit den Strebenanmerkungen können wir erreichenZero Configuration.
Um Anmerkungen in Ihrem Projekt zu verwenden, stellen Sie sicher, dass Sie die folgenden JAR-Dateien in Ihr Projekt aufgenommen haben WebContent/WEB-INF/lib Ordner -
- struts2-convention-plugin-x.y.z.jar
- asm-x.y.jar
- antlr-x.y.z.jar
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
Lassen Sie uns nun sehen, wie Sie die im Internet verfügbare Konfiguration beseitigen können struts.xml Datei und ersetzen Sie es durch Anmerkungen.
Um das Konzept der Annotation in Struts2 zu erläutern, müssten wir unser im Kapitel Struts2-Validierungen erläutertes Validierungsbeispiel überdenken .
Hier nehmen wir ein Beispiel eines Mitarbeiters, dessen Name und Alter auf einer einfachen Seite erfasst werden, und wir werden zwei Validierungen vornehmen, um sicherzustellen, dass ÜSER immer einen Namen eingibt und das Alter zwischen 28 und 65 Jahren liegen sollte.
Beginnen wir mit der JSP-Hauptseite des Beispiels.
Hauptseite erstellen
Lassen Sie uns die Hauptseite der JSP-Datei schreiben index.jsp, mit dem oben erwähnte mitarbeiterbezogene Informationen gesammelt werden.
<%@ 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>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>Die index.jsp verwendet das Struts-Tag, das wir noch nicht behandelt haben, aber wir werden sie in Tags-bezogenen Kapiteln untersuchen. Nehmen wir zunächst an, dass das Tag s: textfield ein Eingabefeld und das Tag s: submit eine Schaltfläche zum Senden druckt. Wir haben die Label-Eigenschaft für jedes Tag verwendet, wodurch ein Label für jedes Tag erstellt wird.
Ansichten erstellen
Wir werden JSP-Datei verwenden success.jsp Dies wird aufgerufen, wenn die definierte Aktion zurückkehrt SUCCESS.
<%@ 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>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>Aktion erstellen
Dies ist der Ort, an dem Anmerkungen verwendet werden. Lassen Sie uns die Aktionsklasse neu definierenEmployee mit Annotation und fügen Sie dann eine Methode mit dem Namen hinzu validate () wie unten in gezeigt Employee.javaDatei. Stellen Sie sicher, dass Ihre Aktionsklasse die erweitertActionSupport Klasse, andernfalls wird Ihre Validierungsmethode nicht ausgeführt.
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import com.opensymphony.xwork2.validator.annotations.*;
@Results({
@Result(name = "success", Location = "/success.jsp"),
@Result(name = "input", Location = "/index.jsp")
})
public class Employee extends ActionSupport {
private String name;
private int age;
@Action(value = "/empinfo")
public String execute() {
return SUCCESS;
}
@RequiredFieldValidator( message = "The name is required" )
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@IntRangeFieldValidator(message = "Age must be in between 28 and 65", min = "29", max = "65")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}In diesem Beispiel haben wir nur wenige Anmerkungen verwendet. Lassen Sie mich sie einzeln durchgehen -
Zunächst haben wir die aufgenommen ResultsAnmerkung. Eine Ergebnisanmerkung ist eine Sammlung von Ergebnissen.
Unter der Ergebnisanmerkung befinden sich zwei Ergebnisanmerkungen. Die Ergebnisanmerkungen haben dienamedas entspricht dem Ergebnis der Ausführungsmethode. Sie enthalten auch einen Speicherort, an dem die Ansicht bereitgestellt werden soll, die dem Rückgabewert von execute () entspricht.
Die nächste Anmerkung ist die ActionAnmerkung. Dies wird verwendet, um die execute () -Methode zu dekorieren. Die Action-Methode nimmt auch einen Wert an, der die URL ist, unter der die Aktion aufgerufen wird.
Schließlich habe ich zwei verwendet validationAnmerkungen. Ich habe den erforderlichen Feldvalidator aktiviertname Feld und der Integer Range Validator auf dem ageFeld. Ich habe auch eine benutzerdefinierte Nachricht für die Validierungen angegeben.
Konfigurationsdateien
Wir brauchen das wirklich nicht struts.xml Konfigurationsdatei, also lassen Sie uns diese Datei entfernen und den Inhalt von überprüfen web.xml Datei -
<?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>
<init-param>
<param-name>struts.devMode</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Klicken Sie nun 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 jetzt keine erforderlichen Informationen ein, klicken Sie einfach auf SubmitTaste. Sie sehen folgendes Ergebnis:
Geben Sie die erforderlichen Informationen ein, aber geben Sie ein falsches From-Feld ein. Sagen Sie den Namen als "Test" und das Alter als 30 und klicken Sie schließlich auf SubmitTaste. Sie sehen folgendes Ergebnis:
Streben 2 Anmerkungstypen
Struts 2-Anwendungen können Java 5-Anmerkungen als Alternative zur Konfiguration von XML- und Java-Eigenschaften verwenden. Sie können die Liste der wichtigsten Anmerkungen zu verschiedenen Kategorien überprüfen.
Streben 2 Anmerkungstypen .
Die Struts 2-Tags verfügen über eine Reihe von Tags, mit denen der Ablauf der Seitenausführung einfach gesteuert werden kann.
Es folgt die Liste der wichtigen Struts 2 Control Tags -
Die If- und Else-Tags
Diese Tags führen einen Grundbedingungsfluss aus, der in jeder Sprache zu finden ist.
'If' Tag wird alleine oder mit verwendet 'Else If' Tag und / oder Single / Multiple 'Else' Tag wie unten gezeigt -
<s:if test = "%{false}">
<div>Will Not Be Executed</div>
</s:if>
<s:elseif test = "%{true}">
<div>Will Be Executed</div>
</s:elseif>
<s:else>
<div>Will Not Be Executed</div>
</s:else>Überprüfen Sie das detaillierte Beispiel
Die Iterator-Tags
Diese iteratorwird über einen Wert iterieren. Ein iterierbarer Wert kann entweder die Datei itherjava.util.Collection oder java.util.Iterator sein. Während Sie über einen Iterator iterieren, können Sie verwendenSort Tag, um das Ergebnis zu sortieren oder SubSet Tag, um eine Teilmenge der Liste oder des Arrays abzurufen.
Im folgenden Beispiel wird der Wert der Methode getDays () des aktuellen Objekts auf dem Wertestapel abgerufen und zum Durchlaufen verwendet.
Das Tag <s: property /> druckt den aktuellen Wert des Iterators aus.
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>Überprüfen Sie das detaillierte Beispiel
Das Merge-Tag
Diese merge Tag verwendet zwei oder mehr Listen als Parameter und führt sie alle wie unten gezeigt zusammen.
<s:merge var = "myMergedIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:merge>
<s:iterator value = "%{#myMergedIterator}">
<s:property />
</s:iterator>Überprüfen Sie das detaillierte Beispiel
Das Append-Tag
Diese append Tag Nehmen Sie zwei oder mehr Listen als Parameter und hängen Sie sie alle wie unten gezeigt an -
<s:append var = "myAppendIterator">
<s:param value = "%{myList1}" />
<s:param value = "%{myList2}" />
<s:param value = "%{myList3}" />
</s:append>
<s:iterator value = "%{#myAppendIterator}">
<s:property />
</s:iterator>Überprüfen Sie das detaillierte Beispiel
Das Generator-Tag
Diese generatorTag generiert einen Iterator basierend auf dem angegebenen val-Attribut. Das folgende Generator-Tag generiert einen Iterator und druckt ihn mit dem Iterator-Tag aus.
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>Überprüfen Sie das detaillierte Beispiel
Die Streben 2 data tagswerden hauptsächlich verwendet, um die auf einer Seite angezeigten Daten zu bearbeiten. Nachfolgend sind die wichtigen Daten-Tags aufgeführt: <Hier starten>
Das Action-Tag
Mit diesem Tag können Entwickler Aktionen direkt von einer JSP-Seite aus aufrufen, indem sie den Aktionsnamen und einen optionalen Namespace angeben. Der Body-Inhalt des Tags wird verwendet, um die Ergebnisse der Aktion zu rendern. Jeder für diese Aktion in struts.xml definierte Ergebnisprozessor wird ignoriert, sofern nicht der Parameter executeResult angegeben ist.
<div>Tag to execute the action</div>
<br />
<s:action name = "actionTagAction" executeresult = "true" />
<br />
<div>To invokes special method in action class</div>
<br />
<s:action name = "actionTagAction!specialMethod" executeresult = "true" />Überprüfen Sie das detaillierte Beispiel
Das Include-Tag
Diese include wird verwendet, um eine JSP-Datei in eine andere JSP-Seite aufzunehmen.
<-- First Syntax -->
<s:include value = "myJsp.jsp" />
<-- Second Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1" value = "value2" />
<s:param name = "param2" value = "value2" />
</s:include>
<-- Third Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1">value1</s:param>
<s:param name = "param2">value2</s:param>
</s:include>Überprüfen Sie das detaillierte Beispiel
Der Bohnenanhänger
Diese beanTag instanziiert eine Klasse, die der JavaBeans-Spezifikation entspricht. Dieses Tag hat einen Body, der eine Reihe von Param-Elementen enthalten kann, um Mutator-Methoden für diese Klasse festzulegen. Wenn das var-Attribut auf dem BeanTag festgelegt ist, wird die instanziierte Bean in den Kontext des Stapels eingefügt.
<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
<s:param name = "first" value = "20"/>
<s:param name = "last" value = "25" />
</s:bean>Überprüfen Sie das detaillierte Beispiel
Das Datums-Tag
Diese dateMit dem Tag können Sie ein Datum schnell und einfach formatieren. Sie können ein benutzerdefiniertes Format angeben (z. B. "TT / MM / JJJJ HH: MM"), leicht lesbare Notationen erstellen (z. B. "in 2 Stunden, 14 Minuten") oder einfach auf ein vordefiniertes Format mit zurückgreifen Geben Sie 'struts.date.format' in Ihre Eigenschaftendatei ein.
<s:date name = "person.birthday" format = "dd/MM/yyyy" />
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}" />
<s:date name = "person.birthday" nice="true" />
<s:date name = "person.birthday" />Überprüfen Sie das detaillierte Beispiel
Das Param-Tag
Diese paramTag kann verwendet werden, um andere Tags zu parametrisieren. Dieses Tag hat die folgenden zwei Parameter.
name (String) - Der Name des Parameters
value (Object) - der Wert des Parameters
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>Überprüfen Sie das detaillierte Beispiel
Das Eigenschaftstag
Diese property Tag wird verwendet, um die Eigenschaft eines Werts abzurufen, der standardmäßig oben im Stapel angezeigt wird, wenn keiner angegeben ist.
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty" />
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value" />
</s:push>Überprüfen Sie das detaillierte Beispiel
Das Push-Tag
Diese push Tag wird verwendet, um den Wert auf dem Stapel zu verschieben, um die Verwendung zu vereinfachen.
<s:push value = "user">
<s:propery value = "firstName" />
<s:propery value = "lastName" />
</s:push>Überprüfen Sie das detaillierte Beispiel
Das Set-Tag
Diese setTag weist einer Variablen in einem bestimmten Bereich einen Wert zu. Dies ist nützlich, wenn Sie einem komplexen Ausdruck eine Variable zuweisen und dann jedes Mal einfach auf diese Variable anstatt auf den komplexen Ausdruck verweisen möchten. Die verfügbaren Bereiche sindapplication, session, request, page und action.
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>Überprüfen Sie das detaillierte Beispiel
Das Text-Tag
Diese text Tag wird zum Rendern einer I18n-Textnachricht verwendet.
<!-- First Example -->
<s:i18n name = "struts.action.test.i18n.Shop">
<s:text name = "main.title"/>
</s:i18n>
<!-- Second Example -->
<s:text name = "main.title" />
<!-- Third Examlpe -->
<s:text name = "i18n.label.greetings">
<s:param >Mr Smith</s:param>
</s:text>Überprüfen Sie das detaillierte Beispiel
Das URL-Tag
Diese url Tag wird verwendet, um eine URL zu erstellen.
<-- Example 1 -->
<s:url value = "editGadget.action">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 2 -->
<s:url action = "editGadget">
<s:param name = "id" value = "%{selected}" />
</s:url>
<-- Example 3-->
<s:url includeParams="get">
<s:param name = "id" value = "%{'22'}" />
</s:url>Überprüfen Sie das detaillierte Beispiel
Die Liste der formTags ist eine Teilmenge der Struts UI-Tags. Diese Tags helfen beim Rendern der für die Struts-Webanwendungen erforderlichen Benutzeroberfläche und können in drei Kategorien eingeteilt werden. In diesem Kapitel werden Sie durch alle drei Arten von UI-Tags geführt.
Einfache UI-Tags
Wir haben diese Tags bereits in unseren Beispielen verwendet, wir werden sie in diesem Kapitel bürsten. Lassen Sie uns eine einfache Ansichtsseite betrachtenemail.jsp mit mehreren einfachen UI-Tags -
<%@ 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>
<s:head/>
<title>Hello World</title>
</head>
<body>
<s:div>Email Form</s:div>
<s:text name = "Please fill in the form below:" />
<s:form action = "hello" method = "post" enctype = "multipart/form-data">
<s:hidden name = "secret" value = "abracadabra"/>
<s:textfield key = "email.from" name = "from" />
<s:password key = "email.password" name = "password" />
<s:textfield key = "email.to" name = "to" />
<s:textfield key = "email.subject" name = "subject" />
<s:textarea key = "email.body" name = "email.body" />
<s:label for = "attachment" value = "Attachment"/>
<s:file name = "attachment" accept = "text/html,text/plain" />
<s:token />
<s:submit key = "submit" />
</s:form>
</body>
</html>Wenn Sie HTML kennen, sind alle verwendeten Tags sehr gebräuchliche HTML-Tags mit einem zusätzlichen Präfix s:zusammen mit jedem Tag und verschiedenen Attributen. Wenn wir das obige Programm ausführen, erhalten wir die folgende Benutzeroberfläche, vorausgesetzt, Sie haben die richtige Zuordnung für alle verwendeten Schlüssel eingerichtet.
Wie gezeigt, generiert der s: head die für die Struts2-Anwendung erforderlichen Javascript- und Stylesheet-Elemente.
Als nächstes haben wir die Textelemente s: div und s:. Mit s: div wird ein HTML Div-Element gerendert. Dies ist nützlich für Personen, die HTML- und Struts-Tags nicht miteinander mischen möchten. Für diese Leute haben sie die Wahl, s: div zu verwenden, um ein div zu rendern.
Der gezeigte s: -Text wird verwendet, um einen Text auf dem Bildschirm zu rendern.
Als nächstes haben wir das famiilar s: form Tag. Das s: form-Tag verfügt über ein Aktionsattribut, das bestimmt, wohin das Formular gesendet werden soll. Da das Formular ein Element zum Hochladen von Dateien enthält, müssen wir den Enctype auf mehrteilig festlegen. Andernfalls können wir dieses Feld leer lassen.
Am Ende des Formular-Tags befindet sich das Tag s: submit. Dies wird verwendet, um das Formular zu senden. Wenn das Formular gesendet wird, werden alle Formularwerte an die im Tag s: form angegebene Aktion gesendet.
In der s: -Form haben wir ein verstecktes Attribut namens secret. Dies rendert ein verstecktes Element im HTML. In unserem Fall hat das "geheime" Element den Wert "Abrakadabra". Dieses Element ist für den Endbenutzer nicht sichtbar und wird verwendet, um den Status von einer Ansicht in eine andere zu übertragen.
Als nächstes haben wir die Tags s: label, s: textfield, s: password und s: textarea. Diese werden verwendet, um die Beschriftung, das Eingabefeld, das Kennwort bzw. den Textbereich zu rendern. Wir haben diese im Beispiel "Streben - E-Mail senden" in Aktion gesehen.
Das Wichtigste dabei ist die Verwendung des Attributs "Schlüssel". Das Attribut "key" wird verwendet, um die Bezeichnung für diese Steuerelemente aus der Eigenschaftendatei abzurufen. Wir haben diese Funktion bereits im Kapitel Struts2-Lokalisierung, Internationalisierung behandelt.
Dann haben wir das s: file-Tag, das eine Upload-Komponente für Eingabedateien rendert. Mit dieser Komponente kann der Benutzer Dateien hochladen. In diesem Beispiel haben wir den Parameter "accept" des s: file-Tags verwendet, um anzugeben, welche Dateitypen hochgeladen werden dürfen.
Endlich haben wir das s: token Tag. Das Token-Tag generiert ein eindeutiges Token, mit dem ermittelt wird, ob ein Formular doppelt gesendet wurde
Beim Rendern des Formulars wird eine versteckte Variable als Token-Wert platziert. Nehmen wir zum Beispiel an, das Token ist "ABC". Wenn dieses Formular gesendet wird, vergleicht der Struts Fitler das Token mit dem in der Sitzung gespeicherten Token. Wenn es übereinstimmt, wird das Token aus der Sitzung entfernt. Wenn das Formular nun versehentlich erneut gesendet wird (entweder durch Aktualisieren oder durch Drücken der Zurück-Schaltfläche des Browsers), wird das Formular mit "ABC" als Token erneut gesendet. In diesem Fall vergleicht der Filter das Token erneut mit dem in der Sitzung gespeicherten Token. Da das Token "ABC" aus der Sitzung entfernt wurde, stimmt es nicht überein und der Struts-Filter lehnt die Anforderung ab.
Gruppen-UI-Tags
Die Gruppen-UI-Tags werden zum Erstellen des Optionsfelds und des Kontrollkästchens verwendet. Lassen Sie uns eine einfache Ansichtsseite betrachtenHelloWorld.jsp mit Kontrollkästchen und Optionsfeld-Tags -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "hello.action">
<s:radio label = "Gender" name = "gender" list="{'male','female'}" />
<s:checkboxlist label = "Hobbies" name = "hobbies"
list = "{'sports','tv','shopping'}" />
</s:form>
</body>
</html>Wenn wir das obige Programm ausführen, sieht unsere Ausgabe wie folgt aus:
Schauen wir uns jetzt das Beispiel an. Im ersten Beispiel erstellen wir ein einfaches Optionsfeld mit der Bezeichnung "Geschlecht". Das Namensattribut ist für das Optionsfeld-Tag obligatorisch, daher geben wir einen Namen an, der "Geschlecht" ist. Wir liefern dann eine Liste nach Geschlecht. Die Liste wird mit den Werten "männlich" und "weiblich" gefüllt. Daher erhalten wir in der Ausgabe ein Optionsfeld mit zwei Werten.
Im zweiten Beispiel erstellen wir eine Checkbox-Liste. Dies dient dazu, die Hobbys des Benutzers zu sammeln. Der Benutzer kann mehr als ein Hobby haben und daher verwenden wir das Kontrollkästchen anstelle des Radiobuttons. Das Kontrollkästchen enthält die Liste "Sport", "Fernsehen" und "Einkaufen". Dies präsentiert die Hobbys als Checkbox-Liste.
Wählen Sie UI-Tags
Lassen Sie uns die verschiedenen Variationen des von Struts angebotenen Select-Tags untersuchen. Lassen Sie uns eine einfache Ansichtsseite betrachtenHelloWorld.jsp mit ausgewählten Tags -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "login.action">
<s:select name = "username" label = "Username"
list = "{'Mike','John','Smith'}" />
<s:select label = "Company Office" name = "mySelection"
value = "%{'America'}" list="%{#{'America':'America'}}">
<s:optgroup label = "Asia"
list = "%{#{'India':'India','China':'China'}}" />
<s:optgroup label = "Europe"
list="%{#{'UK':'UK','Sweden':'Sweden','Italy':'Italy'}}" />
</s:select>
<s:combobox label = "My Sign" name = "mySign"
list = "#{'aries':'aries','capricorn':'capricorn'}" headerkey = "-1"
headervalue = "--- Please Select ---" emptyOption = "true" value = "capricorn" />
<s:doubleselect label = "Occupation" name = "occupation"
list = "{'Technical','Other'}" doublename = "occupations2"
doubleList="top == 'Technical' ?
{'I.T', 'Hardware'} : {'Accounting', 'H.R'}" />
</s:form>
</body>
</html>Wenn wir das obige Programm ausführen, sieht unsere Ausgabe wie folgt aus:
Lassen Sie uns nun die einzelnen Fälle einzeln durchgehen.
Zunächst rendert das Auswahl-Tag das HTML-Auswahlfeld. Im ersten Beispiel erstellen wir ein einfaches Auswahlfeld mit dem Namen "Benutzername" und der Bezeichnung "Benutzername". Das Auswahlfeld wird mit einer Liste gefüllt, die die Namen Mike, John und Smith enthält.
Im zweiten Beispiel hat unser Unternehmen seinen Hauptsitz in Amerika. Es hat auch globale Niederlassungen in Asien und Europa. Wir möchten die Büros in einem Auswahlfeld anzeigen, aber wir möchten die globalen Büros nach dem Namen des Kontinents gruppieren. Hier bietet sich die optgroup an. Wir verwenden das Tag s: optgroup, um eine neue Gruppe zu erstellen. Wir geben der Gruppe ein Label und eine separate Liste.
Im dritten Beispiel wird die Combobox verwendet. Ein Kombinationsfeld ist eine Kombination aus einem Eingabefeld und einem Auswahlfeld. Der Benutzer kann entweder einen Wert aus dem Auswahlfeld auswählen. In diesem Fall wird das Eingabefeld automatisch mit dem vom Benutzer ausgewählten Wert ausgefüllt. Sollte der Benutzer einen Wert direkt eingeben, werden keine Werte aus dem Auswahlfeld ausgewählt.
In unserem Beispiel haben wir die Combobox, in der die Sonnenzeichen aufgelistet sind. Das Auswahlfeld listet nur vier Einträge auf, mit denen der Benutzer sein Sonnenzeichen eingeben kann, wenn es nicht in der Liste enthalten ist. Wir fügen dem Auswahlfeld auch einen Kopfzeileneintrag hinzu. Der Header-Eintrag wird oben im Auswahlfeld angezeigt. In unserem Fall möchten wir "Bitte auswählen" anzeigen. Wenn der Benutzer nichts auswählt, nehmen wir -1 als Wert an. In einigen Fällen möchten wir nicht, dass der Benutzer einen leeren Wert auswählt. Unter diesen Bedingungen würde man die Eigenschaft "emptyOption" auf false setzen. Schließlich geben wir in unserem Beispiel "Steinbock" als Standardwert für die Combobox an.
Im vierten Beispiel haben wir eine doppelte Auswahl. Eine doppelte Auswahl wird verwendet, wenn Sie zwei Auswahlfelder anzeigen möchten. Der im ersten Auswahlfeld ausgewählte Wert bestimmt, was im zweiten Auswahlfeld angezeigt wird. In unserem Beispiel zeigt das erste Auswahlfeld "Technisch" und "Andere" an. Wenn der Benutzer Technisch auswählt, werden IT und Hardware im zweiten Auswahlfeld angezeigt. Andernfalls werden Buchhaltung und Personal angezeigt. Dies ist mit den Attributen "list" und "doubleList" möglich, wie im Beispiel gezeigt.
Im obigen Beispiel haben wir einen Vergleich durchgeführt, um festzustellen, ob das obere Auswahlfeld gleich "Technisch" ist. Wenn ja, zeigen wir IT und Hardware an.
Wir müssen auch einen Namen für das obere Feld ("name = 'Berufe') und das untere Feld (doubleName = 'Berufe2') angeben.
Struts verwendet das DOJO-Framework für die Implementierung des AJAX-Tags. Um mit diesem Beispiel fortzufahren, müssen Sie zunächst struts2-dojo-plugin-2.2.3.jar zu Ihrem Klassenpfad hinzufügen.
Sie können diese Datei aus dem lib-Ordner Ihres struts2-Downloads herunterladen (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar).
Lassen Sie uns für diese Übungen Änderungen vornehmen HelloWorld.jsp wie folgt -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<%@ taglib prefix = "sx" uri = "/struts-dojo-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
<sx:head />
</head>
<body>
<s:form>
<sx:autocompleter label = "Favourite Colour"
list = "{'red','green','blue'}" />
<br />
<sx:datetimepicker name = "deliverydate" label = "Delivery Date"
displayformat = "dd/MM/yyyy" />
<br />
<s:url id = "url" value = "/hello.action" />
<sx:div href="%{#url}" delay="2000">
Initial Content
</sx:div>
<br/>
<sx:tabbedpanel id = "tabContainer">
<sx:div label = "Tab 1">Tab 1</sx:div>
<sx:div label = "Tab 2">Tab 2</sx:div>
</sx:tabbedpanel>
</s:form>
</body>
</html>Wenn wir das obige Beispiel ausführen, erhalten wir die folgende Ausgabe:
Lassen Sie uns nun Schritt für Schritt durch dieses Beispiel gehen.
Als erstes ist das Hinzufügen einer neuen Tag-Bibliothek mit dem Präfix sx zu beachten. Dies (struts-dojo-tags) ist die Tag-Bibliothek, die speziell für die Ajax-Integration erstellt wurde.
Dann nennen wir im HTML-Kopf den sx: head. Dadurch wird das Dojo-Framework initialisiert und für alle AJAX-Aufrufe auf der Seite vorbereitet. Dieser Schritt ist wichtig - Ihre Ajax-Aufrufe funktionieren nicht, ohne dass der sx: head initialisiert wird.
Zuerst haben wir das Autocompleter-Tag. Das Autocompleter-Tag ähnelt einem Auswahlfeld. Es wird mit den Werten Rot, Grün und Blau gefüllt. Der Unterschied zwischen einem Auswahlfeld und diesem ist jedoch, dass es automatisch vervollständigt wird. Das heißt, wenn Sie anfangen, gr einzugeben, wird es mit "grün" gefüllt. Abgesehen davon ist dieses Tag dem s: select-Tag, das wir zuvor behandelt haben, sehr ähnlich.
Als nächstes haben wir eine Datums- / Uhrzeitauswahl. Dieses Tag erstellt ein Eingabefeld mit einer Schaltfläche daneben. Wenn die Taste gedrückt wird, wird eine Popup-Datums- / Uhrzeitauswahl angezeigt. Wenn der Benutzer ein Datum auswählt, wird das Datum in dem im Tag-Attribut angegebenen Format in den Eingabetext eingetragen. In unserem Beispiel haben wir TT / MM / JJJJ als Format für das Datum angegeben.
Als Nächstes erstellen wir ein URL-Tag für die Datei system.action, die wir in den vorherigen Übungen erstellt haben. Es muss nicht die system.action sein - es kann sich um eine beliebige Aktionsdatei handeln, die Sie zuvor erstellt haben. Dann haben wir ein Div mit dem Hyperlink auf die URL und der Verzögerung auf 2 Sekunden. Wenn Sie dies ausführen, wird der "Anfangsinhalt" 2 Sekunden lang angezeigt, und der Inhalt des Div wird durch den Inhalt von ersetzthello.action Ausführung.
Schließlich haben wir ein einfaches Registerkartenfeld mit zwei Registerkarten. Die Registerkarten sind Divs selbst mit den Bezeichnungen Tab 1 und Tab2.
Es sollte beachtet werden, dass die AJAX-Tag-Integration in Struts noch in Arbeit ist und die Reife dieser Integration mit jeder Veröffentlichung langsam zunimmt.
Spring ist ein beliebtes Webframework, das eine einfache Integration mit vielen gängigen Webaufgaben ermöglicht. Die Frage ist also, warum brauchen wir Frühling, wenn wir Struts2 haben? Nun, Spring ist mehr als ein MVC-Framework - es bietet viele andere Extras, die in Struts nicht verfügbar sind.
Zum Beispiel: Abhängigkeitsinjektion, die für jedes Framework nützlich sein kann. In diesem Kapitel werden wir anhand eines einfachen Beispiels sehen, wie Spring und Struts2 zusammen integriert werden.
Zunächst müssen Sie die folgenden Dateien aus der Spring-Installation zum Erstellungspfad des Projekts hinzufügen. Sie können die neueste Version von Spring Framework von herunterladen und installierenhttps://www.springsource.org/download
- org.springframework.asm-x.y.z.M(a).jar
- org.springframework.beans-x.y.z.M(a).jar
- org.springframework.context-x.y.z.M(a).jar
- org.springframework.core-x.y.z.M(a).jar
- org.springframework.expression-x.y.z.M(a).jar
- org.springframework.web-x.y.z.M(a).jar
- org.springframework.web.servlet-x.y.z.M(a).jar
Zum Schluss hinzufügen struts2-spring-plugin-x.y.z.jar in deiner WEB-INF/libaus Ihrem struts lib-Verzeichnis. Wenn Sie Eclipse verwenden, tritt möglicherweise eine Ausnahme auf : java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .
Um dieses Problem zu beheben, sollten Sie hineingehen müssen MarkerKlicken Sie mit der rechten Maustaste nach rechts auf die Klassenabhängigkeiten und führen Sie eine Schnellkorrektur durch, um alle Abhängigkeiten zu veröffentlichen / exportieren. Stellen Sie schließlich sicher, dass auf der Registerkarte Markierung kein Abhängigkeitskonflikt verfügbar ist.
Lassen Sie uns nun das einrichten web.xml für die Struts-Spring-Integration wie folgt:
<?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>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<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>Wichtig hierbei ist der von uns konfigurierte Listener. DasContextLoaderListenerist erforderlich, um die Spring-Kontextdatei zu laden. Die Konfigurationsdatei von Spring wird aufgerufenapplicationContext.xml Datei und es muss auf der gleichen Ebene wie die platziert werden web.xml Datei
Lassen Sie uns eine einfache Aktionsklasse namens erstellen User.java mit zwei Eigenschaften - Vorname und Nachname.
package com.tutorialspoint.struts2;
public class User {
private String firstName;
private String lastName;
public String execute() {
return "success";
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}Lassen Sie uns nun die erstellen applicationContext.xml Federkonfigurationsdatei und instanziieren Sie die User.javaKlasse. Wie bereits erwähnt, sollte sich diese Datei im Ordner WEB-INF befinden.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id = "userClass" class = "com.tutorialspoint.struts2.User">
<property name = "firstName" value = "Michael" />
<property name = "lastName" value = "Jackson" />
</bean>
</beans>Wie oben gezeigt, haben wir die User Bean konfiguriert und die Werte eingefügt Michael und Jacksonin die Bohne. Wir haben dieser Bean auch den Namen "userClass" gegeben, damit wir sie an anderer Stelle wiederverwenden können. Als nächstes erstellen wir dieUser.jsp im WebContent-Ordner -
<%@ 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 - Spring integration</h1>
<s:form>
<s:textfield name = "firstName" label = "First Name"/><br/>
<s:textfield name = "lastName" label = "Last Name"/><br/>
</s:form>
</body>
</html>Das User.jspDatei ist ziemlich einfach. Es dient nur einem Zweck - der Anzeige der Werte des Vor- und Nachnamens des Benutzerobjekts. Lassen Sie uns abschließend alle Entitäten mit dem zusammenfügenstruts.xml Datei.
<?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 = "user" class="userClass"
method = "execute">
<result name = "success">/User.jsp</result>
</action>
</package>
</struts>Wichtig ist, dass wir die ID verwenden userClasssich auf die Klasse beziehen. Dies bedeutet, dass wir spring verwenden, um die Abhängigkeitsinjektion für die User-Klasse durchzuführen.
Klicken Sie nun 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/User.jsp. Daraufhin wird der folgende Bildschirm angezeigt:
Wir haben jetzt gesehen, wie man zwei großartige Frameworks zusammenbringt. Damit ist das Kapitel Struts - Spring-Integration abgeschlossen.
Lassen Sie uns in diesem Kapitel die Schritte zur Integration des Tiles-Frameworks in Struts2 durchgehen. Apache Tiles ist ein Vorlagen-Framework, das die Entwicklung von Benutzeroberflächen für Webanwendungen vereinfacht.
Zunächst müssen wir die Kacheldateien von der Apache Tiles- Website herunterladen. Sie müssen dem Klassenpfad des Projekts die folgenden JAR-Dateien hinzufügen.
- tiles-api-x.y.z.jar
- tiles-compat-x.y.z.jar
- tiles-core-x.y.z.jar
- tiles-jsp-x.y.z.jar
- tiles-servlet-x.y.z.jar
Darüber hinaus müssen wir die folgenden JAR-Dateien aus dem struts2-Download in Ihre kopieren WEB-INF/lib.
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
Lassen Sie uns nun das einrichten web.xmlfür die Struts-Tiles-Integration wie unten angegeben. Hier sind zwei wichtige Punkte zu beachten. Zuerst müssen wir den Kacheln mitteilen, wo sich die Kacheln-Konfigurationsdatei befindettiles.xml. In unserem Fall wird es unter sein/WEB-INFMappe. Als nächstes müssen wir den Tiles-Listener starten, der mit dem Struts2-Download geliefert wird.
<?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_2_5.xsd"
id = "WebApp_ID" version = "2.5">
<display-name>Struts2Example15</display-name>
<context-param>
<param-name>
org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG
</param-name>
<param-value>
/WEB-INF/tiles.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.apache.struts2.tiles.StrutsTilesListener
</listener-class>
</listener>
<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>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>Als nächstes lassen Sie uns erstellen tiles.xml unter / WEB-INF Ordner mit folgendem Inhalt -
<?xml version = "1.0" Encoding = "UTF-8" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
"http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
<tiles-definitions>
<definition name = "baseLayout" template="/baseLayout.jsp">
<put-attribute name = "title" value = "Template"/>
<put-attribute name = "banner" value = "/banner.jsp"/>
<put-attribute name = "menu" value = "/menu.jsp"/>
<put-attribute name = "body" value = "/body.jsp"/>
<put-attribute name = "footer" value = "/footer.jsp"/>
</definition>
<definition name = "tiger" extends = "baseLayout">
<put-attribute name = "title" value = "Tiger"/>
<put-attribute name = "body" value = "/tiger.jsp"/>
</definition>
<definition name = "lion" extends = "baseLayout">
<put-attribute name = "title" value = "Lion"/>
<put-attribute name = "body" value = "/lion.jsp"/>
</definition>
</tiles-definitions>Als nächstes definieren wir ein grundlegendes Skelettlayout in der baseLayout.jsp. Es verfügt über fünf wiederverwendbare / überschreibbare Bereiche. Nämlichtitle, banner, menu, body und footer. Wir stellen die Standardwerte für das baseLayout bereit und erstellen dann zwei Anpassungen, die vom Standardlayout ausgehen. Das Tiger-Layout ähnelt dem Grundlayout, verwendet jedoch dastiger.jspals sein Körper und der Text "Tiger" als Titel. In ähnlicher Weise ähnelt das Löwenlayout dem Grundlayout, verwendet jedoch daslion.jsp als Körper und der Text "Löwe" als Titel.
Schauen wir uns die einzelnen JSP-Dateien an. Es folgt der Inhalt vonbaseLayout.jsp Datei -
<%@ taglib uri = "http://tiles.apache.org/tags-tiles" prefix = "tiles"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset = UTF-8">
<title>
<tiles:insertAttribute name = "title" ignore="true" />
</title>
</head>
<body>
<tiles:insertAttribute name = "banner" /><br/>
<hr/>
<tiles:insertAttribute name = "menu" /><br/>
<hr/>
<tiles:insertAttribute name = "body" /><br/>
<hr/>
<tiles:insertAttribute name = "footer" /><br/>
</body>
</html>Hier haben wir nur eine einfache HTML-Seite zusammengestellt, die die Kachelattribute enthält. Wir fügen die Kachelattribute an den Stellen ein, an denen sie benötigt werden. Als nächstes erstellen wir einebanner.jsp Datei mit folgendem Inhalt -
<img src="http://www.tutorialspoint.com/images/tp-logo.gif"/>Das menu.jsp Die Datei enthält die folgenden Zeilen, die die Links darstellen - zu den Strut-Aktionen TigerMenu.action und LionMenu.action.
<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>Das lion.jsp Datei wird folgenden Inhalt haben -
<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The lionDas tiger.jsp Datei wird folgenden Inhalt haben -
<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tigerAls nächstes erstellen wir die Aktionsklassendatei MenuAction.java welches das folgende enthält -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}Dies ist eine ziemlich einfache Klasse. Wir haben zwei Methoden tiger () und lion () deklariert, die Tiger und Löwe als Ergebnisse zurückgeben. Lassen Sie uns alles in derstruts.xml Datei -
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name = "default" extends = "struts-default">
<result-types>
<result-type name = "tiles"
class="org.apache.struts2.views.tiles.TilesResult" />
</result-types>
<action name = "*Menu" method = "{1}"
class = "com.tutorialspoint.struts2.MenuAction">
<result name = "tiger" type = "tiles">tiger</result>
<result name = "lion" type = "tiles">lion</result>
</action>
</package>
</struts>Lassen Sie uns überprüfen, was wir in der obigen Datei getan haben. Zunächst haben wir einen neuen Ergebnistyp namens "Kacheln" deklariert, da wir jetzt Kacheln anstelle von einfachem JSP für die Ansichtstechnologie verwenden. Struts2 unterstützt den Ergebnistyp "Kacheln", daher erstellen wir den Ergebnistyp "Kacheln" der Klasse "org.apache.struts2.view.tiles.TilesResult".
Als nächstes möchten wir sagen, ob die Anfrage für /tigerMenu.action ist, den Benutzer zur Seite mit den Tiger-Kacheln bringen und wenn die Anfrage für /lionMenu.action ist, den Benutzer zur Seite mit den Löwenkacheln bringen.
Dies erreichen wir mit ein wenig regulärem Ausdruck. In unserer Aktionsdefinition sagen wir, dass alles, was dem Muster "* Menü" entspricht, von dieser Aktion behandelt wird. Die Übereinstimmungsmethode wird in der MenuAction-Klasse aufgerufen. Das heißt, tigerMenu.action ruft tiger () und lionMenu.action lion () auf. Wir müssen dann das Ergebnis des Ergebnisses den entsprechenden Kachelseiten zuordnen.
Klicken Sie nun 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/tigerMenu.jsp. Daraufhin wird der folgende Bildschirm angezeigt:
Wenn Sie zur Seite lionMenu.action gelangen, wird die Seite Lion angezeigt, die dasselbe Kachellayout verwendet.
Hibernate ist ein leistungsstarker Objekt- / relationaler Persistenz- und Abfragedienst, der unter der Open-Source-Lizenz GNU Lesser General Public License (LGPL) lizenziert ist und kostenlos heruntergeladen werden kann. In diesem Kapitel. Wir werden lernen, wie man die Struts 2-Integration mit Hibernate erreicht. Wenn Sie mit Hibernate nicht vertraut sind, können Sie unser Hibernate-Tutorial lesen .
Datenbank-Setup
Für dieses Tutorial werde ich die MySQL-Datenbank "struts2_tutorial" verwenden. Ich verbinde mich mit dieser Datenbank auf meinem Computer mit dem Benutzernamen "root" und ohne Passwort. Zunächst müssen Sie das folgende Skript ausführen. Dieses Skript erstellt eine neue Tabelle mit dem Namenstudent und erstellt nur wenige Datensätze in dieser Tabelle -
CREATE TABLE IF NOT EXISTS `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`first_name` varchar(40) NOT NULL,
`last_name` varchar(40) NOT NULL,
`marks` int(11) NOT NULL,
PRIMARY KEY (`id`)
);
--
-- Dumping data for table `student`
--
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(3, 'Jessica', 'Drake', 21);Konfiguration im Ruhezustand
Als nächstes erstellen wir die Datei hibernate.cfg.xml, die die Konfigurationsdatei des Ruhezustands ist.
<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.connection.driver_class">c
om.mysql.jdbc.Driver
</property>
<property name = "hibernate.connection.url">
jdbc:mysql://www.tutorialspoint.com/struts_tutorial
</property>
<property name = "hibernate.connection.username">root</property>
<property name = "hibernate.connection.password"></property>
<property name = "hibernate.connection.pool_size">10</property>
<property name = "show_sql">true</property>
<property name = "dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.hbm2ddl.auto">update</property>
<mapping class = "com.tutorialspoint.hibernate.Student" />
</session-factory>
</hibernate-configuration>Lassen Sie uns die Konfigurationsdatei für den Ruhezustand durchgehen. Zuerst haben wir erklärt, dass wir den MySQL-Treiber verwenden. Dann haben wir die jdbc-URL für die Verbindung zur Datenbank deklariert. Dann haben wir den Benutzernamen, das Passwort und die Poolgröße der Verbindung angegeben. Wir haben auch angegeben, dass wir die SQL in der Protokolldatei sehen möchten, indem wir "show_sql" auf true setzen. Bitte lesen Sie das Tutorial zum Ruhezustand, um zu verstehen, was diese Eigenschaften bedeuten.
Schließlich setzen wir die Mapping-Klasse auf com.tutorialspoint.hibernate.Student, die wir in diesem Kapitel erstellen werden.
Envrionment Setup
Als nächstes benötigen Sie eine ganze Menge Gläser für dieses Projekt. Im Anhang finden Sie einen Screenshot der vollständigen Liste der erforderlichen JAR-Dateien.
Die meisten JAR-Dateien können als Teil Ihrer Struts-Distribution abgerufen werden. Wenn Sie einen Anwendungsserver wie glassfish, websphere oder jboss installiert haben, können Sie den Großteil der verbleibenden JAR-Dateien aus dem lib-Ordner des Anwendungsservers abrufen. Wenn nicht, können Sie die Dateien einzeln herunterladen -
Jibernate-JAR-Dateien - Hibernate.org
Struts Hibernate Plugin - Struts Hibernate Plugin
JTA-Dateien - JTA-Dateien
Dom4j-Dateien - Dom4j
log4j-Dateien - log4j
Die restlichen Dateien sollten Sie von Ihrer Struts2-Distribution erhalten können.
Ruhezustand Klassen
Lassen Sie uns nun die erforderlichen Java-Klassen für die Integration im Ruhezustand erstellen. Es folgt der Inhalt vonStudent.java - -
package com.tutorialspoint.hibernate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "student")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name = "last_name")
private String lastName;
@Column(name = "first_name")
private String firstName;
private int marks;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
}Dies ist eine POJO-Klasse, die die studentTabelle gemäß Hibernate-Spezifikation. Es hat die Eigenschaften id, firstName und lastName, die den Spaltennamen der Schülertabelle entsprechen. Als nächstes lassen Sie uns erstellenStudentDAO.java Datei wie folgt -
package com.tutorialspoint.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.TransactionTarget;
public class StudentDAO {
@SessionTarget
Session session;
@TransactionTarget
Transaction transaction;
@SuppressWarnings("unchecked")
public List<Student> getStudents() {
List<Student> students = new ArrayList<Student>();
try {
students = session.createQuery("from Student").list();
} catch(Exception e) {
e.printStackTrace();
}
return students;
}
public void addStudent(Student student) {
session.save(student);
}
}Die StudentDAO-Klasse ist die Datenzugriffsschicht für die Student-Klasse. Es gibt Methoden, um alle Schüler aufzulisten und dann einen neuen Schülerdatensatz zu speichern.
Aktionsklasse
Folgende Datei AddStudentAction.javadefiniert unsere Aktionsklasse. Wir haben hier zwei Aktionsmethoden - execute () und listStudents (). Die Methode execute () wird verwendet, um den neuen Schülerdatensatz hinzuzufügen. Wir verwenden die save () -Methode des Dao, um dies zu erreichen.
Die andere Methode, listStudents (), wird verwendet, um die Schüler aufzulisten. Wir verwenden die Listenmethode des Dao, um die Liste aller Schüler zu erhalten.
package com.tutorialspoint.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.hibernate.StudentDAO;
public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {
Student student = new Student();
List<Student> students = new ArrayList<Student>();
StudentDAO dao = new StudentDAO();
@Override
public Student getModel() {
return student;
}
public String execute() {
dao.addStudent(student);
return "success";
}
public String listStudents() {
students = dao.getStudents();
return "success";
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}Sie werden feststellen, dass wir die ModelDriven-Schnittstelle implementieren. Dies wird verwendet, wenn Ihre Aktionsklasse eine konkrete Modellklasse (z. B. Student) im Gegensatz zu einzelnen Eigenschaften (z. B. Vorname, Nachname) verwendet. Für die ModelAware-Schnittstelle müssen Sie eine Methode implementieren, um das Modell zurückzugeben. In unserem Fall geben wir das Objekt "student" zurück.
Ansichtsdateien erstellen
Lassen Sie uns jetzt die erstellen student.jsp Datei mit folgendem Inhalt anzeigen -
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "addStudent">
<s:textfield name = "firstName" label = "First Name"/>
<s:textfield name = "lastName" label = "Last Name"/>
<s:textfield name = "marks" label = "Marks"/>
<s:submit/>
<hr/>
<table>
<tr>
<td>First Name</td>
<td>Last Name</td>
<td>Marks</td>
</tr>
<s:iterator value = "students">
<tr>
<td><s:property value = "firstName"/></td>
<td><s:property value = "lastName"/></td>
<td><s:property value = "marks"/></td>
</tr>
</s:iterator>
</table>
</s:form>
</body>
</html>Die student.jsp ist ziemlich einfach. Im oberen Bereich haben wir ein Formular, das an "addStudent.action" gesendet wird. Es nimmt Vorname, Nachname und Markierungen auf. Da die Aktion addStudent an die ModelAware "AddSudentAction" gebunden ist, wird automatisch eine Schüler-Bean mit den Werten für Vorname, Nachname und Markierungen erstellt, die automatisch ausgefüllt werden.
Im unteren Bereich gehen wir die Studentenliste durch (siehe AddStudentAction.java). Wir durchlaufen die Liste und zeigen die Werte für Vorname, Nachname und Markierungen in einer Tabelle an.
Strebenkonfiguration
Lassen Sie uns alles mit zusammenfügen struts.xml - -
<?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 = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.tutorialspoint.struts2.AddStudentAction">
<result name = "success">/students.jsp</result>
</action>
</package>
</struts>Das Wichtigste dabei ist, dass unser Paket "myhibernate" das struts2-Standardpaket "hibernate-default" erweitert. Wir deklarieren dann zwei Aktionen - addStudent und listStudents. addStudent ruft die execute () für die AddStudentAction-Klasse auf und ruft dann bei Erfolg die listStudents-Aktionsmethode auf.
Die Aktionsmethode listStudent ruft listStudents () in der AddStudentAction-Klasse auf und verwendet die Datei student.jsp als Ansicht.
Klicken Sie nun 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/student.jsp. Daraufhin wird der folgende Bildschirm angezeigt:
Im oberen Bereich erhalten wir ein Formular zur Eingabe der Werte für einen neuen Schülerdatensatz, und im unteren Bereich werden die Schüler in der Datenbank aufgelistet. Fügen Sie einen neuen Schülerdatensatz hinzu und klicken Sie auf Senden. Der Bildschirm wird aktualisiert und zeigt Ihnen jedes Mal eine aktualisierte Liste an, wenn Sie auf Senden klicken.