Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00542 010274 11040600 na godz. na dobę w sumie
JavaServer Faces. Wydanie II - książka
JavaServer Faces. Wydanie II - książka
Autor: , Liczba stron: 648
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1354-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj nowoczesne technologie, aby perfekcyjnie tworzyć sprawne oprogramowanie!

JavaServer Faces (JSF) jest obecnie najpopularniejszą technologią, która pozwala na projektowanie interfejsu użytkownika poprzez umieszczenie na formularzu komponentów i powiązanie ich z obiektami Javy bez konieczności mieszania kodu źródłowego ze znacznikami. Mocną stroną JSF jest rozszerzalny model komponentowy, a także możliwość współpracy z środowiskami do budowy graficznych interfejsów użytkownika metodą przeciągnij-i-upuść. To nowoczesne narzędzie oferuje także mechanizmy rozwiązujące najtrudniejsze problemy w zakresie nawigacji, zarządzania połączeniami z usługami zewnętrznymi i konfiguracjami oraz izolowania prezentacji od logiki biznesowej.

Książka 'JavaServer Faces. Wydanie II' prezentuje gruntownie zaktualizowaną wiedzę dotyczącą JSF oraz wyczerpujące omówienia najnowszych udoskonaleń mechanizmów wiążących tę technologię z platformą Java EE 5, a także analizę rozszerzeń interfejsów API. Zawiera praktyczne porady i wskazówki, dzięki którym szybko nauczysz się technik sterowania przechodzeniem pomiędzy stronami z wykorzystaniem frameworku Shale; poznasz sposoby zastępowania znaczników JSP znacznikami XHTML za pomocą technologii Facelets; do perfekcji opanujesz sztukę rozbudowy tej technologii o własne biblioteki. 'Core JavaServer Faces' to doskonały, usystematyzowany zbiór najlepszych praktyk budowy oprogramowania, minimalizowania trwale kodowanych elementów i maksymalizacji produktywności.

Zastosuj nowoczesne technologie JSP, aby w prosty sposób budować zaawansowane i sprawne aplikacje.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

JavaServer Faces. Wydanie II Autor: David Geary, Cay S. Horstmann T‡umaczenie: Miko‡aj Szczepaniak ISBN: 978-83-246-1354-0 Tytu‡ orygina‡u: Core JavaServer Faces (Core Series) Format: 172x245, stron: 648 Poznaj nowoczesne technologie, aby perfekcyjnie tworzy(cid:230) sprawne oprogramowanie! (cid:149) Jak tworzy(cid:230) aplikacje JSF w (cid:156)rodowisku Eclipse? (cid:149) Jak korzysta(cid:230) z frameworku Boss Seam? (cid:149) Jak implementowa(cid:230) niestandardowe komponenty, konwertery i mechanizmy weryfikuj„ce? JavaServer Faces (JSF) jest obecnie najpopularniejsz„ technologi„, kt(cid:243)ra pozwala na projektowanie interfejsu u¿ytkownika poprzez umieszczenie na formularzu komponent(cid:243)w i powi„zanie ich z obiektami Javy bez konieczno(cid:156)ci mieszania kodu (cid:159)r(cid:243)d‡owego ze znacznikami. Mocn„ stron„ JSF jest rozszerzalny model komponentowy, a tak¿e mo¿liwo(cid:156)(cid:230) wsp(cid:243)‡pracy z (cid:156)rodowiskami do budowy graficznych interfejs(cid:243)w u¿ytkownika metod„ przeci„gnij-i-upu(cid:156)(cid:230). To nowoczesne narzŒdzie oferuje tak¿e mechanizmy rozwi„zuj„ce najtrudniejsze problemy w zakresie nawigacji, zarz„dzania po‡„czeniami z us‡ugami zewnŒtrznymi i konfiguracjami oraz izolowania prezentacji od logiki biznesowej. Ksi„¿ka (cid:132)JavaServer Faces. Wydanie II(cid:148) prezentuje gruntownie zaktualizowan„ wiedzŒ dotycz„c„ JSF oraz wyczerpuj„ce om(cid:243)wienia najnowszych udoskonaleæ mechanizm(cid:243)w wi„¿„cych tŒ technologiŒ z platform„ Java EE 5, a tak¿e analizŒ rozszerzeæ interfejs(cid:243)w API. Zawiera praktyczne porady i wskaz(cid:243)wki, dziŒki kt(cid:243)rym szybko nauczysz siŒ technik sterowania przechodzeniem pomiŒdzy stronami z wykorzystaniem frameworku Shale; poznasz sposoby zastŒpowania znacznik(cid:243)w JSP znacznikami XHTML za pomoc„ technologii Facelets; do perfekcji opanujesz sztukŒ rozbudowy tej technologii o w‡asne biblioteki. (cid:132)Core JavaServer Faces(cid:148) to doskona‡y, usystematyzowany zbi(cid:243)r najlepszych praktyk budowy oprogramowania, minimalizowania trwale kodowanych element(cid:243)w i maksymalizacji produktywno(cid:156)ci. (cid:149) Komponenty zarz„dzane (cid:149) Zaawansowane techniki nawigacji (cid:149) Znaczniki i formularze (cid:149) Konwersja i weryfikacja poprawno(cid:156)ci danych (cid:149) Implementacja klas niestandardowych mechanizm(cid:243)w weryfikacji (cid:149) Powidoki i pakiet Apache Tiles (cid:149) Niestandardowe komponenty, konwertery i mechanizmy weryfikuj„ce (cid:149) Eliminowanie wyciek(cid:243)w po‡„czeæ (cid:149) Uzyskiwanie dostŒpu do informacji sk‡adowych w katalogach LDAP (cid:149) Implementacja mechanizmu weryfikacji w czasie rzeczywistym z wykorzystaniem frameworku Ajax4jsf Zastosuj nowoczesne technologie JSP, aby w prosty spos(cid:243)b budowa(cid:230) zaawansowane i sprawne aplikacje Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Przedmowa ...............................................................................................................................................11 Rozdział 1. Wprowadzenie .......................................................................................................................15 Dlaczego wybieramy technologię JavaServer Faces? ........................................................ 15 Instalacja oprogramowania ........................................................................................... 16 Prosty przykład ............................................................................................................. 18 Elementy składowe ................................................................................................. 20 Struktura katalogów ................................................................................................ 21 Kompilacja przykładowej aplikacji ............................................................................. 22 Analiza przykładowej aplikacji ........................................................................................ 23 Komponenty ........................................................................................................... 23 Strony technologii JSF ............................................................................................. 24 Nawigacja ............................................................................................................... 27 Konfiguracja serwletu .............................................................................................. 29 Strona powitalna ..................................................................................................... 30 Środowiska wytwarzania dla JSF .................................................................................... 31 Zintegrowane środowiska programowania ................................................................. 31 Narzędzia projektowania wizualnego ......................................................................... 32 Automatyzacja procesu kompilacji za pomocą narzędzia Ant ....................................... 34 Usługi frameworka JSF .................................................................................................. 37 Mechanizmy wewnętrzne ............................................................................................... 39 Wizualizacja stron ................................................................................................... 40 Dekodowanie żądań ................................................................................................ 41 Cykl życia aplikacji JSF ............................................................................................ 42 Rozdział 2. Komponenty zarządzane ......................................................................................................45 Definicja komponentu ................................................................................................... 45 Właściwości komponentu ........................................................................................ 47 Wyrażenia reprezentujące wartości ........................................................................... 49 Pakiety komunikatów .................................................................................................... 50 Komunikaty obejmujące zmienne .............................................................................. 51 Konfigurowanie ustawień regionalnych aplikacji ......................................................... 52 Przykładowa aplikacja ................................................................................................... 54 4 JavaServer Faces Komponenty wspierające .............................................................................................. 60 Zasięg komponentów .................................................................................................... 61 Komponenty obejmujące zasięgiem sesję ................................................................. 61 Komponenty obejmujące zasięgiem aplikację ............................................................ 62 Komponenty obejmujące zasięgiem żądanie .............................................................. 62 Adnotacje cyklu życia ............................................................................................... 63 Konfigurowanie komponentów ....................................................................................... 64 Ustawianie wartości właściwości .............................................................................. 65 Inicjalizacja list i map .............................................................................................. 65 Wiązanie definicji komponentów ............................................................................... 66 Konwersje łańcuchów .............................................................................................. 68 Składnia wyrażeń reprezentujących wartości ................................................................... 69 Stosowanie nawiasów kwadratowych ........................................................................ 71 Wyrażenia odwołujące się do map i list ..................................................................... 71 Rozwiązywanie wyrazu początkowego ........................................................................ 72 Wyrażenia złożone ................................................................................................... 74 Wyrażenia odwołujące się do metod ......................................................................... 75 Rozdział 3. Nawigacja .............................................................................................................................77 Nawigacja statyczna ..................................................................................................... 77 Nawigacja dynamiczna .................................................................................................. 79 Zaawansowane techniki nawigacji .................................................................................. 88 Przekierowanie ....................................................................................................... 89 Symbole wieloznaczne ............................................................................................. 90 Stosowanie elementu from-action ............................................................................. 91 Algorytm nawigacji ................................................................................................... 92 Rozdział 4. Znaczniki standardowe JSF ................................................................................................95 Przegląd podstawowych znaczników JSF ......................................................................... 96 Przegląd znaczników JSF reprezentujących znaczniki HTML (JSF HTML) ............................. 98 Atrybuty wspólne ................................................................................................... 100 Formularze ................................................................................................................. 106 Elementy formularzy i skrypty języka JavaScript ....................................................... 108 Jedno- i wielowierszowe pola tekstowe ......................................................................... 111 Pola ukryte ........................................................................................................... 114 Stosowanie jedno- i wielowierszowych pól tekstowych .............................................. 114 Wyświetlanie tekstu i obrazów ................................................................................ 118 Przyciski i łącza .......................................................................................................... 120 Stosowanie przycisków poleceń ............................................................................. 121 Stosowanie łączy poleceń ...................................................................................... 126 Znaczniki selekcji ....................................................................................................... 130 Pola wyboru i przyciski opcji ................................................................................... 133 Menu i listy .......................................................................................................... 135 Elementy .............................................................................................................. 138 Komunikaty ............................................................................................................... 154 Panele ....................................................................................................................... 159 Rozdział 5. Tabele danych ......................................................................................................................165 Znacznik tabeli danych — h:dataTable ......................................................................... 165 Prosta tabela ............................................................................................................. 166 Atrybuty znacznika h:dataTable .............................................................................. 169 Atrybuty znacznika h:column .................................................................................. 170 Spis treści 5 Nagłówki, stopki i podpisy ........................................................................................... 171 Komponenty JSF ........................................................................................................ 174 Edycja komórek tabeli ................................................................................................. 177 Style ......................................................................................................................... 180 Style stosowane dla kolumn .................................................................................. 181 Style stosowane dla wierszy .................................................................................. 182 Tabele bazy danych .................................................................................................... 183 Obiekty wyników biblioteki JSTL kontra zbiory wynikowe ............................................ 187 Modele tabel ............................................................................................................. 187 Edycja modeli tabel ............................................................................................... 188 Sortowanie i filtrowanie ......................................................................................... 192 Techniki przewijania ................................................................................................... 201 Przewijanie z użyciem paska przewijania ................................................................. 201 Przewijanie za pomocą dodatkowych łączy ............................................................... 202 Rozdział 6. Konwersja i weryfikacja poprawności danych ...............................................................205 Przegląd procesu konwersji i weryfikacji poprawności .................................................... 205 Stosowanie konwerterów standardowych ...................................................................... 207 Konwersja liczb i dat ............................................................................................. 207 Błędy konwersji ..................................................................................................... 211 Kompletny przykład konwertera .............................................................................. 216 Stosowanie standardowych mechanizmów weryfikujących .............................................. 218 Weryfikacja długości łańcuchów i przedziałów liczbowych .......................................... 219 Weryfikacja wartości wymaganych .......................................................................... 220 Wyświetlanie komunikatów o błędach weryfikacji ..................................................... 221 Pomijanie procesu weryfikacji ................................................................................. 221 Kompletny przykład mechanizmu weryfikacji ............................................................ 223 Programowanie z wykorzystaniem niestandardowych konwerterów i mechanizmów weryfikujących .................................................................................. 224 Implementacja klas konwerterów niestandardowych ................................................. 225 Implementacja klas niestandardowych mechanizmów weryfikacji .............................. 237 Rejestrowanie własnych mechanizmów weryfikacji ................................................... 240 Weryfikacja danych wejściowych za pomocą metod komponentów JavaBeans ............ 242 Przekazywanie konwerterom atrybutów .................................................................... 242 Relacje weryfikacji łączące wiele komponentów ....................................................... 243 Rozdział 7. Obsługa zdarzeń .................................................................................................................249 Zdarzenia cyklu życia .................................................................................................. 250 Zdarzenia zmiany wartości .......................................................................................... 251 Zdarzenia akcji ........................................................................................................... 256 Znaczniki metod nasłuchujących zdarzeń ...................................................................... 263 Znaczniki f:actionListener i f:valueChangeListener ................................................... 264 Komponenty bezpośrednie .......................................................................................... 265 Stosowanie bezpośrednich komponentów wejściowych ............................................ 266 Stosowanie bezpośrednich komponentów poleceń ................................................... 268 Przekazywanie danych z interfejsu użytkownika na serwer .............................................. 269 Znacznik f:param .................................................................................................. 270 Znacznik f:attribute ............................................................................................... 271 Znacznik f:setPropertyActionListener ...................................................................... 272 Zdarzenia fazy ............................................................................................................ 273 Podsumowanie całego materiału w jednym miejscu ....................................................... 281 6 JavaServer Faces Rozdział 8. Podwidoki i pakiet Apache Tiles ..........................................................................................291 Typowe rozmieszczenia ............................................................................................... 291 Przeglądarka książek i biblioteka ................................................................................. 292 Przeglądarka książek .................................................................................................. 294 Monolityczne strony JSF ........................................................................................ 295 Dołączanie wspólnej treści ..................................................................................... 300 Dołączanie treści w aplikacjach zbudowanych na bazie technologii JSP ...................... 300 Dołączanie treści w kontekście aplikacji JSF ............................................................ 301 Dołączanie treści w ramach aplikacji przeglądarki książek ............................................. 302 Prezentacja pakietu Apache Tiles ........................................................................... 305 Instalacja pakietu Tiles .......................................................................................... 305 Stosowanie pakietu Tiles w ramach aplikacji przeglądarki książek ............................. 306 Parametryzacja kafelków ....................................................................................... 308 Rozszerzanie kafelków ........................................................................................... 309 Biblioteka .................................................................................................................. 312 Kafelki zagnieżdżone ............................................................................................. 313 Kontroler kafelków ................................................................................................ 313 Rozdział 9. Niestandardowe komponenty, konwertery i mechanizmy weryfikujące ......................323 Klasy implementujące komponenty niestandardowe ...................................................... 325 Znaczniki i komponenty JavaBeans ......................................................................... 327 Zestaw narzędzi twórcy komponentów niestandardowych ......................................... 328 Kodowanie: generowanie znaczników ........................................................................... 330 Dekodowanie: przetwarzanie wartości żądania .............................................................. 334 Stosowanie konwerterów ....................................................................................... 337 Implementacja znaczników komponentów niestandardowych .......................................... 339 Plik deskryptora TLD ............................................................................................. 340 Klasa obsługująca znacznik ................................................................................... 343 Aplikacja zbudowana z wykorzystaniem kontrolki datownika ...................................... 346 Definiowanie klas obsługujących znaczniki w technologii JSF 1.1 .............................. 349 Doskonalenie komponentu datownika .......................................................................... 354 Stosowanie zewnętrznych mechanizmów wizualizacji ................................................ 354 Wywoływanie konwerterów z poziomu zewnętrznych mechanizmów wizualizacji ........... 359 Obsługa metod nasłuchujących zmian wartości ....................................................... 360 Obsługa wyrażeń wskazujących na metody .............................................................. 361 Przykładowa aplikacja ............................................................................................ 363 Użycie skryptu JavaScript do ograniczenia komunikacji z serwerem ................................ 369 Stosowanie komponentów i facet potomnych ............................................................... 372 Przetwarzanie znaczników potomnych typu SelectItem .............................................. 375 Przetwarzanie facet ............................................................................................... 376 Kodowanie stylów CSS .......................................................................................... 377 Stosowanie pól ukrytych ........................................................................................ 378 Zapisywanie i przywracanie stanu ........................................................................... 379 Generowanie zdarzeń akcji ..................................................................................... 382 Stosowanie komponentu panelu podzielonego na zakładki ....................................... 387 Implementacja niestandardowych konwerterów i mechanizmów weryfikacji ...................... 393 Znaczniki konwerterów niestandardowych ............................................................... 393 Znaczniki niestandardowych mechanizmów weryfikacji ............................................. 401 Spis treści 7 Rozdział 10. Usługi zewnętrzne ............................................................................................................409 Dostęp do bazy danych za pośrednictwem interfejsu JDBC ............................................ 409 Wykonywanie wyrażeń języka SQL ........................................................................... 409 Zarządzanie połączeniami ...................................................................................... 411 Eliminowanie wycieków połączeń ............................................................................ 411 Stosowanie gotowych wyrażeń ................................................................................ 413 Konfigurowanie źródła danych ..................................................................................... 414 Konfigurowanie zasobów baz danych w ramach serwera GlassFish ............................ 415 Konfigurowanie zasobów baz danych w ramach serwera Tomcat ............................... 417 Uzyskiwanie dostępu do zasobów zarządzanych przez kontener ................................ 419 Kompletny przykład użycia bazy danych ................................................................... 420 Wprowadzenie do technologii LDAP .............................................................................. 428 Katalogi LDAP ....................................................................................................... 428 Konfigurowanie serwera LDAP ................................................................................ 430 Uzyskiwanie dostępu do informacji składowanych w katalogach LDAP ....................... 433 Zarządzanie danymi konfiguracyjnymi ........................................................................... 438 Konfigurowanie komponentu .................................................................................. 438 Konfigurowanie kontekstu zewnętrznego ................................................................. 440 Konfigurowanie zasobu zarządzanego przez kontener ............................................... 441 Tworzenie aplikacji LDAP ....................................................................................... 445 Uwierzytelnianie i autoryzacja zarządzana przez kontener ............................................... 455 Stosowanie usług sieciowych ...................................................................................... 464 Rozdział 11. AJAX ...................................................................................................................................475 Podstawy techniki AJAX ............................................................................................... 476 Biblioteki języka JavaScript ......................................................................................... 478 Biblioteka Prototype .............................................................................................. 479 Biblioteka Fade Anything Technique ........................................................................ 479 Uzupełnianie danych formularzy ................................................................................... 480 Weryfikacja w czasie rzeczywistym ............................................................................... 482 Propagowanie stanu widoku po stronie klienta .............................................................. 487 Biblioteka Direct Web Remoting .................................................................................. 488 Komponenty AJAX ...................................................................................................... 490 Komponenty hybrydowe ......................................................................................... 491 Izolowanie kodu języka JavaScript od mechanizmów wizualizacji ............................... 495 Przekazywanie atrybutów znaczników JSP do kodu języka JavaScript .......................... 496 Ajax4jsf ..................................................................................................................... 497 Implementowanie mechanizmu uzupełniania danych formularzy z wykorzystaniem frameworku Ajax4jsf ........................................................................................... 498 Implementacja mechanizmu weryfikacji w czasie rzeczywistym z wykorzystaniem frameworku Ajax4jsf ........................................................................................... 502 Rozdział 12. Frameworki open-source ..................................................................................................511 Przepływ stron WWW — pakiet Shale ........................................................................... 512 Konfiguracja dialogu .............................................................................................. 516 Inicjowanie dialogu ................................................................................................ 516 Nawigacja w ramach dialogu .................................................................................. 517 Zasięg dialogu ...................................................................................................... 518 Zależność od kontekstu dialogu ............................................................................. 520 Poddialogi ............................................................................................................ 522 Alternatywne technologie widoku — Facelets ................................................................ 524 Widoki XHTML ...................................................................................................... 525 8 JavaServer Faces Zastępowanie znaczników komponentami JSF — atrybut jsfc .................................... 526 Stosowanie znaczników technologii JSF .................................................................. 529 Kompozycje stron złożonych z szablonów ................................................................ 531 Znaczniki niestandardowe technologii Facelets ........................................................ 533 Integracja z technologią EJB — Seam .......................................................................... 535 Książka adresowa ................................................................................................. 535 Konfiguracja ......................................................................................................... 539 Komponenty encyjne ............................................................................................. 540 Stanowe komponenty sesyjne ................................................................................ 541 Integracja z modelem danych technologii JSF .......................................................... 544 Zasięg konwersacji ................................................................................................ 545 Rozdział 13. Jak to zrobić? ...................................................................................................................547 Projektowanie interfejsu użytkownika aplikacji internetowej ............................................ 547 Gdzie należy szukać dodatkowych komponentów? ................................................... 547 Jak zaimplementować obsługę wysyłania plików na serwer? ..................................... 550 Jak wyświetlać mapę obrazów? .............................................................................. 558 Jak dołączać aplet do naszej strony? ...................................................................... 559 Jak generować dane binarne w ramach stron JSF? ................................................... 561 Jak prezentować ogromne zbiory danych podzielone na mniejsze strony? .................. 570 Jak generować wyskakujące okna? ......................................................................... 574 Jak selektywnie prezentować i ukrywać komponenty? ............................................... 582 Jak dostosowywać wygląd stron o błędach? ............................................................ 583 Weryfikacja danych ..................................................................................................... 587 Jak utworzyć własny, niestandardowy znacznik weryfikacji po stronie klienta? ............ 587 Jak weryfikować dane po stronie klienta za pomocą mechanizmu Shale Validator? ..... 593 Jak weryfikować relacje pomiędzy komponentami? ................................................... 595 Programowanie .......................................................................................................... 596 Jak tworzyć aplikacje JSF w środowisku Eclipse? ..................................................... 596 Jak zmieniać lokalizację plików konfiguracyjnych? .................................................... 599 Jak komponenty JSF mogą uzyskiwać dostęp do zasobów dostępnych w pliku JAR? ....... 600 Jak spakować zbiór znaczników w ramach pliku JAR? ............................................... 604 Jak uzyskać identyfikator formularza niezbędny do wygenerowania struktury document.forms[id] w języku JavaScript? .............................................................. 604 Jak sprawić, by funkcja języka JavaScript była definiowana tylko raz dla danej strony? ....... 605 Jak realizować zadania związane z inicjalizacją i przywracaniem oryginalnego stanu środowiska? ...................................................................................................... 605 Jak składować komponent zarządzany poza zasięgiem żądania, ale w czasie krótszym od okresu istnienia zasięgu sesji? ...................................... 606 Jak rozszerzyć język wyrażeń technologii JSF? .......................................................... 607 Diagnostyka i rejestrowanie zdarzeń ............................................................................ 611 Jak rozszyfrować ślad stosu? ................................................................................. 611 Jak unikać „śladów stosu z piekła rodem”? ............................................................ 613 Jak wdrażać aplikacje „na gorąco”? ........................................................................ 614 Jak umieścić w komentarzu wybrany fragment kodu strony JSF? ............................... 615 Gdzie należy szukać plików dziennika? .................................................................... 616 Jak sprawdzić, które parametry przekazano za pośrednictwem naszej strony? ............ 617 Jak włączyć tryb rejestrowania zdarzeń związanych z pracą kontenera JSF? ................ 620 Jak diagnozować stronę, na której zatrzymała się nasza aplikacja? ........................... 622 Gdzie należy szukać kodu źródłowego biblioteki? ..................................................... 624 Skorowidz ..............................................................................................................................................471 2 Komponenty zarządzane Centralnym elementem projektów aplikacji internetowych jest rozdział warstw prezentacji i logiki biznesowej. W technologii JavaServer Faces za taki rozdział odpowiadają komponenty (ang. beans). Strony JSF odwołują się do właściwości komponentów. Kod implementacji tych komponentów definiuje właściwą logikę programu. Ponieważ właśnie komponenty są kluczem do programowania aplikacji JSF, w niniejszym rozdziale skoncentrujemy się na ich szczegółowym omówieniu. W pierwszej części tego rozdziału przeanalizujemy podstawowe elementy komponentów, o których powinien wiedzieć każdy programista aplikacji JSF. W dalszej części omówimy program przykładowy, który dobrze ilustruje łączne funkcjonowanie tych elementów. W pozo- stałych podrozdziałach skupimy się na technicznych aspektach konfiguracji komponentów i wyrażeń reprezentujących wartości. Czytelnicy, którzy mają tę książkę w rękach po raz pierwszy, mogą te podrozdziały pominąć i wrócić do nich w przyszłości. Definicja komponentu Zgodnie ze specyfikacją JavaBeans (dostępną na stronie internetowej http://java.sun.com (cid:180)/products/javabeans/) komponent Javy ma postać „wielokrotnego komponentu oprogra- mowania, który można modyfikować za pomocą narzędzia do projektowania”. Przytoczona definicja jest bardzo szeroka, co jest o tyle zrozumiałe, że — jak się niedługo okaże — kom- ponenty można wykorzystywać do rozmaitych celów. Na pierwszy rzut oka komponent wydaje się bardzo podobny do zwykłego obiektu Javy. Okazuje się jednak, że komponent Javy odpowiada za realizację innych zadań. Obiekty są tworzone i wykorzystywane w ramach programów Javy (odpowiednio przez wywołania konstruktorów i wywołania metod). Nieco inaczej jest w przypadku komponentów, które mogą być konfigurowane i wykorzystywane bez konieczności programowania. 46 JavaServer Faces Część Czytelników zapewne zastanawia się, skąd się wziął angielski termin bean. W Stanach Zjednoczonych słowo Java jest synonimem kawy, a smak kawy kryje się w jej ziarnach (ang. beans). Opisywana analogia części programistów wydaje się wyjątkowo zmyślna, innych po prostu denerwuje — nam nie pozostaje nic innego, jak pogodzić się z przyjętą terminologią. „Klasycznym” zastosowaniem komponentów JavaBeans jest konstruowanie interfejsów użytkownika. Okno palety oferowane przez narzędzia do projektowania takich interfejsów obejmuje takie komponenty jak pola tekstowe, suwaki, pola wyboru itp. Zamiast samodzielnie pisać kod Swinga, korzystamy z narzędzia do projektowania interfejsu, który umożliwia nam przeciąganie komponentów dostępnych na palecie i upuszczanie ich na tworzonym formu- larzu. Możemy następnie dostosowywać właściwości tych komponentów przez ustawianie odpowiednich wartości w odpowiednim oknie dialogowym (patrz rysunek 2.1). Rysunek 2.1. Dostosowywanie komponentu do potrzeb aplikacji za pośrednictwem narzędzia do projektowania graficznego interfejsu użytkownika W technologii JavaServer Faces zadania komponentów nie kończą się na obsłudze elementów interfejsu użytkownika. Stosujemy je za każdym razem, gdy musimy wiązać klasy Javy ze stronami WWW lub plikami konfiguracyjnymi. Wróćmy na chwilę do aplikacji login przedstawionej w podrozdziale „Prosty przykład” w roz- dziale 1. Egzemplarz komponentu UserBean skonfigurowano w pliku faces-config.xml: managed-bean managed-bean-name user /managed-bean-name managed-bean-class com.corejsf.UserBean /managed-bean-class managed-bean-scope session /managed-bean-scope /managed-bean Znaczenie tych zapisów można by wyrazić następującymi słowami: skonstruuj obiekt klasy com.corejsf.UserBean, nadaj mu nazwę user i utrzymuj go przy życiu w czasie trwania sesji (czyli dla wszystkich żądań wygenerowanych przez tego samego klienta). Rozdział 2. (cid:81) Komponenty zarządzane 47 Do tak zdefiniowanego komponentu JavaBean można uzyskiwać dostęp z poziomu kompo- nentów JSF. Na przykład poniższe pole tekstowe odczytuje i aktualizuje właściwość password komponentu user: h:inputSecret value= #{user.password} / Jak widać, programista aplikacji JavaServer Faces nie musi pisać żadnego kodu konstruującego i operującego na komponencie user. Za konstruowanie komponentów zgodnie z elementami zdefiniowanymi w znaczniku managed-bean (w ramach pliku konfiguracyjnego) odpowiada implementacja JSF. W aplikacjach JSF komponenty są zwykle wykorzystywane do następujących celów: (cid:81) w roli komponentów interfejsu użytkownika (w formie tradycyjnych komponentów interfejsu); (cid:81) w roli elementów łączących w jedną całość zachowanie formularza internetowego (są to tzw. komponenty wspomagające; ang. backing beans); (cid:81) w roli obiektów biznesowych, których właściwości są wyświetlane na stronach WWW; (cid:81) w roli takich usług jak zewnętrzne źródła danych wymagające skonfigurowania w momencie wdrażania aplikacji. Z uwagi na wszechobecność i uniwersalność komponentów skoncentrujemy się wyłącznie na tych elementach specyfikacji JavaBeans, które znajdują zastosowanie z perspektywy programistów aplikacji JavaServer Faces. Właściwości komponentu Klasy komponentów muszą być tworzone w zgodzie z pewnymi konwencjami programowania, aby odpowiednie narzędzia mogły swobodnie operować na ich składowych. W niniejszym punkcie zajmiemy się właśnie tymi konwencjami. Do najważniejszych elementów klasy komponentu należą udostępniane właściwości. Właściwością jest każdy atrybut komponentu, który obejmuje: (cid:81) nazwę, (cid:81) (cid:81) metody zwracające i (lub) ustawiające wartość tej właściwości. typ, Na przykład klasa UserBean zdefiniowana i wykorzystywana w poprzednim przykładzie zawiera właściwość typu String nazwaną password. Za zapewnianie dostępu do wartości tej właściwości odpowiadają metody getPassword i setPassword. Niektóre języki programowania, w szczególności Visual Basic i C#, oferują bezpośrednią obsługę właściwości. Z drugiej strony, w języku Java komponent ma postać zwykłej klasy zaimplementowanej zgodnie z pewnymi konwencjami kodowania. 48 JavaServer Faces Specyfikacja JavaBeans definiuje pojedyncze wymaganie stawiane klasom komponentów — każda taka klasa musi definiować publiczny konstruktor domyślny, czyli konstruktor bezpa- rametrowy. Z drugiej strony, aby definiowanie właściwości było możliwe, twórca kompo- nentu musi albo stosować wzorzec nazewniczy dla metod zwracających i ustawiających, albo definiować deskryptory właściwości. Drugi model jest dość kłopotliwy i nie zyskał popu- larności, więc nie będziemy się nim zajmować. Szczegółowe omówienie tego zagadnienia można znaleźć w rozdziale 8. książki Core Java™ 2, vol. 2 — Advanced Features (7th ed.)1 autorstwa Caya Horstmanna i Gary’ego Cornella. Definiowanie właściwości w zgodzie ze wzorcami nazewniczymi jest bardzo proste. Prze- analizujmy teraz następującą parę metod: public T getFoo() public void setFoo(T newValue) Przedstawiona para definiuje właściwość dostępną do odczytu i zapisu, typu T, nazwaną foo. Gdybyśmy użyli tylko pierwszej z powyższych metod, nasza właściwość byłaby dostępna tylko do odczytu. Pozostawienie samej drugiej metody oznaczałoby, że jest to właściwość dostępna tylko do zapisu. Nazwy i sygnatury metod muszą gwarantować pełną zgodność z tym wzorcem. Nazwa metody musi się rozpoczynać od przedrostka get lub set. Metoda get nie może otrzymywać żadnych parametrów. Metoda set musi otrzymywać jeden parametr, ale nie może zwracać żadnych wartości. Klasa komponentu może zawierać inne metody (odbiegające od opisanej konwencji), które jednak nie definiują dodatkowych właściwości. Warto pamiętać, że nazwa samej właściwości jest identyczna jak nazwa metod uzyskujących dostęp do jej wartości po usunięciu przedrostka get lub set oraz zamianie pierwszej litery na małą. Tworząc na przykład metodę getFoo, definiujemy właściwość nazwaną foo (z pierw- szą literą F zamienioną na f). Jeśli jednak za przedrostkiem znajdują się co najmniej dwie wielkie litery, pierwsza litera nazwy właściwości pozostaje niezmieniona. Na przykład metoda nazwana getURL definiuje właściwość URL, nie uRL. W przypadku właściwości typu boolean mamy do wyboru dwa różne prefiksy dla metod zwracających ich wartości. Obie wersje: public boolean isConnected() i public boolean getConnected() są prawidłowymi nazwami metod zwracających wartość właściwości connected. Specyfikacja JavaBeans milczy na temat zachowań metod zwracających i ustawiających. W wielu przypadkach działanie tych metod sprowadza się do prostego operowania na polach egzemplarza. Z drugiej strony, te same metody mogą równie dobrze obejmować bardziej wyszukane operacje, jak dostęp do bazy danych, konwersję danych, weryfikację danych itd. 1 Polskie wydanie: Java 2. Techniki zaawansowane. Wydanie II, Helion, 2005 — przyp. tłum. Rozdział 2. (cid:81) Komponenty zarządzane 49 Specyfikacja JavaBeans przewiduje też możliwość stosowania właściwości indek- sowanych definiowanych w formie zbiorów metod podobnych do tego, który przed- stawiono poniżej: public T[] getFoo() public T getFoo(int index) public void setFoo(T[] newArray) public void setFoo(int index, T newValue) Okazuje się jednak, że technologia JSF nie zapewnia obsługi operacji dostępu do in- deksowanych wartości. Klasa komponentu może też zawierać metody inne niż te odpowiedzialne za zwracanie i ustawianie wartości właściwości. Takie metody oczywiście nie definiują kolejnych wła- ściwości komponentu. Wyrażenia reprezentujące wartości Wiele komponentów interfejsu użytkownika aplikacji JSF definiuje atrybut value, który umoż- liwia określanie wartości bądź odwołania do wartości uzyskiwanej z właściwości komponentu JavaBean. Wartość stosowaną bezpośrednio można zdefiniować na przykład w następujący sposób: h:outputText value= Witaj świecie! / Można też użyć wyrażenia reprezentującego wartość: h:outputText value= #{user.name} / W większości przypadków wyrażenia podobne do #{user.name} odwołują się do właściwości. Warto pamiętać, że wyrażenie w tej formie może być stosowane nie tylko do odczytywania wartości, ale też do ich zapisywania, jeśli zostanie użyte dla komponentu wejściowego: h:inputText value= #{user.name} / W momencie renderowania danego komponentu zostanie wywołana metoda zwracająca właściwość będącą przedmiotem odwołania. Metoda ustawiająca zostanie wywołana w czasie przetwarzania odpowiedzi użytkownika. Wyrażenia reprezentujące wartości stosowane w aplikacjach JSF mają ścisły związek z językiem wyrażeń znanym z technologii JSP. Dla tego rodzaju wyrażeń stosuje się jednak separator ${...} (zamiast separatora #{...}). W standardach JSF 1.2 i JSP 1.2 zunifikowano składnię obu języków wyrażeń. (Kompletną analizę tej składni można znaleźć w podrozdziale „Składnia wyrażeń reprezentujących wartości”). Separator ${...} oznacza, że dane wyrażenie ma zostać przetworzone natychmiast, czyli w czasie przetwarzania odpowiedniej strony przez serwer aplikacji. Separator #{...} sto- suje się dla wyrażeń, które mają być przetwarzane możliwie późno. W takim przypadku serwer aplikacji zachowuje wyrażenie w niezmienionej formie i przystępuje do jego prze- twarzania dopiero wtedy, gdy odpowiednia wartość jest naprawdę potrzebna. Warto pamiętać, że wyrażenia odroczone stosuje się dla wszystkich właściwości kom- ponentów JSF, natomiast wyrażenia przetwarzane natychmiast są wykorzystywane dla tradycyjnych konstrukcji JSP lub JSTL (od ang. JavaServer Pages Standard Template Library), które rzadko są niezbędne w procesie tworzenia stron JSF. 50 JavaServer Faces Szczegółowe omówienie składni wyrażeń reprezentujących wartości można znaleźć w pod- rozdziale „Składnia wyrażeń reprezentujących wartości”. Pakiety komunikatów Implementując aplikację internetową, warto rozważyć zgromadzenie wszystkich łańcuchów komunikatów w jednym, centralnym miejscu. Taki proces ułatwi zachowanie spójności komunikatów i — co bardzo ważne — upraszcza lokalizowanie (internacjonalizację) apli- kacji z myślą o różnych ustawieniach regionalnych. W tym podrozdziale przeanalizujemy mechanizmy technologii JSF umożliwiające organizację komunikatów. W podrozdziale „Przy- kładowa aplikacja” przeanalizujemy przykład komponentów zarządzanych pracujących łącznie z pakietami komunikatów. Łańcuchy komunikatów należy zebrać w pliku, którego format odpowiada przyjętemu porząd- kowi chronologicznemu: guessNext=Odgadnij następną liczbę w sekwencji! answer=Twoja odpowiedź: Precyzyjne omówienie formatu tego pliku można znaleźć w dokumentacji API dla metody load klasy java.util.Properties. Należy ten plik zapisać w katalogu, w którym składujemy klasy — np. jako insrc/java/com/ (cid:180)corejsf/messages.properties. Można oczywiście wybrać dowolną ścieżkę do katalogu i nazwę pliku, jednak musimy użyć rozszerzenia .properties. Pakiety komunikatów możemy deklarować na dwa sposoby. Najprostszym rozwiązaniem jest umieszczenie następujących elementów w pliku konfiguracyjnym faces-config.xml: application resource-bundle base-name com.corejsf.messages /base-name var msgs /var /resource-bundle /application Alternatywnym rozwiązaniem jest dodanie elementu f:loadBundle do każdej strony JavaServer Faces wymagającej dostępu do danego pakietu komunikatów: f:loadBundle basename= com.corejsf.messages var= msgs / W obu przypadkach dostęp do komunikatów wchodzących w skład pakietu odbywa się za pośrednictwem zmiennej odwzorowania (mapy) nazwanej msgs. (Nazwa bazowa, czyli com.corejsf.messages, przypomina nazwę klasy i rzeczywiście okazuje się, że plik właści- wości jest wczytywany przez mechanizm ładowania klas). Możemy teraz uzyskiwać dostęp do łańcuchów komunikatów w ramach wyrażeń reprezen- tujących wartości: h:outputText value= #{msgs.guessNext} / Rozdział 2. (cid:81) Komponenty zarządzane 51 To wszystko, czego nam trzeba! Kiedy zdecydujemy się na lokalizację naszej aplikacji z myślą o innych ustawieniach regionalnych, będziemy musieli tylko opracować odpowiednie pliki z komunikatami. Element resource-bundle zapewnia większą efektywność niż element f:loadBundle, ponieważ zapewnia, że pakiet komunikatów będzie odczytywany jednorazowo dla całej aplikacji. Warto jednak pamiętać, że element resource-bundle jest obsługiwany, począwszy od wersji JSF 1.2. Oznacza to, że jeśli chcemy zapewnić zgodność naszej aplikacji ze specyfikacją JSF 1.1, musimy się posługiwać elementem f:loadBundle. Lokalizując pakiety komunikatów, musimy nadawać odpowiednim plikom nazwy z przy- rostkiem właściwym dla ustawień regionalnych, czyli dwuliterowego kodu języka (zgodnego ze standardem ISO-639) poprzedzonego znakiem podkreślenia. Na przykład łańcuchy w języku niemieckim należałoby zdefiniować w pliku com/corejsf/messages_de.properties. Listę wszystkich dwu- i trzyliterowych kodów języków standardu ISO-639 można znaleźć na stronie internetowej http://www.loc.gov/standards/iso639-2/. Mechanizmy obsługi umiędzynarodawiania aplikacji Javy automatycznie ładują pakiety komunikatów właściwe dla bieżących ustawień regionalnych. Pakiet domyślny (bez przy- rostka języka ISO-639) jest swoistym zabezpieczeniem na wypadek, gdyby zlokalizowany pakiet był niedostępny. Szczegółowe omówienie problemu umiędzynarodawiania aplikacji Javy można znaleźć w rozdziale 10. książki Core Java™ 2, vol. 2 — Advanced Features (7th ed.)2 autorstwa Caya Horstmanna i Gary’ego Cornella. Przygotowując tłumaczenia aplikacji, należy mieć na uwadze jeden dość specyficzny aspekt — pliki pakietów komunikatów nie są kodowane z wykorzystaniem schematu UTF-8. Znaki Unicode spoza zbioru pierwszych 127 znaków są kodowane za pomocą sekwencji specjalnej uxxxx. Tego rodzaju pliki można tworzyć za pomocą narzędzia native2ascii pakietu Java SDK. Dla tych samych ustawień regionalnych może istnieć wiele pakietów komunikatów. Możemy na przykład opracować odrębne pakiety dla najczęściej wykorzystywanych komunikatów o błędach. Komunikaty obejmujące zmienne Komunikaty często obejmują elementy zmienne, które — co oczywiste — wymagają wy- pełnienia przed wyświetleniem. Przypuśćmy na przykład, że chcemy wyświetlić na ekranie zdanie Masz n punktów, gdzie n jest wartością uzyskiwaną z komponentu. W tym celu musimy utworzyć łańcuch źródłowy z symbolem zastępczym: currentScore=Masz {0} punktów. 2 Polskie wydanie: Java 2. Techniki zaawansowane. Wydanie II, Helion, 2005 — przyp. tłum. 52 JavaServer Faces Symbole zastępcze (ang. placehorders) mają postać {0}, {1}, {2} itd. W kodzie naszej strony JSF powinniśmy użyć znacznika h:outputFormat i zdefiniować wartości dla tych symboli zastępczych w formie elementów potomnych f:param: h:outputFormat value= #{msgs.currentScore} f:param value= #{quiz.score} / /h:outputFormat Znacznik h:outputFormat wykorzystuje do formatowania łańcuchów komunikatów klasę MessageFormat biblioteki standardowej. Wspomniana klasa oferuje szereg mechanizmów opracowanych z myślą o formatowaniu łańcuchów zależnych od ustawień regionalnych. Za pomocą przyrostka number,currency dołączanego do symbolu zastępczego możemy formatować liczby jako kwoty w lokalnej walucie: currentTotal=Dysponujesz kwotą {0,number,currency}. W Stanach Zjednoczonych wartość 1023.95 zostanie sformatowana jako $1,023.95. Ta sama wartość w Niemczech zostałaby wyświetlona jako €1.023,95 (w Polsce 1 023,95 zł) — z uwzględnieniem symbolu lokalnej waluty i konwencji separatora części dziesiętnej. Format choice umożliwia nam formatowanie liczb na różne sposoby (w zależności od wartości poprzedzającej jednostkę), czyli: zero punktów, jeden punkt, dwa punkty, 3 punkty, 4 punkty, 5 punktów itd. Poniżej przedstawiono łańcuch formatu zapewniający oczekiwany efekt: currentScore=Masz {0,choice,0#zero punktów|1#jeden punkt|2#dwa punkty|3#trzy punkty |4#cztery punkty|5#{0} punktów}. Mamy do czynienia z sześcioma możliwymi przypadkami (0, 1, 2, 3, 4 oraz ≥5), z których każdy definiuje odrębny łańcuch komunikatu. Łatwo zauważyć, że symbol zastępczy 0 występuje dwukrotnie: raz na etapie wyboru formatu i drugi raz w ostatniej, szóstej opcji, gdzie generuje wynik w postaci komunikatu 5 punktów. Przykłady użycia tej konstrukcji można znaleźć na listingach 2.5 i 2.6 w podrozdziale „Przy- kładowa aplikacja”. O ile angielskie ustawienia regionalne (z komunikatem Your score is ...) w ogóle nie wymagają stosowania formatu choice w naszej przykładowej aplikacji, o tyle niemieckie wyrażenie Sie haben ... punkte (podobnie jak polskie Masz ... punktów) nie jest uniwersalne, ponieważ nie uwzględnia liczby pojedynczej einen punkt. Dodatkowych informacji na temat klasy MessageFormat należy szukać w dokumentacji API lub w rozdziale 10. książki Core Java™ 2, vol. 2 — Advanced Features (7th ed.)3 autorstwa Caya Horstmanna i Gary’ego Cornella. Konfigurowanie ustawień regionalnych aplikacji Po opracowaniu pakietów komunikatów musimy zdecydować, jak zdefiniować ustawienia regionalne naszej aplikacji. Mamy do dyspozycji trzy rozwiązania: 3 Polskie wydanie: Java 2. Techniki zaawansowane. Wydanie II, Helion, 2005 — przyp. tłum. Rozdział 2. (cid:81) Komponenty zarządzane 53 1. Możemy pozostawić wybór ustawień regionalnych przeglądarce. Ustawienia domyślne i wszystkie ustawienia obsługiwane należy zdefiniować w pliku konfiguracyjnym WEB-INF/faces-config.xml (lub innym zasobie konfiguracyjnym aplikacji): faces-config application locale-config default-locale pl /default-locale supported-locale de /supported-locale /locale-config /application /faces-config Kiedy przeglądarka nawiązuje połączenie z naszą aplikacją, zwykle dołącza do nagłówka protokołu HTTP wartość Accept-Language (patrz http://www.w3.org/ (cid:180)International/questions/qa-accept-lang-locales.html). Implementacja technologii JavaServer Faces odczytuje ten nagłówek i odnajduje najlepsze dopasowanie wśród obsługiwanych ustawień regionalnych. Możemy sprawdzić funkcjonowanie tego mechanizmu, ustawiając język preferowany w swojej przeglądarce (patrz rysunek 2.2). Rysunek 2.2. Wybór preferowanego języka 2. Możemy dodać atrybut locale do elementu f:view — oto przykład: f:view locale= de Ustawienia regionalne można też określać dynamicznie: f:view locale= #{user.locale} / Kod reprezentujący ustawienia regionalne ma teraz postać łańcucha zwracanego przez metodę getLocale. Takie rozwiązanie jest wygodne w przypadku aplikacji, które umożliwiają użytkownikowi wybór preferowanych ustawień. 3. Ustawienia regionalne można też definiować programowo. W tym celu wystarczy wywołać metodę setLocale obiektu klasy UIViewRoot: UIViewRoot viewRoot = FacesContext.getCurrentInstance().getViewRoot(); viewRoot.setLocale(new Locale( de )); Przykład praktycznego użycia tego mechanizmu można znaleźć w punkcie „Stosowanie łączy poleceń” w rozdziale 4. 54 JavaServer Faces Przykładowa aplikacja Po omówieniu tych dość abstrakcyjnych reguł i obostrzeń warto przystąpić do analizy kon- kretnego przykładu. Działanie naszej aplikacji będzie się sprowadzało do prezentowania szere- gu pytań swoistego quizu. Każde z nich będzie obejmowało sekwencję cyfr i wymagało od użytkownika wskazania kolejnej cyfry danej sekwencji. Na rysunku 2.3 przedstawiono przykładowy ekran aplikacji z prośbą o podanie kolejnej liczby dla następującej sekwencji: 3 1 4 1 5 Rysunek 2.3. Quiz liczbowy Podobne łamigłówki często są stosowane w testach na inteligencję. Rozwiązanie tej zagadki wymaga znalezienia pewnego wzorca (w tym przypadku mamy do czynienia z pierwszymi cyframi liczby π). Kiedy prawidłowo określimy kolejną cyfrę tej sekwencji (w tym przypadku 9), nasz wynik zostanie powiększony o jeden punkt. Istnieje angielski zwrot (wprost idealnie pasujący do środowisk opartych na Javie), którego zapamiętanie ułatwia identyfikację pierwszych ośmiu cyfr liczby π: Can I have a small container of coffee? Wystarczy policzyć litery w kolejnych wyrazach, aby otrzymać sekwencję 3 1 4 1 5 9 2 6. Więcej informacji o podobnych konstrukcjach można znaleźć na stronie internetowej http://dir.yahoo.com/Science/Mathematics/Numerical (cid:180)_Analysis/Numbers/Specific_Numbers/Pi/Mnemonics/. W naszym przykładzie kolejne pytania zaimplementujemy w klasie QuizBean. W rzeczywistej aplikacji najprawdopodobniej wykorzystalibyśmy bazę danych do składowania tego rodzaju informacji. Celem tego przykładu jest jednak demonstracja sposobu wykorzystywania kom- ponentów JavaBeans o złożonej strukturze. W pierwszej kolejności przeanalizujemy kod klasy ProblemBean, która definiuje dwie wła- ściwości: solution typu int oraz sequence typu ArrayList (patrz listing 2.1). Listing 2.1. Kod zdefiniowany w pliku numberquiz/src/java/com/corejsf/ProblemBean.java Rozdział 2. (cid:81) Komponenty zarządzane 55 1. package com.corejsf; 2. import java.util.ArrayList; 3. 4. public class ProblemBean { 5. private ArrayList Integer sequence; 6. private int solution; 7. 8. public ProblemBean() {} 9. 10. public ProblemBean(int[] values, int solution) { 11. sequence = new ArrayList Integer (); 12. for (int i = 0; i values.length; i++) 13. sequence.add(values[i]); 14. this.solution = solution; 15. } 16. 17. // właściwość sequence: 18. public ArrayList Integer getSequence() { return sequence; } 19. public void setSequence(ArrayList Integer newValue) { sequence = newValue; } 20. 21. // właściwość solution: 22. public int getSolution() { return solution; } 23. public void setSolution(int newValue) { solution = newValue; } 24. } Musimy teraz zdefiniować właściwy komponent quizu z następującymi właściwościami: (cid:81) problems: właściwość dostępna tylko do zapisu i reprezentująca pytania quizu; (cid:81) score: właściwość dostępna tylko do odczytu i reprezentująca bieżącą punktację; (cid:81) current: właściwość dostępna tylko do odczytu i reprezentująca bieżące pytanie; (cid:81) answer: właściwość umożliwiająca odczyt i zapis bieżącej odpowiedzi podanej przez użytkownika. Właściwość problems w ogóle nie jest wykorzystywana przez nasz przykładowy program — ograniczamy się do inicjalizacji zbioru problemów w konstruktorze klasy QuizBean. Z drugiej strony, w punkcie „Wiązanie definicji komponentów” w dalszej części tego roz- działu omówimy sposób definiowania zbioru problemów wewnątrz pliku faces-config.xml, a więc bez konieczności pisania jakiegokolwiek kodu. Właściwość current jest wykorzystywana do wyświetlania bieżącego problemu. Warto jednak pamiętać, że wspomniana właściwość reprezentuje obiekt klasy ProblemBean, którego nie możemy bezpośrednio wyświetlać w polu tekstowym. W związku z tym sekwencję liczb uzyskujemy za pośrednictwem jeszcze jednej właściwości: h:outputText value= #{quiz.current.sequence} / Właściwość sequence reprezentuje wartość typu ArrayList. W procesie wyświetlania można ją przekonwertować na łańcuch, wywołując metodę toString. W wyniku tego wywołania otrzymamy następujący łańcuch wynikowy: [3, 1, 4, 1, 5] 56 JavaServer Faces I wreszcie musimy się zmierzyć z problemem obsługi właściwości answer. W pierwszej kolejności wiążemy ją z polem tekstowym formularza: h:inputText value= #{quiz.answer} / W momencie wyświetlania tego pola tekstowego następuje wywołanie metody zwracającej getAnswer, którą zaimplementowano w taki sposób, aby zwracała pusty łańcuch. Po wysłaniu formularza implementacja JSF wywołuje metodę ustawiającą, przekazując na jej wejściu wartość wpisaną przez użytkownika w tym polu tekstowym. Metoda setAnswer sprawdza odpowiedź, aktualizuje wynik punktowy (w przypadku prawidłowej decyzji użytkownika) i przechodzi do kolejnego problemu. public void setAnswer(String newValue) { try { int answer = Integer.parseInt(newValue.trim()); if (getCurrent().getSolution() == answer) score++; currentIndex = (currentIndex + 1) problems.size(); } catch (NumberFormatException ex) { } } Umieszczanie w metodzie ustawiającej wartość właściwości kodu niezwiązanego z jej ory- ginalnym przeznaczeniem nie jest najlepszym rozwiązaniem. Operacje aktualizacji wyniku i przejścia do kolejnego problemu powinny być realizowane przez metodę obsługującą akcję kliknięcia przycisku. Ponieważ jednak nie analizowaliśmy mechanizmów reagujących na tego rodzaju zdarzenia, na razie będziemy korzystać z elastyczności oferowanej przez metody ustawiające. Inną wadą naszej przykładowej aplikacji jest brak mechanizmu przerywania działania po ostatnim pytaniu quizu. Ograniczyliśmy się do rozwiązania polegającego na powrocie do pierwszej strony, aby umożliwić użytkownikowi uzyskiwanie coraz lepszych rezultatów. W następnym rozdziale omówimy sposób implementacji lepszego modelu. Warto raz jeszcze przypomnieć, że celem tej aplikacji jest pokazanie, jak w praktyce konfigurować i wyko- rzystywać komponenty. Na koniec warto zwrócić uwagę na mechanizm umiędzynarodowienia naszej aplikacji przez opracowanie dodatkowych pakietów komunikatów. Zachęcamy do przełączenia przeglądarki na język niemiecki, aby naszym oczom ukazał się ekran podobny do tego z rysunku 2.4. Rysunek 2.4. Viel Spaß mit dem Zahlenquiz! Rozdział 2. (cid:81) Komponenty zarządzane 57 Na tym możemy zakończyć analizę naszej przykładowej aplikacji. Na rysunku 2.5 przedsta- wiono strukturę katalogów. Pozostały kod źródłowy przedstawiono na listingach od 2.2 do 2.6. Rysunek 2.5. Struktura katalogów przykładowej aplikacji łamigłówki liczbowej Listing 2.2. Zawartość pliku numberquiz/web/index.jsp 1. html 2. @ taglib uri= http://java.sun.com/jsf/html prefix= h 3. @ taglib uri= http://java.sun.com/jsf/core prefix= f 4. 5. f:view 6. head 7. title h:outputText value= #{msgs.title} / /title 8. /head 9. body 10. h:form 11. h3 12. h:outputText value= #{msgs.heading} / 13. /h3 14. p 15. h:outputFormat value= #{msgs.currentScore} 16. f:param value= #{quiz.score} / 17. /h:outputFormat 18. /p 19. p 20. h:outputText value= #{msgs.guessNext} / 21. /p 22. p 23. h:outputText value= #{quiz.current.sequence} / 24. /p 25. p 26. h:outputText value= #{msgs.answer} / 27. h:inputText value= #{quiz.answer} / /p 28. p 29. h:commandButton value= #{msgs.next} action= next / 30. /p 31. /h:form 32. /body 33. /f:view 34. /html 58 JavaServer Faces Listing 2.3. Zawartość pliku numberquiz/src/java/com/corejsf/QuizBean.java
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

JavaServer Faces. Wydanie II
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: