Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00302 005355 13079300 na godz. na dobę w sumie
JavaServer Faces. Wydanie III - książka
JavaServer Faces. Wydanie III - książka
Autor: , Liczba stron: 586
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2904-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Ta książka zawiera wszystko, czego Ci potrzeba
do opanowania frameworka JSF 2.0!

JavaServer Faces (JSF) to technologia platformy Java EE, ułatwiająca projektowanie i tworzenie interfejsów użytkownika aplikacji internetowych. Umożliwia sprawną pracę nad aplikacjami działającymi po stronie serwera i wprowadzanie jasnego podziału na wizualną prezentację oraz właściwą logikę aplikacji. Specyfikacja JSF 2.0 (inaczej niż poprzednia) jest pochodną wielu rzeczywistych projektów open source. Dzięki temu sam framework jest dużo prostszy i lepiej zintegrowany ze stosem technologii Java EE niż wersja JSF 1.0. Co więcej, jego specyfikacja przewiduje teraz obsługę technologii takich, jak AJAX czy REST. Framework JSF 2.0 jest obecnie jednym z najznamienitszych frameworków aplikacji internetowych tworzonych w Javie. Do jego mocnych stron należą także: uproszczony model programowania poprzez zastosowanie adnotacji i wprowadzenie zasady konwencji ponad konfiguracją oraz rozszerzalny model komponentów.

Książka 'JavaServer Faces. Wydanie III' zawiera wszystko, czego trzeba do opanowania rozbudowanych elementów frameworka JSF 2.0. Poznaj tajniki znaczników frameworka JSF oraz obsługi zdarzeń. Dowiedz się, jak budować komponenty złożone, i naucz się implementować własne, niestandardowe. Wykorzystaj w swoich aplikacjach technologię AJAX i opanuj nawiązywanie połączeń z bazami danych czy innymi usługami zewnętrznymi. W ostatnim rozdziale znajdziesz pomocne wskazówki na temat diagnozowania i rejestrowania zdarzeń, a także praktyczne przykłady kodu, rozszerzające technologię JSF.

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

Darmowy fragment publikacji:

Idź do • Spis treści • Przykładowy rozdział Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2011 JavaServer Faces. Wydanie III Autorzy: David Geary, Cay S. Horstmann Tłumaczenie: Mikołaj Szczepaniak ISBN: 978-83-246-2904-6 Tytuł oryginału: Core JavaServer Faces (3rd Edition) Format: 172×245, stron: 584 Ta książka zawiera wszystko, czego Ci potrzeba do opanowania frameworka JSF 2.0! • Jak korzystać ze znaczników JSF? • Jak tworzyć komponenty złożone? • Jak nawiązywać połączenie z bazami danych i usługami zewnętrznymi? JavaServer Faces (JSF) to technologia platformy Java EE, ułatwiająca projektowanie i tworzenie interfejsów użytkownika aplikacji internetowych. Umożliwia sprawną pracę nad aplikacjami działającymi po stronie serwera i wprowadzanie jasnego podziału na wizualną prezentację oraz właściwą logikę aplikacji. Specyfikacja JSF 2.0 (inaczej niż poprzednia) jest pochodną wielu rzeczywistych projektów open source. Dzięki temu sam framework jest dużo prostszy i lepiej zintegrowany ze stosem technologii Java EE niż wersja JSF 1.0. Co więcej, jego specyfikacja przewiduje teraz obsługę technologii takich, jak AJAX czy REST. Framework JSF 2.0 jest obecnie jednym z najznamienitszych frameworków aplikacji internetowych tworzonych w Javie. Do jego mocnych stron należą także: uproszczony model programowania poprzez zastosowanie adnotacji i wprowadzenie zasady konwencji ponad konfiguracją oraz rozszerzalny model komponentów. Książka „JavaServer Faces. Wydanie III” zawiera wszystko, czego trzeba do opanowania rozbudowanych elementów frameworka JSF 2.0. Poznaj tajniki znaczników frameworka JSF oraz obsługi zdarzeń. Dowiedz się, jak budować komponenty złożone, i naucz się implementować własne, niestandardowe. Wykorzystaj w swoich aplikacjach technologię AJAX i opanuj nawiązywanie połączeń z bazami danych czy innymi usługami zewnętrznymi. W ostatnim rozdziale znajdziesz pomocne wskazówki na temat diagnozowania i rejestrowania zdarzeń, a także praktyczne przykłady kodu, rozszerzające technologię JSF. • Komponenty zarządzane • Zasięg komponentów • Nawigacja statyczna i dynamiczna • Znaczniki standardowe • Facelety • Tabele danych • Konwersja i weryfikacja danych • Obsługa zdarzeń • Komponenty złożone • Technologia AJAX • Usługi zewnętrzne • Praca z bazami danych Spis treÊci Przedmowa .................................................................................................................... 9 Podziökowania ............................................................................................................. 13 RozdziaÄ 1. Wprowadzenie .......................................................................................................................15 Dlaczego wybieramy technologiö JavaServer Faces? ........................................................ 15 Prosty przykäad ............................................................................................................. 16 Elementy skäadowe ................................................................................................. 18 Struktura katalogów ................................................................................................ 19 Kompilacja przykäadowej aplikacji ............................................................................. 21 WdraĔanie aplikacji technologii JSF ........................................................................... 22 ćrodowiska wytwarzania dla JSF .................................................................................... 24 Analiza przykäadowej aplikacji ........................................................................................ 26 Komponenty ........................................................................................................... 27 Strony technologii JSF ............................................................................................. 29 Konfiguracja serwletu .............................................................................................. 31 Pierwsze spojrzenie na technologiö Ajax ............................................................... 33 Usäugi frameworku JSF .................................................................................................. 36 Mechanizmy wewnötrzne ............................................................................................... 38 Wizualizacja stron ................................................................................................... 38 Dekodowanie Ĕñdaþ ................................................................................................ 39 Cykl Ĕycia aplikacji JSF ............................................................................................ 40 Podsumowanie ............................................................................................................ 42 RozdziaÄ 2. Komponenty zarz¾dzane ......................................................................................................43 Definicja komponentu ................................................................................................... 43 WäaĈciwoĈci komponentu ........................................................................................ 46 WyraĔenia reprezentujñce wartoĈci ........................................................................... 47 Komponenty wspierajñce ......................................................................................... 48 Komponenty CDI .................................................................................................... 49 Pakiety komunikatów .................................................................................................... 50 Komunikaty obejmujñce zmienne .............................................................................. 52 Konfigurowanie ustawieþ regionalnych aplikacji ......................................................... 53 Przykäadowa aplikacja ................................................................................................... 54 Zasiög komponentów .................................................................................................... 60 Zasiög sesji ............................................................................................................ 61 4 JavaServer Faces Zasiög Ĕñdania ....................................................................................................... 62 Zasiög aplikacji ....................................................................................................... 63 ........................................................................................... 63 Zasiög konwersacji Zasiög widoku .............................................................................................. 64 Zasiögi niestandardowe ................................................................................. 65 Konfigurowanie komponentów ....................................................................................... 65 Wstrzykiwanie komponentów CDI ....................................................................... 65 ..................................................... 66 Wstrzykiwanie komponentów zarzñdzanych Adnotacje cyklu Ĕycia komponentu ............................................................................ 66 Konfigurowanie komponentów zarzñdzanych na poziomie XML-a ................................. 67 Skäadnia jözyka wyraĔeþ ................................................................................................ 72 Tryby l-wartoĈci i r-wartoĈci ....................................................................................... 72 Stosowanie nawiasów kwadratowych ........................................................................ 73 WyraĔenia odwoäujñce siö do map i list ..................................................................... 73 Wywoäywanie metod i funkcji rysunek JSF 2.0 ........................................................ 74 Przetwarzanie wyrazu poczñtkowego ......................................................................... 76 WyraĔenia zäoĔone ................................................................................................... 77 WyraĔenia odwoäujñce siö do metod ......................................................................... 78 Parametry wyraĔeþ odwoäujñcych siö do metod ................................................ 79 Podsumowanie ............................................................................................................ 80 RozdziaÄ 3. Nawigacja ..............................................................................................................................81 Nawigacja statyczna ..................................................................................................... 81 Nawigacja dynamiczna .................................................................................................. 82 Odwzorowywanie wyników na identyfikatory widoków .................................................. 83 Aplikacja JavaQuiz ................................................................................................... 85 Przekierowania ............................................................................................................. 93 .......................................................................... 94 Przekierowanie i obiekt flash Nawigacja zgodna ze stylem REST i adresy URL zapewniajñce moĔliwoĈè stosowania zakäadek ......................................................................................... 95 Parametry widoku ................................................................................................... 96 ãñcza Ĕñdaþ GET ..................................................................................................... 97 OkreĈlanie parametrów Ĕñdania ............................................................................... 98 Dodanie äñczy umoĔliwiajñcych stosowanie zakäadek do aplikacji quizu ........................ 99 Zaawansowane techniki nawigacji ................................................................................ 103 Symbole wieloznaczne ........................................................................................... 104 Stosowanie elementu from-action ........................................................................... 104 Warunkowe przypadki nawigacji .................................................................... 105 Dynamiczne identyfikatory widoków docelowych ............................................. 105 Podsumowanie .......................................................................................................... 105 RozdziaÄ 4. Znaczniki standardowe JSF ...............................................................................................107 Przeglñd podstawowych znaczników JSF ....................................................................... 108 Atrybuty, parametry i facety .................................................................................... 109 Przeglñd znaczników JSF reprezentujñcych znaczniki HTML (JSF HTML) ........................... 110 Atrybuty wspólne ................................................................................................... 112 Panele ....................................................................................................................... 120 Znaczniki head, body i form ......................................................................................... 122 Elementy formularzy i skrypty jözyka JavaScript ....................................................... 123 Jedno- i wielowierszowe pola tekstowe ......................................................................... 127 Pola ukryte ........................................................................................................... 130 Stosowanie jedno- i wielowierszowych pól tekstowych .............................................. 130 WyĈwietlanie tekstu i obrazów ................................................................................ 133 Spis treÊci 5 RozdziaÄ 5. Facelety Przyciski i äñcza .......................................................................................................... 136 Stosowanie przycisków .......................................................................................... 138 Stosowanie äñczy poleceþ ...................................................................................... 142 Znaczniki selekcji ....................................................................................................... 145 Pola wyboru i przyciski opcji ................................................................................... 148 Menu i listy .......................................................................................................... 150 Elementy .............................................................................................................. 152 Komunikaty ............................................................................................................... 169 Podsumowanie .......................................................................................................... 174 ....................................................................................................................175 Znaczniki projektu Facelets ......................................................................................... 175 Stosowanie szablonów technologii Facelets .................................................................. 176 Budowanie stron na podstawie wspólnych szablonów .............................................. 179 Organizacja widoków ............................................................................................. 182 Dekoratory ........................................................................................................... 188 Parametry ............................................................................................................. 189 Znaczniki niestandardowe ........................................................................................... 190 Komponenty i fragmenty ........................................................................................ 192 Zakoþczenie .............................................................................................................. 193 Znacznik ui:debug ............................................................................................. 193 Znacznik ui:remove ........................................................................................... 195 Obsäuga znaków biaäych ......................................................................................... 196 Podsumowanie .......................................................................................................... 196 RozdziaÄ 6. Tabele danych ......................................................................................................................197 Znacznik tabeli danych — h:dataTable ......................................................................... 197 Prosta tabela ............................................................................................................. 198 Atrybuty znacznika h:dataTable .............................................................................. 201 Atrybuty znacznika h:column .................................................................................. 201 Nagäówki, stopki i podpisy ........................................................................................... 201 Style ......................................................................................................................... 205 Style stosowane dla kolumn .................................................................................. 206 Style stosowane dla wierszy .................................................................................. 207 Znacznik ui:repeat ...................................................................................... 207 Komponenty JSF w tabelach ........................................................................................ 208 Edycja tabel ............................................................................................................... 212 Edycja komórek tabeli ........................................................................................... 212 Usuwanie wierszy ........................................................................................ 215 Tabele bazy danych .................................................................................................... 218 Modele tabel ............................................................................................................. 222 WyĈwietlanie numerów wierszy ............................................................................... 222 Identyfikacja wybranego wiersza ............................................................................. 223 Sortowanie i filtrowanie ......................................................................................... 223 Techniki przewijania ................................................................................................... 230 Przewijanie z uĔyciem paska przewijania ................................................................. 230 Przewijanie za pomocñ widgetów stronicowania ....................................................... 231 Podsumowanie .......................................................................................................... 232 RozdziaÄ 7. Konwersja i weryfikacja poprawnoÊci danych ...............................................................233 Przeglñd procesu konwersji i weryfikacji poprawnoĈci .................................................... 233 Stosowanie konwerterów standardowych ...................................................................... 235 Konwersja liczb i dat ............................................................................................. 235 6 JavaServer Faces Bäödy konwersji ..................................................................................................... 239 Kompletny przykäad konwertera .............................................................................. 244 Stosowanie standardowych mechanizmów weryfikujñcych .............................................. 247 Weryfikacja däugoĈci äaþcuchów i przedziaäów liczbowych .......................................... 247 Weryfikacja wartoĈci wymaganych .......................................................................... 249 WyĈwietlanie komunikatów o bäödach weryfikacji ..................................................... 250 Pomijanie procesu weryfikacji ................................................................................. 250 Kompletny przykäad mechanizmu weryfikacji ............................................................ 252 ....................................................... 254 Weryfikacja na poziomie komponentów Javy Programowanie z wykorzystaniem niestandardowych konwerterów i mechanizmów weryfikujñcych .................................................................................. 259 Implementacja klas konwerterów niestandardowych ................................................. 259 Wskazywanie konwerterów ........................................................................... 262 Raportowanie bäödów konwersji .............................................................................. 264 Uzyskiwanie dostöpu do komunikatów o bäödach zapisanych w pakiecie komunikatów .................................................................... 265 Przykäadowa aplikacja zbudowana na bazie konwertera niestandardowego ................. 269 Przekazywanie konwerterom atrybutów .................................................................... 272 Implementacja klas niestandardowych mechanizmów weryfikacji .............................. 273 Rejestrowanie wäasnych mechanizmów weryfikacji ................................................... 274 Weryfikacja danych wejĈciowych za pomocñ metod komponentów Javy ...................... 277 Weryfikacja relacji äñczñcych wiele komponentów ..................................................... 277 Implementacja niestandardowych znaczników konwerterów i mechanizmów weryfikacji .... 279 Podsumowanie .......................................................................................................... 285 RozdziaÄ 8. ObsÄuga zdarzeÆ .................................................................................................................287 Zdarzenia i cykl Ĕycia aplikacji JSF ............................................................................... 288 Zdarzenia zmiany wartoĈci .......................................................................................... 289 Zdarzenia akcji ........................................................................................................... 293 Znaczniki metod nasäuchujñcych zdarzeþ ...................................................................... 299 Znaczniki f:actionListener i f:valueChangeListener ................................................... 299 Komponenty bezpoĈrednie .......................................................................................... 301 Stosowanie bezpoĈrednich komponentów wejĈciowych ............................................ 301 Stosowanie bezpoĈrednich komponentów poleceþ ................................................... 304 Przekazywanie danych z interfejsu uĔytkownika na serwer .............................................. 305 Parametry wyraĔenia odwoäujñcego siö do metody ......................................... 306 Znacznik f:param .................................................................................................. 306 Znacznik f:attribute ............................................................................................... 307 Znacznik f:setPropertyActionListener ...................................................................... 308 Zdarzenia fazy ............................................................................................................ 309 Zdarzenia systemowe ....................................................................................... 310 Weryfikacja wielu komponentów ............................................................................. 311 Podejmowanie decyzji przed wizualizacjñ widoku ...................................................... 312 Podsumowanie caäego materiaäu w jednym miejscu ....................................................... 317 Podsumowanie .......................................................................................................... 324 ...............................................................................................325 Biblioteka znaczników komponentów zäoĔonych ............................................................. 326 Stosowanie komponentów zäoĔonych ........................................................................... 327 Implementowanie komponentów zäoĔonych ................................................................... 329 Konfigurowanie komponentów zäoĔonych ...................................................................... 330 Typy atrybutów ........................................................................................................... 331 Atrybuty wymagane i domyĈlne wartoĈci atrybutów ........................................................ 332 RozdziaÄ 9. Komponenty zÄoÑone Spis treÊci 7 Przetwarzanie danych po stronie serwera ..................................................................... 333 Lokalizacja komponentów zäoĔonych ............................................................................ 336 Udostöpnianie komponentów zäoĔonych ....................................................................... 337 Udostöpnianie Ēródeä akcji ..................................................................................... 339 Facety ....................................................................................................................... 341 Komponenty potomne ................................................................................................. 342 JavaScript .................................................................................................................. 343 Komponenty wspomagajñce ........................................................................................ 348 Pakowanie komponentów zäoĔonych w plikach JAR ........................................................ 356 Podsumowanie .......................................................................................................... 357 ........................................................................................................................359 Ajax i JSF ................................................................................................................... 359 Cykl Ĕycia aplikacji JSF i technologia Ajax ..................................................................... 361 Technologie JSF i Ajax — prosty przepis ....................................................................... 362 Znacznik f:ajax ........................................................................................................... 363 Grupy technologii Ajax ................................................................................................. 366 Weryfikacja pól przy uĔyciu technologii Ajax ................................................................... 368 Monitorowanie Ĕñdaþ technologii Ajax .......................................................................... 369 Przestrzenie nazw JavaScriptu ..................................................................................... 372 Obsäuga bäödów technologii Ajax .................................................................................. 373 Odpowiedzi technologii Ajax ........................................................................................ 374 Biblioteka JavaScriptu frameworku JSF 2.0 .................................................................. 375 Przekazywanie dodatkowych parametrów Ĕñdania Ajax ................................................... 378 Kolejkowanie zdarzeþ ................................................................................................. 379 ãñczenie zdarzeþ ........................................................................................................ 380 Przechwytywanie wywoäaþ funkcji jsf.ajax.request() ........................................................ 381 Stosowanie technologii Ajax w komponentach zäoĔonych ............................................... 382 Podsumowanie .......................................................................................................... 388 RozdziaÄ 11. Niestandardowe komponenty, konwertery i mechanizmy weryfikuj¾ce ......................389 Implementacja klasy komponentu ................................................................................ 390 Kodowanie: generowanie kodu jözyka znaczników ......................................................... 394 Dekodowanie: przetwarzanie wartoĈci Ĕñdania .............................................................. 397 Deskryptor biblioteki znaczników ....................................................................... 403 Stosowanie zewnötrznych mechanizmów wizualizacji ..................................................... 406 Przetwarzanie atrybutów znacznika .................................................................... 410 Obsäuga metod nasäuchujñcych zmian wartoĈci ....................................................... 412 Obsäuga wyraĔeþ odwoäujñcych siö do metod ........................................................... 413 Kolejkowanie zdarzeþ ............................................................................................ 414 Przykäadowa aplikacja ............................................................................................ 415 Kodowanie JavaScriptu ............................................................................................... 421 Stosowanie komponentów i facet potomnych ............................................................... 424 Przetwarzanie znaczników potomnych typu SelectItem .............................................. 427 Przetwarzanie facet ............................................................................................... 428 Stosowanie pól ukrytych ........................................................................................ 429 Zapisywanie i przywracanie stanu ................................................................................ 435 ...................................................................... 436 ...................................................... 439 Implementacja autonomicznej funkcji Ajax w ramach komponentu niestandardowego ....... 441 Obsäuga znacznika f:ajax w komponentach niestandardowych ................................... 445 Podsumowanie .......................................................................................................... 450 Konstruowanie komponentów technologii Ajax RozdziaÄ 10. Ajax CzöĈciowe zapisywanie stanu 8 JavaServer Faces RozdziaÄ 12. UsÄugi zewnÂtrzne .............................................................................................................451 Dostöp do bazy danych za poĈrednictwem interfejsu JDBC ............................................ 451 Wykonywanie wyraĔeþ jözyka SQL ........................................................................... 451 Zarzñdzanie poäñczeniami ...................................................................................... 453 Eliminowanie wycieków poäñczeþ ............................................................................ 453 Stosowanie gotowych wyraĔeþ ................................................................................ 455 Transakcje ........................................................................................................... 456 UĔywanie bazy danych Derby .................................................................................. 457 Konfigurowanie Ēródäa danych ..................................................................................... 459 Uzyskiwanie dostöpu do zasobów zarzñdzanych przez kontener ................................ 459 Konfigurowanie zasobów baz danych w ramach serwera GlassFish ............................ 460 Konfigurowanie zasobów baz danych w ramach serwera Tomcat ............................... 460 Kompletny przykäad uĔycia bazy danych ................................................................... 462 Stosowanie architektury JPA ........................................................................................ 470 Krótki kurs architektury JPA ................................................................................... 470 Stosowanie architektury JPA w aplikacjach internetowych ......................................... 472 Stosowanie komponentów zarzñdzanych i bezstanowych komponentów sesyjnych ...... 476 Stanowe komponenty sesyjne .......................................................................... 479 Uwierzytelnianie i autoryzacja zarzñdzana przez kontener ............................................... 481 Wysyäanie poczty elektronicznej ................................................................................... 492 Stosowanie usäug sieciowych ...................................................................................... 497 Podsumowanie .......................................................................................................... 503 RozdziaÄ 13. Jak to zrobiÀ? ...................................................................................................................505 Gdzie naleĔy szukaè dodatkowych komponentów? ......................................................... 505 Jak zaimplementowaè obsäugö wysyäania plików na serwer? .......................................... 506 Jak wyĈwietlaè mapö obrazów? ................................................................................... 514 Jak generowaè dane binarne w ramach stron JSF? ........................................................ 516 Jak prezentowaè ogromne zbiory danych podzielone na mniejsze strony? ........................ 524 Jak generowaè wyskakujñce okna? .............................................................................. 528 Jak selektywnie prezentowaè i ukrywaè komponenty? .................................................... 535 Jak dostosowywaè wyglñd stron o bäödach? .................................................................. 536 Jak utworzyè wäasny, niestandardowy znacznik weryfikacji po stronie klienta? .................. 541 Jak skonfigurowaè aplikacjö? ...................................................................................... 548 Jak rozszerzyè jözyk wyraĔeþ technologii JSF? ............................................................... 549 Jak dodaè funkcjö do jözyka wyraĔeþ JSF? .......................................................... 551 Jak monitorowaè ruch pomiödzy przeglñdarkñ a serwerem? ........................................... 553 Jak diagnozowaè stronö, na której zatrzymaäa siö nasza aplikacja? ................................ 555 Jak uĔywaè narzödzi testujñcych w procesie wytwarzania aplikacji JSF? ........................... 557 Jak uĔywaè jözyka Scala podczas tworzenia aplikacji frameworku JSF? ........................... 559 Jak uĔywaè jözyka Groovy w aplikacjach frameworku JSF? .............................................. 560 Podsumowanie .......................................................................................................... 561 Skorowidz .............................................................................................................................................563 3 Nawigacja W tym krótkim rozdziale omówimy sposób konfigurowania reguá nawigacji w ramach budo- wanej aplikacji internetowej. W szczególnoĞci wyjaĞnimy, jak aplikacja moĪe przechodziü od jednej do drugiej strony internetowej w zaleĪnoĞci od czynnoĞci wykonywanych przez uĪytkownika i decyzji podejmowanych na poziomie logiki biznesowej. Nawigacja statyczna Przeanalizujmy teraz sytuacjĊ, w której uĪytkownik aplikacji internetowej wypeánia formu- larz na stronie internetowej. UĪytkownik moĪe wpisywaü dane w polach tekstowych, klikaü przyciski opcji i wybieraü elementy list. Wszystkie te dziaáania są realizowane na poziomie przeglądarki internetowej uĪytkownika. Kiedy uĪytkownik klika przycisk akceptujący i wysyáający dane formularza, zmiany są prze- kazywane na serwer. Aplikacja internetowa analizuje wówczas dane wpisane przez uĪytkownika i na ich podsta- wie decyduje, której strony JSF naleĪy uĪyü do wizualizacji odpowiedzi. Za wybór kolejnej strony JSF odpowiada mechanizm obsáugujący nawigacjĊ (ang. navigation handle). W przypadku prostych aplikacji internetowych nawigacja pomiĊdzy stronami ma charakter statyczny. Oznacza to, Īe klikniĊcie okreĞlonego przycisku zawsze powoduje przejĞcie do tej samej strony JSF odpowiedzialnej za wizualizacjĊ odpowiedzi. W podrozdziale „Prosty przykáad” w rozdziale 1. Czytelnicy mieli okazjĊ zapoznaü siĊ z najprostszym mechanizmem zapisywania reguá nawigacji statycznej pomiĊdzy stronami JSF. Dla kaĪdego przycisku definiujemy atrybut action — przykáad takiego rozwiązania przed- stawiono poniĪej: h:commandButton label= Zaloguj action= welcome / 82 JavaServer Faces Podczas lektury rozdziaäu 4. bödzie siö moĔna przekonaè, Ĕe akcje nawigacji moĔna przypisywaè takĔe do hiperäñczy. WartoĞü atrybutu action okreĞla siĊ mianem wyniku (ang. outcome). Wrócimy do tematu wyniku w punkcie „Odwzorowywanie wyników na identyfikatory widoków” w nastĊpnym podrozdziale — okazuje siĊ, Īe wynik moĪna opcjonalnie odwzorowywaü na identyfikatory widoków. W specyfikacji JavaServer Faces mianem widoku (ang. view) okreĞla siĊ stronĊ JSF. JeĞli programista nie zdefiniuje takiego odwzorowania dla okreĞlonego wyniku, wynik jest przeksztaácany w identyfikator widoku wedáug nastĊpujących reguá: 1. JeĞli wynik nie obejmuje rozszerzenia pliku, dopisuje siĊ do niego rozszerzenie bieĪącego widoku. 2. JeĞli wynik nie rozpoczyna siĊ od prawego ukoĞnika (/), poprzedza siĊ go ĞcieĪką do bieĪącego widoku. Na przykáad wynik welcome w widoku /index.xhtml zostanie automatycznie przeksztaácony w identyfikator widoku docelowego /welcome.xhtml. Odwzorowania wyników na identyfikatory widoków sñ opcjonalne, poczñw- szy od wersji JSF 2.0. We wczeĈniejszych wersjach programista musiaä wprost okreĈlaè reguäy nawigacji dla kaĔdego wyniku. Nawigacja dynamiczna W przypadku wiĊkszoĞci aplikacji internetowych nawigacja nie ma charakteru statycznego. ĝcieĪka przechodzenia pomiĊdzy stronami nie zaleĪy tylko od klikanych przycisków, ale takĪe od danych wejĞciowych wpisywanych przez uĪytkownika. Na przykáad wysyáając dane ze strony logowania (zwykle nazwĊ uĪytkownika i hasáo), moĪemy oczekiwaü dwóch odpo- wiedzi ze strony serwera: akceptacji tych danych bądĨ ich odrzucenia. OdpowiedĨ serwera zaleĪy wiĊc od pewnych obliczeĔ (w tym konkretnym przypadku od poprawnoĞci nazwy uĪytkownika i hasáa). Aby zaimplementowaü nawigacjĊ dynamiczną, przycisk akceptacji formularza naleĪy zwią- zaü z wyraĪeniem odwoáującym siĊ do metody: h:commandButton label= Zaloguj action= #{loginController.verifyUser} / W naszym przypadku wyraz loginController odwoáuje siĊ do komponentu pewnej klasy, która musi definiowaü metodĊ nazwaną verifyUser. WyraĪenie odwoáujące siĊ do metody, które przypisujemy atrybutowi action, nie otrzymuje Īadnych parametrów, ale moĪe zwracaü wartoĞü jakiegoĞ typu. Zwracana wartoĞü jest konwer- towana na áaĔcuch za pomocą wywoáania metody toString. RozdziaÄ 3. Q Nawigacja 83 W standardzie JSF 1.1 metody bödñce przedmiotem odwoäaþ w tego rodzaju wyra- Ĕeniach musiaäy zwracaè wartoĈci typu String. W technologii JSF 1.2 zwracana wartoĈè moĔe byè obiektem dowolnego typu. Taka moĔliwoĈè jest szczególnie waĔna w przypadku typów wyliczeniowych, poniewaĔ eliminuje ryzyko przeoczenia literówek w nazwach akcji (wychwytywanych przez kompilator). Przykáad metody akcji przedstawiono poniĪej: String verifyUser() { if (...) return success ; else return failure ; } PowyĪsza metoda zwraca jeden z dwóch áaĔcuchów wynikowych: success lub failure . Na podstawie tej wartoĞci identyfikuje siĊ nastĊpny widok. Metoda akcji moĔe zwróciè wartoĈè null, aby zasygnalizowaè koniecznoĈè ponow- nego wyĈwietlenia tej samej strony. W takim przypadku zasiög widoku (który omówi- liĈmy w rozdziale 2.) jest zachowywany. KaĔdy wynik inny niĔ null powoduje wyczysz- czenie tego zasiögu, nawet jeĈli widok wynikowy jest taki sam jak widok bieĔñcy. Krótko mówiąc, za kaĪdym razem, gdy uĪytkownik klika przycisk polecenia, dla którego zdefiniowano wyraĪenie odwoáujące siĊ do metody w atrybucie action, implementacja JSF podejmuje nastĊpujące kroki: 1. uzyskuje dostĊp do wskazanego komponentu; 2. wywoáuje wskazaną metodĊ; 3. przeksztaáca áaĔcuch wynikowy w identyfikator widoku; 4. wyĞwietla odpowiednią stronĊ (na podstawie identyfikatora widoku). Oznacza to, Īe implementacja rozgaáĊzieĔ (ang. branching) wymaga przekazania referencji do metody w klasie odpowiedniego komponentu. Mamy duĪą dowolnoĞü w kwestii miejsca umieszczenia tej metody. Najlepszym rozwiązaniem jest znalezienie klasy obejmującej wszyst- kie dane potrzebne do podejmowania wáaĞciwych decyzji. Odwzorowywanie wyników na identyfikatory widoków Jednym z najwaĪniejszych celów projektowych technologii JSF jest oddzielenie prezentacji od logiki biznesowej. JeĞli decyzje nawigacyjne mają charakter dynamiczny, kod obliczający wynik z natury rzeczy nie powinien byü zobligowany do znajomoĞci precyzyjnych nazw stron internetowych. Technologia JSF oferuje mechanizm odwzorowywania wyników logicznych, na przykáad success i failure, na wáaĞciwe strony internetowe. Takie odwzorowanie moĪna zdefiniowaü, dodając wpisy navigation-rule do pliku faces- config.xml. Typowy przykáad takiej konstrukcji pokazano poniĪej: 84 JavaServer Faces navigation-rule from-view-id /index.xhtml /from-view-id navigation-case from-outcome success /from-outcome to-view-id /welcome.xhtml /to-view-id /navigation-case /navigation-rule Przytoczona reguáa okreĞla, Īe wynik success na stronie /index.xhtml ma kierowaü uĪytkow- nika na stronĊ /welcome.xhtml. ãaþcuchy identyfikatorów widoków rozpoczynajñ siö od prawego ukoĈnika (/). JeĈli programista stosuje odwzorowania rozszerzeþ (na przykäad przyrostka .faces), roz- szerzenia muszñ odpowiadaè rozszerzeniom plików (na przykäad .xhtml), nie rozszerze- niom adresów URL. JeĞli programista odpowiednio dobierze áaĔcuchy wyników, bĊdzie mógá zebraü wiele reguá nawigacji w jednym miejscu. Programista moĪe na przykáad stworzyü jedną reguáĊ dla wszystkich przycisków skojarzonych z akcją logout (dostĊpnych na wielu stronach danej aplikacji). Wszystkie te przyciski mogą powodowaü przejĞcie na stronĊ loggedOut.xhtml — wystarczy zdefiniowaü jedną reguáĊ: navigation-rule navigation-case from-outcome logout /from-outcome to-view-id /loggedOut.xhtml /to-view-id /navigation-case /navigation-rule Ta reguáa jest stosowana dla wszystkich stron, poniewaĪ nie zdefiniowano elementu from- ´view-id. Istnieje teĪ moĪliwoĞü scalania reguá nawigacji z tym samym elementem from-view-id. Przykáad takiego rozwiązania pokazano poniĪej: navigation-rule from-view-id /index.xhtml /from-view-id navigation-case from-outcome success /from-outcome to-view-id /welcome.xhtml /to-view-id /navigation-case navigation-case from-outcome failure /from-outcome to-view-id /newuser.xhtml /to-view-id /navigation-case /navigation-rule W przypadku prostych aplikacji reguäy nawigacji zwykle w ogóle nie sñ potrzebne. Kiedy jednak budowane aplikacje stajñ siö coraz bardziej zäoĔone, warto stosowaè wyniki logiczne w ramach komponentów zarzñdzanych oraz reguäy nawigacji odwzorowu- jñce te wyniki na widoki docelowe. RozdziaÄ 3. Q Nawigacja 85 Aplikacja JavaQuiz W tym punkcie umieĞcimy zapisy dotyczące nawigacji w przykáadowym programie prezen- tującym uĪytkownikowi sekwencjĊ pytaĔ quizu (patrz rysunek 3.1). Rysunek 3.1. Pytanie quizu Kiedy uĪytkownik klika przycisk SprawdĨ odpowiedĨ, aplikacja sprawdza, czy podana odpo- wiedĨ jest prawidáowa. JeĞli nie, uĪytkownik otrzymuje jeszcze jedną szansĊ rozwiązania tego samego problemu (patrz rysunek 3.2). Rysunek 3.2. Jedna bäödna odpowiedĒ — spróbuj ponownie Po dwóch báĊdnych odpowiedziach aplikacja prezentuje uĪytkownikowi kolejny problem do rozwiązania (patrz rysunek 3.3). OczywiĞcie takĪe w razie podania prawidáowej odpowiedzi aplikacja przechodzi do nastĊpnego problemu. I wreszcie po rozwiązaniu ostatniego problemu nastĊpuje wyĞwietlenie strony pod- sumowania z uzyskaną liczbą punktów i propozycją ponownego przystąpienia do quizu (patrz rysunek 3.4). 86 JavaServer Faces Rysunek 3.3. Dwie bäödne odpowiedzi — kontynuuj Rysunek 3.4. Quiz zakoþczony — punktacja Nasza aplikacja skáada siĊ z dwóch klas. Klasa Problem (przedstawiona na listingu 3.1) opisuje pojedynczy problem, czyli pytanie, odpowiedĨ oraz metodĊ weryfikacji, czy dana odpowiedĨ jest prawidáowa. Listing 3.1. ZawartoĈè pliku javaquiz/src/java/com/corejsf/Problem.java 1. package com.corejsf; 2. 3. import java.io.Serializable; 4. 5. public class Problem implements Serializable { 6. private String question; 7. private String answer; 8. 9. public Problem(String question, String answer) { 10. this.question = question; 11. this.answer = answer; 12. } RozdziaÄ 3. Q Nawigacja 87 13. 14. public String getQuestion() { return question; } 15. 16. public String getAnswer() { return answer; } 17. 18. // naleĪy przykryü tĊ metodĊ bardziej wyszukanym kodem sprawdzającym 19. public boolean isCorrect(String response) { 20. return response.trim().equalsIgnoreCase(answer); 21. } 22. } Klasa QuizBean opisuje quiz obejmujący szereg pytaĔ. Egzemplarz tej klasy dodatkowo Ğledzi bieĪące pytanie i áączną punktacjĊ uzyskaną przez uĪytkownika. Kompletny kod tej klasy przedstawiono na listingu 3.2. Listing 3.2. ZawartoĈè pliku javaquiz/src/java/com/corejsf/QuizBean.java 1. package com.corejsf; 2. 3. import java.io.Serializable; 4. 5. import java.util.ArrayList; 6. import java.util.Arrays; 7. import java.util.Collections; 8. 9. import javax.inject.Named; 10. // lub import javax.faces.bean.ManagedBean; 11. import javax.enterprise.context.SessionScoped; 12. // lub import javax.faces.bean.SessionScoped; 13. 14. @Named // lub @ManagedBean 15. @SessionScoped 16. public class QuizBean implements Serializable { 17. private int currentProblem; 18. private int tries; 19. private int score; 20. private String response = ; 21. private String correctAnswer; 22. 23. // PoniĪej zakodowano problemy na staáe. W rzeczywistej aplikacji 24. // najprawdopodobniej odczytywalibyĞmy je z bazy danych. 25. private ArrayList Problem problems = new ArrayList Problem (Arrays.asList( 26. new Problem( 27. Jaki slogan reklamowađ programowanie w Javie? Write once, ... , 28. run anywhere ), 29. new Problem( 30. Jak wyglædajæ 4 pierwsze bajty kaľdego pliku klasy (szesnastkowo)? , 31. CAFEBABE ), 32. new Problem( 33. Co zostanie wyħwietlone przez to wyraľenie? System.out.println(1+ 2 ); , 34. 12 ), 35. new Problem( 36. Które sđowo kluczowe Javy sđuľy do definiowania podklasy? , 37. extends ), 38. new Problem( 39. Jak brzmiađa oryginalna nazwa júzyka programowania Java? , 40. Oak ), 88 JavaServer Faces 41. new Problem( 42. Która klasa pakietu java.util opisuje punkt w czasie? , 43. Date ))); 44. 45. public String getQuestion() { return problems.get(currentProblem).getQuestion(); } 46. 47. public String getAnswer() { return correctAnswer; } 48. 49. public int getScore() { return score; } 50. 51. public String getResponse() { return response; } 52. public void setResponse(String newValue) { response = newValue; } 53. 54. public String answerAction() { 55. tries++; 56. if (problems.get(currentProblem).isCorrect(response)) { 57. score++; 58. nextProblem(); 59. if (currentProblem == problems.size()) return done ; 60. else return success ; 61. } 62. else if (tries == 1) return again ; 63. else { 64. nextProblem(); 65. if (currentProblem == problems.size()) return done ; 66. else return failure ; 67. } 68. } 69. 70. public String startOverAction() { 71. Collections.shuffle(problems); 72. currentProblem = 0; 73. score = 0; 74. tries = 0; 75. response = ; 76. return startOver ; 77. } 78. 79. private void nextProblem() { 80. correctAnswer = problems.get(currentProblem).getAnswer(); 81. currentProblem++; 82. tries = 0; 83. response = ; 84. } 85. } W analizowanym przykáadzie wáaĞnie klasa QuizBean jest wáaĞciwym miejscem dla metod odpowiedzialnych za nawigacjĊ. Wspomniany komponent dysponuje peáną wiedzą o dziaáa- niach uĪytkownika i moĪe bez trudu okreĞliü, która strona powinna byü wyĞwietlona jako nastĊpna. LogikĊ nawigacji zaimplementowano w metodzie answerAction klasy QuizBean. Metoda answerAction zwraca jeden z kilku moĪliwych áaĔcuchów: success lub done (jeĞli uĪyt- kownik prawidáowo odpowiedziaá na pytanie), again (jeĞli uĪytkownik po raz pierwszy udzieliá báĊdnej odpowiedzi) oraz failure lub done (jeĞli po raz drugi padáa záa odpowiedĨ). RozdziaÄ 3. Q Nawigacja 89 public String answerAction() { tries++; if (problems.get(currentProblem).isCorrect(response)) { score++; nextProblem(); if (currentProblem == problems.size()) return done ; else return success ; } else if (tries == 1) return again ; else { nextProblem(); if (currentProblem == problems.size()) return done ; else return failure ; } } Z przyciskami na kaĪdej z tych stron wiąĪemy wyraĪenie odwoáujące siĊ do metody answer ´Action. Na przykáad strona index.xhtml zawiera nastĊpujący element: h:commandButton value= #{msgs.checkAnswer} action= #{quizBean.answerAction} / Na rysunku 3.5 przedstawiono strukturĊ katalogów naszej aplikacji. Na listingu 3.3 przed- stawiono kod strony gáównej aplikacji quizu: index.xhtml. Kodem stron success.xhtml i failure. xhtml nie bĊdziemy siĊ zajmowaü, poniewaĪ róĪni siĊ od kodu strony index.xhtml tylko komunikatem wyĞwietlanym w górnej czĊĞci. Rysunek 3.5. Struktura katalogów aplikacji quizu o Javie Listing 3.3. Kod strony javaquiz/web/index.xhtml 1. ?xml version= 1.0 encoding= UTF-8 ? 2. !DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Transitional//EN 3. http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd 4. html xmlns= http://www.w3.org/1999/xhtml 5. xmlns:h= http://java.sun.com/jsf/html 6. h:head 7. title #{msgs.title} /title 8. /h:head 90 JavaServer Faces 9. h:body 10. h:form 11. p #{quizBean.question} /p 12. p h:inputText value= #{quizBean.response} / /p 13. p 14. h:commandButton value= #{msgs.checkAnswer} 15. action= #{quizBean.answerAction} / 16. /p 17. /h:form 18. /h:body 19. /html Strona done.xhtml, której kod przedstawiono na listingu 3.4, prezentuje uĪytkownikowi ostateczny wynik i zachĊca go do ponownej gry. Warto zwróciü uwagĊ na jedyny przycisk dostĊpny na tej stronie. Na pierwszy rzut oka moĪe siĊ wydawaü, Īe mamy do czynienia z nawigacją statyczną, poniewaĪ kaĪde klikniĊcie przycisku Rozpocznij od nowa powoduje powrót na stronĊ index.xhtml. Okazuje siĊ jednak, Īe element definiujący ten przycisk wyko- rzystuje wyraĪenie odwoáujące siĊ do metody: h:commandButton value= #{msgs.startOver} action= #{quizBean.startOverAction} / Listing 3.4. ZawartoĈè pliku javaquiz/web/done.xhtml 1. ?xml version= 1.0 encoding= UTF-8 ? 2. !DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Transitional//EN 3. http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd 4. html xmlns= http://www.w3.org/1999/xhtml 5. xmlns:f= http://java.sun.com/jsf/core 6. xmlns:h= http://java.sun.com/jsf/html 7. h:head 8. title #{msgs.title} /title 9. /h:head 10. h:body 11. h:form 12. p 13. #{msgs.thankYou} 14. h:outputFormat value= #{msgs.score} 15. f:param value= #{quizBean.score} / 16. /h:outputFormat 17. /p 18. p 19. h:commandButton value= #{msgs.startOver} 20. action= #{quizBean.startOverAction} / 21. /p 22. /h:form 23. /h:body 24. /html Metoda startOverAction wykonuje wszelkie dziaáania niezbĊdne do przywrócenia oryginal- nego stanu gry. Dziaáanie tej metody polega na przypadkowym uporządkowaniu pytaĔ i wyze- rowaniu wyniku: public String startOverAction() { Collections.shuffle(problems); currentProblem = 0; RozdziaÄ 3. Q Nawigacja 91 score = 0; tries = 0; response = ; return startOver ; } Ogólnie metody akcji peánią dwie funkcje: Q aktualizują model w reakcji na dziaáania podejmowane przez uĪytkownika; Q sygnalizują mechanizmowi nawigacji koniecznoĞü skierowania uĪytkownika w okreĞlone miejsce. Podczas lektury rozdziaäu 8. Czytelnicy przekonajñ siö, Ĕe istnieje moĔliwoĈè doäñ- czania do przycisków takĔe obiektów nasäuchujñcych akcji. Kiedy uĔytkownik klika tak zdefiniowany przycisk, nastöpuje wykonanie kodu metody processAction obiektu nasäuchujñcego. Warto jednak pamiötaè, Ĕe obiekt nasäuchujñcy akcji nie komunikuje siö z mechanizmem odpowiedzialnym za nawigacjö. Na listingu 3.5 przedstawiono plik konfiguracyjny tej aplikacji obejmujący miĊdzy innymi reguáy nawigacji. Aby lepiej zrozumieü te reguáy, warto rzuciü okiem na diagram przechodze- nia pomiĊdzy stronami, pokazany na rysunku 3.6. Listing 3.5. ZawartoĈè pliku javaquiz/web/WEB-INF/faces-config.xml 1. ?xml version= 1.0 ? 2. faces-config xmlns= http://java.sun.com/xml/ns/javaee 3. xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance 4. xsi:schemaLocation= http://java.sun.com/xml/ns/javaee 5. http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd 6. version= 2.0 7. navigation-rule 8. navigation-case 9. from-outcome startOver /from-outcome 10. to-view-id /index.xhtml /to-view-id 11. /navigation-case 12. /navigation-rule 13. navigation-rule 14. from-view-id /again.xhtml /from-view-id 15. navigation-case 16. from-outcome failure /from-outcome 17. to-view-id /failure.xhtml /to-view-id 18. /navigation-case 19. /navigation-rule 20. navigation-rule 21. navigation-case 22. from-outcome failure /from-outcome 23. to-view-id /again.xhtml /to-view-id 24. /navigation-case 25. /navigation-rule 26. 27. application 28. resource-bundle 29. base-name com.corejsf.messages /base-name 30. var msgs /var 92 JavaServer Faces Rysunek 3.6. Diagram przejĈè aplikacji quizu o Javie 31. /resource-bundle 32. /application 33. /faces-config Dla trzech spoĞród naszych wyników ( success , again i done ) nie zdefiniowano reguá nawigacji. Wymienione wyniki zawsze kierują uĪytkownika odpowiednio na strony /success. xhtml, /again.xhtml oraz /done.xhtml. Wynik startOver odwzorowujemy na stronĊ /index.xhtml. Nieco trudniejsza jest obsáuga wyniku failure, który początkowo kieruje uĪyt- kownika na stronĊ /again.xhtml, stwarzając mu drugą okazjĊ do udzielenia odpowiedzi. JeĞli jednak takĪe odpowiedĨ wpisana na tej stronie okazuje siĊ báĊdna, ten sam wynik kieruje uĪytkownika na stronĊ /failure.xhtml: navigation-rule from-view-id /again.xhtml /from-view-id navigation-case from-outcome failure /from-outcome to-view-id /failure.xhtml /to-view-id /navigation-case /navigation-rule navigation-rule navigation-case from-outcome failure /from-outcome to-view-id /again.xhtml /to-view-id /navigation-case /navigation-rule Warto pamiĊtaü o tym, Īe kolejnoĞü reguá nie jest bez znaczenia. Druga reguáa jest uwzglĊd- niana w sytuacji, gdy bieĪącą stroną nie jest /again.xhtml. RozdziaÄ 3. Q Nawigacja 93 I wreszcie na listingu 3.6 pokazano áaĔcuchy komunikatów. Listing 3.6. ZawartoĈè pliku javaquiz/src/java/com/corejsf/messages.properties 1. title=Dziecinnie prosty quiz o Javie 2. checkAnswer=Sprawdļ odpowiedļ 3. startOver=Rozpocznij od nowa 4. correct=Gratulacje, prawidđowa odpowiedļ. 5. notCorrect=Przykro nam, Twoja odpowiedļ jest bđúdna. Spróbuj ponownie! 6. stillNotCorrect=Przykro nam, takľe tym razem podađeħ bđúdnæ odpowiedļ. 7. correctAnswer=Prawidđowa odpowiedļ: {0}. 8. score=Twój wynik punktowy: {0}. 9. nextProblem=A oto nastúpne pytanie. 10. thankYou=Dziúkujemy za udziađ w quizie. Przekierowania Programista moĪe wymusiü na implementacji technologii JavaServer Faces przekierowanie (ang. redirection) uĪytkownika do nowego widoku. Implementacja JSF wysyáa nastĊpnie przekierowanie protokoáu HTTP do klienta. OdpowiedĨ przekierowania wskazuje klientowi adres URL kolejnej strony — na tej podstawie klient generuje Īądanie GET na odpowiedni adres URL. Przekierowywanie jest czasocháonne, poniewaĪ wymaga powtórzenia caáego cyklu komuni- kacji z udziaáem przeglądarki. Przekierowanie ma jednak tĊ zaletĊ, Īe stwarza przeglądarce moĪliwoĞü aktualizacji jej pola adresu. Na rysunku 3.7 pokazano, jak zmienia siĊ zawartoĞü pola adresu wskutek uĪycia mechanizmu przekierowania. Bez przekierowania oryginalny adres URL (localhost:8080/javaquiz/faces/index.xhtml) pozostaáby niezmieniony przy okazji przejĞcia uĪytkownika ze strony /index.xhtml na stronĊ /success.xhtml. Przekierowanie powoduje, Īe przeglądarka wyĞwietla nowy adres URL (localhost:8080/javaquiz/faces/success.xhtml). JeĞli nie stosujemy reguá nawigacji, powinniĞmy uzupeániü áaĔcuch wyniku o nastĊpujący zapis: ?faces-redirect=true Po wprowadzeniu tej zmiany przykáadowy áaĔcuch wyniku moĪe mieü nastĊpującą postaü: h:commandButton label= Zaloguj action= welcome?faces-redirect=true / W regule nawigacji naleĪy umieĞciü element redirect bezpoĞrednio za elementem to-view-id: navigation-case from-outcome success /from-outcome to-view-id /success.xhtml /to-view-id redirect/ /navigation-case 94 JavaServer Faces Rysunek 3.7. Przekierowanie aktualizujñce adres URL w przeglñdarce Przekierowanie i obiekt flash Aby zminimalizowaü rozmiary zasiĊgu sesji, warto moĪliwie czĊsto rezygnowaü z tego zasiĊgu na rzecz zasiĊgu Īądania. Bez elementu redirect istnieje moĪliwoĞü stosowania komponen- tów o zasiĊgu Īądania dla danych prezentowanych w nastĊpnym widoku. Przeanalizujmy teraz, jak bĊdzie dziaáaáa nasza aplikacja w przypadku uĪycia elementu redirect: 1. Klient wysyáa Īądanie na serwer. 2. Mapa zasiĊgu Īądania jest wypeániana komponentami o zasiĊgu Īądania. 3. Serwer wysyáa do klienta status HTTP 302 (przekierowanie tymczasowe) wraz z miejscem docelowym przekierowania. Ten krok koĔczy bieĪące Īądanie, zatem komponenty o zasiĊgu Īądania są usuwane. 4. Klient generuje Īądanie GET i wysyáa pod nowy adres. 5. Serwer wizualizuje nastĊpny widok. Okazuje siĊ jednak, Īe komponenty naleĪące do zasiĊgu poprzedniego Īądania nie są juĪ dostĊpne. Aby obejĞü ten problem, technologia JSF 2.0 oferuje obiekt flash, który moĪna wypeániü podczas obsáugi jednego Īądania i uĪyü w ramach kolejnego Īądania. (KoncepcjĊ obiektu flash RozdziaÄ 3. Q Nawigacja 95 zaczerpniĊto z frameworku internetowego Ruby on Rails). Typowym zastosowaniem obiektów flash są komunikaty. Na przykáad metoda obsáugująca przycisk moĪe umieĞciü jakiĞ komu- nikat wáaĞnie w obiekcie flash: ExternalContext.getFlash().put( message , Twoje hasđo niedđugo straci waľnoħè ); Metoda ExternalContext.getFlash() zwraca obiekt klasy Flash implementującej interfejs Map String, Object . W kodzie strony JSF moĪna odwoáaü siĊ do obiektu flash za pomocą zmiennej flash. Na przykáad powyĪszy komunikat moĪna wyĞwietliü, stosując konstrukcjĊ: #{flash.message} Po wizualizacji komunikatu i dostarczeniu przekierowania do klienta áaĔcuch komunikatu jest automatycznie usuwany z obiektu flash. Okazuje siĊ, Īe wartoĞü w obiekcie flash moĪna utrzymywaü dáuĪej niĪ podczas przetwarza- nia jednego Īądania. Na przykáad wyraĪenie w postaci: #{flash.keep.message} nie tylko zwraca wartoĞü klucza message przechowywaną w obiekcie flash, ale teĪ dodaje tĊ wartoĞü ponownie z myĞlą o kolejnym cyklu Īądania. JeĈli z czasem iloĈè danych przerzucanych pomiödzy obiektem flash a kompo- nentem staje siö naprawdö duĔa, warto rozwaĔyè uĔycie zasiögu konwersacji. Nawigacja zgodna ze stylem REST i adresy URL zapewniaj¾ce moÑliwoÊÀ stosowania zakÄadek Aplikacja JSF domyĞlnie generuje sekwencjĊ ĪądaĔ POST wysyáanych na serwer. KaĪde Īąda- nie POST zawiera dane formularza. Takie rozwiązanie jest uzasadnione w przypadku aplikacji gromadzących duĪą iloĞü danych wejĞciowych wpisywanych przez uĪytkownika. Okazuje siĊ jednak, Īe znaczna czĊĞü aplikacji internetowych dziaáa w zupeánie inny sposób. WyobraĨmy sobie na przykáad sytuacjĊ, w której uĪytkownik przegląda katalog sklepu internetowego, klikając áącza do kolejnych produktów. Poza wyborem klikanych áączy trudno w tym przy- padku mówiü o jakichkolwiek danych wejĞciowych uĪytkownika. àącza powinny zapew- niaü moĪliwoĞü stosowania zakáadek (ang. bookmarkable), aby uĪytkownik mógá wróciü na tĊ samą stronĊ po wpisaniu tego samego adresu URL. Co wiĊcej, strony powinny byü przy- stosowane do przechowywania w pamiĊci podrĊcznej (ang. cacheable). Przechowywanie stron w pamiĊci podrĊcznej jest waĪnym czynnikiem decydującym o efektywnoĞci aplikacji internetowych. Stosowanie zakáadek ani przechowywanie w pamiĊci podrĊcznej oczywiĞcie nie jest moĪliwe w przypadku ĪądaĔ POST. Zgodnie z zaleceniami stylu architektury nazwanego REST (od ang. Representational State Transfer) aplikacje internetowe powinny posáugiwaü siĊ protokoáem HTTP wedáug oryginalnych 96 JavaServer Faces reguá przyjĊtych przez jego twórców. Na potrzeby operacji wyszukiwania naleĪy stosowaü Īądania GET. ĩądania PUT, POST i DELETE powinny byü wykorzystywane odpowiednio do two- rzenia, modyfikowania i usuwania. Zwolennicy stylu REST najbardziej cenią sobie adresy URL w nastĊpującej formie: http://serwer.pl/catalog/item/1729 Architektura REST nie narzuca nam jednak jednego stylu. Na przykáad dla Īądania GET z parametrem moĪna by uĪyü nastĊpującego adresu: http://serwer.pl/catalog?item=1729 TakĪe ten adres jest w peáni zgodny ze stylem REST. NaleĪy pamiĊtaü, Īe ĪądaĔ GET nigdy nie powinno siĊ uĪywaü do aktualizowania informacji. Na przykáad Īądanie GET dodające element do koszyka w tej formie: http://serwer.pl/addToCart?cart=314159 item=1729 nie byáoby wáaĞciwe. ĩądania GET powinny byü idempotentne. Oznacza to, Īe dwukrotne uĪycie tego samego Īądania nie powinno prowadziü do rezultatów innych niĪ jednorazowe Īądanie. WáaĞnie od tego zaleĪy moĪliwoĞü przechowywania ĪądaĔ w pamiĊci podrĊcznej. ĩądanie dodaj do koszyka z natury rzeczy nie jest idempotentne — jego dwukrotne wysáa- nie spowoduje dodanie dwóch takich samych towarów do koszyka. W tym kontekĞcie duĪo odpowiedniejsze byáoby Īądanie POST. Oznacza to, Īe nawet aplikacje internetowe zgodne ze stylem REST muszą korzystaü z ĪądaĔ POST. Technologia JSF nie oferuje obecnie standardowego mechanizmu generowania ani przetwa- rzania tzw. dobrych adresów URL, jednak począwszy od wersji JSF 2.0, moĪemy liczyü na obsáugĊ ĪądaĔ GET. Omówimy ten aspekt w kolejnych punktach tego podrozdziaáu. Parametry widoku Przeanalizujmy teraz Īądanie GET, które ma spowodowaü wyĞwietlenie informacji o konkret- nym produkcie: http://serwer.pl/catalog?item=1729 Identyfikator produktu jest przekazywany w formie parametru zapytania. Po otrzymaniu Īądania wartoĞü tego parametru musi zostaü przekazana do wáaĞciwego komponentu. Progra- mista moĪe uĪyü do tego celu parametrów widoku. Na początku strony naleĪy dodaü znaczniki podobne do poniĪszych: f:metadata f:viewParam name= item value= #{catalog.currentItem} / /f:metadata W czasie przetwarzania Īądania wartoĞü parametru zapytania item jest przekazywana do metody setCurrentItem komponentu
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

JavaServer Faces. Wydanie III
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ą: