Struts - aplikacje internetowe w Javie

Witaj, Janie Kowalski

Nadszedł czas na coś bardziej złożonego. Twoja aplikacja przywita cię z imienia i nazwiska. Wystarczy, że w tym celu podasz jej te dane, wypełniając odpowiedni formularz. Zasada działania będzie następująca:

• aplikacja wyświetli formularz zawierający pola na wpisanie imienia oraz nazwiska,
• dane wprowadzone w formularzu zostaną sprawdzone,
• jeśli będą niepoprawne, zostaniesz poproszony o dokonanie korekty,
• jeśli podasz poprawne dane, program przywita cię z imienia i nazwiska.

Na początku utwórz nowy katalog na kod aplikacji, a następnie rozpakuj w nim plik struts-blank-1.3.5.war, tak jak robiłeś to przy wcześniejszym przykładzie.

Tym razem aplikacja będzie się składała z dwóch klas. Pierwsza z nich będzie odpowiadała za przechowywanie oraz sprawdzanie informacji o użytkowniku na potrzeby akcji. Klasa taka dziedziczy po klasie ActionForm i zawsze posiada przynajmniej dwie metody - validate oraz reset.

Mają one za zadanie sprawdzenie poprawności wprowadzonych danych oraz czyszczenie tych danych. Dodatkowo klasa ta musi zawierać pola z wartościami, które użytkownik wprowadza za pośrednictwem formularza. Nie możesz zapomnieć o stworzeniu dla każdego pola odpowiedniego settera oraz gettera - zgodnie z zasadą działania beanów:

 1. package hello;
 2. import javax.servlet.http.HttpServletRequest;
 3. import org.apache.struts.action.ActionMessage;
 4. import org.apache.struts.action.ActionErrors;
 5. import org.apache.struts.action.ActionForm;
 6. import org.apache.struts.action.ActionMapping;
 7. public class UserInformationForm extends ActionForm {
 8.   private String firstName;
 9.   private String lastName;
10.   public String getFirstName() {
11.     return firstName;
12.   }
13.   public void setFirstName(String name) {
14.     firstName = name;
15.   }
16.   public String getLastName() {
17.     return lastName;
18.   }
19.   public void setLastName(String name) {
20.     lastName = name;
21.   }
22.   public void reset(ActionMapping mapping, HttpServletRequest request) {
23.     firstName = null;
24.     lastName = null;
25.   }
26.   public ActionErrors validate(ActionMapping mapping, HttpServletRequest
    request) {
27.     ActionErrors errors = new ActionErrors();
28.     if (firstName == null || firstName.trim().equals("")) {
29.       errors.add("firstName", new
    ActionMessage("userInformation.firstName.problem"));
30.     }
31.     if (lastName == null || lastName.trim().equals("")) {
32.       errors.add("lastName", new
    ActionMessage("userInformation.lastName.problem"));
33.     }
34.     return errors;
35.   }
36. }

Listing zwinięty - 36 linii

Najważniejsze i wymagające w związku z tym szerszego wyjaśnienia metody to oczywiście reset oraz validate. Pierwsza z nich ustawia pola klasy na wartości domyślne - w tym przypadku na null. Metoda validate natomiast odpowiada za sprawdzenie poprawności danych wprowadzonych do formularza przez użytkownika aplikacji. W tym przypadku sprawdzanie poprawności jest bardzo proste.

Jeśli użytkownik wpisał cokolwiek do pól formularza, uznajemy, że podał on swoje dane. W przeciwnym razie zgłaszamy błąd (obcinamy z lewej i z prawej strony tekst z białych znaków - czyli w tym przypadku ze spacji i tabulatorów - a następnie porównujemy to, co zostało, z pustym napisem).

Jak widzisz, metoda validate zwraca obiekt klasy ActionErrors. Klasa ta jest kolekcją przechowującą informację o błędach. Każdy ewentualny błąd możesz dodać do kolekcji, korzystając z metody add:

errors.add("firstName", new Action-Message("userInformation.firstName.problem"));

Metoda ta przyjmuje dwa parametry: nazwę pola klasy zawierającego niepoprawną wartość oraz obiekt klasy ActionMessage z informacji o błędzie. Informacja o błędzie jest kluczem do informacji zapisanej w pliku zasobów aplikacji.

Dodajmy więc stosowne informacje do pliku WEB-INFsrcjavaMessageResources.properties:

1. userInformation.firstName.problem=Podaj imie
2. userInformation.lastName.problem=Podaj nazwisko

Listing zwinięty - 2 linii

Na końcu metody validate musisz zwrócić obiekt kolekcji ApplicationErrors, czy to pusty, czy zawierający informacje o błędach:

return errors:

Druga klasa tej aplikacji będzie identyczna z klasą poprzednio opisanej akcji HelloWorldAction. Zmień tylko jej nazwę na HelloAction. Gdy wszystkie klasy są już gotowe, czas na odpowiednie skonfigurowanie całości. W pliku struts-conf.xml, w sekcji <form-beans> dodaj następujące linie:

<form-bean name="userInformationForm"type="hello.UserInformationForm"/>

oraz konfigurację twojej nowej akcji w sekcji <action-mappings>:

1. <action path="/hello" type="hello.HelloAction" name="userInformation-Form"
   input="/pages/userInformation.jsp" attribute="user">
2.   <forward name="hello" path="/pages/hello.jsp"/>
3. </action>

Listing zwinięty - 3 linii

Jak widzisz, konfiguracja akcji różni się nieco od tej, z którą miałeś do czynienia przy omawianiu poprzedniego przykładu. Najpierw za pomocą znacznika <form-bean> łączymy nazwę userInformationFrom z klasą hello. UserInformationFrom.

Następnie w konfiguracji akcji ustalamy stronę JSP - userInformation.jsp - która ma służyć do wprowadzania danych przez użytkownika. To ona będzie się pojawiała w przeglądarce w pierwszej kolejności. Następnie za pomocą parametru name łączymy naszą akcję z klasą hello.UserInformationForm. Wykorzystujemy tu form-beana zdefiniowanego wcześniej.

To ona będzie sprawdzała poprawność danych wprowadzonych przez użytkownika na stronie userInformation.jsp i ona również będzie odpowiadała za wyświetlanie tej strony (z odpowiednimi informacjami o błędach) aż do czasu, gdy użytkownik wprowadzi poprawne dane, czyli takie, które zostaną zaakceptowane przez metodę validate.