Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00534 010078 11029969 na godz. na dobę w sumie
Java Servlet i JavaServer Pages. Tom 1. Wydanie II - książka
Java Servlet i JavaServer Pages. Tom 1. Wydanie II - książka
Autor: , Liczba stron: 632
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0032-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> jsp i javaservlet - programowanie
Porównaj ceny (książka, ebook, audiobook).

Zastosuj platformę Java 2 do tworzenia
aplikacji internetowych i dynamicznych witryn WWW

Java Servlet i JavaServer Pages to oparte na platformie Java 2 technologie wykorzystywane do tworzenia aplikacji internetowych i dynamicznych witryn WWW. Stosuje się je wszędzie tam, gdzie niezbędna jest wysoka stabilność i niezawodność, wydajność przy przetwarzaniu danych i elastyczność pozwalająca na szybkie dodawanie kolejnych modułów rozszerzających możliwości aplikacji. W oparciu o te technologie powstają między innymi systemy bankowości elektronicznej, aplikacje finansowe oraz systemy do obsługi programów lojalnościowych. Ogromną zaletą tej technologii jest fakt, że zarówno narzędzia programistyczne, jak i serwery aplikacji dostępne są nieodpłatnie, na zasadach open source, co redukuje koszty tworzenia oraz użytkowania stworzonych za ich pomocą systemów.

Książka 'Java Servlet i JavaServer Pages. Tom 1. Wydanie II' przedstawia sposoby wykorzystywania najnowszych możliwości serwletów i stron JSP. Wyjaśnia, w jakich przypadkach należy stosować serwlety, w jakich JSP oraz kiedy połączyć te technologie. Czytając ją, poznasz specyfikację technologii Java Servlet w wersji 2.4 oraz technologii JSP w wersji 2.0, nauczysz się instalować i konfigurować serwery aplikacji oraz dowiesz się, jak tworzyć aplikacje w obu technologiach i jak łączyć je z bazami danych za pomocą interfejsów JDBC. Zastosujesz w swoich projektach najlepsze strategie, których omówienie również znajdziesz w tej książce.

Napisz wydajne i stabilne aplikacje internetowe,
wykorzystując nowoczesne technologie.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Java Servlet i JavaServer Pages. Tom 1. Wydanie II Autorzy: Marty Hall, Larry Brown T³umaczenie: Piotr Rajca ISBN: 83-246-0032-9 Tytu³ orygina³u: Core Servlets and JavaServer Pages, Vol. 1: Core Technologies, Second Edition Format: B5, stron: 640 Zastosuj platformê Java 2 do tworzenia aplikacji internetowych i dynamicznych witryn WWW (cid:127) Zainstaluj i skonfiguruj serwery aplikacji (cid:129) Poznaj zasady tworzenia serwletów i dokumentów JSP (cid:129) Po³¹cz aplikacjê z baz¹ danych Java Servlet i JavaServer Pages to oparte na platformie Java 2 technologie wykorzystywane do tworzenia aplikacji internetowych i dynamicznych witryn WWW. Stosuje siê je wszêdzie tam, gdzie niezbêdna jest wysoka stabilnoœæ i niezawodnoœæ, wydajnoœæ przy przetwarzaniu danych i elastycznoœæ pozwalaj¹ca na szybkie dodawanie kolejnych modu³ów rozszerzaj¹cych mo¿liwoœci aplikacji. W oparciu o te technologie powstaj¹ miêdzy innymi systemy bankowoœci elektronicznej, aplikacje finansowe oraz systemy do obs³ugi programów lojalnoœciowych. Ogromn¹ zalet¹ tej technologii jest fakt, ¿e zarówno narzêdzia programistyczne, jak i serwery aplikacji dostêpne s¹ nieodp³atnie, na zasadach open source, co redukuje koszty tworzenia oraz u¿ytkowania stworzonych za ich pomoc¹ systemów. Ksi¹¿ka „Java Servlet i JavaServer Pages. Tom 1. Wydanie II” przedstawia sposoby wykorzystywania najnowszych mo¿liwoœci serwletów i stron JSP. Wyjaœnia, w jakich przypadkach nale¿y stosowaæ serwlety, w jakich JSP oraz kiedy po³¹czyæ te technologie. Czytaj¹c j¹, poznasz specyfikacjê technologii Java Servlet w wersji 2.4 oraz technologii JSP w wersji 2.0, nauczysz siê instalowaæ i konfigurowaæ serwery aplikacji oraz dowiesz siê, jak tworzyæ aplikacje w obu technologiach i jak ³¹czyæ je z bazami danych za pomoc¹ interfejsów JDBC. Zastosujesz w swoich projektach najlepsze strategie, których omówienie równie¿ znajdziesz w tej ksi¹¿ce. (cid:129) Instalacja i konfiguracja serwera Tomcat, JRun i Resin (cid:129) Zasady tworzenia serwletów (cid:129) Obs³uga protoko³u HTTP oraz danych z formularzy HTML (cid:129) Generowanie plików XLS (cid:129) œledzenie sesji i stosowanie plików cookie (cid:129) Podstawy stosowania JSP (cid:129) Wykorzystywanie komponentów JavaBean (cid:129) Architektura MVC (cid:129) Po³¹czenie z bazami danych za pomoc¹ JDBC Napisz wydajne i stabilne aplikacje internetowe, wykorzystuj¹c nowoczesne technologie Spis treści Podziękowania ......................................................................................................................................... 13 O autorach ................................................................................................................................................ 14 Wprowadzenie ......................................................................................................................................... 15 Rozdział 1. Ogólne informacje o serwletach i JavaServer Pages ........................................................25 1.1. Rola serwletów .................................................................................................. 25 1.2. Dlaczego warto dynamicznie generować strony WWW? .......................................... 27 1.3. Przedstawienie kodu serwletu ............................................................................. 28 1.4. Zalety serwletów w porównaniu ze zwykłymi programami CGI ................................. 30 Efektywność ................................................................................................. 30 Wygoda ........................................................................................................ 30 Duże możliwości ............................................................................................ 31 Przenośność ................................................................................................. 31 Niewielkie koszty ........................................................................................... 31 Bezpieczeństwo ............................................................................................ 32 Główny kierunek rozwoju ................................................................................ 33 1.5. JavaServer Pages .............................................................................................. 33 Część I Serwlety 35 Rozdział 2. Instalacja i konfiguracja serwera ......................................................................................37 2.1. Pobranie oraz instalacja Java Software Development Kit (SDK) .............................. 38 2.2. Pobranie serwera na lokalny komputer ................................................................ 39 2.3. Konfiguracja serwera .......................................................................................... 42 2.4. Konfiguracja serwera Tomcat .............................................................................. 43 Określanie wartości zmiennej środowiskowej JAVA_HOME ................................ 44 Określanie portu używanego przez serwer ........................................................ 45 Uaktywnianie opcji automatycznej aktualizacji serwletów .................................. 46 Uaktywnienie kontekstu głównego .................................................................. 47 Włączenie serwletu wywołującego ................................................................... 47 Powiększenie limitów pamięci dla programów DOS ........................................... 48 Określenie wartości zmiennej środowiskowej CATALINA_HOME ......................... 48 Testowanie podstawowej konfiguracji serwera ................................................. 48 4 Java Servlet i JavaServer Pages. Tom 1 2.5. Konfiguracja serwera JRun .................................................................................. 49 Numer seryjny serwera .................................................................................. 50 Ograniczenia użytkowników ............................................................................ 50 Katalog instalacyjny Javy ................................................................................ 50 Katalog instalacyjny serwera .......................................................................... 51 Nazwa i hasło administratora ......................................................................... 51 Możliwość automatycznego uruchamiania serwera ........................................... 51 Określenie portu serwera ............................................................................... 52 Testowanie podstawowej konfiguracji serwera ................................................. 53 2.6. Konfiguracja serwera Resin ................................................................................ 54 Określanie wartości zmiennej środowiskowej JAVA_HOME ................................ 54 Określenie portu używanego przez serwer Resin .............................................. 55 Testowanie podstawowej konfiguracji serwera ................................................. 55 2.7. Konfiguracja środowiska pracy ............................................................................ 55 Stworzenie katalogu roboczego ...................................................................... 56 Określanie wartości zmiennej środowiskowej CLASSPATH ................................. 57 Tworzenie skrótów ułatwiających uruchamianie i zatrzymywanie serwera ............ 58 Zapisanie adresu lub zainstalowanie dokumentacji API serwletów i JSP ............. 59 2.8. Testowanie konfiguracji ...................................................................................... 60 Sprawdzenie konfiguracji SDK ........................................................................ 60 Sprawdzenie podstawowej konfiguracji serwera ............................................... 61 Kompilacja i wdrożenie prostych serwletów ..................................................... 63 2.9. Tworzenie uproszczonej metody wdrażania ........................................................... 69 Utworzenie skrótów lub łączy symbolicznych .................................................... 70 Stosowanie opcji -d kompilatora ..................................................................... 71 Wdrażanie przy wykorzystaniu IDE ................................................................... 71 Zastosowanie programu ant lub podobnego .................................................... 72 2.10. Katalogi wdrożeniowe dla domyślnych aplikacji WWW. Podsumowanie .................. 72 Tomcat ......................................................................................................... 73 JRun ............................................................................................................ 73 Resin ........................................................................................................... 74 2.11. Aplikacje WWW — prezentacja .......................................................................... 75 Utworzenie katalogu aplikacji ......................................................................... 76 Aktualizacja zmiennej środowiskowej CLASSPATH ............................................ 77 Zarejestrowanie aplikacji WWW na serwerze .................................................... 77 Stosowanie prefiksów adresów URL ................................................................ 79 Przypisywanie serwletom niestandardowych adresów URL ................................ 81 Rozdział 3. Podstawy tworzenia serwletów .........................................................................................85 3.1. Podstawowa struktura serwletów ........................................................................ 86 3.2. Serwlet generujący zwykły tekst .......................................................................... 88 3.3. Serwlet generujący kod HTML ............................................................................. 89 3.4. Umieszczanie serwletów w pakietach .................................................................. 92 3.5. Proste narzędzia pomocne podczas tworzenia dokumentów HTML ......................... 93 3.6. Cykl istnienia serwletów ..................................................................................... 96 Metoda service ............................................................................................. 97 Metody doGet, doPost oraz doXxx ................................................................... 98 Metoda init ................................................................................................... 98 Metoda destroy ........................................................................................... 103 3.7. Interfejs SingleThreadModel ............................................................................. 104 3.8. Testowanie serwletów ...................................................................................... 108 Spis treści 5 Rozdział 4. Obsługa żądań: dane przesyłane za pomocą formularzy ...................................................111 4.1. Znaczenie informacji przesyłanych za pomocą formularzy .................................... 111 4.2. Odczytywanie danych formularzy w serwletach .................................................... 113 Odczytywanie pojedynczych wartości: metoda getParameter ............................ 113 Odczytywanie wielu wartości: metoda getParameterValues ............................. 114 Pobieranie nazw parametrów: metody getParameterNames oraz getParameterMap ........................................................................... 114 Odczytywanie nieprzetworzonych danych formularza i analiza przesyłanych plików: metody getReader oraz getInputStream ........ 115 Odczyt danych zakodowanych przy użyciu różnych zbiorów znaków: metoda setCharacterEncoding ................................................................ 116 4.3. Przykład: odczytanie trzech konkretnych parametrów ........................................... 117 4.4. Przykład: odczytanie wszystkich parametrów ...................................................... 120 4.5. Stosowanie wartości domyślnych, gdy nie podano parametru lub jego wartość jest niewłaściwa ..................................................................... 123 4.6. Filtrowanie łańcuchów w poszukiwaniu znaków specjalnych HTML ........................ 133 Implementacja filtrowania ............................................................................ 134 Przykład: serwlet wyświetlający fragmenty kodu ............................................. 136 4.7. Automatyczne zapisywanie wartości parametrów w obiektach Javy: komponenty formularzy .................................................................................... 139 Zastosowanie klasy BeanUtilities ................................................................. 142 Pobieranie i instalacja pakietów Jakarta Commons ........................................ 145 4.8. Ponowne wyświetlanie formularza w przypadku pominięcia lub błędnego podania wartości parametrów ....................................................... 146 Opcje ponownego wyświetlania formularza .................................................... 146 Serwlet obsługujący aukcje .......................................................................... 148 Rozdział 5. Obsługa żądań: nagłówki żądań HTTP ................................................................................ 155 5.1. Odczytywanie wartości nagłówków żądania w serwletach ..................................... 156 5.2. Wyświetlanie wszystkich nagłówków .................................................................. 157 5.3. Nagłówki żądań protokołu HTTP 1.1 .................................................................. 159 5.4. Przesyłanie skompresowanych stron WWW ........................................................ 164 5.5. Rozróżnianie przeglądarek różnych typów ........................................................... 167 5.6. Modyfikowanie strony w zależności od tego, skąd użytkownik na nią trafił ............ 169 5.7. Dostęp do standardowych zmiennych CGI .......................................................... 173 Odpowiedniki zmiennych CGI dostępne w serwletach ..................................... 173 Serwlet wyświetlający wartości zmiennych CGI ............................................... 176 Rozdział 6. Generowanie odpowiedzi: kody statusu HTTP ................................................................... 179 6.1. Określanie kodów statusu ................................................................................ 180 Określanie dowolnego kodu statusu: metoda setStatus ................................. 180 Stosowanie kodów statusu 302 oraz 404: metody sendRedirect oraz sendError ....................................................... 181 6.2. Kody statusu protokołu HTTP 1.1 oraz ich przeznaczenie .................................... 182 6.3. Serwlet przekierowujący użytkownika na stronę wybraną zależnie od używanej przeglądarki ..................................................................... 187 6.4. Interfejs użytkownika obsługujący różne serwisy wyszukujące .............................. 189 Rozdział 7. Generowanie odpowiedzi: nagłówki odpowiedzi HTTP ...................................................... 195 7.1. Określanie nagłówków odpowiedzi z poziomu serwletów ...................................... 195 7.2. Nagłówki odpowiedzi protokołu HTTP 1.1 oraz ich znaczenie ................................ 197 7.3. Generowanie arkuszy kalkulacyjnych programu Excel .......................................... 204 6 Java Servlet i JavaServer Pages. Tom 1 7.4. Trwałe przechowywanie stanu serwletu i automatyczne odświeżanie stron ............ 205 Znajdowanie liczb pierwszych na potrzeby systemów kryptograficznych z kluczem publicznym ............................................................................. 206 7.5. Zastosowanie serwletów do generowania obrazów JPEG ..................................... 215 Rozdział 8. Obsługa cookies ................................................................................................................. 225 8.1. Korzyści płynące ze stosowania cookies ............................................................ 225 Identyfikacja użytkowników podczas trwania sesji na witrynach zajmujących się handlem elektronicznym .............................. 226 Zapamiętywanie nazwy użytkownika i hasła ................................................... 226 Dostosowywanie witryny ............................................................................... 227 Dobór reklam .............................................................................................. 227 8.2. Niektóre problemy związane ze stosowaniem cookies ......................................... 227 8.3. Usuwanie cookies ............................................................................................ 230 8.4. Wysyłanie i odbieranie cookies ......................................................................... 230 Wysyłanie cookies do przeglądarki ................................................................ 231 Odczytywanie cookies przesyłanych przez klienta ........................................... 233 8.5. Zastosowanie cookies do wykrywania użytkowników odwiedzających stronę po raz pierwszy ................................................................................................ 234 8.6. Stosowanie atrybutów cookies .......................................................................... 236 8.7. Rozróżnianie cookies sesyjnych od trwałych ....................................................... 239 8.8. Proste narzędzia do obsługi cookies .................................................................. 242 Odnajdywanie cookie o określonej nazwie ..................................................... 242 Tworzenie cookies o długim czasie ważności ................................................. 243 8.9. Praktyczne zastosowanie klas ułatwiających obsługę cookies .............................. 244 8.10. Modyfikacja wartości cookie: śledzenie ilości odwiedzin użytkownika .................... 246 8.11. Użycie cookies do zapamiętywania preferencji użytkownika ................................. 248 Rozdział 9. Śledzenie sesji ................................................................................................................... 253 9.1. Potrzeba śledzenia sesji ................................................................................... 253 Cookies ...................................................................................................... 254 Przepisywanie adresów URL ......................................................................... 254 Ukryte pola formularzy ................................................................................. 255 Śledzenie sesji w serwletach ........................................................................ 255 9.2. Podstawowe informacje o śledzeniu sesji .......................................................... 255 Pobieranie obiektu HttpSession skojarzonego z bieżącym żądaniem ................ 256 Pobieranie informacji skojarzonych z sesją .................................................... 257 Kojarzenie informacji z sesją ........................................................................ 257 Usuwanie danych sesji ................................................................................ 258 9.3. Interfejs programowania aplikacji służący do obsługi sesji ................................... 258 9.4. Sesje przeglądarki a sesje serwera ................................................................... 260 9.5. Przepisywanie adresów URL przesyłanych do przeglądarki ................................... 261 9.6. Serwlet generujący indywidualny licznik odwiedzin dla każdego użytkownika .......... 263 9.7. Gromadzenie listy danych użytkownika ............................................................... 265 9.8. Internetowy sklep wykorzystujący koszyki i śledzenie sesji ................................... 269 Tworzenie interfejsu użytkownika .................................................................. 269 Obsługa zamówień ...................................................................................... 273 To, czego nie widać: implementacja koszyka i katalogu produktów .................. 277 Spis treści 7 Część II JavaServer Pages 285 Rozdział 10. Przegląd technologii JSP ................................................................................................. 287 10.1. Potrzeba technologii JSP ................................................................................ 288 10.2. Zalety JSP ..................................................................................................... 289 10.3. Zalety JSP w porównaniu z innymi technologiami .............................................. 290 W porównaniu z platformą .NET oraz technologią Active Server Pages (ASP) ..... 291 W porównaniu z PHP .................................................................................... 291 W porównaniu z serwletami .......................................................................... 291 W porównaniu z językiem JavaScript ............................................................. 292 W porównaniu z WebMacro oraz Velocity ....................................................... 292 10.4. Błędne opinie dotyczące JSP ........................................................................... 293 Ignorowanie faktu, że JSP jest technologią działającą po stronie serwera ......... 293 Mylenie czasu przekształcania z czasem żądania ........................................... 294 Przypuszczenie, że wystarczy znajomość i stosowanie samej technologii JSP ... 295 Przypuszczenie, że wystarczy znajomość i stosowanie samych serwletów ......... 296 10.5. Instalacja stron JSP ....................................................................................... 296 Katalogi JSP na serwerze Tomcat (domyślna aplikacja WWW) ......................... 297 Katalogi JSP na serwerze JRun (domyślna aplikacja WWW) ............................. 297 Katalogi JSP na serwerze Resin (domyślna aplikacja WWW) ............................ 297 10.6. Podstawowa składnia JSP .............................................................................. 298 Tekst HTML ................................................................................................ 298 Komentarze HTML ....................................................................................... 298 Tekst szablonu ............................................................................................ 298 Komentarze JSP .......................................................................................... 299 Wyrażenia JSP ............................................................................................. 299 Skryptlet ..................................................................................................... 299 Deklaracja JSP ............................................................................................ 299 Dyrektywa JSP ............................................................................................. 300 Akcja JSP ................................................................................................... 300 Element Języka Wyrażeń JSP ........................................................................ 300 Znacznik niestandardowy (akcja niestandardowa) .......................................... 300 Zabezpieczony tekst szablonu ...................................................................... 301 Rozdział 11. Wywoływanie kodu Javy przy użyciu elementów skryptowych JSP ........................... 303 11.1. Tworzenie tekstu szablonu .............................................................................. 303 11.2. Wywoływanie kodu Javy w stronach JSP ........................................................... 304 Typy elementów skryptowych JSP .................................................................. 305 11.3. Ograniczanie ilości kodu umieszczanego na stronach JSP ................................. 305 Znaczenie stosowania pakietów ................................................................... 307 11.4. Stosowanie wyrażeń JSP ................................................................................ 309 Zmienne predefiniowane .............................................................................. 309 Te same rozwiązania w serwletach i stronach JSP .......................................... 309 Zapis wyrażeń przy użyciu składni XML .......................................................... 311 11.5. Przykład: wyrażenia JSP .................................................................................. 311 11.6. Porównanie serwletów i stron JSP ................................................................... 313 11.7. Pisanie skryptletów ........................................................................................ 315 Te same rozwiązania w serwletach i stronach JSP .......................................... 316 Składnia XML do zapisu skryptletów ............................................................. 317 11.8. Przykład skryptletu ......................................................................................... 317 11.9. Zastosowanie skryptletów do warunkowego wykonywania fragmentów stron JSP ... 319 8 Java Servlet i JavaServer Pages. Tom 1 11.10. Stosowanie deklaracji .................................................................................... 321 Te same rozwiązania w serwletach i stronach JSP .......................................... 322 Składnia XML do zapisu deklaracji ................................................................ 323 11.11. Przykład zastosowania deklaracji ..................................................................... 323 11.12. Stosowanie zmiennych predefiniowanych ......................................................... 325 11.13. Porównanie wyrażeń JSP, deklaracji oraz skryptletów ........................................ 327 Przykład 1.: wyrażenia JSP ........................................................................... 328 Przykład 2.: skryptlety .................................................................................. 328 Przykład 3.: deklaracje JSP .......................................................................... 330 Rozdział 12. Dyrektywa page: strukturalizacja generowanych serwletów .................................... 333 12.1. Atrybut import ................................................................................................ 334 12.2. Atrybuty contentType oraz pageEncoding .......................................................... 337 Generowanie arkuszy kalkulacyjnych programu Microsoft Excel ....................... 337 12.3. Warunkowe generowanie arkuszy kalkulacyjnych programu Microsoft Excel ......... 338 12.4. Atrybut session ............................................................................................. 341 12.5. Atrybut isELIgnored ........................................................................................ 341 12.6. Atrybuty buffer oraz autoFlush ......................................................................... 342 12.7. Atrybut info ................................................................................................... 343 12.8. Atrybuty errorPage oraz isErrorPage ................................................................. 343 12.9. Atrybut isThreadSafe ...................................................................................... 346 12.10. Atrybut extends .............................................................................................. 347 12.11. Atrybut language ............................................................................................ 348 12.12. Składnia XML zapisu dyrektyw ......................................................................... 348 Rozdział 13. Dołączanie plików i apletów do dokumentów JSP .......................................................... 349 13.1. Dołączanie plików podczas obsługi żądań: znacznik akcji jsp:include .................. 350 Atrybut page: określanie dołączanej strony .................................................... 350 Składnia XML a znacznik akcji jsp:include ..................................................... 352 Atrybut flush ............................................................................................... 352 Strona z najnowszymi doniesieniami ............................................................. 352 Element jsp:param: uzupełnianie parametrów żądania .................................... 354 13.2. Dołączanie plików w czasie przekształcania strony ............................................ 355 Problemy z utrzymaniem kodu w przypadku stosowania dyrektywy include ........ 356 Dodatkowe możliwości, jakie daje dyrektywa include ...................................... 357 Aktualizacja strony głównej ........................................................................... 357 Zapis dyrektywy include w postaci elementu XML ........................................... 358 Przykład: wielokrotne stosowanie stopki ........................................................ 358 13.3. Przekazywanie żądań przy użyciu znacznika akcji jsp:forward ............................. 360 13.4. Dołączanie apletów związanych z Java Plug-In ................................................... 361 Element jsp:plugin ....................................................................................... 363 Elementy jsp:param oraz jsp:params ............................................................ 365 Element jsp:fallback .................................................................................... 365 Przykład zastosowania znacznika jsp:plugin ................................................... 366 Rozdział 14. Zastosowanie komponentów JavaBean w dokumentach JSP ........................................ 371 14.1. Dlaczego warto stosować komponenty? ........................................................... 371 14.2. Czym są komponenty? ................................................................................... 372 14.3. Podstawowe sposoby użycia komponentów ...................................................... 374 Tworzenie komponentów: jsp:useBean .......................................................... 374 Instalacja klas komponentów ....................................................................... 375 Spis treści 9 Stosowanie atrybutów znacznika akcji jsp:useBean: scope, beanName oraz type .................................................................... 375 Dostęp do właściwości komponentów: jsp:getProperty ................................... 376 Podstawowy sposób określania wartości właściwości: jsp:setProperty ............. 377 14.5. Określanie wartości właściwości komponentów: techniki zaawansowane ............ 380 Kojarzenie właściwości z parametrami wejściowymi ........................................ 384 Kojarzenie wszystkich właściwości z parametrami wejściowymi ....................... 385 14.6. Współużytkowanie komponentów .................................................................... 386 Warunkowe tworzenie komponentów ............................................................. 387 14.7. Współużytkowanie komponentów na cztery różne sposoby — przykład ............... 390 Tworzenie komponentu oraz testera komponentów ........................................ 391 Zastosowanie atrybutu scope= page — komponent nie jest współużytkowany 392 Współużytkowanie komponentu w obrębie żądania ......................................... 393 Współużytkowanie komponentu w obrębie sesji ............................................. 396 Współużytkowanie komponentu w obrębie aplikacji ........................................ 398 Rozdział 15. Integracja serwletów i JSP: architektura model-widok-kontroler (MVC) ................... 401 15.1. Potrzeba stosowania architektury MVC ............................................................ 401 Szkielety MVC ............................................................................................. 403 Architektura czy podejście? .......................................................................... 403 15.2. Implementacja architektury MVC przy użyciu interfejsu RequestDispatcher ......... 403 Definiowanie komponentów reprezentujących dane ........................................ 404 Tworzenie serwletów obsługujących żądania .................................................. 404 Zapis danych w komponentach ..................................................................... 405 Zapis wyników ............................................................................................. 405 Przekazywanie żądania na stronę JSP ........................................................... 406 Pobieranie danych z komponentów ............................................................... 408 15.3. Podsumowanie kodu architektury MVC ............................................................ 409 Przechowywanie współużytkowanych danych w obiekcie żądania ..................... 409 Przechowywanie współużytkowanych danych w obiekcie sesji .......................... 409 Przechowywanie współużytkowanych danych w obiekcie aplikacji ..................... 410 15.4. Interpretacja adresów URL na stronie docelowej ............................................... 410 15.5. Stosowanie architektury MVC: dostęp do stanu konta bankowego ..................... 411 15.6. Porównanie trzech sposobów współużytkowania danych .................................... 417 Współużytkowanie danych przy użyciu obiektu żądania ................................... 418 Współużytkowanie danych przy użyciu obiektu sesji ........................................ 419 Współużytkowanie danych przy użyciu kontekstu serwletu ............................... 422 15.7. Przekazywanie żądań ze stron JSP ................................................................... 424 15.8. Dołączanie stron ............................................................................................ 425 Rozdział 16. Upraszczanie dostępu do kodu Javy: język wyrażeń JSP 2.0 ...................................... 427 16.1. Cele stosowania języka wyrażeń ...................................................................... 427 16.2. Stosowanie języka wyrażeń ............................................................................. 429 Oznaczanie znaków specjalnych ................................................................... 430 16.3. Zapobieganie przetwarzaniu wyrażeń EL ........................................................... 430 Wyłączanie obsługi języka wyrażeń w całej aplikacji ........................................ 430 Wyłączanie obsługi języka wyrażeń na wielu stronach JSP ............................... 431 Wyłączanie obsługi języka wyrażeń na konkretnych stronach JSP ..................... 431 Wyłączanie obsługi konkretnych instrukcji języka wyrażeń ............................... 432 16.4. Uniemożliwianie stosowania zwyczajnych elementów skryptowych ...................... 432 10 Java Servlet i JavaServer Pages. Tom 1 16.5. Odwołania do zmiennych dostępnych w określonym zakresie ............................. 433 Wybór nazw atrybutów ................................................................................. 434 Przykład ...................................................................................................... 434 16.6. Dostęp do właściwości komponentów .............................................................. 436 Równoważność notacji kropkowej oraz notacji charakterystycznej dla tablic ...... 437 Przykład ...................................................................................................... 438 16.7. Dostęp do zawartości kolekcji ......................................................................... 441 Przykład ...................................................................................................... 441 16.8. Odwołania do obiektów niejawnych .................................................................. 443 Przykład ...................................................................................................... 445 16.9. Stosowanie operatorów języka wyrażeń ............................................................ 446 Operatory arytmetyczne ............................................................................... 446 Operatory relacyjne ...................................................................................... 447 Operatory logiczne ....................................................................................... 448 Operator empty ........................................................................................... 448 Przykład ...................................................................................................... 448 16.10. Warunkowe przetwarzanie wyrażeń .................................................................. 450 Przykład ...................................................................................................... 451 16.11. Informacje o innych możliwościach języka wyrażeń ............................................ 453 Część III Technologie pomocnicze 455 Rozdział 17. Obsługa baz danych przy użyciu JDBC ........................................................................... 457 17.1. Podstawowe sposoby stosowania JDBC ........................................................... 458 Załadowanie sterownika .............................................................................. 459 Określenie adresu URL połączenia ................................................................ 461 Nawiązanie połączenia ................................................................................. 461 Utworzenie polecenia ................................................................................... 462 Wykonanie zapytania ................................................................................... 462 Przetworzenie wyników ................................................................................. 463 Zamknięcie połączenia ................................................................................ 466 17.2. Prosty przykład wykorzystania JDBC ................................................................. 466 17.3. Narzędzia JDBC ułatwiające korzystanie z baz danych ....................................... 472 17.4. Stosowanie poleceń przygotowanych ............................................................... 483 17.5. Tworzenie poleceń wywoływanych .................................................................... 487 Zdefiniowanie wywołania procedury zachowanej ............................................. 488 Przygotowanie obiektu CallableStatement reprezentującego procedurę ............ 488 Zarejestrowanie typów parametrów wyjściowych ............................................. 489 Podanie wartości parametrów wejściowych .................................................... 489 Wykonanie procedury zachowanej ................................................................. 489 Pobranie parametrów wyjściowych ................................................................ 489 Przykład ...................................................................................................... 490 17.6. Stosowanie transakcji .................................................................................... 493 17.7. Odwzorowywanie danych na obiekty przy użyciu szkieletów ORM ........................ 497 Rozdział 18. Konfiguracja baz danych MS Access, MySQL oraz Oracle9i ......................................... 505 18.1. Konfiguracja programu Microsoft Access do współpracy z JDBC ......................... 506 Wybór systemowej nazwy źródła danych w programie Administrator źródeł danych ODBC ........................................ 507 Wybór sterownika dla DSN ........................................................................... 507 Wybór źródła danych .................................................................................... 508 Zaakceptowanie nowego DSN ...................................................................... 509 Spis treści 11 18.2. Instalacja i konfiguracja serwera MySQL .......................................................... 509 Pobieranie i instalacja serwera MySQL .......................................................... 510 Tworzenie bazy danych ................................................................................ 510 Tworzenie użytkownika ................................................................................. 511 Instalacja sterownika JDBC .......................................................................... 511 18.3. Instalacja i konfiguracja serwera Oracle9i ........................................................ 512 Pobieranie i instalacja Oracle9i .................................................................... 514 Tworzenie bazy danych ................................................................................ 522 Tworzenie bazy danych przy użyciu programu Configuration Assistant .............. 522 Ręczne tworzenie bazy danych ...................................................................... 528 Utworzenie użytkownika ............................................................................... 535 Instalacja sterownika JDBC .......................................................................... 535 18.4. Testowanie bazy danych przy wykorzystaniu połączenia JDBC ............................ 536 18.5. Tworzenie tabeli music ................................................................................... 543 Tworzenie tabeli music przy użyciu programu CreateMusicTable.java ............... 543 Tworzenie tabeli music przy użyciu skryptu create_music_table.sql .................. 546 Rozdział 19. Tworzenie i przetwarzanie formularzy HTML ............................................................... 549 Domyślna aplikacja WWW: Tomcat ............................................................... 549 Domyślna aplikacja WWW: JRun ................................................................... 550 Domyślna aplikacja WWW: Resin .................................................................. 550 19.1. Jak przesyłane są dane z formularzy HTML ...................................................... 550 19.2. Element FORM .............................................................................................. 554 19.3. Tekstowe elementy sterujące .......................................................................... 560 Pola tekstowe ............................................................................................. 560 Pola hasła .................................................................................................. 562 Wielowierszowe pola tekstowe ..................................................................... 563 19.4. Przyciski ........................................................................................................ 564 Przycisk SUBMIT ......................................................................................... 565 Przyciski RESET ........................................................................................... 567 Przyciski JavaScript ..................................................................................... 568 19.5. Pola wyboru i przyciski opcji ............................................................................ 569 Pola wyboru ................................................................................................ 569 Przyciski opcji ............................................................................................. 570 19.6. Listy i listy rozwijane ...................................................................................... 572 19.7. Element sterujący służący do przesyłania plików ............................................... 576 19.8. Mapy odnośników obsługiwane na serwerze ..................................................... 578 IMAGE — standardowe mapy odnośników obsługiwane po stronie serwera ...... 579 ISMAP — alternatywny sposób tworzenia map odnośników obsługiwanych po stronie serwera ................................................................................. 580 19.9. Pola ukryte .................................................................................................... 582 19.10. Grupowanie elementów sterujących ................................................................. 583 19.11. Określanie kolejności poruszania się pomiędzy elementami formularzy .............. 585 19.12. Testowy serwer WWW ..................................................................................... 586 EchoServer ................................................................................................. 586 Dodatki 593 Dodatek A Organizacja i struktura serwera ...................................................................................... 595 Skorowidz ............................................................................................................................................. 609 16 Upraszczanie dostępu do kodu Javy: język wyrażeń JSP 2.0 Specyfikacja JSP 2.0 wprowadza uproszczony język służący do przetwarzania i wyświetlania wartości obiektów Javy przechowywanych w standardowych „miejscach”. Ten język wy- rażeń (ang. Expression Language, nazywany także skrótowo „EL”) jest jedną z najważniej- szych nowych możliwości, które pojawiły się w specyfikacji JSP 2.0; kolejną jest możliwość tworzenia znaczników niestandardowych przy użyciu kodu JSP, a nie kodu Javy (zagadnie- nia związane z tworzeniem znaczników niestandardowych zostały opisane w II tomie niniejszej książki). Języka wyrażeń nie można stosować na serwerach zgodnych ze specyfikacją JSP w wersji 1.2 lub wcześniejszą. 16.1. Cele stosowania języka wyrażeń Zgodnie z informacjami podanymi na rysunku 16.1, strona JSP może używać kodu napisa- nego w języku Java na kilka różnych sposobów. Jednym z najlepszych i najbardziej ela- stycznych rozwiązań jest architektura MVC (opisana w rozdziale 15.). W tym rozwiązaniu na żądanie przesłane przez klienta odpowiada serwlet. Wywołuje on następnie kod imple- mentujący logikę biznesową lub realizujący operacje na bazie danych, umieszcza wyniko- we dane w komponentach, które z kolei są zapisywane w obiekcie żądania, sesji lub kon- tekście serwletu; w końcu serwlet wywołuje stronę JSP, której zadaniem jest przedstawienie wyników. Jedyną częścią tego rozwiązania, która utrudnia jego stosowanie, jest ostatnia wykonywana czynność: wyświetlenie wyników na stronie JSP. Zazwyczaj do tego celu są stosowane znaczniki akcji jsp:useBean oraz jsp:getProperty; jednak kod, jaki należy stworzyć, by ich użyć, jest dosyć rozbudowany i niewygodny. Co więcej, znacznik jsp:getProperty po zwala 428 Część II (cid:81) JavaServer Pages Rysunek 16.1. Strategie wywoływania dynamicznego kodu ze stron JSP jedynie na pobieranie wartości prostych właściwości; jeśli właściwość jest kolekcją lub in- nym komponentem, to odczytanie jej wartości wymaga zastosowania złożonego wyrażenia napisanego w Javie (a przecież zastosowanie architektury MVC ma na celu uniknięcie ta- kiej konieczności). Język wyrażeń JSP 2.0 pozwala na uproszczenie warstwy prezentacji aplikacji WWW, po- przez zastąpienie trudnego do utrzymania kodu składającego się z elementów skryptowych JSP lub znaczników akcji jsp:useBean oraz jsp:getProperty znacznie krótszymi i bardziej przejrzystymi wyrażeniami o postaci: ${wyrażenie} Konkretnie rzecz biorąc, język wyrażeń zapewnia następujące możliwości: (cid:81) Zwięzły sposób dostępu do zapisanych obiektów. W celu wyświetlenia zmiennej o nazwie sprzedazWartosc dostępnej w określonym zakresie (czyli obiektu zapamiętanego poprzez wywołanie metody setAttribute obiektów PageContext, HttpServletRequest, HttpSession lub ServletContext), można użyć wyrażenia o postaci ${sprzedazWartosc}. Patrz podrozdział 16.5 (cid:81) Uproszczony zapis odwołań do właściwości komponentów. Aby wyświetlić właściwość nazwaFirmy (na przykład wynik zwracany przez metodę getNazwaFirmy) innej zmiennej dostępnej w określonym zakresie, należy posłużyć się wyrażeniem ${firma.nazwaFirmy}. Podobnie, aby odczytać właściwość imie obiektu dostępnego jako właściwość prezes obiektu firma przechowywanego w zmiennej dostępnej w określonym zakresie, należałoby użyć wyrażenia o postaci ${firma.prezes.imie). Patrz podrozdział 16.6. (cid:81) Uproszczony dostęp do elementów kolekcji. Do odczytywania wartości elementów list, zawartości obiektów List oraz Map służą wyrażenia o postaci: ${zmienna[indeksLubKlucz]}. Jeśli indeks lub klucz ma postać, jaką w języku Java muszą przybierać zmienne, to oprócz zapisu wykorzystującego nawiasy kwadratowe, można także zastosować standardową postać odwołań do właściwości komponentów. Patrz podrozdział 16.7. Rozdział 16. (cid:81) Upraszczanie dostępu do kodu Javy: język wyrażeń JSP 2.0 429 (cid:81) Zwięzły dostęp do parametrów żądania, cookies oraz innych danych przesyłanych w żądaniu. W celu uzyskania dostępu do standardowych rodzajów informacji przesyłanych w żądaniu, można posłużyć się kilkoma predefiniowanymi, niejawnymi obiektami. Patrz podrozdział 16.8. (cid:81) Niewielki, lecz użyteczny zbiór prostych operatorów. Możliwe jest wykonywanie operacji na obiektach używanych w wyrażeniach EL. Do tego celu służy kilka operatorów arytmetycznych, relacyjnych i logicznych oraz operator sprawdzający, czy została określona wartość właściwości. (cid:81) Prezentację warunkową. W celu wybrania jednej z opcji prezentacji, nie trzeba już stosować elementów skryptowych. Zamiast tego można użyć konstrukcji o postaci ${test ? wartosc1 : wartosc2}. Patrz podrozdział 16.10. (cid:81) Automatyczną konwersję typów. Dzięki językowi wyrażeń nie trzeba stosować większości operacji rzutowania typów oraz konwersji łańcuchów znaków na liczby. (cid:81) Zastosowanie pustych wartości zamiast komunikatów o błędach. W większości przypadków brak wartości parametru wejściowego lub zgłoszenie wyjątku NullPointerException powoduje zastosowanie pustego łańcucha znaków, a nie zgłoszenie wyjątku. 16.2. Stosowanie języka wyrażeń W JSP 2.0 język wyrażeń jest „wywoływany” w przypadku zastosowania elementu o na- stępującej postaci: ${wyrażenie} Elementy EL można umieszczać w zwyczajnym tekście, bądź też w atrybutach znaczników JSP (zakładając, że można w nich umieszczać standardowe wyrażenia JSP. Oto przykład: UL LI Imię: ${wyrażenie} LI Adres: ${wyrażenie2} /UL jsp:include page= ${expression} / W przypadku stosowania języka wyrażeń w atrybutach znaczników, można w nich umieszczać większą liczbę wyrażeń (a nawet umieszczać pomiędzy wyrażeniami fragmenty tekstu) — takie wyrażenia zostaną przetworzone do postaci łańcucha znaków, a wszystkie te łańcuchy połączone. Na przykład: jsp:include page= ${wyrażenie1}NieNieNie${wyrażenie1} / W niniejszym rozdziale zostało przedstawione zastosowanie języka wyrażeń w zwyczaj- nym tekście. Natomiast w II tomie książki podano informacje o stosowaniu elementów EL w atrybutach samodzielnie tworzonych znaczników niestandardowych oraz znaczników wchodzących w skład bibliotek JSTL (ang. JSP Standard Tag Library) i JSF (ang. Java- Server Faces). 430 Część II (cid:81) JavaServer Pages Oznaczanie znaków specjalnych Jeśli się zdarzy, że w tekście strony JSP musi się pojawić łańcuch znaków ${, to należy go zapisać jako ${. Jeśli w wyrażeniu EL należy umieścić apostrof lub znaku cudzysłowu, należy je zapisywać w postaci: oraz . 16.3. Zapobieganie przetwarzaniu wyrażeń EL W specyfikacji JSP 1.2 oraz wcześniejszych, łańcuchy znaków o postaci ${...} nie miały żadnego szczególnego znaczenia. A zatem może się zdarzyć, iż w poprawnych stronach JSP, które obecnie zaczęły być używane na serwerze obsługującym JSP 2.0, pojawią się łańcuchy znaków ${. W takim przypadku należy wyłączyć na stronie obsługę języka wyrażeń. Można to zrobić na cztery sposoby: (cid:81) Wyłączając obsługę języka wyrażeń w całej aplikacji WWW. Można to zrobić w pliku web.xml definiującym serwlety zgodne ze specyfikacją JavaServlet w wersji 2.3 (JSP 1.2) lub wcześniejszej. Szczegółowe informacje na ten temat podano w kolejnym punkcie rozdziału. (cid:81) Wyłączając obsługę języka wyrażeń na wielu stronach JSP. Wybrane strony można wskazać w elemencie jsp-property-group umieszczanym w pliku web.xml. To rozwiązanie opisano w drugim kolejnym punkcie rozdziału. (cid:81) Wyłączając obsługę języka wyrażeń na pojedynczych stronach JSP. Do tego celu służy atrybut isELEnabled dyrektywy page. Więcej informacji na ten temat podano w trzecim kolejnym punkcie rozdziału. (cid:81) Wyłączając pojedyncze instrukcje języka wyrażeń. Jeśli strony JSP tworzone zgodnie ze specyfikacją 1.2 muszą być przenoszone w oryginalnej postaci (bez wprowadzania jakichkolwiek modyfikacji w pliku web.xml) na serwery obsługujące nowsze wersje specyfikacji JSP, to wszystkie znaki $ występujące w normalnym tekście można zastąpić symbolem HTML o postaci #36;. W stronach JSP tworzonych zgodnie ze specyfikacją JSP 2.0, zawierających zarówno wyrażenia EL, jak i znaki $ występujące w normalnym tekście, łańcuchy znaków ${, które mają być traktowane dosłownie, należy zapisywać jako ${. Należy pamiętać, iż powyższe rozwiązania są konieczne wyłącznie w przypadkach, gdy strona zawiera łańcuch znaków o postaci ${. Wyłączanie obsługi języka wyrażeń w całej aplikacji Język wyrażeń JSP 2.0 jest automatycznie wyłączany w aplikacjach WWW, których de- skryptor rozmieszczenia (czyli plik /WEB-INF/web.xml) odwołuje się do specyfikacji ser- wletów w wersji 2.3 lub wcześniejszej (czyli JSP 1.2 lub wcześniejszej). Zagadnienia zwią- zane z plikami web.xml zostały szczegółowo opisane w II tomie książki, jednak krótkie informacje na ich temat można znaleźć w podrozdziale 2.11 („Aplikacje WWW — pre- zentacja”). Na przykład, poniższy pusty (lecz całkowicie poprawny) plik web.xml jest Rozdział 16. (cid:81) Upraszczanie dostępu do kodu Javy: język wyrażeń JSP 2.0 431 zgodny ze specyfikacją JSP 1.2, a zatem oznacza, że język wyrażeń powinien zostać do- myślnie wyłączony w całej aplikacji. ?xml version= 1.0 encoding= ISO-8859-1 ? !DOCTYPE web-app PUBLIC -//Sun Microsystems, Inc.//DTD Web Application 2.3//EN http://java.sun.com/dtd/web-app_2_3.dtd web-app /web-app Z kolei poniższy plik web.xml jest zgodny ze specyfikacją JSP 2.0, co sprawia, że język wyrażeń będzie domyślnie włączony. (Oba pliki XML można znaleźć w archiwum przy- kładów zamieszczonych w niniejszej książce, dostępnym pod adresem ftp://ftp.helion.pl/ przyklady/jsjsp1.zip). ?xml version= 1.0 encoding= ISO-8859-1 ? web-app xmlns= http://java.sun.com/xml/ns/j2ee xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation= http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd version= 2.4 /web-app Wyłączanie obsługi języka wyrażeń na wielu stronach JSP W aplikacjach WWW, których deskryptor rozmieszczenia informuje, że aplikacja jest two- rzona zgodnie ze specyfikacją 2.4 (JSP 2.0), istnieje możliwość określenia grupy stron, na jakich język wyrażeń powinien być ignorowany. Służy do tego element jsp-property-group oraz jego atrybut el-ignored. Poniższy, przykładowy plik web.xml pokazuje, w jaki sposób można wyłączyć obsługę języka wyrażeń we wszystkich stronach JSP umieszczonych w katalogu stareWersje: ?xml version= 1.0 encoding= ISO-8859-1 ? web-app xmlns= http://java.sun.com/xml/ns/j2ee xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation= http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd version= 2.4 jsp-property-group url-pattern /stareWersje/*.jsp /url-pattern el-ignored true /el-ignored /jsp-property-group /web-app Element jsp-property-group został szczegółowo opisany w II tomie niniejszej książki. Wyłączanie obsługi języka wyrażeń na konkretnych stronach JSP Aby wyłączyć obsługę języka wyrażeń na konkretnej stronie JSP, atrybutowi isELEnabled dyrektywy page należy przypisać wartość false: @ page isELEnabled= false 432 Część II (cid:81) JavaServer Pages Należy zauważyć, iż atrybut isELEnabled został wprowadzony w specyfikacji JSP 2.0, a za- stosowanie go w aplikacjach zgodnych ze specyfikacją JSP 1.2 zostanie potraktowane jako błąd. Nie można zatem wykorzystać tej metody, by zapewnić poprawne działanie stron JSP na nowszych i starszych serwerach, bez konieczności wprowadzania żadnych zmian w ich kodzie. Dlatego też zastosowanie elementu jsp-property-group jest zazwyczaj lepszym rozwiązaniem niż stosowanie atrybutu isELEnabled. Wyłączanie obsługi konkretnych instrukcji języka wyrażeń Wyobraźmy sobie, że istnieje pewna strona JSP tworzona zgodnie ze specyfikacją JSP 1.2, w której pojawia się łańcuch znaków ${. Tę stronę należy zastosować w wielu miejscach, w tym także w aplikacjach tworzonych zgodnie ze specyfikacją JSP 1.2, oraz aplikacjach zawierają- cych strony, na których jest stosowany język wyrażeń. Co więcej, musi istnieć możliwość używania tej strony w dowolnych aplikacjach, i to bez wprowadzania jakichkolwiek modyfikacji zarówno w kodzie samej strony, jak i w kodzie pliku web.xml. Choć taki scenariusz jest ra- czej mało prawdopodobny, to jednak może się zdarzyć, a żadne z rozwiązań przedstawionych wcześniej nie zapewnia takich możliwości. W takim przypadku wystarczy zamienić znaki $ występujące w kodzie strony na symbole HTML reprezentujące ten znak. Innymi słowy, każdy umieszczony w kodzie strony łańcuch znaków ${ należy zastąpić łańcuchem #36;{. Na przykład, łańcuch znaków: #36;{uhaha} zostanie zapewne wyświetlony w postaci: ${uhaha} Należy jednak pamiętać, iż te symbole HTML są zamieniane na odpowiednie znaki (w tym przypadku na znak $) przez przeglądarkę, a nie przez serwer. A zatem rozwiązanie to można stosować wyłącznie w przypadku generowania kodu HTML, który będzie interpretowany i wyświetlany w przeglądarce WWW. A co zrobić w przypadku strony JSP tworzonej zgodnie ze specyfikacją JSP 2.0, na której używany jest zarówno język wyrażeń, jak i łańcuchy znaków ${? W takich sytuacjach przed znakami $, które mają być wyświetlone w niezmienionej postaci, należy zapisać znak lewego ukośnika. Na przykład: ${1+1} to ${1+1} zostanie wyświetlone jako: ${1+1} to 2 16.4. Uniemożliwianie stosowania zwyczajnych elementów skryptowych Język wyrażeń JSP zapewnia zwarty i przejrzysty sposób dostępu do obiektów Javy prze- chowywanych w standardowych „miejscach”. Możliwość ta sprawia, że w znacznej mierze można zrezygnować ze stosowania jawnych elementów skryptowych opisanych w rozdziale 11. Rozdział 16. (cid:81) Upraszczanie dostępu do kodu Javy: język wyrażeń JSP 2.0 433 W rzeczywistości, niektóry programiści decydują się nawet na całkowitą rezygnację ze sto- sowania takich standardowych elementów skryptowych. W takim przypadku można użyć elementu scripting-invalid umieszczanego wewnątrz elementu jsp-propety-group, który sprawia, że zastosowanie standardowego elementu skryptowego zostanie potraktowane jako błąd. Poniższy plik web.xml przedstawia przykład zastosowania tego elementu: ?xml version= 1.0 encoding= ISO-8859-1 ? web-app xmlns= http://java.sun.com/xml/ns/j2ee xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation= http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd version= 2.4 jsp-property-group url-pattern *.jsp /url-pattern scripting-invalid true /scripting-invalid /jsp-property-group /web-app 16.5. Odwołania do zmiennych dostępnych w określonym zakresie W przypadku stosowania architektury MVC (opisanej w rozdziale 15.) serwlet wywołuje kod, który tworzy dane, a następnie przekazuje obsługę żądania do odpowiedniej strony JSP używając do tego celu metod RequestDispatcher.forward lub response.sendRedirect. Aby strona JSP mogła uzyskać dostęp do tych danych, serwlet musi zapisać je przy użyciu metody setAttribute w jednym ze standardowych „miejsc”: obiekcie HttpServletRequest, obiekcie HttpSession lub obiekcie ServletContext. Obiekty zapisane w tych „miejscach” są nazywane „zmiennymi dostępnymi w określonym zakresie” (ang. scoped variables), a język wyrażeń JSP 2.0 zapewnia możliwość łatwego i szyb- kiego dostępu do nich. Takie zmienne można także zapisywać w obiektach PageContext, jednak to rozwiązanie jest znacznie mniej użyteczne, gdyż obiekty PageContext nie są współużytkowane przez serwlety i strony JSP. A zatem zmienne dostępne w zakresie strony reprezentują jedynie obiekty zapisane wcześniej na tej samej stronie JSP, a nie obiekty zapi- sane przez serwlet. Aby wyświetlić zawartość zmiennej dostępnej w pewnym zakresie, należy podać jej nazwę w elemencie języka wyrażeń. Na przykład, wyrażenie: ${nazwa} oznacza, że należy przeszukać obiekty PageContext, HttpServletRequest, HttpSession oraz ServletContext (dokładnie w podanej kolejności), w poszukiwaniu atrybutu o nazwie na- zwa. Jeśli uda się odnaleźć atrybut, to wywoływana jest jego metoda toString, a uzyskany w ten sposób łańcuch znaków jest zwracany jako wartość wyrażenia. A zatem poniższe dwa wyrażenia zwrócą identyczne wyniki: ${nazwa} = pageContext.findAttribute( nazwa ) 434 Część II (cid:81) JavaServer Pages Jak widać, drugie z przedstawionych wyrażeń jest znacznie dłuższe, a co gorsza, wymaga jawnego zastosowania kodu napisanego w języku Java. Istnieje co prawda możliwość wy- eliminowania kodu Javy, jednak w efekcie trzeba użyć jeszcze bardziej rozbudowanego znacznika akcji jsp:useBean: jsp:useBean id= nazwa type= jakisPakiet.JakasKlasa scope= ... = nazwa Poza tym, w przypadku stosowania znacznika jsp:useBean należy wiedzieć, w jakim zakresie została zapisana zmienna, oraz znać pełną nazwę jej klasy. Stanowi to dosyć duży problem, zwłaszcza jeśli tworzeniem stron JSP nie zajmuje się autor serwletu, lecz inna osoba. Wybór nazw atrybutów Przy stosowaniu języka wyrażeń do operowania na zmiennych dostępnych w określonych zakresach, nazwy tworzonych atrybutów muszą być zgodne ze wszystkimi zasadami okre- ślającymi dopuszczalną postać nazw zmiennych w języku Java
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java Servlet i JavaServer Pages. Tom 1. 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ą: