Zastosuj platformę Java 2 do tworzenia
Zainstaluj i skonfiguruj serwery aplikacji
Poznaj zasady tworzenia serwletów i dokumentów JSP
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.
Instalacja i konfiguracja serwera Tomcat, JRun i Resin
Zasady tworzenia serwletów
Obsługa protokołu HTTP oraz danych z formularzy HTML
Generowanie plików XLS
Śledzenie sesji i stosowanie plików cookie
Podstawy stosowania JSP
Wykorzystywanie komponentów JavaBean
Architektura MVC
Połączenie z bazami danych za pomocą JDBC
Napisz wydajne i stabilne aplikacje internetowe,
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)
