Struts 2 - Szybki przewodnik
Model View Controller lub MVCjak jest popularnie nazywany, jest wzorcem projektowania oprogramowania do tworzenia aplikacji internetowych. Wzorzec kontrolera widoku modelu składa się z następujących trzech części -
Model - Najniższy poziom wzorca, który odpowiada za przechowywanie danych.
View - Jest odpowiedzialny za wyświetlanie całości lub części danych użytkownikowi.
Controller - Kod oprogramowania, który kontroluje interakcje między modelem a widokiem.
MVC jest popularny, ponieważ izoluje logikę aplikacji od warstwy interfejsu użytkownika i wspiera rozdzielanie problemów. Tutaj Administrator otrzymuje wszystkie zapytania dotyczące aplikacji, a następnie współpracuje z Modelką w celu przygotowania wszelkich danych wymaganych przez Widok. Widok następnie wykorzystuje dane przygotowane przez kontrolera do wygenerowania ostatecznej, możliwej do zaprezentowania odpowiedzi. Abstrakcję MVC można przedstawić graficznie w następujący sposób.
Model
Model jest odpowiedzialny za zarządzanie danymi aplikacji. Odpowiada na żądanie z widoku, a także odpowiada na instrukcje administratora, aby się zaktualizować.
Widok
Oznacza prezentację danych w określonym formacie, wywołaną decyzją administratora o ich przedstawieniu. Są to systemy szablonów oparte na skryptach, takie jak JSP, ASP, PHP i bardzo łatwe do zintegrowania z technologią AJAX.
Administrator
Kontroler jest odpowiedzialny za reagowanie na dane wejściowe użytkownika i wykonywanie interakcji na obiektach modelu danych. Kontroler odbiera dane wejściowe, sprawdza je, a następnie wykonuje operację biznesową, która modyfikuje stan modelu danych.
Struts2jest frameworkiem opartym na MVC. W kolejnych rozdziałach zobaczmy, jak możemy wykorzystać metodologię MVC w Struts2.
Struts2to popularny i dojrzały framework aplikacji internetowych oparty na wzorcu projektowym MVC. Struts2 to nie tylko nowa wersja Struts 1, ale to kompletne przepisanie architektury Struts.
Struktura Webwork początkowo rozpoczęła się od frameworka Struts jako podstawy, a jej celem było zaoferowanie ulepszonej i ulepszonej struktury opartej na Struts, aby ułatwić programistom tworzenie stron internetowych.
Po pewnym czasie środowisko Webwork i społeczność Struts połączyły się, aby stworzyć słynny framework Struts2.
Funkcje struktury Struts 2
Oto kilka wspaniałych funkcji, które mogą zmusić Cię do rozważenia Struts2 -
POJO Forms and POJO Actions- Struts2 wyeliminował formularze działań, które były integralną częścią struktury Struts. W Struts2 możesz używać dowolnego POJO do odbierania danych wejściowych formularza. Podobnie, możesz teraz zobaczyć dowolny POJO jako klasę Action.
Tag Support - Struts2 ulepszył tagi formularzy i nowe tagi, które pozwalają programistom pisać mniej kodu.
AJAX Support - Struts2 rozpoznał przejęcie technologii Web2.0 i zintegrował obsługę AJAX z produktem poprzez tworzenie tagów AJAX. Ta funkcja jest bardzo podobna do standardowych tagów Struts2.
Easy Integration - Integracja z innymi frameworkami, takimi jak Spring, Tiles i SiteMesh jest teraz łatwiejsza dzięki różnorodnym możliwościom integracji dostępnym w Struts2.
Template Support - Wsparcie dla generowania widoków za pomocą szablonów.
Plugin Support- Podstawowe zachowanie Struts2 można ulepszyć i rozszerzyć za pomocą wtyczek. Dostępnych jest wiele wtyczek dla Struts2.
Profiling- Struts2 oferuje zintegrowane profilowanie do debugowania i profilowania aplikacji. Oprócz tego Struts oferuje również zintegrowane debugowanie za pomocą wbudowanych narzędzi do debugowania.
Easy to Modify Tags- Znaczniki znaczników w Struts2 można modyfikować za pomocą szablonów Freemarker. Nie wymaga to znajomości JSP ani Java. Do modyfikacji tagów wystarczy podstawowa znajomość HTML, XML i CSS.
Promote Less configuration- Struts2 promuje mniejszą konfigurację za pomocą używania wartości domyślnych dla różnych ustawień. Nie musisz niczego konfigurować, chyba że odbiega to od domyślnych ustawień określonych przez Struts2.
View Technologies - Struts2 ma świetne wsparcie dla wielu opcji widoku (JSP, Freemarker, Velocity i XSLT)
Powyżej wymieniono 10 najważniejszych funkcji Struts 2 co sprawia, że jest to framework gotowy na Enterprise.
Struts 2 Wady
Chociaż Struts 2 zawiera listę wspaniałych funkcji, obecna wersja Struts 2 ma pewne ograniczenia, które wymagają dalszych ulepszeń. Wymienione są niektóre z głównych punktów -
Bigger Learning Curve - Aby używać MVC z Struts, musisz czuć się komfortowo ze standardowym JSP, interfejsami API serwletów oraz dużym i rozbudowanym frameworkiem.
Poor Documentation - W porównaniu ze standardowymi interfejsami API serwletów i JSP, Struts ma mniej zasobów online, a wielu początkujących użytkowników uważa, że dokumentacja Apache w trybie online jest zagmatwana i źle zorganizowana.
Less Transparent - W przypadku aplikacji Struts za kulisami dzieje się o wiele więcej niż w przypadku zwykłych aplikacji internetowych opartych na języku Java, co utrudnia zrozumienie struktury.
Uwaga końcowa, dobra struktura powinna zapewniać ogólne zachowanie, które może wykorzystywać wiele różnych typów aplikacji.
Struts 2 jest jednym z najlepszych frameworków internetowych i jest często używany do tworzenia bogatych aplikacji internetowych (RIA).
Naszym pierwszym zadaniem jest uruchomienie minimalnej aplikacji Struts 2. W tym rozdziale dowiesz się, jak przygotować środowisko programistyczne do rozpoczęcia pracy z Struts 2.
Zakładam, że masz już zainstalowane na swoim komputerze JDK (5+), Tomcat i Eclipse. Jeśli nie masz zainstalowanych tych komponentów, wykonaj podane kroki w trybie szybkim -
Krok 1 - Skonfiguruj zestaw Java Development Kit (JDK)
Najnowszą wersję pakietu SDK można pobrać z witryny Oracle Java - Java SE Downloads . Znajdziesz instrukcje instalacji JDK w pobranych plikach, postępuj zgodnie z podanymi instrukcjami, aby zainstalować i skonfigurować instalację. Na koniec ustaw zmienne środowiskowe PATH i JAVA_HOME, aby odwoływały się do katalogu zawierającego elementy java i javac, zazwyczaj odpowiednio katalog_instalacyjny_java / bin i katalog_instalacyjny_java.
Jeśli używasz systemu Windows i zainstalowałeś SDK w C: \ jdk1.5.0_20, powinieneś wprowadzić następujący wiersz w pliku C: \ autoexec.bat.
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20Alternatywnie w systemie Windows NT / 2000 / XP -
Możesz kliknąć prawym przyciskiem myszy Mój komputer, Wybierz Właściwości, następnie Zaawansowane, a następnie Zmienne środowiskowe. Następnie zaktualizuj wartość PATH i naciśnij przycisk OK.
W systemie Unix (Solaris, Linux itp.), Jeśli SDK jest zainstalowany w /usr/local/jdk1.5.0_20 i używasz powłoki C, umieściłbyś następujące elementy w swoim pliku .cshrc.
W systemie Unix (Solaris, Linux itp.), Jeśli SDK jest zainstalowany w /usr/local/jdk1.5.0_20 i używasz powłoki C, umieściłbyś następujące elementy w swoim pliku .cshrc.
setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20Alternatywnie, jeśli używasz zintegrowanego środowiska programistycznego (IDE), takiego jak Borland JBuilder, Eclipse, IntelliJ IDEA lub Sun ONE Studio, skompiluj i uruchom prosty program, aby potwierdzić, że IDE wie, gdzie zainstalowałeś Javę, w przeciwnym razie wykonaj właściwą konfigurację zgodnie z dany dokument IDE.
Krok 2 - Skonfiguruj Apache Tomcat
Najnowszą wersję programu Tomcat można pobrać z witryny https://tomcat.apache.org/. Po pobraniu instalacji rozpakuj dystrybucję binarną w dogodnej lokalizacji.
Na przykład w C: \ apache-tomcat-6.0.33 w systemie Windows lub /usr/local/apachetomcat-6.0.33 w systemie Linux / Unix i utwórz zmienną środowiskową CATALINA_HOME wskazującą na te lokalizacje.
Możesz uruchomić Tomcat, wykonując następujące polecenia na komputerze z systemem Windows lub po prostu dwukrotnie kliknąć plik startup.bat
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batTomcat można uruchomić, wykonując następujące polecenia na komputerze z systemem Unix (Solaris, Linux itp.) -
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.shPo pomyślnym uruchomieniu domyślne aplikacje internetowe dołączone do Tomcat będą dostępne pod adresem http://localhost:8080/. Jeśli wszystko jest w porządku, powinien wyświetlić następujący wynik -
Więcej informacji o konfigurowaniu i uruchamianiu Tomcat można znaleźć w dokumentacji dołączonej tutaj, a także w witrynie Tomcat: https://tomcat.apache.org/
Tomcat można zatrzymać, wykonując następujące polecenia na komputerze z systemem Windows -
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownTomcat można zatrzymać, wykonując następujące polecenia na komputerze z systemem Unix (Solaris, Linux itp.) -
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shKrok 3 - Konfiguracja Eclipse (IDE)
Wszystkie przykłady w tym samouczku zostały napisane przy użyciu środowiska Eclipse IDE. Sugeruję, abyś miał zainstalowaną najnowszą wersję Eclipse na swoim komputerze.
Aby zainstalować Eclipse Pobierz najnowsze pliki binarne Eclipse z witryny https://www.eclipse.org/downloads/. Po pobraniu instalacji rozpakuj dystrybucję binarną w dogodnej lokalizacji.
Na przykład w C: \ eclipse w systemie Windows lub / usr / local / eclipse w systemie Linux / Unix i na koniec ustaw odpowiednio zmienną PATH. Eclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Windows lub klikając dwukrotnie plik eclipse.exe
%C:\eclipse\eclipse.exeEclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Unix (Solaris, Linux itp.) -
$/usr/local/eclipse/eclipsePo udanym uruchomieniu, jeśli wszystko jest w porządku, powinien wyświetlić następujący wynik -
Krok 4 - Skonfiguruj biblioteki Struts2
Jeśli wszystko jest w porządku, możesz przystąpić do konfiguracji framemwork Struts2. Poniżej przedstawiono proste kroki, aby pobrać i zainstalować Struts2 na komputerze.
Wybierz, czy chcesz zainstalować Struts2 w systemie Windows, czy Unix, a następnie przejdź do następnego kroku, aby pobrać plik .zip dla systemu Windows i plik .tz dla systemu Unix.
Pobierz najnowszą wersję plików binarnych Struts2 z witryny https://struts.apache.org/download.cgi.
W momencie pisania tego samouczka pobrałem struts-2.0.14-all.zip a kiedy rozpakujesz pobrany plik, otrzymasz strukturę katalogów wewnątrz C: \ struts-2.2.3 w następujący sposób.
Drugim krokiem jest wyodrębnienie pliku zip w dowolnej lokalizacji, pobrałem i rozpakowałem struts-2.2.3-all.zip w c:\ na moim komputerze z systemem Windows 7, tak żebym miał wszystkie pliki jar do C:\struts-2.2.3\lib. Upewnij się, że poprawnie ustawiłeś zmienną CLASSPATH, w przeciwnym razie napotkasz problem podczas uruchamiania aplikacji.
Z wysokiego poziomu Struts2 jest frameworkiem pull-MVC (lub MVC2). Wzorzec Model-ViewController w Struts2 jest implementowany z następującymi pięcioma podstawowymi komponentami -
- Actions
- Interceptors
- Stos wartości / OGNL
- Wyniki / typy wyników
- Zobacz technologie
Struts 2 różni się nieco od tradycyjnego frameworka MVC, w którym akcja przyjmuje rolę modelu, a nie kontrolera, chociaż istnieje pewne nakładanie się.
Powyższy schemat przedstawia Model, View i Controller do architektury wysokiego poziomu Struts2. Kontroler jest zaimplementowany z rozszerzeniemStruts2wysyłania filtru serwletów, jak również przechwytywaczy, model ten jest zaimplementowany w akcjach, a widok jest połączeniem typów wyników i wyników. Stos wartości i OGNL zapewniają wspólny wątek, łącząc i umożliwiając integrację między innymi komponentami.
Poza powyższymi komponentami będzie dużo informacji związanych z konfiguracją. Konfiguracja aplikacji internetowej, a także konfiguracja akcji, przechwytywaczy, wyników itp.
To jest przegląd architektury wzorca Struts 2 MVC. W kolejnych rozdziałach omówimy szczegółowo każdy element.
Żądaj cyklu życia
Na podstawie powyższego diagramu można zrozumieć przepływ pracy przez cykl życia żądań użytkownika w programie Struts 2 w następujący sposób -
Użytkownik wysyła żądanie do serwera w celu zażądania jakiegoś zasobu (np. Stron).
Dispatcher filtru sprawdza żądanie, a następnie określa odpowiednią akcję.
Skonfigurowane funkcje przechwytywacza, takie jak walidacja, przesyłanie plików itp.
Wybrana akcja jest wykonywana na podstawie żądanej operacji.
Ponownie, skonfigurowane przechwytywacze są stosowane do wykonywania dowolnego przetwarzania końcowego, jeśli jest to wymagane.
Na koniec wynik jest przygotowywany przez widok i zwraca wynik użytkownikowi.
Jak już wiesz z architektury Struts 2, po kliknięciu hiperłącza lub przesłaniu formularza HTML w aplikacji internetowej Struts 2 dane wejściowe są zbierane przez kontroler i wysyłane do klasy Java o nazwie Actions. Po wykonaniu akcji wynik wybiera zasób do renderowania odpowiedzi. Zasób to zazwyczaj JSP, ale może to być również plik PDF, arkusz kalkulacyjny programu Excel lub okno apletu Java.
Zakładając, że masz już zbudowane środowisko programistyczne. Teraz przejdźmy do budowy naszego pierwszegoHello World Struts2projekt. Celem tego projektu jest zbudowanie aplikacji internetowej, która zbiera nazwę użytkownika i wyświetla napis „Hello World”, po którym następuje nazwa użytkownika.
Musielibyśmy utworzyć następujące cztery komponenty dla dowolnego projektu Struts 2 -
| Sr.No | Komponenty i opis |
|---|---|
| 1 | Action Utwórz klasę akcji, która będzie zawierać pełną logikę biznesową i sterować interakcją między użytkownikiem, modelem i widokiem. |
| 2 | Interceptors Utwórz przechwytywacze, jeśli jest to wymagane, lub użyj istniejących. To jest część kontrolera. |
| 3 | View Utwórz strony JSP, aby współdziałać z użytkownikiem, przyjmując dane wejściowe i przedstawiając ostateczne komunikaty. |
| 4 | Configuration Files Utwórz pliki konfiguracyjne, aby połączyć akcję, widok i kontrolery. Te pliki to struts.xml, web.xml, struts.properties. |
Mam zamiar używać Eclipse IDE, aby wszystkie wymagane komponenty zostały utworzone w ramach Dynamic Web Project. Zacznijmy teraz od stworzenia Dynamic Web Project.
Utwórz dynamiczny projekt internetowy
Uruchom Eclipse, a następnie idź z File > New > Dynamic Web Project i wprowadź nazwę projektu jako HelloWorldStruts2 i ustaw pozostałe opcje zgodnie z poniższym ekranem -
Wybierz wszystkie domyślne opcje na następnych ekranach i na koniec sprawdź Generate Web.xml deployment descriptoropcja. Spowoduje to utworzenie dynamicznego projektu internetowego w Eclipse. Teraz idź zWindows > Show View > Project Explorer, a zobaczysz okno swojego projektu, jak poniżej -
Teraz skopiuj następujące pliki z folderu lib struts 2 C:\struts-2.2.3\lib do naszego projektu WEB-INF\libteczka. Aby to zrobić, możesz po prostu przeciągnąć i upuścić wszystkie następujące pliki do folderu WEB-INF \ lib.
- 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
Utwórz klasę akcji
Klasa Action jest kluczem do aplikacji Struts 2 i większość logiki biznesowej implementujemy w klasach akcji. Stwórzmy więc plik java HelloWorldAction.java podJava Resources > src z nazwą pakietu com.tutorialspoint.struts2 o treści podanej poniżej.
Klasa Action reaguje na działanie użytkownika, gdy użytkownik kliknie adres URL. Wykonywana jest co najmniej jedna metoda klasy Action i zwracany jest wynik typu String. Na podstawie wartości wyniku renderowana jest określona strona JSP.
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;
}
}Jest to bardzo prosta klasa z jedną właściwością o nazwie „nazwa”. Mamy standardowe metody pobierające i ustawiające dla właściwości „name” oraz metodę wykonywania, która zwraca ciąg znaków „sukces”.
Framework Struts 2 utworzy obiekt HelloWorldActionclass i wywołaj wykonaną metodę w odpowiedzi na akcję użytkownika. Umieszczasz logikę biznesową wewnątrz tej metody, która ostatecznie zwraca stałą String. Innymi słowy, dla każdego adresu URL musiałbyś zaimplementować jedną klasę akcji i albo możesz użyć tej nazwy klasy bezpośrednio jako nazwy akcji, albo możesz mapować na inną nazwę za pomocą pliku struts.xml, jak pokazano poniżej.
Utwórz widok
Potrzebujemy strony JSP do zaprezentowania ostatecznej wiadomości, ta strona zostanie wywołana przez środowisko Struts 2, gdy nastąpi predefiniowana akcja, a mapowanie zostanie zdefiniowane w pliku struts.xml. Stwórzmy więc poniższy plik jspHelloWorld.jspw folderze WebContent w projekcie eclipse. Aby to zrobić, kliknij prawym przyciskiem myszy folder WebContent w eksploratorze projektów i wybierzNew >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>Dyrektywa taglib informuje kontener serwletu, że ta strona będzie używać rozszerzenia Struts 2 tagi i że te tagi będą poprzedzone s.
Znacznik s: property wyświetla wartość właściwości klasy akcji „nazwa>, która jest zwracana przez metodę getName() klasy HelloWorldAction.
Utwórz stronę główną
Musimy też tworzyć index.jspw folderze WebContent. Ten plik będzie służył jako początkowy adres URL akcji, w którym użytkownik może kliknąć, aby polecić platformie Struts 2 wywołanie zdefiniowanej metody klasy HelloWorldAction i wyrenderowanie widoku 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>Plik helloakcja zdefiniowana w powyższym pliku widoku zostanie odwzorowana na klasę HelloWorldAction i jej metodę wykonania za pomocą pliku struts.xml. Gdy użytkownik kliknie przycisk Prześlij, spowoduje to, że platforma Struts 2 uruchomi metodę wykonywania zdefiniowaną w klasie HelloWorldAction i na podstawie zwróconej wartości metody zostanie wybrany odpowiedni widok i wyrenderowany jako odpowiedź.
Pliki konfiguracyjne
Potrzebujemy mapowania, aby powiązać adres URL, klasę HelloWorldAction (Model) i HelloWorld.jsp (widok) razem. Mapowanie informuje frameworku Struts 2, która klasa odpowie na akcję użytkownika (adres URL), która metoda tej klasy zostanie wykonana i jaki widok ma zostać wyrenderowany na podstawie wyniku typu String, który zwraca ta metoda.
Stwórzmy więc plik o nazwie struts.xml. Ponieważ Struts 2 wymaga, aby plik struts.xml znajdował się w folderze klas. Dlatego utwórz plik struts.xml w folderze WebContent / WEB-INF / classes. Eclipse nie tworzy domyślnie folderu „classes”, więc musisz to zrobić samodzielnie. Aby to zrobić, kliknij prawym przyciskiem myszy folder WEB-INF w eksploratorze projektów i wybierzNew > Folder. Twój plik struts.xml powinien wyglądać następująco -
<?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>Kilka słów, które należy zrozumieć odnośnie powyższego pliku konfiguracyjnego. Tutaj ustawiamy stałąstruts.devMode do true, ponieważ pracujemy w środowisku programistycznym i musimy zobaczyć przydatne komunikaty dziennika. Następnie definiujemy pakiet o nazwiehelloworld.
Tworzenie pakietu jest przydatne, gdy chcesz zgrupować swoje akcje. W naszym przykładzie nazwaliśmy naszą akcję „hello”, co odpowiada adresowi URL/hello.action i jest wspierany przezHelloWorldAction.class. Plikexecute metoda HelloWorldAction.class to metoda, która jest uruchamiana, gdy adres URL /hello.actionjest wywoływana. Jeśli wynik metody execute zwróci „sukces”, to przeniesiemy użytkownika doHelloWorld.jsp.
Następnym krokiem jest utworzenie pliku web.xmlplik, który jest punktem wejścia dla każdego żądania do Struts 2. Punktem wejścia aplikacji Struts2 będzie filtr zdefiniowany w deskryptorze wdrażania (web.xml). Dlatego zdefiniujemy wpis klasy org.apache.struts2.dispatcher.FilterDispatcher w pliku web.xml. Plik web.xml należy utworzyć w folderze WEB-INF w katalogu WebContent. Eclipse utworzył już szkieletowy plik web.xml podczas tworzenia projektu. Więc zmodyfikujmy to w następujący sposób -
<?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>Określiliśmy index.jsp jako nasz plik powitalny. Następnie skonfigurowaliśmy filtr Struts2, aby działał na wszystkich adresach URL (tj. Każdym adresie URL, który pasuje do wzorca / *)
Aby włączyć szczegółowy dziennik
Możesz włączyć pełną funkcjonalność rejestrowania podczas pracy z Struts 2, tworząc logging.properties plik w ramach WEB-INF/classesteczka. Zachowaj następujące dwa wiersze w pliku właściwości -
org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandlerDomyślne logowanie.properties określa ConsoleHandler do kierowania logowania na standardowe wyjście, a także FileHandler. Próg poziomu dziennika obsługi można ustawić za pomocą opcji POWAŻNE, OSTRZEŻENIE, INFORMACJE, KONFIGURACJA, DOKŁADNE, DOKŁADNIEJSZE, NAJLEPSZE lub WSZYSTKIE.
Otóż to. Jesteśmy gotowi do uruchomienia naszej aplikacji Hello World przy użyciu frameworka Struts 2.
Procedura wykonywania wniosku
Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR File aby utworzyć plik wojny.
Następnie wdróż tę WAR w katalogu webapps serwera Tomcat.
Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URL http://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Wpisz wartość „Struts2” i prześlij stronę. Powinieneś zobaczyć następną stronę
Pamiętaj, że możesz zdefiniować index jako akcję w pliku struts.xml iw takim przypadku możesz wywołać stronę indeksu jako http://localhost:8080/HelloWorldStruts2/index.action. Sprawdź poniżej, jak możesz zdefiniować indeks jako akcję -
<?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>Ten rozdział poprowadzi Cię przez podstawową konfigurację, która jest wymagana dla Struts 2podanie. Tutaj zobaczymy, co można skonfigurować za pomocą kilku ważnych plików konfiguracyjnych, takich jakweb.xml, struts.xml, strutsconfig.xml i struts.properties
Szczerze mówiąc, możesz zacząć od używania web.xml i struts.xmlpliki konfiguracyjne (jak już widzieliście w poprzednim rozdziale, gdzie nasz przykład działał przy użyciu tych dwóch plików). Jednak dla Twojej wiedzy wyjaśnimy również inne pliki.
Plik web.xml
Plik konfiguracyjny web.xml jest plikiem konfiguracyjnym J2EE, który określa, w jaki sposób elementy żądania HTTP są przetwarzane przez kontener serwletu. Nie jest to plik konfiguracyjny Struts2, ale jest to plik, który należy skonfigurować, aby Struts2 działał.
Jak wspomniano wcześniej, ten plik stanowi punkt wejścia dla dowolnej aplikacji internetowej. Punktem wejścia aplikacji Struts2 będzie filtr zdefiniowany w deskryptorze wdrażania (web.xml). Dlatego zdefiniujemy wpis klasy FilterDispatcher w pliku web.xml. W folderze należy utworzyć plik web.xmlWebContent/WEB-INF.
Jest to pierwszy plik konfiguracyjny, który będziesz musiał skonfigurować, jeśli zaczynasz bez pomocy szablonu lub narzędzia, które go generuje (np. Eclipse lub Maven2).
Poniżej znajduje się zawartość pliku web.xml, którego użyliśmy w naszym ostatnim przykładzie.
<?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>Zauważ, że mapujemy filtr Struts 2 na /*, a nie /*.actionco oznacza, że wszystkie adresy URL zostaną przeanalizowane przez filtr Struts. Omówimy to, gdy przejdziemy przez rozdział Adnotacje.
Plik Struts.xml
Plik struts.xmlplik zawiera informacje konfiguracyjne, które będziesz modyfikować w miarę opracowywania działań. Tego pliku można użyć do zastąpienia domyślnych ustawień aplikacji, na przykład struts.devMode = false i innych ustawień, które są zdefiniowane w pliku właściwości. Ten plik można utworzyć w folderzeWEB-INF/classes.
Przyjrzyjmy się plikowi struts.xml, który utworzyliśmy w przykładzie Hello World wyjaśnionym w poprzednim rozdziale.
<?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>Pierwszą rzeczą, na którą należy zwrócić uwagę, jest plik DOCTYPE. Wszystkie pliki konfiguracyjne struts muszą mieć poprawny typ dokumentu, jak pokazano w naszym małym przykładzie. <struts> to główny element tagu, pod którym deklarujemy różne pakiety za pomocą tagów <package>. Tutaj <package> umożliwia separację i modularyzację konfiguracji. Jest to bardzo przydatne, gdy masz duży projekt, a projekt jest podzielony na różne moduły.
Na przykład, jeśli Twój projekt ma trzy domeny - aplikacja_biznesowa, aplikacja_klienta i aplikacja_pracowników, możesz utworzyć trzy pakiety i przechowywać powiązane akcje w odpowiednim pakiecie.
Znacznik pakietu ma następujące atrybuty -
| Sr.No | Atrybut i opis |
|---|---|
| 1 | name (required) Unikalny identyfikator pakietu |
| 2 | extends Z jakiego pakietu obejmuje ten pakiet? Domyślnie używamy struts-default jako pakietu podstawowego. |
| 3 | abstract Jeśli oznaczono wartość true, pakiet nie jest dostępny do użytku przez użytkownika końcowego. |
| 4 | namespace Unikalna przestrzeń nazw dla akcji |
Plik constant tag wraz z atrybutami nazwy i wartości należy użyć do zastąpienia dowolnej z następujących właściwości zdefiniowanych w default.properties, tak jak właśnie ustawiliśmy struts.devModewłasność. Oprawastruts.devMode właściwość pozwala nam zobaczyć więcej komunikatów debugowania w pliku dziennika.
Definiujemy action tagi odpowiadają każdemu adresowi URL, do którego chcemy uzyskać dostęp i definiujemy klasę za pomocą metody execute (), do której zostanie uzyskany dostęp za każdym razem, gdy uzyskamy dostęp do odpowiedniego adresu URL.
Wyniki określają, co jest zwracane do przeglądarki po wykonaniu akcji. Ciąg zwracany z akcji powinien być nazwą wyniku. Wyniki są konfigurowane według akcji, jak powyżej, lub jako wynik „globalny”, dostępny dla każdej akcji w pakiecie. Wyniki są opcjonalnename i typeatrybuty. Domyślna wartość nazwy to „sukces”.
Plik Struts.xml może z czasem urosnąć, więc dzielenie go na pakiety jest jednym ze sposobów jego modularyzacji, ale Strutsoferuje inny sposób modularyzacji pliku struts.xml. Możesz podzielić plik na wiele plików xml i zaimportować je w następujący sposób.
<?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>Innym plikiem konfiguracyjnym, którego nie omówiliśmy, jest struts-default.xml. Ten plik zawiera standardowe ustawienia konfiguracyjne dla Struts i nie musisz ich zmieniać w przypadku 99,99% projektów. Z tego powodu nie będziemy wchodzić w zbyt wiele szczegółów na temat tego pliku. Jeśli jesteś zainteresowany, zajrzyj dodefault.properties plik dostępny w pliku struts2-core-2.2.3.jar.
Plik Struts-config.xml
Plik konfiguracyjny struts-config.xml jest łączem między komponentami widoku i modelu w programie Web Client, ale nie musisz zmieniać tych ustawień w przypadku 99,99% projektów.
Plik konfiguracyjny zawiera zasadniczo następujące główne elementy -
| Sr.No | Interceptor i opis |
|---|---|
| 1 | struts-config To jest węzeł główny pliku konfiguracyjnego. |
| 2 | form-beans Tutaj mapujesz podklasę ActionForm na nazwę. Tej nazwy używasz jako aliasu dla swojego ActionForm w pozostałej części pliku strutsconfig.xml, a nawet na stronach JSP. |
| 3 | global forwards Ta sekcja mapuje stronę w Twojej aplikacji internetowej na nazwę. Możesz użyć tej nazwy, aby odnieść się do rzeczywistej strony. Pozwala to uniknąć zakodowanych adresów URL na stronach internetowych. |
| 4 | action-mappings Tutaj deklarujesz programy obsługi formularzy i są one również znane jako mapowania akcji. |
| 5 | controller Ta sekcja zawiera konfigurację elementów wewnętrznych Struts i jest rzadko używana w praktycznych sytuacjach. |
| 6 | plug-in Ta sekcja informuje Struts, gdzie znaleźć pliki właściwości, które zawierają monity i komunikaty o błędach |
Poniżej znajduje się przykładowy plik 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>Aby uzyskać więcej informacji na temat pliku struts-config.xml, zapoznaj się z dokumentacją struts.
Plik Struts.properties
Ten plik konfiguracyjny zapewnia mechanizm zmiany domyślnego zachowania struktury. W rzeczywistości wszystkie właściwości zawarte wstruts.properties plik konfiguracyjny można również skonfigurować w web.xml używając init-param, a także przy użyciu stałego tagu w struts.xmlplik konfiguracyjny. Ale jeśli chcesz, aby rzeczy były oddzielne i bardziej szczegółowe, możesz utworzyć ten plik w folderzeWEB-INF/classes.
Wartości skonfigurowane w tym pliku zastąpią wartości domyślne skonfigurowane w default.propertiesktóry jest zawarty w dystrybucji struts2-core-xyzjar. Istnieje kilka właściwości, które można rozważyć za pomocą rozszerzeniastruts.properties plik -
### 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 = 8080Tutaj każda linia zaczynająca się od hash (#) zostanie przyjęty jako komentarz i zostanie zignorowany przez Struts 2.
Actionssą rdzeniem frameworka Struts2, podobnie jak w przypadku każdej struktury MVC (Model View Controller). Każdy adres URL jest mapowany do określonej akcji, która zapewnia logikę przetwarzania niezbędną do obsługi żądania od użytkownika.
Ale akcja spełnia również dwie inne ważne funkcje. Po pierwsze, akcja odgrywa ważną rolę w przekazywaniu danych od żądania do widoku, niezależnie od tego, czy jest to JSP, czy inny typ wyniku. Po drugie, działanie musi wspomagać ramy w określeniu, który wynik powinien dawać pogląd, który zostanie zwrócony w odpowiedzi na żądanie.
Utwórz akcję
Jedyny wymóg dotyczący działań w Struts2polega na tym, że musi istnieć jedna metoda noargument, która zwraca obiekt String lub Result i musi być POJO. Jeśli nie określono metody bezargumentowej, domyślnym zachowaniem jest użycie metody execute ().
Opcjonalnie możesz przedłużyć ActionSupport klasa, która implementuje sześć interfejsów, w tym Actionberło. Interfejs akcji jest następujący -
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;
}Przyjrzyjmy się metodzie akcji w przykładzie Hello World -
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;
}
}Aby zilustrować punkt, w którym metoda akcji kontroluje widok, wprowadźmy następującą zmianę w pliku execute i rozszerz klasę ActionSupport w następujący sposób -
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;
}
}W tym przykładzie mamy pewną logikę w metodzie execute, aby spojrzeć na atrybut name. Jeśli atrybut jest równy łańcuchowi"SECRET", wracamy SUCCESS w rezultacie w przeciwnym razie wrócimy ERRORjako wynik. Ponieważ rozszerzyliśmy ActionSupport, więc możemy używać stałych typu StringSUCCESSi ERROR. Teraz zmodyfikujmy nasz plik struts.xml w następujący sposób -
<?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>Utwórz widok
Stwórzmy poniższy plik jsp HelloWorld.jspw folderze WebContent w projekcie eclipse. Aby to zrobić, kliknij prawym przyciskiem myszy folder WebContent w eksploratorze projektów i wybierzNew >JSP File. Ten plik zostanie wywołany w przypadku, gdy wynikiem zwrócenia jest SUCCESS, która jest stałą typu „sukces” typu String, zgodnie z definicją w interfejsie akcji -
<%@ 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>Poniżej znajduje się plik, który zostanie wywołany przez framework w przypadku, gdy wynikiem akcji jest ERROR, co jest równe stałej typu „błąd”. Poniżej znajduje się treśćAccessDenied.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>Musimy też tworzyć index.jspw folderze WebContent. Ten plik będzie służyć jako początkowy adres URL akcji, w którym użytkownik może kliknąć, aby przekazać platformie Struts 2 wywołanie plikuexecutemetody klasy HelloWorldAction i wyrenderuj widok 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>To wszystko, nie jest wymagana żadna zmiana dla pliku web.xml, więc użyjmy tego samego web.xml, który stworzyliśmy w Examplesrozdział. Teraz jesteśmy gotowi do uruchomienia naszegoHello World aplikacja wykorzystująca framework Struts 2.
Uruchom aplikację
Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WARPlik, aby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Wpiszmy słowo jako „TAJNE”, a powinieneś zobaczyć następującą stronę -
Teraz wprowadź dowolne słowo inne niż „SECRET”. Powinna zostać wyświetlona następująca strona -
Utwórz wiele działań
Często będziesz definiować więcej niż jedną akcję, aby obsłużyć różne żądania i zapewnić użytkownikom różne adresy URL, w związku z tym zdefiniujesz różne klasy zgodnie z poniższą definicją -
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;
}
...
}Skonfigurujesz te akcje w pliku struts.xml w następujący sposób -
<?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>Jak widać na powyższym hipotetycznym przykładzie, akcja skutkuje SUCCESS i ERROR’s są zduplikowane.
Aby obejść ten problem, sugeruje się utworzenie klasy zawierającej wyniki wyników.
Pod względem koncepcyjnym elementy przechwytujące są takie same jak filtry serwletów lub klasa JDKs Proxy. Interceptory pozwalają na implementację funkcji przekrojowych niezależnie od działania i struktury. Możesz osiągnąć następujące cele za pomocą przechwytywaczy -
Zapewnienie logiki przetwarzania wstępnego przed wywołaniem akcji.
Zapewnienie logiki postprocessingu po wywołaniu akcji.
Przechwytywanie wyjątków, aby można było wykonać przetwarzanie alternatywne.
Wiele funkcji dostępnych w Struts2 ramy są implementowane za pomocą przechwytywaczy;
Examples obejmuje obsługę wyjątków, przesyłanie plików, wywołania zwrotne cyklu życia itp. W rzeczywistości, ponieważ Struts2 kładzie duży nacisk na swoją funkcjonalność na przechwytywaczach, jest mało prawdopodobne, aby przypisano do niego 7 lub 8 przechwytywaczy na akcję.
Struts2 Framework Interceptors
Struktura Struts 2 zawiera dobrą listę gotowych do użycia przechwytywaczy, które są wstępnie skonfigurowane i gotowe do użycia. Poniżej wymieniono kilka ważnych przechwytywaczy -
| Sr.No | Interceptor i opis |
|---|---|
| 1 | alias Umożliwia parametrom nadawanie różnych aliasów nazw w żądaniach. |
| 2 | checkbox Wspomaga zarządzanie polami wyboru, dodając wartość parametru false dla pól wyboru, które nie są zaznaczone. |
| 3 | conversionError Umieszcza informacje o błędach z konwersji łańcuchów na typy parametrów w błędy pól akcji. |
| 4 | createSession Automatycznie tworzy sesję HTTP, jeśli jeszcze nie istnieje. |
| 5 | debugging Udostępnia programistom kilka różnych ekranów debugowania. |
| 6 | execAndWait Wysyła użytkownika na pośrednią stronę oczekiwania, podczas gdy akcja jest wykonywana w tle. |
| 7 | exception Mapuje wyjątki, które są generowane z akcji, na wynik, umożliwiając automatyczną obsługę wyjątków przez przekierowanie. |
| 8 | fileUpload Ułatwia przesyłanie plików. |
| 9 | i18n Śledzi wybrane ustawienia regionalne podczas sesji użytkownika. |
| 10 | logger Zapewnia proste rejestrowanie, wyświetlając nazwę wykonywanej akcji. |
| 11 | params Ustawia parametry żądania dla akcji. |
| 12 | prepare Jest to zwykle używane do wykonywania wstępnych czynności przetwarzania, takich jak konfigurowanie połączeń z bazą danych. |
| 13 | profile Umożliwia rejestrowanie prostych informacji o profilowaniu w celu wykonania działań. |
| 14 | scope Przechowuje i pobiera stan akcji w zakresie sesji lub aplikacji. |
| 15 | ServletConfig Zapewnia działaniu dostęp do różnych informacji opartych na serwletach. |
| 16 | timer Zapewnia proste informacje o profilowaniu w postaci czasu wykonywania czynności. |
| 17 | token Sprawdza akcję pod kątem prawidłowego tokenu, aby zapobiec przesyłaniu zduplikowanych formularzy. |
| 18 | validation Zapewnia obsługę walidacji dla akcji |
Zapoznaj się z dokumentacją Struts 2, aby uzyskać szczegółowe informacje na temat wyżej wymienionych przechwytywaczy. Ale pokażę ci, jak ogólnie używać przechwytywacza w aplikacji Struts.
Jak używać przechwytywaczy?
Zobaczmy, jak użyć już istniejącego przechwytywacza do naszego programu „Hello World”. Będziemy używaćtimerprzechwytywacz, którego celem jest zmierzenie, ile czasu zajęło wykonanie metody akcji. W tym samym czasie używamparamsprzechwytywacz, którego celem jest przesłanie parametrów żądania do akcji. Możesz spróbować swojego przykładu bez używania tego przechwytywacza i przekonasz się, żename właściwość nie jest ustawiana, ponieważ parametr nie jest w stanie dotrzeć do akcji.
Zachowamy pliki HelloWorldAction.java, web.xml, HelloWorld.jsp i index.jsp w takiej postaci, w jakiej zostały utworzone w Examples rozdział, ale zmodyfikujmy struts.xml plik, aby dodać przechwytywacz w następujący sposób -
<?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>Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz wprowadź dowolne słowo w podanym polu tekstowym i kliknij przycisk Say Hello, aby wykonać zdefiniowaną akcję. Teraz, jeśli sprawdzisz wygenerowany dziennik, znajdziesz następujący tekst -
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.Tutaj generowany jest wynik finansowy z powodu timer przechwytujący, który mówi, że wykonanie akcji zajęło łącznie 109 ms.
Utwórz niestandardowe przechwytywacze
Używanie niestandardowych przechwytywaczy w aplikacji to elegancki sposób na zapewnienie funkcji przekrojowych aplikacji. Stworzenie własnego przechwytywacza jest łatwe; interfejs, który należy rozszerzyć, jest następującyInterceptor interfejs -
public interface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation)
throws Exception;
}Jak sugerują nazwy, metoda init () zapewnia sposób na zainicjowanie elementu przechwytującego, a metoda zniszcz () zapewnia możliwość czyszczenia elementu przechwytującego. W przeciwieństwie do akcji, elementy przechwytujące są ponownie wykorzystywane w żądaniach i muszą być wątkowo bezpieczne, zwłaszcza metoda intercept ().
Plik ActionInvocationobiekt zapewnia dostęp do środowiska wykonawczego. Umożliwia dostęp do samej akcji i metod w celu wywołania akcji i określenia, czy akcja została już wywołana.
Jeśli nie potrzebujesz kodu inicjującego ani czyszczącego, plik AbstractInterceptorklasa może zostać przedłużona. Zapewnia to domyślną implementację metod init () i zniszcz () bez operacji.
Utwórz klasę przechwytującą
Utwórzmy następujący plik MyInterceptor.java w formacie Java Resources > src folder -
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;
}
}Jak zauważyłeś, faktyczna akcja zostanie wykonana przy użyciu przechwytywacza przez invocation.invoke()połączenie. Możesz więc wykonać trochę przetwarzania wstępnego i trochę przetwarzania końcowego w oparciu o swoje wymagania.
Struktura sama uruchamia proces, wykonując pierwsze wywołanie metody invoke () obiektu ActionInvocation. Za każdym razeminvoke()jest wywoływana, ActionInvocation sprawdza swój stan i wykonuje następny przechwytywacz. Gdy wszystkie skonfigurowane przechwytywacze zostaną wywołane, metoda invoke () spowoduje wykonanie samej akcji.
Poniższy diagram przedstawia tę samą koncepcję w przepływie żądań -
Utwórz klasę akcji
Utwórzmy plik java HelloWorldAction.java pod Java Resources > src z nazwą pakietu com.tutorialspoint.struts2 o treści podanej poniżej.
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;
}
}To ta sama klasa, którą widzieliśmy w poprzednich przykładach. Mamy standardowe metody pobierające i ustawiające dla właściwości „name” oraz metodę wykonywania, która zwraca ciąg znaków „sukces”.
Utwórz widok
Stwórzmy poniższy plik jsp HelloWorld.jsp w folderze WebContent w projekcie eclipse.
<%@ 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>Utwórz stronę główną
Musimy też tworzyć index.jspw folderze WebContent. Ten plik będzie służył jako początkowy adres URL akcji, w którym użytkownik może kliknąć, aby polecić platformie Struts 2 wywołanie zdefiniowanej metody klasy HelloWorldAction i wyrenderowanie widoku 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>Plik hello akcja zdefiniowana w powyższym pliku widoku zostanie odwzorowana na klasę HelloWorldAction i jej metodę wykonania za pomocą pliku struts.xml.
Pliki konfiguracyjne
Teraz musimy zarejestrować nasz przechwytywacz, a następnie nazwać go tak, jak nazwaliśmy domyślny przechwytywacz w poprzednim przykładzie. Aby zarejestrować nowo zdefiniowany przechwytywacz, znaczniki <interceptors> ... </interceptors> są umieszczane bezpośrednio pod tagiem <package> insstruts.xmlplik. Możesz pominąć ten krok dla domyślnych przechwytywaczy, tak jak to zrobiliśmy w naszym poprzednim przykładzie. Ale tutaj zarejestrujmy się i używajmy w następujący sposób -
<?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>Należy zauważyć, że w środku można zarejestrować więcej niż jeden przechwytywacz <package> iw tym samym czasie możesz wywołać więcej niż jeden przechwytywacz wewnątrz <action>etykietka. Możesz wywołać ten sam przechwytujący z różnymi akcjami.
Plik web.xml należy utworzyć w folderze WEB-INF w WebContent w następujący sposób -
<?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>Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz wprowadź dowolne słowo w podanym polu tekstowym i kliknij przycisk Say Hello, aby wykonać zdefiniowaną akcję. Teraz, jeśli sprawdzisz wygenerowany dziennik, na dole znajdziesz następujący tekst -
Pre-Processing
Inside action....
Post-ProcessingStacking Multiple Interceptors
Jak możesz sobie wyobrazić, konieczność skonfigurowania wielu przechwytywaczy dla każdej akcji szybko stałby się niezwykle niemożliwy do zarządzania. Z tego powodu przechwytywacze są zarządzane za pomocą stosów przechwytywaczy. Oto przykład bezpośrednio z pliku 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>Powyższa stawka jest nazywana basicStacki może być używany w Twojej konfiguracji, jak pokazano poniżej. Ten węzeł konfiguracji znajduje się w węźle <package ... />. Każdy znacznik <interceptor-ref ... /> odwołuje się do przechwytywacza lub stosu przechwytywaczy, który został skonfigurowany przed bieżącym stosem przechwytywaczy. Dlatego bardzo ważne jest, aby podczas konfigurowania początkowych elementów przechwytujących i stosów przechwytywaczy upewnić się, że nazwa jest unikalna we wszystkich konfiguracjach przechwytywaczy i stosów.
Widzieliśmy już, jak zastosować przechwytywacz do akcji, nie inaczej jest przy stosowaniu stosów przechwytujących. W rzeczywistości używamy dokładnie tego samego tagu -
<action name = "hello" class = "com.tutorialspoint.struts2.MyAction">
<interceptor-ref name = "basicStack"/>
<result>view.jsp</result>
</actionPowyższa rejestracja „basicStack” zarejestruje pełną stawkę wszystkich sześciu przechwytujących z akcją hello. Należy zauważyć, że przechwytywacze są wykonywane w kolejności, w jakiej zostały skonfigurowane. Na przykład w powyższym przypadku wyjątek zostanie wykonany jako pierwszy, drugi to servlet-config i tak dalej.
Jak wspomniano wcześniej, plik <results> tag pełni rolę viewwe frameworku Struts2 MVC. Akcja jest odpowiedzialna za wykonanie logiki biznesowej. Następnym krokiem po wykonaniu logiki biznesowej jest wyświetlenie widoku przy użyciu<results> etykietka.
Często do wyników dołączone są reguły nawigacji. Na przykład, jeśli metodą akcji jest uwierzytelnienie użytkownika, możliwe są trzy wyniki.
- Udane logowanie
- Nieudane logowanie - nieprawidłowa nazwa użytkownika lub hasło
- Konto zablokowane
W tym scenariuszu metoda akcji zostanie skonfigurowana z trzema możliwymi ciągami wynikowymi i trzema różnymi widokami, aby renderować wynik. Widzieliśmy to już w poprzednich przykładach.
Jednak Struts2 nie ogranicza Cię do korzystania z JSP jako technologii wyświetlania. Ostatecznie celem paradygmatu MVC jest utrzymanie oddzielnych warstw i wysoce konfigurowalnych. Na przykład w przypadku klienta Web2.0 możesz chcieć zwrócić XML lub JSON jako dane wyjściowe. W takim przypadku możesz utworzyć nowy typ wyniku dla XML lub JSON i osiągnąć ten cel.
W Struts dostępnych jest kilka wstępnie zdefiniowanych result types i cokolwiek już widzieliśmy, był to domyślny typ wyniku dispatcher, który jest używany do wysyłania do stron JSP. Struts umożliwiają korzystanie z innych języków znaczników w technologii widoku w celu przedstawienia wyników, a wśród popularnych wyborów sąVelocity, Freemaker, XSLT i Tiles.
Typ wyniku dyspozytora
Plik dispatchertyp wyniku jest typem domyślnym i jest używany, jeśli nie określono innego typu wyniku. Służy do przekazywania do serwletu, strony JSP, strony HTML i tak dalej na serwerze. Używa metody RequestDispatcher.forward () .
Wersję „skróconą” widzieliśmy we wcześniejszych przykładach, w których podaliśmy ścieżkę JSP jako treść znacznika wynikowego.
<result name = "success">
/HelloWorld.jsp
</result>Możemy również określić plik JSP za pomocą znacznika <param name = "location"> w elemencie <result ...> w następujący sposób -
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>Możemy również dostarczyć plik parseparametr, który domyślnie jest prawdziwy. Parametr parse określa, czy parametr lokalizacji będzie analizowany pod kątem wyrażeń OGNL.
Typ wyniku FreeMaker
W tym przykładzie zobaczymy, jak możemy użyć FreeMakerjako technologia widoku. Freemaker to popularny silnik do tworzenia szablonów, który służy do generowania danych wyjściowych przy użyciu predefiniowanych szablonów. Utwórzmy teraz plik szablonu Freemaker o nazwiehello.fm z następującą zawartością -
Hello World ${name}Powyższy plik jest szablonem, w którym nameto parametr, który zostanie przekazany z zewnątrz za pomocą zdefiniowanej akcji. Zachowasz ten plik w swojej CLASSPATH.
Następnie zmodyfikujmy plik struts.xml aby określić wynik w następujący sposób -
<?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>Zachowajmy nasze pliki HelloWorldAction.java, HelloWorldAction.jsp i index.jsp tak, jak stworzyliśmy je w rozdziale z przykładami.
Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR File aby utworzyć plik wojny.
Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu.
Wpisz wartość „Struts2” i prześlij stronę. Powinieneś zobaczyć następną stronę.
Jak widać, jest to dokładnie to samo, co widok JSP, z wyjątkiem tego, że nie jesteśmy przywiązani do używania JSP jako technologii widoku. W tym przykładzie użyliśmy Freemakera.
Typ wyniku przekierowania
Plik redirecttyp wyniku wywołuje standardową metodę response.sendRedirect () , powodując, że przeglądarka tworzy nowe żądanie do podanej lokalizacji.
Możemy podać lokalizację albo w treści elementu <result ...>, albo jako element <param name = "location">. Przekierowanie obsługuje równieżparseparametr. Oto przykład skonfigurowany przy użyciu XML -
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>Po prostu zmodyfikuj plik struts.xml, aby zdefiniować typ przekierowania, jak wspomniano powyżej, i utwórz nowy plik NewWorld.jpg, do którego zostaniesz przekierowany za każdym razem, gdy akcja hello zwróci sukces. Możesz sprawdzić przykład działania przekierowania Struts 2, aby lepiej zrozumieć.
Stos wartości
Stos wartości to zestaw kilku obiektów, który utrzymuje następujące obiekty w podanej kolejności -
| Sr.No | Obiekty i opis |
|---|---|
| 1 | Temporary Objects Istnieje wiele obiektów tymczasowych, które są tworzone podczas wykonywania strony. Na przykład bieżąca wartość iteracji kolekcji zapętlonej w znaczniku JSP. |
| 2 | The Model Object Jeśli używasz obiektów modelu w aplikacji Struts, bieżący obiekt modelu jest umieszczany przed operacją na stosie wartości. |
| 3 | The Action Object Będzie to aktualnie wykonywany obiekt akcji. |
| 4 | Named Objects Te obiekty obejmują #application, #session, #request, #attr i #parameters i odwołują się do odpowiednich zakresów serwletów. |
Dostęp do stosu wartości można uzyskać za pośrednictwem tagów przewidzianych dla JSP, Velocity lub Freemarker. Istnieją różne znaczniki, które będziemy badać w oddzielnych rozdziałach, służą do pobierania i ustawiania stosu wartości Struts 2.0. Możesz pobrać obiekt valueStack wewnątrz akcji w następujący sposób -
ActionContext.getContext().getValueStack()Gdy masz już obiekt ValueStack, możesz manipulować tym obiektem za pomocą następujących metod:
| Sr.No | Metody i opis ValueStack |
|---|---|
| 1 | Object findValue(String expr) Znajdź wartość, porównując dane wyrażenie ze stosem w domyślnej kolejności wyszukiwania. |
| 2 | CompoundRoot getRoot() Pobierz CompoundRoot, który przechowuje obiekty odłożone na stos. |
| 3 | Object peek() Umieść obiekt na szczycie stosu bez zmiany stosu. |
| 4 | Object pop() Umieść obiekt na szczycie stosu i usuń go ze stosu. |
| 5 | void push(Object o) Umieść ten obiekt na szczycie stosu. |
| 6 | void set(String key, Object o) Ustawia obiekt na stosie z podanym kluczem, aby można go było pobrać przez findValue (klucz, ...) |
| 7 | void setDefaultType(Class defaultType) Ustawia domyślny typ do konwersji, jeśli podczas pobierania wartości nie zostanie podany żaden typ. |
| 8 | void setValue(String expr, Object value) Próbuje ustawić właściwość fasoli w stosie z podanym wyrażeniem przy użyciu domyślnej kolejności wyszukiwania. |
| 9 | int size() Uzyskaj liczbę obiektów w stosie. |
OGNL
Plik Object-Graph Navigation Language(OGNL) to zaawansowany język wyrażeń używany do odwoływania się do danych w ValueStack i manipulowania nimi. OGNL pomaga również w przesyłaniu danych i konwersji typów.
OGNL jest bardzo podobny do języka wyrażeń JSP. OGNL opiera się na idei posiadania głównego lub domyślnego obiektu w kontekście. Do właściwości obiektu domyślnego lub głównego można się odwoływać za pomocą notacji znaczników, która jest symbolem funta.
Jak wspomniano wcześniej, OGNL opiera się na kontekście, a Struts tworzy mapę ActionContext do użytku z OGNL. Mapa ActionContext składa się z następujących elementów -
Application - Zmienne o zakresie aplikacji
Session - Zmienne o zasięgu sesji
Root / value stack - Wszystkie zmienne akcji są tutaj przechowywane
Request - Zmienne o zasięgu żądania
Parameters - Parametry żądania
Atributes - Atrybuty przechowywane na stronie, żądaniu, sesji i zakresie aplikacji
Ważne jest, aby zrozumieć, że obiekt Action jest zawsze dostępny na stosie wartości. Dlatego jeśli obiekt Action ma właściwości“x” i “y” są łatwo dostępne do użycia.
Do obiektów w ActionContext można odwoływać się za pomocą symbolu funta, jednak do obiektów na stosie wartości można się bezpośrednio odwoływać.
Na przykład, jeśli employee jest właściwością klasy akcji, można do niej odwoływać się w następujący sposób -
<s:property value = "name"/>zamiast
<s:property value = "#name"/>Jeśli masz atrybut w sesji o nazwie „login”, możesz go pobrać w następujący sposób -
<s:property value = "#session.login"/>OGNL wspiera również obsługę zbiorów - a mianowicie Map, List i Set. Na przykład, aby wyświetlić rozwijaną listę kolorów, możesz zrobić -
<s:select name = "color" list = "{'red','yellow','green'}" />Wyrażenie OGNL sprytnie interpretuje „czerwony”, „żółty”, „zielony” jako kolory i buduje na tej podstawie listę.
Wyrażenia OGNL będą szeroko używane w następnych rozdziałach, w których będziemy badać różne znaczniki. Więc zamiast patrzeć na nie osobno, przyjrzyjmy się temu, korzystając z kilku przykładów w sekcji Tagi formularzy / Tagi kontrolne / Tagi danych i tagi Ajax.
Przykład ValueStack / OGNL
Utwórz akcję
Rozważmy następującą klasę akcji, w której uzyskujemy dostęp do valueStack, a następnie ustawiamy kilka kluczy, do których będziemy uzyskiwać dostęp za pomocą OGNL w naszym widoku, tj. Strona JSP.
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;
}
}W rzeczywistości Struts 2 dodaje twoją akcję na początek valueStack po wykonaniu. Tak więc zwykłym sposobem umieszczania rzeczy na stosie wartości jest dodanie pobierających / ustawiających wartości do klasy Action, a następnie użycie tagu <s: property> w celu uzyskania dostępu do wartości. Ale pokazuję ci, jak dokładnie ActionContext i ValueStack działają w struts.
Utwórz widoki
Stwórzmy poniższy plik jsp HelloWorld.jspw folderze WebContent w projekcie eclipse. Ten widok zostanie wyświetlony w przypadku, gdy akcja zwróci sukces -
<%@ 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>Musimy też tworzyć index.jsp w folderze WebContent, którego zawartość jest następująca -
<%@ 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>Pliki konfiguracyjne
Poniżej znajduje się treść struts.xml plik -
<?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>Poniżej znajduje się treść web.xml plik -
<?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>Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat.
Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URL http://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu
Teraz wprowadź dowolne słowo w podanym polu tekstowym i kliknij przycisk „Say Hello”, aby wykonać zdefiniowaną akcję. Teraz, jeśli sprawdzisz wygenerowany dziennik, na dole znajdziesz następujący tekst -
Size of the valueStack: 3Spowoduje to wyświetlenie następującego ekranu, na którym zostanie wyświetlona dowolna wartość, którą wprowadzisz, oraz wartość klucza1 i klucza2, które umieściliśmy w ValueStack.
Struktura Struts 2 zapewnia wbudowaną obsługę przesyłania plików za pomocą funkcji „Przesyłanie plików w formacie HTML na podstawie formularzy”. Po przesłaniu pliku jest on zwykle przechowywany w katalogu tymczasowym i powinien zostać przetworzony lub przeniesiony przez klasę Action do katalogu stałego, aby zapewnić, że dane nie zostaną utracone.
Note - Serwery mogą mieć politykę bezpieczeństwa, która zabrania zapisywania do katalogów innych niż katalog tymczasowy i katalogi należące do twojej aplikacji internetowej.
Przesyłanie plików do Struts jest możliwe poprzez predefiniowany przechwytywacz o nazwie FileUpload przechwytywacz, który jest dostępny za pośrednictwem klasy org.apache.struts2.interceptor.FileUploadInterceptor i dołączony jako częśćdefaultStack. Mimo to możesz użyć tego w swoim pliku struts.xml, aby ustawić różne parametry, jak zobaczymy poniżej.
Utwórz pliki widoku
Zacznijmy od stworzenia naszego widoku, który będzie potrzebny do przeglądania i wgrywania wybranego pliku. Stwórzmy więc plikindex.jsp ze zwykłym formularzem HTML do przesyłania, który pozwala użytkownikowi przesłać plik -
<%@ 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>W powyższym przykładzie warto zwrócić uwagę na kilka punktów. Najpierw ustawiany jest kodowanie formularzamultipart/form-data. Należy to ustawić tak, aby przesyłanie plików było pomyślnie obsługiwane przez przechwytywacz przesyłania plików. Następnym punktem jest metoda akcji formularzaupload i nazwa pola przesyłania pliku - czyli myFile. Potrzebujemy tych informacji, aby utworzyć metodę akcji i konfigurację rozpórek.
Następnie stwórzmy prosty plik jsp success.jsp aby wyświetlić wynik przesłania naszego pliku na wypadek, gdyby zakończył się sukcesem.
<%@ 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>Poniżej znajduje się plik wynikowy error.jsp w przypadku wystąpienia błędu podczas przesyłania pliku -
<%@ 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>Utwórz klasę akcji
Następnie stwórzmy klasę Java o nazwie uploadFile.java który zadba o przesłanie pliku i przechowywanie go w bezpiecznej lokalizacji -
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;
}
}Plik uploadFile.javato bardzo prosta klasa. Ważną rzeczą do zapamiętania jest to, że przechwytywacz FileUpload wraz z przechwytywaczem parametrów wykonuje za nas całą ciężką pracę.
Przechwytywacz FileUpload domyślnie udostępnia trzy parametry. Są one nazwane według następującego wzoru -
[your file name parameter] - To jest rzeczywisty plik przesłany przez użytkownika. W tym przykładzie będzie to „myFile”
[your file name parameter]ContentType- To jest typ treści przesłanego pliku. W tym przykładzie będzie to „myFileContentType”
[your file name parameter]FileName- To jest nazwa przesłanego pliku. W tym przykładzie będzie to „myFileFileName”
Te trzy parametry są dla nas dostępne dzięki Struts Interceptors. Wszystko, co musimy zrobić, to utworzyć trzy parametry o poprawnych nazwach w naszej klasie Action i automatycznie te zmienne są automatycznie łączone za nas. Zatem w powyższym przykładzie mamy trzy parametry i metodę akcji, która po prostu zwraca „sukces”, jeśli wszystko pójdzie dobrze, w przeciwnym razie zwraca „błąd”.
Pliki konfiguracyjne
Poniżej przedstawiono właściwości konfiguracyjne Struts2, które sterują procesem przesyłania plików -
| Sr.No | Właściwości i opis |
|---|---|
| 1 | struts.multipart.maxSize Maksymalny rozmiar (w bajtach) pliku, który ma zostać zaakceptowany jako przesyłany plik. Wartość domyślna to 250 M. |
| 2 | struts.multipart.parser Biblioteka używana do przesyłania formularza wieloczęściowego. Domyślnie jest tojakarta |
| 3 | struts.multipart.saveDir Lokalizacja przechowywania pliku tymczasowego. Domyślnie jest to javax.servlet.context.tempdir. |
Aby zmienić którekolwiek z tych ustawień, możesz użyć constant tag w pliku struts.xml aplikacji, tak jak zmieniłem maksymalny rozmiar przesyłanego pliku.
Miejmy nasze struts.xml w następujący sposób -
<?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>Od, FileUploadprzechwytywacz jest częścią domyślnego stosu przechwytywaczy, nie musimy go konfigurować wprost. Ale możesz dodać tag <interceptor-ref> wewnątrz <action>. Przechwytywacz fileUpload przyjmuje dwa parametry(a) maximumSize i (b) allowedTypes.
Parametr maximumSize ustawia maksymalny dozwolony rozmiar pliku (wartość domyślna to około 2 MB). Parametr allowedTypes to rozdzielona przecinkami lista akceptowanych typów treści (MIME), jak pokazano poniżej -
<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>Poniżej znajduje się treść web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/upload.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz wybierz plik „Contacts.txt” za pomocą przycisku Przeglądaj i kliknij przycisk przesyłania, który załaduje plik na Twój serwis i powinieneś zobaczyć następną stronę. Możesz sprawdzić, czy przesłany plik powinien zostać zapisany w C: \ apache-tomcat-6.0.33 \ work.
Zwróć uwagę, że FileUpload Interceptor automatycznie usuwa przesłany plik, więc musisz programowo zapisać przesłany plik w jakiejś lokalizacji, zanim zostanie usunięty.
Komunikaty o błędach
Przechwytywacz fileUplaod używa kilku domyślnych kluczy komunikatów o błędach -
| Sr.No | Klucz i opis komunikatu o błędzie |
|---|---|
| 1 | struts.messages.error.uploading Ogólny błąd występujący, gdy nie można przesłać pliku. |
| 2 | struts.messages.error.file.too.large Występuje, gdy przekazany plik jest zbyt duży, jak określono w maximumSize. |
| 3 | struts.messages.error.content.type.not.allowed Występuje, gdy przekazany plik nie jest zgodny z określonymi oczekiwanymi typami zawartości. |
Możesz zastąpić tekst tych wiadomości w formacie WebContent/WEB-INF/classes/messages.properties pliki zasobów.
W tym rozdziale dowiesz się, jak w prostych krokach uzyskać dostęp do bazy danych za pomocą Struts 2. Struts to framework MVC, a nie szkielet bazy danych, ale zapewnia doskonałą obsługę integracji JPA / Hibernate. W następnym rozdziale przyjrzymy się integracji hibernacji, ale w tym rozdziale będziemy używać zwykłego starego JDBC, aby uzyskać dostęp do bazy danych.
Pierwszym krokiem w tym rozdziale jest skonfigurowanie i przygotowanie naszej bazy danych. W tym przykładzie używam MySQL jako mojej bazy danych. Mam zainstalowany MySQL na moim komputerze i utworzyłem nową bazę danych o nazwie "struts_tutorial". Utworzyłem tabelę o nazwielogini zapełnił go pewnymi wartościami. Poniżej znajduje się skrypt, którego użyłem do utworzenia i wypełnienia tabeli.
Moja baza danych MYSQL ma domyślną nazwę użytkownika „root” i hasło „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');Następnym krokiem jest pobranie pliku jar programu MySQL Connector i umieszczenie go w folderze WEB-INF \ lib projektu. Gdy to zrobimy, jesteśmy teraz gotowi do stworzenia klasy akcji.
Utwórz akcję
Klasa akcji ma właściwości odpowiadające kolumnom w tabeli bazy danych. Mamyuser, password i namejako atrybuty String. W metodzie akcji używamy parametrów użytkownika i hasła, aby sprawdzić, czy użytkownik istnieje, jeśli tak, wyświetlamy nazwę użytkownika na następnym ekranie.
Jeśli użytkownik podał błędne informacje, ponownie odsyłamy go do ekranu logowania.
Poniżej znajduje się treść LoginAction.java plik -
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;
}
}Utwórz stronę główną
Teraz stwórzmy plik JSP index.jspaby zebrać nazwę użytkownika i hasło. Ta nazwa użytkownika i hasło zostaną sprawdzone w bazie danych.
<%@ 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>Utwórz widoki
Teraz stwórzmy success.jsp plik, który zostanie wywołany w przypadku, gdy akcja zwróci SUCCESS, ale będziemy mieć inny plik widoku w przypadku zwrócenia błędu przez akcję.
<%@ 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>Poniżej znajduje się plik widoku error.jsp w przypadku BŁĘDU jest zwracana z akcji.
<%@ 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>Pliki konfiguracyjne
Na koniec zbierzmy wszystko razem za pomocą pliku konfiguracyjnego struts.xml w następujący sposób -
<?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>Poniżej znajduje się treść web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Wprowadź nieprawidłową nazwę użytkownika i hasło. Powinieneś zobaczyć następną stronę.
Teraz wejdź scott jako nazwa użytkownika i navyjako hasło. Powinieneś zobaczyć następną stronę.
W tym rozdziale wyjaśniono, jak wysłać wiadomość e-mail za pomocą aplikacji Struts 2.
W tym ćwiczeniu musisz pobrać i zainstalować mail.jar z JavaMail API 1.4.4 i umieścić plikmail.jar w folderze WEB-INF \ lib, a następnie postępuj zgodnie ze standardowymi krokami tworzenia plików akcji, widoku i konfiguracji.
Utwórz akcję
Następnym krokiem jest stworzenie metody Action, która zajmie się wysyłaniem wiadomości e-mail. Utwórzmy nową klasę o nazwieEmailer.java z następującą treścią.
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;
}
}Jak widać w powyższym kodzie źródłowym, plik Emailer.javama właściwości, które odpowiadają atrybutom formularza na stronie email.jsp podanej poniżej. Te atrybuty to -
From- adres e-mail nadawcy. Ponieważ używamy SMTP Google, potrzebujemy prawidłowego identyfikatora gtalk
Password - hasło do powyższego konta
To - Do kogo wysłać e-mail?
Subject - temat wiadomości e-mail
Body - Rzeczywista wiadomość e-mail
Nie rozważaliśmy żadnych walidacji na powyższych polach, walidacje zostaną dodane w następnym rozdziale. Przyjrzyjmy się teraz metodzie execute (). Metoda execute () używa biblioteki javax Mail do wysyłania wiadomości e-mail przy użyciu podanych parametrów. Jeśli wiadomość zostanie wysłana pomyślnie, akcja zwraca SUCCESS, w przeciwnym razie zwraca ERROR.
Utwórz stronę główną
Napiszmy plik JSP strony głównej index.jsp, które będą wykorzystywane do zbierania wyżej wymienionych informacji związanych z e-mailami -
<%@ 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>Utwórz widoki
Użyjemy pliku JSP success.jsp który zostanie wywołany w przypadku, gdy akcja zwróci SUCCESS, ale będziemy mieć inny plik widoku w przypadku zwrócenia błędu przez akcję.
<%@ 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>Poniżej znajduje się plik widoku error.jsp w przypadku BŁĘDU jest zwracana z akcji.
<%@ 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>Pliki konfiguracyjne
Teraz połączmy wszystko razem za pomocą pliku konfiguracyjnego struts.xml w następujący sposób -
<?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>Poniżej znajduje się treść web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Wprowadź wymagane informacje i kliknij Send Emailprzycisk. Jeśli wszystko pójdzie dobrze, powinieneś zobaczyć następną stronę.
W tym rozdziale przyjrzymy się bliżej strukturze walidacji Struts. W rdzeniu Struts mamy strukturę walidacji, która pomaga aplikacji w uruchomieniu reguł w celu wykonania walidacji przed wykonaniem metody akcji.
Walidację po stronie klienta zwykle przeprowadza się za pomocą JavaScript. Nie należy jednak polegać wyłącznie na walidacji po stronie klienta. Najlepsze praktyki sugerują, że walidację należy wprowadzić na wszystkich poziomach struktury aplikacji. Przyjrzyjmy się teraz dwóm sposobom dodania walidacji do naszego projektu Struts.
Tutaj weźmiemy przykład Employee których imię i wiek powinny być przechwycone za pomocą prostej strony, a my umieścimy te dwie walidacje, aby upewnić się, że użytkownik zawsze wprowadza imię i wiek, które powinny mieścić się w zakresie od 28 do 65 lat.
Zacznijmy od głównej strony JSP przykładu.
Utwórz stronę główną
Napiszmy plik JSP strony głównej index.jsp, które będą wykorzystywane do zbierania informacji związanych z Pracownikami, o których mowa powyżej.
<%@ 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>W pliku index.jsp jest używany tag Struts, którego jeszcze nie omówiliśmy, ale przeanalizujemy je w rozdziałach dotyczących tagów. Ale na razie załóżmy, że znacznik s: textfield drukuje pole wejściowe, a s: submit wyświetla przycisk przesyłania. Użyliśmy właściwości label dla każdego tagu, która tworzy etykietę dla każdego tagu.
Utwórz widoki
Użyjemy pliku JSP success.jsp, który zostanie wywołany w przypadku, gdy zdefiniowana akcja zwróci 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>Utwórz akcję
Zdefiniujmy więc małą klasę akcji Employee, a następnie dodaj metodę o nazwie validate() jak pokazano poniżej w Employee.javaplik. Upewnij się, że Twoja klasa akcji rozszerza rozszerzenieActionSupport class, w przeciwnym razie metoda walidacji nie zostanie wykonana.
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");
}
}
}Jak pokazano w powyższym przykładzie, metoda walidacji sprawdza, czy pole „Nazwa” ma wartość, czy nie. Jeśli nie podano żadnej wartości, dodajemy błąd pola do pola „Nazwa” z niestandardowym komunikatem o błędzie. Po drugie sprawdzamy, czy wpisana wartość pola „Wiek” mieści się w przedziale od 28 do 65 lat, czy nie, jeśli ten warunek nie spełnia, dodajemy błąd nad sprawdzanym polem.
Pliki konfiguracyjne
Na koniec zbierzmy wszystko razem za pomocą struts.xml plik konfiguracyjny w następujący sposób -
<?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>Poniżej znajduje się treść web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz nie wprowadzaj żadnych wymaganych informacji, po prostu kliknij Submitprzycisk. Zobaczysz następujący wynik -
Wprowadź wymagane informacje, ale wpisz nieprawidłowe pole Od, powiedzmy imię i nazwisko jako „test” i wiek 30 lat, a na koniec kliknij Submitprzycisk. Zobaczysz następujący wynik -
Jak działa ta walidacja?
Gdy użytkownik naciśnie przycisk przesyłania, Struts 2 automatycznie wykona metodę sprawdzania poprawności, a jeśli którykolwiek z plików “if”instrukcje podane w metodzie są prawdziwe, Struts 2 wywoła metodę addFieldError. Jeśli zostały dodane jakieś błędy, Struts 2 nie będzie wywoływać metody execute. Raczej powróci framework Struts 2input w wyniku wywołania akcji.
W związku z tym, gdy walidacja nie powiedzie się i Struts 2 powraca input, środowisko Struts 2 ponownie wyświetli plik index.jsp. Ponieważ użyliśmy znaczników formularzy Struts 2, Struts 2 automatycznie doda komunikaty o błędach tuż nad wypełnionym formularzem.
Te komunikaty o błędach są tymi, które określiliśmy w wywołaniu metody addFieldError. Metoda addFieldError przyjmuje dwa argumenty. Pierwszy toform nazwa pola, do którego odnosi się błąd, a druga to komunikat o błędzie wyświetlany nad tym polem formularza.
addFieldError("name","The name is required");Aby obsłużyć zwracaną wartość input musimy dodać następujący wynik do naszego węzła akcji w struts.xml.
<result name = "input">/index.jsp</result>Walidacja oparta na XML
Drugą metodą sprawdzania poprawności jest umieszczenie pliku xml obok klasy akcji. Walidacja oparta na XML Struts2 zapewnia więcej opcji walidacji, takich jak walidacja adresu e-mail, walidacja zakresu liczb całkowitych, pole walidacji formularza, walidacja wyrażenia, walidacja wyrażenia regularnego, wymagana walidacja, walidacja wymaganego ciągu znaków, walidacja długości ciągu itp.
Plik xml musi mieć nazwę '[action-class]'-validation.xml. Więc w naszym przypadku tworzymy plik o nazwieEmployee-validation.xml z następującą zawartością -
<!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>Powyższy plik XML byłby idealnie przechowywany w CLASSPATH razem z plikiem klasy. Przyjmijmy, że nasza klasa akcji Pracownika jest następująca bez posiadaniavalidate() metoda -
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;
}
}Reszta konfiguracji pozostanie taka, jaka była w poprzednim przykładzie, teraz, jeśli uruchomisz aplikację, da ona taki sam wynik, jaki otrzymaliśmy w poprzednim przykładzie.
Zaleta posiadania pliku xml do przechowywania konfiguracji pozwala na oddzielenie walidacji od kodu aplikacji. Możesz poprosić programistę o napisanie kodu i analityka biznesowego, aby utworzył pliki XML walidacji. Inną rzeczą, na którą należy zwrócić uwagę, są typy walidatorów, które są dostępne domyślnie.
Istnieje wiele innych walidatorów, które są domyślnie dostępne w Struts. Typowe walidatory obejmują walidator daty, walidator Regex i walidator długości ciągu. Kliknij poniższe łącze, aby uzyskać więcej informacji na temat Struts - walidatory oparte na języku XML .
Umiędzynarodowienie (i18n) to proces planowania i wdrażania produktów i usług, tak aby można je było łatwo dostosować do określonych lokalnych języków i kultur, proces zwany lokalizacją. Proces umiędzynarodowienia nazywany jest tłumaczeniem lub włączaniem lokalizacji.
Internacjonalizacja jest w skrócie i18n ponieważ słowo zaczyna się od litery “i” i kończy się na “n”i jest 18 znaków między pierwszym i a ostatnim n.
Struts2 zapewnia obsługę lokalizacji, tj. Internacjonalizacji (i18n) za pośrednictwem pakietów zasobów, modułów przechwytujących i bibliotek znaczników w następujących miejscach -
Tagi interfejsu użytkownika
Komunikaty i błędy.
W ramach klas akcji.
Pakiety zasobów
Struts2 korzysta z pakietów zasobów, aby zapewnić użytkownikom aplikacji WWW wiele opcji językowych i regionalnych. Nie musisz się martwić pisaniem stron w różnych językach. Wszystko, co musisz zrobić, to utworzyć pakiet zasobów dla każdego języka, który chcesz. Pakiety zasobów będą zawierać tytuły, komunikaty i inny tekst w języku użytkownika. Pakiety zasobów to plik zawierający pary klucz / wartość dla domyślnego języka aplikacji.
Najprostszym formatem nazewnictwa pliku zasobów jest -
bundlename_language_country.propertiesTutaj, bundlenamemoże być ActionClass, Interface, SuperClass, Model, Package, Global resource properties. Następna częśćlanguage_country reprezentuje ustawienia regionalne kraju, na przykład język hiszpański (Hiszpania) jest reprezentowany przez es_ES, a język angielski (Stany Zjednoczone) jest reprezentowany przez en_US itp., gdzie można pominąć część kraju, która jest opcjonalna.
Gdy odwołujesz się do elementu komunikatu za pomocą jego klucza, środowisko Struts wyszukuje odpowiedni pakiet komunikatów w następującej kolejności -
- ActionClass.properties
- Interface.properties
- SuperClass.properties
- model.properties
- package.properties
- struts.properties
- global.properties
Aby opracować aplikację w wielu językach, należy zachować wiele plików właściwości odpowiadających tym językom / ustawieniom narodowym i zdefiniować całą zawartość za pomocą par klucz / wartość.
Na przykład, jeśli zamierzasz opracować aplikację w języku angielskim (domyślnym), hiszpańskim i francuskim, musisz utworzyć trzy pliki właściwości. Tutaj użyjęglobal.properties tylko plik, możesz również skorzystać z różnych plików właściwości, aby posegregować różne typy wiadomości.
global.properties - Domyślnie zostanie zastosowany język angielski (Stany Zjednoczone)
global_fr.properties - Będzie to używane dla lokalizacji Franch.
global_es.properties - Będzie to używane dla hiszpańskich ustawień regionalnych.
Uzyskaj dostęp do wiadomości
Istnieje kilka sposobów uzyskiwania dostępu do zasobów komunikatów, w tym getText, znacznik tekstowy, atrybut klucza znaczników UI oraz znacznik i18n. Zobaczmy je w skrócie -
Do wyświetlenia i18n tekst, zadzwoń do getText w tagu właściwości lub w dowolnym innym tagu, takim jak tagi interfejsu użytkownika w następujący sposób -
<s:property value = "getText('some.key')" />Plik text tag pobiera komunikat z domyślnego pakietu zasobów, tj. struts.properties
<s:text name = "some.key" />Plik i18n tagwypycha dowolny pakiet zasobów na stos wartości. Inne znaczniki w zakresie znacznika i18n mogą wyświetlać komunikaty z tego pakietu zasobów
<s:i18n name = "some.package.bundle">
<s:text name = "some.key" />
</s:i18n>Plik key atrybut większości tagów UI może służyć do generowania wiadomości z pakietu zasobów -
<s:textfield key = "some.key" name = "textfieldName"/>Przykład lokalizacji
Postawmy sobie za cel tworzenie index.jspz poprzedniego rozdziału w wielu językach. Ten sam plik zostałby zapisany w następujący sposób -
<%@ 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>Stworzymy success.jsp plik, który zostanie wywołany w przypadku powrotu zdefiniowanej akcji 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>Tutaj musielibyśmy utworzyć następujące dwie akcje. (a) Pierwsza akcja a, aby zająć się lokalizacją i wyświetlić ten sam plik index.jsp w innym języku (b) Kolejną czynnością jest zadbanie o samo przesłanie formularza. Obie akcje zwrócą SUKCES, ale podejmiemy różne działania w oparciu o zwracane wartości, ponieważ nasz cel jest inny dla obu działań
Działania mające na celu dbanie o lokalizację
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}Akcja wysyłania formularza
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;
}
}Teraz stwórzmy następujące trzy global.properties pliki i wstaw plik 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 correctamenteStworzymy nasze struts.xml z dwoma działaniami w następujący sposób -
<?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>Poniżej znajduje się treść web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz wybierz dowolny z języków, powiedzmy, że wybieramy Spanish, wyświetli następujący wynik -
Możesz także spróbować z językiem francuskim. Na koniec spróbujmy kliknąćSubmit przycisk, gdy jesteśmy w języku hiszpańskim, wyświetli następujący ekran -
Gratulacje, teraz masz wielojęzyczną stronę internetową, możesz ją uruchomić globalnie.
Wszystko w żądaniu HTTP jest traktowane jako plik Stringprotokołem. Obejmuje to liczby, wartości logiczne, liczby całkowite, daty, liczby dziesiętne i wszystko inne. Jednak w klasie Struts można mieć właściwości dowolnego typu danych.
W jaki sposób Struts automatycznie przewodzi nieruchomości?
Struts używa różnych typów konwerterów pod osłonami do wykonywania ciężkich prac.
Na przykład, jeśli w klasie Action masz atrybut liczby całkowitej, Struts automatycznie konwertuje parametr żądania na atrybut liczby całkowitej bez wykonywania jakichkolwiek czynności. Domyślnie Struts jest dostarczany z wieloma konwerterami typów
Jeśli używasz któregokolwiek z wymienionych poniżej konwerterów, nie masz się czym martwić -
- Liczba całkowita, zmiennoprzecinkowa, podwójna, dziesiętna
- Data i data i godzina
- Tablice i kolekcje
- Enumerations
- Boolean
- BigDecimal
Czasami, gdy używasz własnego typu danych, konieczne jest dodanie własnych konwerterów, aby Struts wiedział, jak konwertować te wartości przed wyświetleniem. Rozważmy następującą klasę POJOEnvironment.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;
}
}To jest bardzo prosta klasa, która ma atrybut o nazwie name, więc nic specjalnego w tej klasie. Stwórzmy kolejną klasę zawierającą informacje o systemie -SystemDetails.java.
Na potrzeby tego ćwiczenia na stałe zakodowałem środowisko na „Rozwój”, a system operacyjny na „Windows XP SP3”.
W projekcie czasu rzeczywistego można uzyskać te informacje z konfiguracji systemu.
Miejmy następującą klasę działań -
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;
}
}Następnie stwórzmy prosty plik JSP System.jsp aby wyświetlić informacje o środowisku i systemie operacyjnym.
<%@ 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>Połączmy system.jsp i SystemDetails.java klasa razem za pomocą struts.xml.
Klasa SystemDetails zawiera prostą metodę execute (), która zwraca ciąg znaków "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>Kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR File aby utworzyć plik wojny.
Następnie wdróż tę WAR w katalogu webapps serwera Tomcat.
Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URL http://localhost:8080/HelloWorldStruts2/system.action. Spowoduje to wyświetlenie następującego ekranu -
Co jest nie tak z powyższym wyjściem? Struts wie, jak wyświetlić i przekonwertować ciąg „Windows XP SP3” i inne wbudowane typy danych, ale nie wie, co zrobić z właściwościąEnvironmentrodzaj. To się po prostu nazywatoString() metoda na klasie
Aby rozwiązać ten problem, utwórzmy i zarejestrujmy plik simple TypeConverter dla klasy Environment.
Utwórz klasę o nazwie EnvironmentConverter.java z następującymi.
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();
}
}Plik EnvironmentConverter rozszerza StrutsTypeConverter i informuje Struts, jak przekonwertować Environment na String i odwrotnie, zastępując dwie metody, które są convertFromString() i convertToString().
Zarejestrujmy teraz ten konwerter, zanim użyjemy go w naszej aplikacji. Istnieją dwa sposoby zarejestrowania konwertera.
Jeśli konwerter będzie używany tylko w określonej akcji, wówczas należałoby utworzyć plik właściwości, który należy nazwać jako '[action-class]'converstion.properties.
W naszym przypadku tworzymy plik o nazwie SystemDetails-converstion.properties z następującym wpisem rejestracyjnym -
environment = com.tutorialspoint.struts2.EnvironmentConverterW powyższym przykładzie „środowisko” to nazwa właściwości w SystemDetails.java i mówimy Struts, aby używał rozszerzenia EnvironmentConverter do konwersji na iz tej właściwości.
Jednak tego nie zrobimy, zamiast tego zarejestrujemy ten konwerter globalnie, aby można go było używać w całej aplikacji. Aby to zrobić, utwórz plik właściwości o nazwiexwork-conversion.properties w WEBINF/classes folder z następującym wierszem
com.tutorialspoint.struts2.Environment = \
com.tutorialspoint.struts2.EnvironmentConverterTo po prostu rejestruje konwerter globalnie, więc Strutsmoże automatycznie wykonać konwersję za każdym razem, gdy napotka obiekt typu Environment. Teraz, jeśli ponownie skompilujesz i ponownie uruchomisz program, uzyskasz lepszy wynik w następujący sposób -
Oczywiście teraz wynik będzie lepszy, co oznacza, że nasz konwerter Struts działa dobrze.
W ten sposób możesz utworzyć wiele konwerterów i zarejestrować je do użytku zgodnie z własnymi wymaganiami.
Zanim przejdziemy do samouczka do tego rozdziału, przyjrzyjmy się kilku definicjom podanym przez https://struts.apache.org-
| Sr.No | Termin i opis |
|---|---|
| 1 | TAG Mały fragment kodu wykonywany z poziomu JSP, FreeMarker lub Velocity. |
| 2 | TEMPLATE Fragment kodu, zwykle napisany we FreeMarker, który może być renderowany przez określone tagi (tagi HTML). |
| 3 | THEME Zbiór szablonów spakowanych razem, aby zapewnić wspólną funkcjonalność. |
Sugerowałbym również przejrzenie rozdziału Lokalizacja Struts2, ponieważ weźmiemy ten sam przykład jeszcze raz, aby wykonać nasze ćwiczenie.
Kiedy używasz Struts 2tag, taki jak <s: submit ...>, <s: textfield ...> itp. na swojej stronie internetowej, framework Struts 2 generuje kod HTML ze wstępnie skonfigurowanym stylem i układem. Struts 2 zawiera trzy wbudowane motywy -
| Sr.No | Motyw i opis |
|---|---|
| 1 | SIMPLE theme Minimalistyczny motyw bez „dzwonków i gwizdków”. Na przykład znacznik textfield renderuje tag HTML <input /> bez etykiety, walidacji, raportowania błędów ani żadnego innego formatowania lub funkcji. |
| 2 | XHTML theme Jest to domyślny motyw używany w Struts 2 i zapewnia wszystkie podstawy, które zapewnia prosty motyw i dodaje kilka funkcji, takich jak standardowy układ dwukolumnowej tabeli dla kodu HTML, etykiety dla każdego kodu HTML, walidacja i raportowanie błędów itp. |
| 3 | CSS_XHTML theme Ten motyw zapewnia wszystkie podstawy, które zapewnia prosty motyw i dodaje kilka funkcji, takich jak standardowy dwukolumnowy układ oparty na CSS, używając <div> dla tagów HTML Struts, etykiet dla każdego z tagów HTML Struts, umieszczonych zgodnie z arkuszem stylów CSS . |
Jak wspomniano powyżej, jeśli nie określisz motywu, Struts 2 użyje domyślnie motywu xhtml. Na przykład ten znacznik wyboru Struts 2 -
<s:textfield name = "name" label = "Name" />generuje następujące znaczniki HTML -
<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>Tutaj empinfo to nazwa działania zdefiniowana w pliku struts.xml.
Wybieranie motywów
Możesz określić motyw zgodnie z Struts 2, na podstawie tagów lub możesz użyć jednej z następujących metod, aby określić, jakiego motywu ma używać Struts 2 -
Atrybut motywu na określonym znaczniku
Atrybut motywu na otaczającym znacznik znaczniku formularza
Atrybut o zakresie strony o nazwie „theme”
Atrybut w zakresie żądania o nazwie „theme”
Atrybut o zasięgu sesji o nazwie „theme”
Atrybut w zakresie aplikacji o nazwie „theme”
Właściwość struts.ui.theme w struts.properties (domyślnie xhtml)
Poniżej znajduje się składnia służąca do określania ich na poziomie tagu, jeśli chcesz używać różnych motywów dla różnych tagów -
<s:textfield name = "name" label = "Name" theme="xhtml"/>Ponieważ używanie motywów na podstawie tagów nie jest zbyt praktyczne, więc możemy po prostu określić regułę w struts.properties plik przy użyciu następujących tagów -
# 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 = ftlPoniżej przedstawiono wynik, który uzyskaliśmy z rozdziału dotyczącego lokalizacji, w którym użyliśmy domyślnego motywu z ustawieniem struts.ui.theme = xhtml w struts-default.properties domyślny plik struts2-core.xy.z.jar.
Jak działa motyw?
Dla danego motywu każdy tag Struts ma powiązany szablon, np. s:textfield → text.ftl i s:password → password.ftl itp.
Te pliki szablonów są spakowane w pliku struts2-core.xy.z.jar. Te pliki szablonów zachowują wstępnie zdefiniowany układ HTML dla każdego znacznika.
W ten sposób, Struts 2 Framework generuje ostateczny kod HTML przy użyciu tagów Sturts i powiązanych szablonów.
Struts 2 tags + Associated template file = Final HTML markup code.Domyślne szablony są napisane we FreeMarker i mają rozszerzenie .ftl.
Możesz także zaprojektować swoje szablony za pomocą velocity lub JSP i odpowiednio ustawić konfigurację w struts.properties za pomocą struts.ui.templateSuffix i struts.ui.templateDir.
Tworzenie nowych motywów
Najprostszym sposobem stworzenia nowego motywu jest skopiowanie dowolnego z istniejących plików motywu / szablonu i dokonanie wymaganych modyfikacji.
Zacznijmy od stworzenia folderu o nazwie templatew WebContent / WEBINF / classes i podfolderze z nazwą naszego nowego motywu. Na przykład WebContent / WEB-INF / classes / template / mytheme .
W tym miejscu możesz rozpocząć tworzenie szablonów od podstaw lub możesz również skopiować szablony z pliku Struts2 distribution gdzie możesz je zmodyfikować zgodnie z wymaganiami w przyszłości.
Zamierzamy zmodyfikować istniejący domyślny szablon xhtmldo celów edukacyjnych. Teraz skopiujmy zawartość z struts2-core-xyzjar / template / xhtml do naszego katalogu z motywami i zmodyfikujmy tylko plik WebContent / WEBINF / classes / template / mytheme / control .ftl. Kiedy otworzymy plik control.ftl, który będzie miał następujące wiersze -
<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>Zmieńmy powyższy plik control.ftl mieć następującą zawartość -
<table style = "border:1px solid black;">Jeśli będziesz sprawdzać form.ftl wtedy to znajdziesz control.ftljest używany w tym pliku, ale form.ftl odwołuje się do tego pliku z motywu xhtml. Więc zmieńmy to w następujący sposób -
<#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" />Zakładam, że nie miałbyś zbyt wiele zrozumienia FreeMarker języka szablonów, nadal możesz zorientować się, co należy zrobić, patrząc na pliki .ftl.
Zapiszmy jednak powyższe zmiany i wróćmy do naszego przykładu lokalizacji i utwórzmy plik WebContent/WEB-INF/classes/struts.properties plik z następującą zawartością
# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftlTeraz po tej zmianie kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2. Spowoduje to wyświetlenie następującego ekranu -
Możesz zobaczyć obramowanie wokół komponentu formularza, które jest wynikiem zmiany, którą wprowadziliśmy w naszym motywie po skopiowaniu go z motywu xhtml. Jeśli włożysz niewielki wysiłek w naukę FreeMarkera, będziesz w stanie bardzo łatwo tworzyć lub modyfikować swoje motywy.
Mam nadzieję, że teraz masz podstawowe zrozumienie Sturts 2 motywy i szablony, prawda?
Strutszapewnia łatwiejszy sposób obsługi nieprzechwyconych wyjątków i przekierowywania użytkowników do dedykowanej strony błędu. Możesz łatwo skonfigurować Struts tak, aby miał różne strony błędów dla różnych wyjątków.
Struts ułatwia obsługę wyjątków dzięki zastosowaniu przechwytywacza „wyjątków”. Przechwytywacz „wyjątków” jest częścią domyślnego stosu, więc nie musisz robić nic więcej, aby go skonfigurować. Jest dostępny od razu po wyjęciu z pudełka i gotowy do użycia.
Zobaczmy prosty przykład Hello World z pewnymi modyfikacjami w pliku HelloWorldAction.java. Tutaj celowo wprowadziliśmy wyjątek NullPointer w naszymHelloWorldAction kod akcji.
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;
}
}Zachowajmy zawartość HelloWorld.jsp w następujący sposób -
<%@ 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>Poniżej znajduje się treść 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>Twój struts.xml powinno wyglądać jak -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Wpisz wartość „Struts2” i prześlij stronę. Powinieneś zobaczyć następującą stronę -
Jak pokazano w powyższym przykładzie, domyślny przechwytywacz wyjątków świetnie radzi sobie z obsługą wyjątku.
Utwórzmy teraz dedykowaną stronę błędu dla naszego wyjątku. Utwórz plik o nazwieError.jsp z następującą zawartością -
<%@ 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>Skonfigurujmy teraz Struts, aby używał tej strony błędu w przypadku wyjątku. Zmodyfikujmystruts.xml w następujący sposób -
<?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>Jak pokazano w powyższym przykładzie, teraz skonfigurowaliśmy Struts do używania dedykowanego pliku Error.jsp dla wyjątku NullPointerException. Jeśli teraz uruchomisz program ponownie, zobaczysz teraz następujące dane wyjściowe -
Oprócz tego framework Struts2 jest wyposażony w przechwytywacz „logowania” do rejestrowania wyjątków. Umożliwiając rejestratorowi rejestrowanie nieprzechwyconych wyjątków, możemy łatwo przejrzeć ślad stosu i ustalić, co poszło nie tak
Globalne mapowania wyjątków
Widzieliśmy, jak możemy obsłużyć wyjątek specyficzny dla akcji. Możemy ustawić wyjątek globalnie, który będzie dotyczył wszystkich działań. Na przykład, aby złapać te same wyjątki NullPointerException, możemy dodać<global-exception-mappings...> tag wewnątrz tagu <package ...>, a jego tag <result ...> należy dodać wewnątrz tagu <action ...> w pliku struts.xml w następujący sposób -
<?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>Jak wspomniano wcześniej, Struts udostępnia dwie formy konfiguracji. Tradycyjnym sposobem jest użyciestruts.xmlplik dla wszystkich konfiguracji. Jak dotąd widzieliśmy wiele przykładów tego w tutorialu. Innym sposobem konfiguracji Struts jest użycie funkcji adnotacji Java 5. Korzystając z adnotacji rozpórek, możemy to osiągnąćZero Configuration.
Aby rozpocząć korzystanie z adnotacji w projekcie, upewnij się, że w swoim pliku WebContent/WEB-INF/lib folder -
- 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
Zobaczmy teraz, jak możesz pozbyć się konfiguracji dostępnej w struts.xml plik i zastąp go adnotacjami.
Aby wyjaśnić koncepcję adnotacji w Struts2, musielibyśmy ponownie rozważyć nasz przykład walidacji wyjaśniony w rozdziale Walidacje Struts2 .
W tym miejscu weźmiemy przykład pracownika, którego imię i nazwisko, wiek zostałby przechwycony za pomocą prostej strony, i wprowadzimy dwie walidacje, aby upewnić się, że ÜSER zawsze wprowadza imię i nazwisko, a wiek powinien mieścić się w przedziale od 28 do 65 lat.
Zacznijmy od głównej strony JSP przykładu.
Utwórz stronę główną
Napiszmy plik JSP strony głównej index.jsp, który służy do zbierania informacji związanych z Pracownikami, o których mowa powyżej.
<%@ 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>W pliku index.jsp jest używany tag Struts, którego jeszcze nie omówiliśmy, ale przeanalizujemy je w rozdziałach dotyczących tagów. Ale na razie załóżmy, że znacznik s: textfield drukuje pole wejściowe, a s: submit wyświetla przycisk przesyłania. Użyliśmy właściwości label dla każdego tagu, która tworzy etykietę dla każdego tagu.
Utwórz widoki
Użyjemy pliku JSP success.jsp która zostanie wywołana w przypadku powrotu zdefiniowanej akcji 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>Utwórz akcję
To jest miejsce, w którym używa się adnotacji. Zdefiniujmy ponownie klasę działaniaEmployee z adnotacją, a następnie dodaj metodę o nazwie validate () jak pokazano poniżej w Employee.javaplik. Upewnij się, że Twoja klasa akcji rozszerza rozszerzenieActionSupport class, w przeciwnym razie metoda walidacji nie zostanie wykonana.
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;
}
}W tym przykładzie użyliśmy kilku adnotacji. Pozwól, że przejdę przez nie jeden po drugim -
Po pierwsze, dołączyliśmy Resultsadnotacja. Adnotacja wyników to zbiór wyników.
Pod adnotacją wyników mamy dwie adnotacje wyników. Adnotacje wyników mają rozszerzenienamektóre odpowiadają wynikowi metody wykonania. Zawierają również lokalizację, w którym widok powinien być obsługiwany, odpowiadający wartości zwracanej z funkcji execute ()
Następna adnotacja to Actionadnotacja. Służy do dekorowania metody execute (). Metoda Action przyjmuje również wartość będącą adresem URL, z którego wywoływana jest akcja.
Wreszcie użyłem dwóch validationadnotacje. Skonfigurowałem wymagany walidator pólname i walidator zakresu liczb całkowitych na agepole. Podałem również niestandardowy komunikat do walidacji.
Pliki konfiguracyjne
Naprawdę nie potrzebujemy struts.xml plik konfiguracyjny, więc usuńmy ten plik i sprawdźmy zawartość web.xml plik -
<?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>Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/index.jsp. Spowoduje to wyświetlenie następującego ekranu -
Teraz nie wprowadzaj żadnych wymaganych informacji, po prostu kliknij Submitprzycisk. Zobaczysz następujący wynik -
Wprowadź wymagane informacje, ale wpisz nieprawidłowe pole Od, powiedzmy imię i nazwisko jako „test” i wiek 30 lat, a na koniec kliknij Submitprzycisk. Zobaczysz następujący wynik -
Typy adnotacji Struts 2
Aplikacje Struts 2 mogą używać adnotacji Java 5 jako alternatywy dla konfiguracji właściwości XML i Java. Możesz sprawdzić listę najważniejszych adnotacji związanych z różnymi kategoriami -
Typy adnotacji Struts 2 .
Tagi Struts 2 zawierają zestaw tagów, które ułatwiają sterowanie przepływem wykonywania strony.
Poniżej znajduje się lista ważnych znaczników sterujących Struts 2 -
Tagi Jeśli i Inaczej
Te tagi wykonują podstawowy przepływ warunków występujący w każdym języku.
'If' tag jest używany samodzielnie lub z 'Else If' Tag i / lub pojedynczy / wielokrotny 'Else' Tag, jak pokazano poniżej -
<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>Sprawdź szczegółowy przykład
Tagi iteratora
To iteratorbędzie iterować po wartości. Iterowalną wartością może być plik itherjava.util.Collection lub java.util.Iterator. Podczas iteracji po iteratorze możesz użyćSort tag, aby posortować wynik lub SubSet tag, aby uzyskać podzbiór listy lub tablicy.
Poniższy przykład pobiera wartość metody getDays () bieżącego obiektu na stosie wartości i używa jej do iteracji.
Znacznik <s: property /> wyświetla bieżącą wartość iteratora.
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>Sprawdź szczegółowy przykład
Znacznik scalania
Te merge tag przyjmuje dwie lub więcej list jako parametry i łączy je wszystkie razem, jak pokazano poniżej -
<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>Sprawdź szczegółowy przykład
Dołącz tag
Te append tag bierze dwie lub więcej list jako parametry i dołącza je wszystkie razem, jak pokazano poniżej -
<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>Sprawdź szczegółowy przykład
Tag generatora
Te generatortag generuje iterator na podstawie podanego atrybutu val. Poniższy tag generatora generuje iterator i drukuje go przy użyciu tagu iterator.
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>Sprawdź szczegółowy przykład
The Struts 2 data tagssłużą głównie do manipulowania danymi wyświetlanymi na stronie. Poniżej wymienione są ważne znaczniki danych: <Zacznij tutaj>
Tag akcji
Ten znacznik umożliwia programistom wywoływanie akcji bezpośrednio ze strony JSP przez określenie nazwy akcji i opcjonalnej przestrzeni nazw. Treść znacznika służy do renderowania wyników z akcji. Każdy procesor wyników zdefiniowany dla tej akcji w struts.xml będzie ignorowany, chyba że zostanie określony parametr executeResult.
<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" />Sprawdź szczegółowy przykład
Tag Include
Te include posłuży do dołączenia pliku JSP na innej stronie JSP.
<-- 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>Sprawdź szczegółowy przykład
Tag fasoli
Te beantag tworzy instancję klasy zgodnej ze specyfikacją JavaBeans. Ten znacznik ma treść, która może zawierać wiele elementów Param do ustawiania metod mutatora w tej klasie. Jeśli atrybut var jest ustawiony w BeanTag, umieści on utworzony komponent bean w Context stosu.
<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
<s:param name = "first" value = "20"/>
<s:param name = "last" value = "25" />
</s:bean>Sprawdź szczegółowy przykład
Tag z datą
Te datetag pozwoli Ci sformatować datę w szybki i łatwy sposób. Możesz określić format niestandardowy (np. „Dd / MM / rrrr gg: mm”), możesz generować łatwe do odczytania zapisy (np. „Za 2 godziny, 14 minut”) lub po prostu wrócić do wstępnie zdefiniowanego formatu z klucz „struts.date.format” w pliku właściwości.
<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" />Sprawdź szczegółowy przykład
Tag Param
Te paramtag może służyć do parametryzacji innych tagów. Ten tag ma następujące dwa parametry.
name (String) - nazwa parametru
value (Object) - wartość parametru
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>Sprawdź szczegółowy przykład
Etykieta właściwości
Te property tag jest używany do pobierania właściwości wartości, która domyślnie znajdzie się na szczycie stosu, jeśli żadna nie zostanie określona.
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty" />
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value" />
</s:push>Sprawdź szczegółowy przykład
Tag push
Te push tag służy do umieszczania wartości na stosie w celu uproszczenia użycia.
<s:push value = "user">
<s:propery value = "firstName" />
<s:propery value = "lastName" />
</s:push>Sprawdź szczegółowy przykład
Ustaw tag
Te settag przypisuje wartość do zmiennej w określonym zakresie. Jest to przydatne, gdy chcesz przypisać zmienną do złożonego wyrażenia, a następnie po prostu odwoływać się do tej zmiennej za każdym razem, a nie do złożonego wyrażenia. Dostępne zakresy toapplication, session, request, page i action.
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>Sprawdź szczegółowy przykład
Tag tekstowy
Te text tag jest używany do renderowania wiadomości tekstowej I18n.
<!-- 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>Sprawdź szczegółowy przykład
Tag adresu URL
Te url tag służy do tworzenia adresu URL.
<-- 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>Sprawdź szczegółowy przykład
Lista formTagi to podzbiór tagów interfejsu użytkownika Struts. Znaczniki te pomagają w renderowaniu interfejsu użytkownika wymaganego dla aplikacji internetowych Struts i można je podzielić na trzy kategorie. W tym rozdziale omówimy wszystkie trzy typy tagów interfejsu użytkownika -
Proste tagi interfejsu użytkownika
Użyliśmy już tych tagów w naszych przykładach, będziemy je szczotkować w tym rozdziale. Spójrzmy na prostą stronę widokuemail.jsp z kilkoma prostymi tagami interfejsu użytkownika -
<%@ 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>Jeśli znasz język HTML, wszystkie używane tagi są bardzo popularnymi tagami HTML z dodatkowym przedrostkiem s:wraz z każdym tagiem i różnymi atrybutami. Kiedy wykonujemy powyższy program, otrzymujemy następujący interfejs użytkownika, pod warunkiem, że skonfigurowałeś odpowiednie mapowanie dla wszystkich używanych kluczy.
Jak pokazano, s: head generuje elementy javascript i arkusza stylów wymagane dla aplikacji Struts2.
Następnie mamy elementy s: div i s: text. Element s: div służy do renderowania elementu HTML Div. Jest to przydatne dla osób, które nie lubią mieszać razem tagów HTML i Struts. Dla tych ludzi mogą oni użyć s: div do renderowania div.
S: text, jak pokazano, służy do renderowania tekstu na ekranie.
Następnie mamy tag rodziny s: form. Znacznik s: form ma atrybut akcji, który określa, gdzie przesłać formularz. Ponieważ mamy w formularzu element uploadu pliku, musimy ustawić enctype na multipart. W przeciwnym razie możemy pozostawić to pole puste.
Na końcu tagu formularza mamy tag s: submit. Służy do przesyłania formularza. Po przesłaniu formularza wszystkie wartości formularza są przekazywane do akcji określonej w tagu s: form.
Wewnątrz formularza s: mamy ukryty atrybut o nazwie sekret. To renderuje ukryty element w kodzie HTML. W naszym przypadku element „sekret” ma wartość „abrakadabra”. Ten element nie jest widoczny dla użytkownika końcowego i służy do przenoszenia stanu z jednego widoku do drugiego.
Następnie mamy tagi s: label, s: textfield, s: password i s: textarea. Są one używane do renderowania odpowiednio etykiety, pola wprowadzania, hasła i obszaru tekstowego. Widzieliśmy je w akcji w przykładzie „Struts - wysyłanie wiadomości e-mail”.
Ważną rzeczą do zapamiętania jest użycie atrybutu „klucz”. Atrybut „klucz” służy do pobierania etykiety dla tych formantów z pliku właściwości. Omówiliśmy już tę funkcję w rozdziale Lokalizacja Struts2, internacjonalizacja.
Następnie mamy tag s: file, który renderuje komponent przesyłania pliku wejściowego. Ten komponent umożliwia użytkownikowi przesyłanie plików. W tym przykładzie użyliśmy parametru „accept” tagu s: file, aby określić, które typy plików mogą być przesyłane.
Wreszcie mamy tag s: token. Znacznik token generuje unikalny token, który służy do sprawdzenia, czy formularz został przesłany dwukrotnie
Podczas renderowania formularza ukryta zmienna jest umieszczana jako wartość tokenu. Powiedzmy na przykład, że tokenem jest „ABC”. Po przesłaniu tego formularza Struts Fitler porównuje token z tokenem przechowywanym w sesji. Jeśli pasuje, usuwa token z sesji. Teraz, jeśli formularz zostanie przypadkowo przesłany ponownie (przez odświeżenie lub naciśnięcie przycisku Wstecz w przeglądarce), formularz zostanie ponownie przesłany z „ABC” jako tokenem. W takim przypadku filtr ponownie porównuje token z tokenem przechowywanym w sesji. Ale ponieważ token „ABC” został usunięty z sesji, nie będzie pasował, a filtr Struts odrzuci żądanie.
Grupuj znaczniki interfejsu użytkownika
Tagi grupowego interfejsu użytkownika służą do tworzenia przycisku opcji i pola wyboru. Spójrzmy na prostą stronę widokuHelloWorld.jsp z polami wyboru i tagami przycisków opcji -
<%@ 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>Kiedy wykonamy powyższy program, nasze dane wyjściowe będą wyglądać podobnie do następującego -
Spójrzmy teraz na przykład. W pierwszym przykładzie tworzymy prosty przycisk opcji z etykietą „Płeć”. Atrybut name jest obowiązkowy w przypadku tagu przycisku opcji, dlatego określamy nazwę „płeć”. Następnie podajemy listę płci. Lista jest zapełniana wartościami „mężczyzna” i „kobieta”. Dlatego w wyniku otrzymujemy przycisk radiowy z dwiema wartościami.
W drugim przykładzie tworzymy listę checkboxów. Ma to na celu zebranie zainteresowań użytkownika. Użytkownik może mieć więcej niż jedno hobby, dlatego zamiast przycisku radiowego używamy pola wyboru. Pole wyboru zawiera listę „sport”, „telewizja” i „zakupy”. To przedstawia hobby jako listę pól wyboru.
Wybierz Tagi interfejsu użytkownika
Przyjrzyjmy się różnym wariantom tagu Select oferowanym przez Struts. Spójrzmy na prostą stronę widokuHelloWorld.jsp z zaznaczonymi tagami -
<%@ 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>Kiedy wykonamy powyższy program, nasze dane wyjściowe będą wyglądać podobnie do następującego -
Przejdźmy teraz przez poszczególne przypadki, jeden po drugim.
Najpierw tag select renderuje pole wyboru HTML. W pierwszym przykładzie tworzymy proste pole wyboru z nazwą „nazwa użytkownika” i etykietą „nazwa użytkownika”. Pole wyboru zostanie wypełnione listą zawierającą nazwiska Mike, John i Smith.
W drugim przykładzie nasza firma ma siedzibę w Ameryce. Posiada również biura na całym świecie w Azji i Europie. Chcemy wyświetlić biura w zaznaczonym polu, ale chcemy pogrupować biura globalne według nazwy kontynentu. Tutaj przydaje się optgroup. Używamy tagu s: optgroup do tworzenia nowej grupy. Dajemy grupie etykietę i osobną listę.
W trzecim przykładzie używany jest combobox. Pole kombi to połączenie pola wejściowego i pola wyboru. Użytkownik może wybrać wartość z pola wyboru, w którym to przypadku pole wejściowe zostanie automatycznie wypełnione wartością wybraną przez użytkownika. Jeśli użytkownik wprowadzi wartość bezpośrednio, żadne wartości z pola wyboru nie zostaną wybrane.
W naszym przykładzie mamy pole combobox z listą znaków słonecznych. Pole wyboru zawiera tylko cztery wpisy umożliwiające użytkownikowi wpisanie swojego znaku słonecznego, jeśli nie ma go na liście. Dodajemy również nagłówek do pola wyboru. Nagłówek to ten, który jest wyświetlany w górnej części pola wyboru. W naszym przypadku chcemy wyświetlić „Proszę wybrać”. Jeśli użytkownik niczego nie wybierze, przyjmujemy wartość -1. W niektórych przypadkach nie chcemy, aby użytkownik wybierał pustą wartość. W takich warunkach należałoby ustawić właściwość „emptyOption” na false. Na koniec, w naszym przykładzie podajemy „koziorożec” jako domyślną wartość kombi.
W czwartym przykładzie mamy podwójny wybór. Podwójne zaznaczenie jest używane, gdy chcesz wyświetlić dwa pola wyboru. Wartość wybrana w pierwszym polu wyboru określa, co pojawi się w drugim polu wyboru. W naszym przykładzie pierwsze pole wyboru wyświetla „Techniczne” i „Inne”. Jeśli użytkownik wybierze opcję Techniczne, w drugim polu wyboru wyświetlimy IT i sprzęt. W przeciwnym razie wyświetlimy Księgowość i HR. Jest to możliwe przy użyciu atrybutów „list” i „doubleList”, jak pokazano w przykładzie.
W powyższym przykładzie przeprowadziliśmy porównanie, aby sprawdzić, czy górne pole wyboru jest równe Technicznemu. Jeśli tak, wyświetlamy IT i sprzęt.
Musimy także podać nazwę górnego pola ("name = 'Occupations') i dolnego (doubleName = 'zawody2')
Struts używa frameworka DOJO do implementacji tagów AJAX. Przede wszystkim, aby przejść do tego przykładu, musisz dodać struts2-dojo-plugin-2.2.3.jar do swojej ścieżki klas.
Możesz pobrać ten plik z folderu lib pobranego pliku struts2 (C: \ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar)
W tym przypadku zmodyfikujmy HelloWorld.jsp w następujący sposób -
<%@ 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>Po uruchomieniu powyższego przykładu otrzymujemy następujące dane wyjściowe -
Przejdźmy teraz przez ten przykład krok po kroku.
Pierwszą rzeczą, na którą należy zwrócić uwagę, jest dodanie nowej biblioteki znaczników z przedrostkiem sx. To (struts-dojo-tags) jest biblioteką tagów stworzoną specjalnie do integracji Ajax.
Następnie wewnątrz nagłówka HTML nazywamy sx: head. Spowoduje to zainicjowanie struktury dojo i przygotowanie jej na wszystkie wywołania AJAX na stronie. Ten krok jest ważny - twoje wywołania Ajax nie będą działać bez zainicjowania sx: head.
Najpierw mamy tag autocompleter. Znacznik autouzupełniania wygląda prawie jak pole wyboru. Jest wypełniony wartościami czerwonym, zielonym i niebieskim. Ale różnica między polem wyboru a tym polega na tym, że uzupełnia się automatycznie. Oznacza to, że jeśli zaczniesz wpisywać gr, wypełni go „zielonym”. Poza tym ten tag jest bardzo podobny do tagu s: select, który omówiliśmy wcześniej.
Następnie mamy selektor dat i godzin. Ten znacznik tworzy pole wejściowe z przyciskiem obok niego. Po naciśnięciu przycisku zostanie wyświetlony wyskakujący selektor daty i godziny. Gdy użytkownik wybierze datę, data jest wypełniana w tekście wejściowym w formacie określonym w atrybucie znacznika. W naszym przykładzie jako format daty określiliśmy dd / MM / rrrr.
Następnie tworzymy tag url do pliku system.action, który stworzyliśmy we wcześniejszych ćwiczeniach. Nie musi to być system.action - może to być dowolny plik akcji, który utworzyłeś wcześniej. Następnie mamy div z hiperłączem ustawionym na adres URL i opóźnieniem ustawionym na 2 sekundy. Co się stanie, gdy to uruchomisz, „Zawartość początkowa” będzie wyświetlana przez 2 sekundy, a następnie zawartość elementu div zostanie zastąpiona zawartością zhello.action wykonanie.
Wreszcie mamy prosty panel z dwiema zakładkami. Zakładki są oddzielnymi rękawami z etykietami Tab 1 i Tab2.
Warto zauważyć, że integracja tagów AJAX w Struts jest nadal w toku, a dojrzałość tej integracji powoli rośnie z każdym wydaniem.
Spring to popularna platforma internetowa, która zapewnia łatwą integrację z wieloma typowymi zadaniami internetowymi. Pytanie brzmi, po co nam Spring, skoro mamy Struts2? Cóż, Spring to więcej niż framework MVC - oferuje wiele innych dodatków, które nie są dostępne w Struts.
Na przykład: iniekcja zależności, która może być przydatna w dowolnej strukturze. W tym rozdziale przejdziemy przez prosty przykład, aby zobaczyć, jak zintegrować razem Spring i Struts2.
Przede wszystkim musisz dodać następujące pliki do ścieżki budowania projektu z instalacji Springa. Możesz pobrać i zainstalować najnowszą wersję Spring Framework zhttps://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
Wreszcie dodaj struts2-spring-plugin-x.y.z.jar w Twoim WEB-INF/libz katalogu lib struts. Jeśli używasz Eclipse, możesz napotkać wyjątek java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener .
Aby rozwiązać ten problem, powinieneś wejść Markeri kliknij prawym przyciskiem myszy zależności klas jeden po drugim i wykonaj Szybką poprawkę, aby opublikować / wyeksportować wszystkie zależności. Na koniec upewnij się, że w zakładce znacznika nie ma konfliktu zależności.
Teraz skonfigurujmy web.xml do integracji Struts-Spring w następujący sposób -
<?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>Ważną rzeczą, na którą należy zwrócić uwagę, jest skonfigurowany przez nas odbiornik. PlikContextLoaderListenerjest wymagany do wczytania pliku kontekstu sprężyny. Plik konfiguracyjny Springa nosi nazwęapplicationContext.xml plik i musi być umieszczony na tym samym poziomie co plik web.xml plik
Stwórzmy prostą klasę akcji o nazwie User.java z dwiema właściwościami - firstName i lastName.
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;
}
}Teraz stwórzmy plik applicationContext.xml Spring plik konfiguracyjny i utwórz wystąpienie User.javaklasa. Jak wspomniano wcześniej, ten plik powinien znajdować się w folderze WEB-INF -
<?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>Jak widać powyżej, skonfigurowaliśmy komponent bean użytkownika i wprowadziliśmy wartości Michael i Jacksondo fasoli. Nadaliśmy również tej fasoli nazwę „userClass”, abyśmy mogli użyć jej ponownie w innym miejscu. Następnie stwórzmy plikUser.jsp w folderze WebContent -
<%@ 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>Plik User.jspplik jest dość prosty. Służy tylko jednemu celowi - wyświetlaniu wartości imienia i nazwiska obiektu użytkownika. Na koniec zbierzmy wszystkie elementy razem, używającstruts.xml plik.
<?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>Ważne jest, aby pamiętać, że używamy identyfikatora userClassodnosić się do klasy. Oznacza to, że używamy sprężyny do wstrzykiwania zależności dla klasy User.
Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/User.jsp. Spowoduje to wyświetlenie następującego ekranu -
Widzieliśmy teraz, jak połączyć ze sobą dwie świetne ramy. Na tym kończy się rozdział dotyczący integracji Struts - Spring.
W tym rozdziale przyjrzyjmy się krokom związanym z integracją frameworka Tiles z Struts2. Apache Tiles to platforma szablonów zbudowana w celu uproszczenia tworzenia interfejsów użytkownika aplikacji internetowych.
Przede wszystkim musimy pobrać pliki jar kafelków ze strony Apache Tiles . Musisz dodać następujące pliki jar do ścieżki klas projektu.
- 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
Oprócz powyższego musimy skopiować następujące pliki jar z pliku struts2 do pobrania w pliku WEB-INF/lib.
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
Teraz skonfigurujmy web.xmldo integracji Struts-Tiles, jak podano poniżej. Należy tu zwrócić uwagę na dwie ważne kwestie. Najpierw musimy powiedzieć kafelkom, gdzie znaleźć plik konfiguracyjny kafelkówtiles.xml. W naszym przypadku będzie poniżej/WEB-INFteczka. Następnie musimy zainicjować odbiornik Tiles, który jest dostarczany wraz z pobieraniem Struts2.
<?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>Następnie stwórzmy tiles.xml w folderze / WEB-INF o następującej zawartości -
<?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>Następnie definiujemy podstawowy układ szkieletu w baseLayout.jsp. Ma pięć obszarów wielokrotnego użytku / nadających się do zastąpienia. Mianowicietitle, banner, menu, body i footer. Podajemy domyślne wartości dla baseLayout, a następnie tworzymy dwa dostosowania, które wykraczają poza domyślny układ. Układ tygrysa jest podobny do układu podstawowego, z wyjątkiem tego, że używa rozszerzeniatiger.jspjako treść i tekst „Tiger” jako tytuł. Podobnie układ lwa jest podobny do układu podstawowego, z wyjątkiem tego, że używa rozszerzenialion.jsp jako treść i tekst „Lew” jako tytuł.
Przyjrzyjmy się poszczególnym plikom jsp. Poniżej znajduje się treśćbaseLayout.jsp plik -
<%@ 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>Tutaj po prostu utworzyliśmy podstawową stronę HTML, która ma atrybuty kafelków. Wstawiamy atrybuty kafelków w miejscach, w których ich potrzebujemy. Następnie stwórzmy plikbanner.jsp plik o następującej treści -
<img src="http://www.tutorialspoint.com/images/tp-logo.gif"/>Plik menu.jsp plik będzie miał następujące wiersze, które są linkami - do akcji TigerMenu.action i LionMenu.action struts.
<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>Plik lion.jsp plik będzie miał następującą zawartość -
<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The lionPlik tiger.jsp plik będzie miał następującą zawartość -
<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tigerNastępnie stwórzmy plik klasy akcji MenuAction.java który zawiera następujące -
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}To dość prosta klasa. Zadeklarowaliśmy dwie metody tiger () i lion (), które zwracają odpowiednio tygrysa i lwa jako wyniki. Połączmy to wszystko razem wstruts.xml plik -
<!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>Sprawdźmy, co zrobiliśmy w powyższym pliku. Przede wszystkim zadeklarowaliśmy nowy typ wyniku o nazwie „kafelki”, ponieważ w technologii widoku używamy teraz kafelków zamiast zwykłego pliku jsp. Struts2 obsługuje typ wynikowy Tiles View, więc tworzymy typ wynikowy „tiles” jako klasy „org.apache.struts2.view.tiles.TilesResult”.
Następnie chcemy powiedzieć, czy żądanie dotyczy /tigerMenu.action, przenosi użytkownika na stronę kafelków tygrysa, a jeśli żądanie dotyczy /lionMenu.action, przenosi użytkownika na stronę kafelków lwa.
Osiągamy to za pomocą wyrażenia regularnego. W naszej definicji akcji mówimy, że wszystko, co pasuje do wzorca „* Menu”, będzie obsługiwane przez tę akcję. Metoda dopasowania zostanie wywołana w klasie MenuAction. Oznacza to, że tigerMenu.action wywoła funkcję tiger (), a lionMenu.action - lion (). Następnie musimy zmapować wynik wyniku na odpowiednich stronach kafelków.
Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/tigerMenu.jsp. Spowoduje to wyświetlenie następującego ekranu -
Podobnie, jeśli wejdziesz na stronę lionMenu.action, zobaczysz stronę lwa, która używa tego samego układu kafelków.
Hibernate to wysokowydajna usługa Object / Relational trwałości i zapytań, która jest licencjonowana na podstawie licencji GNU Lesser General Public License (LGPL) i można ją pobrać bezpłatnie. W tym rozdziale. dowiemy się, jak osiągnąć integrację Struts 2 z Hibernate. Jeśli nie znasz Hibernacji, możesz zapoznać się z naszym samouczkiem Hibernacja .
Konfiguracja bazy danych
W tym samouczku użyję bazy danych MySQL „struts2_tutorial”. Łączę się z tą bazą danych na moim komputerze przy użyciu nazwy użytkownika „root” i bez hasła. Przede wszystkim musisz uruchomić następujący skrypt. Ten skrypt tworzy nową tabelę o nazwiestudent i tworzy kilka rekordów w tej tabeli -
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);Konfiguracja hibernacji
Następnie stwórzmy plik hibernate.cfg.xml, który jest plikiem konfiguracyjnym hibernacji.
<?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>Przejdźmy przez plik konfiguracyjny hibernacji. Najpierw zadeklarowaliśmy, że używamy sterownika MySQL. Następnie zadeklarowaliśmy URL jdbc do połączenia z bazą danych. Następnie zadeklarowaliśmy nazwę użytkownika, hasło i rozmiar puli połączenia. Wskazaliśmy również, że chcielibyśmy zobaczyć SQL w pliku dziennika, ustawiając „show_sql” na true. Przejdź przez samouczek hibernacji, aby zrozumieć, co oznaczają te właściwości.
Na koniec ustawiliśmy klasę mapowania na com.tutorialspoint.hibernate.Student, którą utworzymy w tym rozdziale.
Konfiguracja środowiska
Następnie do tego projektu potrzebujesz wielu słoików. W załączeniu zrzut ekranu przedstawiający pełną listę wymaganych plików JAR -
Większość plików JAR można pobrać jako część dystrybucji Struts. Jeśli masz zainstalowany serwer aplikacji, taki jak glassfish, websphere lub jboss, możesz pobrać większość pozostałych plików jar z folderu lib serwera appserver. Jeśli nie, możesz pobrać pliki pojedynczo -
Pliki jar Hibernate - Hibernate.org
Wtyczka hibernacji Struts - wtyczka hibernacji Struts
Pliki JTA - pliki JTA
Pliki Dom4j - Dom4j
pliki log4j - log4j
Resztę plików powinieneś móc pobrać z dystrybucji Struts2.
Klasy hibernacji
Utwórzmy teraz wymagane klasy Java do integracji w trybie hibernacji. Poniżej znajduje się treśćStudent.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;
}
}To jest klasa POJO, która reprezentuje studenttabela zgodnie ze specyfikacją Hibernate. Ma właściwości id, firstName i lastName, które odpowiadają nazwom kolumn tabeli uczniów. Następnie stwórzmyStudentDAO.java plik w następujący sposób -
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);
}
}Klasa StudentDAO jest warstwą dostępu do danych dla klasy Student. Ma metody na wyświetlenie wszystkich uczniów, a następnie zapisanie nowego rekordu ucznia.
Klasa akcji
Poniższy plik AddStudentAction.javadefiniuje naszą klasę działania. Mamy tutaj dwie metody akcji - execute () i listStudents (). Metoda execute () służy do dodawania nowego rekordu ucznia. W tym celu używamy metody save () dao.
Druga metoda, listStudents (), służy do tworzenia listy studentów. Używamy metody listy dao, aby uzyskać listę wszystkich uczniów.
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;
}
}Zauważysz, że wdrażamy interfejs ModelDriven. Jest to używane, gdy klasa akcji ma do czynienia z konkretną klasą modelu (taką jak Student), a nie z indywidualnymi właściwościami (takimi jak firstName, lastName). Interfejs ModelAware wymaga zaimplementowania metody zwracania modelu. W naszym przypadku zwracamy obiekt „student”.
Utwórz pliki widoku
Utwórzmy teraz plik student.jsp wyświetl plik z następującą zawartością -
<%@ 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>Plik student.jsp jest dość prosty. W górnej sekcji mamy formularz, który przesyła się do „addStudent.action”. Przyjmuje firstName, lastName i marks. Ponieważ akcja addStudent jest powiązana z ModelAware „AddSudentAction”, automatycznie zostanie utworzony komponent bean ucznia z wartościami firstName, lastName i markami automatycznie wypełnionymi.
W dolnej części przeglądamy listę uczniów (zobacz AddStudentAction.java). Iterujemy po liście i wyświetlamy wartości imienia, nazwiska i znaków w tabeli.
Konfiguracja rozpórki
Połączmy to wszystko za pomocą 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>Należy tu zauważyć, że nasz pakiet „myhibernate” rozszerza domyślny pakiet struts2 o nazwie „hibernate-default”. Następnie deklarujemy dwie akcje - addStudent i listStudents. addStudent wywołuje metodę execute () w klasie AddStudentAction, a następnie po sukcesie wywołuje metodę akcji listStudents.
Metoda akcji listStudent wywołuje metodę listStudents () w klasie AddStudentAction i używa pliku student.jsp jako widoku.
Teraz kliknij prawym przyciskiem myszy nazwę projektu i kliknij Export > WAR Fileaby utworzyć plik wojny. Następnie wdróż tę WAR w katalogu webapps serwera Tomcat. Na koniec uruchom serwer Tomcat i spróbuj uzyskać dostęp do adresu URLhttp://localhost:8080/HelloWorldStruts2/student.jsp. Spowoduje to wyświetlenie następującego ekranu -
W górnej sekcji otrzymujemy formularz do wpisania wartości dla nowego rekordu ucznia, a dolna sekcja zawiera listę uczniów w bazie danych. Śmiało, dodaj nowy rekord ucznia i naciśnij Prześlij. Ekran odświeży się i wyświetli zaktualizowaną listę za każdym razem, gdy klikniesz Prześlij.