Upload
wydawnictwo-helion
View
1.315
Download
0
Embed Size (px)
DESCRIPTION
Kompendium wiedzy dla profesjonalnych programistów serwisów internetowych.Książka zawiera komplet informacji niezbędnych twórcom zaawansowanych aplikacji sieciowych i opisuje: HTML 4, Java Standard Edition 1.3, serwlety, JavaServer Pages i wiele innych technologii. "Serwisy internetowe. Programowanie" łączy te technologie pokazując, jak przy ich pomocy tworzyć profesjonalne systemy.HTML 4: Dogłębny, praktyczny opis struktury dokumentu HTML, jego elementów, ramek i styli kaskadowych.Java 2: Podstawy składni, projektowanie zorientowane obiektowo, aplety, tworzenie animacji, narzędzie Java PlugIn, tworzenie interfejsu użytkownika (Swing), Java 2D API, aplikacje wielowątkowe, programowanie sieciowe, korzystanie z baz danych i jeszcze więcej.Technologie serwerowe Javy: Serwlety, JSP, XML, JDBC – fundamentalne technologie umożliwiające budowę aplikacji w Javie. Tematy zaawansowane dotyczą tworzenia własnych bibliotek znaczników JSP, łączenia serwletów z JSP (MVC), tworzenie puli połączeń do baz danych, SAX, DOM i XSLT. Dokładnie omówiono także HTTP 1.1.JavaScript: Dynamiczne tworzenie zawartości stron WWW, śledzenie zachowania użytkownika, sprawdzanie poprawności danych w formularzach HTML. Dołączono podręczny skorowidz komend.Pierwsze wydanie tej książki jest używane jako podręcznik na takich uczelniach jak MIT, Standford, UC Berkeley, UCLA, Princeton i John Hopkins. Książka, którą trzymasz w ręku, została zaktualizowana i uzupełniona o najnowsze technologie oraz towarzyszące im przykłady gotowego kodu. * Światowy bestseller -- aktualne kompendium dla zaawansowanychprogramistów serwisów WWW * Dogłębny opis HTML 4, CSS, Javy 2, serwletów, JavaServer Pages i XML * Przykłady kodu używanego przez profesjonalistów
Citation preview
Wydawnictwo Helionul. Chopina 644-100 Gliwicetel. (32)230-98-63e-mail: [email protected]
PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£
IDZ DOIDZ DO
ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG
KATALOG KSI¥¯EKKATALOG KSI¥¯EK
TWÓJ KOSZYKTWÓJ KOSZYK
CENNIK I INFORMACJECENNIK I INFORMACJE
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW CENNIKZAMÓW CENNIK
CZYTELNIACZYTELNIA
FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE
SPIS TRE�CISPIS TRE�CI
DODAJ DO KOSZYKADODAJ DO KOSZYKA
KATALOG ONLINEKATALOG ONLINE
Serwisy internetowe.Programowanie Autorzy: Marty Hall, Larry BrownT³umaczenie: Szymon Kobalczyk,Marek Pa³czyñski, Rafa³ Szpoton ISBN: 83-7361-155-X Tytu³ orygina³u: Core Web Programming, 2nd EditionFormat: B5, stron: 1254Przyk³ady na ftp: 1211 kB
Kompendium wiedzy dla profesjonalnych programistów serwisów internetowych.
Ksi¹¿ka zawiera komplet informacji niezbêdnych twórcom zaawansowanych aplikacji sieciowych i opisuje: HTML 4, Java Standard Edition 1.3, serwlety, JavaServer Pages i wiele innych technologii. „Serwisy internetowe. Programowanie” ³¹czy te technologie pokazuj¹c, jak przy ich pomocy tworzyæ profesjonalne systemy.
HTML 4: Dog³êbny, praktyczny opis struktury dokumentu HTML, jego elementów, ramek i styli kaskadowych.
Java 2: Podstawy sk³adni, projektowanie zorientowane obiektowo, aplety, tworzenie animacji, narzêdzie Java PlugIn, tworzenie interfejsu u¿ytkownika (Swing), Java 2D API, aplikacje wielow¹tkowe, programowanie sieciowe, korzystanie z baz danych i jeszcze wiêcej.
Technologie serwerowe Javy: Serwlety, JSP, XML, JDBC – fundamentalne technologie umo¿liwiaj¹ce budowê aplikacji w Javie. Tematy zaawansowane dotycz¹ tworzenia w³asnych bibliotek znaczników JSP, ³¹czenia serwletów z JSP (MVC), tworzenie puli po³¹czeñ do baz danych, SAX, DOM i XSLT. Dok³adnie omówiono tak¿e HTTP 1.1.
JavaScript: Dynamiczne tworzenie zawarto�ci stron WWW, �ledzenie zachowania u¿ytkownika, sprawdzanie poprawno�ci danych w formularzach HTML. Do³¹czono podrêczny skorowidz komend.
Pierwsze wydanie tej ksi¹¿ki jest u¿ywane jako podrêcznik na takich uczelniach jak MIT, Standford, UC Berkeley, UCLA, Princeton i John Hopkins. Ksi¹¿ka, któr¹ trzymasz w rêku, zosta³a zaktualizowana i uzupe³niona o najnowsze technologie oraz
towarzysz¹ce im przyk³ady gotowego kodu.
• �wiatowy bestseller — aktualne kompendium dla zaawansowanych programistów serwisów WWW • Dog³êbny opis HTML 4, CSS, Javy 2, serwletów, JavaServer Pages i XML • Przyk³ady kodu u¿ywanego przez profesjonalistów
Spis treści
O Autorach...................................................................................................................................................21
Wstęp.......................................................................................................................................................... 23
Część I Język HTML 29
Rozdział 1. Projektowanie stron WWW w HTML 4.0................................................................................. 31
1.1. Język HTML ........................................................................................................... 321.2. HTML 4.0 oraz inne standardy HTML ....................................................................... 331.3. Publikacja dokumentu WWW................................................................................... 35
Tworzenie dokumentu ............................................................................................ 35Umieszczenie dokumentu w sieci WWW................................................................... 35Sprawdzanie poprawność dokumentu...................................................................... 37
1.4. Podstawowa struktura dokumentów HTML ............................................................... 38Szablon dokumentu HTML...................................................................................... 39Deklaracja DOCTYPE.............................................................................................. 39
1.5. Nagłówek HEAD — ogólne informacje o stronie ........................................................ 41Obowiązkowy element nagłówka HEAD .................................................................... 42Opcjonalne elementy nagłówka HEAD...................................................................... 42
1.6. Sekcja BODY — część główna dokumentu ............................................................... 471.7. Podsumowanie ...................................................................................................... 50
Rozdział 2. Elementy blokowe w HTML 4.0................................................................................................51
2.1. Nagłówki ............................................................................................................... 522.2. Podstawowe bloki tekstu ........................................................................................ 53
Podstawowy akapit ................................................................................................ 54Akapit zachowujący znaki rozdzielające.................................................................... 55Blok cytatu............................................................................................................ 56Adresy .................................................................................................................. 56
2.3. Listy numerowane, wypunktowane i wcięte............................................................... 57Listy numerowane ................................................................................................. 57Listy wypunktowane ............................................................................................... 59Listy definicji ......................................................................................................... 61
2.4. Tabele .................................................................................................................. 62Podstawowa struktura tabel ................................................................................... 62Definiowanie wierszy tabeli..................................................................................... 66Nagłówki kolumn i komórki danych.......................................................................... 67Grupowanie zawartości tabeli ................................................................................. 70
2.5. Formularze ............................................................................................................ 722.6. Pozostałe elementy blokowe ................................................................................... 732.7. Podsumowanie ...................................................................................................... 75
4 Spis treści
Rozdział 3. Elementy tekstowe w HTML 4.0 ............................................................................................. 77
3.1. Fizyczne style znaków............................................................................................. 773.2. Logiczne style znaków ............................................................................................ 823.3. Tworzenie łączy hipertekstowych ............................................................................. 843.4. Umieszczanie ilustracji ........................................................................................... 87
Animowane obrazki GIF .......................................................................................... 87Element IMG ......................................................................................................... 88
3.5. Mapy obrazu interpretowane po stronie klienta......................................................... 913.6. Osadzenie innych obiektów w dokumentach ............................................................. 94
Osadzanie apletów Javy ......................................................................................... 94Osadzanie plików w formatach audio, wideo i innych przez moduły rozszerzające ........ 96Osadzanie kontrolek ActiveX................................................................................... 97Wyświetlanie ruchomych szyldów ............................................................................ 99
3.7. Sterowanie łamaniem tekstu ................................................................................ 1003.8. Podsumowanie .................................................................................................... 101
Rozdział 4. Ramki ......................................................................................................................................103
4.1. Szablon dokumentu ramek ................................................................................... 1044.2. Definiowanie układu ramek................................................................................... 1054.3. Definiowanie zawartości komórek ramek................................................................ 109
Przykłady............................................................................................................. 1114.4. Odwoływanie się do komórek ramek ...................................................................... 112
Predefiniowane nazwy ramek ................................................................................ 1154.5. Rozwiązywanie najczęstszych problemów z ramkami ............................................... 115
Tworzenie zakładek do stron z ramkami................................................................. 116Drukowanie stron z ramkami ................................................................................ 116Uaktualnianie wielu ramek równocześnie............................................................... 117Chronienie dokumentu przed umieszczeniem w ramce............................................ 120Tworzenie pustych komórek.................................................................................. 120
4.6. Ramki wewnętrzne ............................................................................................... 1214.7. Podsumowanie .................................................................................................... 124
Rozdział 5. Kaskadowe arkusze stylów .................................................................................................125
5.1. Definiowanie reguł stylu........................................................................................ 1265.2. Zewnętrzne i lokalne arkusze stylów ...................................................................... 128
Zewnętrzne arkusze stylów ................................................................................... 128Element STYLE i arkusze stylów JavaScript ............................................................ 130Wewnętrzne definicje stylów ................................................................................. 130
5.2. Wskaźniki............................................................................................................ 131Elementy HTML ................................................................................................... 132Klasy definiowane przez użytkownika..................................................................... 133Identyfikatory definiowane przez użytkownika ......................................................... 133Pseudoklasy odsyłaczy......................................................................................... 134
5.4. Łączenie kaskadowe. Reguły pierwszeństwa w arkuszach stylów.............................. 1355.5. Właściwości kroju pisma....................................................................................... 1365.6. Właściwości pierwszego planu i tła ........................................................................ 1415.7. Właściwości tekstu .............................................................................................. 1435.8. Właściwości prostokąta ograniczającego................................................................ 147
Marginesy ........................................................................................................... 148Obramowanie ...................................................................................................... 148Dopełnienie......................................................................................................... 150Tryby wyświetlania prostokąta ograniczającego....................................................... 150
Spis treści 5
5.9. Obrazki i elementy pływające ................................................................................ 1515.10. Właściwości list ................................................................................................. 1535.11. Standardowe formaty zapisu wartości .................................................................. 153
Długości ............................................................................................................. 154Kolory................................................................................................................. 154
5.12. Warstwy ............................................................................................................ 155Definiowanie warstw przez elementy LAYER i ILAYER .............................................. 155Definiowanie warstw przez arkusze stylów ............................................................. 159
5.13. Podsumowanie .................................................................................................. 162
Część II Programowanie w języku Java 163
Rozdział 6. Podstawowe informacje o Javie ..........................................................................................165
6.1. Cechy charakterystyczne Javy................................................................................ 166Java jest językiem współpracującym z Internetem i aplikacjami sieciowymi ............... 167Java jest językiem przeznaczonym dla różnych platform........................................... 169Java jest językiem łatwym do nauczenia ................................................................ 172Java jest językiem obiektowym.............................................................................. 173Dzięki standardowym bibliotekom Java ma wiele zastosowań.................................. 173
6.2. Nieprawdziwe informacje na temat Javy ................................................................. 175Java jest przeznaczona jedynie do zastosowań sieciowych ...................................... 175Java jest językiem niezależnym od platformy .......................................................... 175Java jest językiem łatwym do nauczenia ................................................................ 177Java jest językiem obiektowym.............................................................................. 177Java jest językiem, który można stosować w każdym projekcie informatycznym......... 178
6.3. Wersje Javy ......................................................................................................... 178Której wersji powinno się używać?......................................................................... 180Bez względu na to, która wersja zostanie wybrana… .............................................. 180
6.4. Rozpoczęcie pracy................................................................................................ 181Instalacja Javy..................................................................................................... 182Instalacja przeglądarki obsługującej Javę............................................................... 183Zapisanie odsyłacza lub instalowanie dokumentacji API Javy ................................... 183Opcjonalne instalowanie zintegrowanego środowiska programistycznego.................. 184Utworzenie i uruchomienie programu..................................................................... 185
6.5. Przykładowe programy Javy ................................................................................... 185Aplikacja „Witaj świecie” ...................................................................................... 186Argumenty linii poleceń ........................................................................................ 186Aplet „Witaj świecie” ........................................................................................... 187Parametry apletu ustalane przez użytkownika......................................................... 188
6.6. Podsumowanie .................................................................................................... 191
Rozdział 7. Programowanie obiektowe w języku Java.........................................................................193
7.1. Zmienne obiektowe.............................................................................................. 1947.2. Metody ............................................................................................................... 1967.3. Konstruktory i słowo kluczowe „this” ..................................................................... 197
Inicjacja statyczna ............................................................................................... 2007.4. Destruktory ......................................................................................................... 2007.5. Przeciążanie ........................................................................................................ 2017.6. Udostępnianie klas w oddzielnych plikach .............................................................. 204
6 Spis treści
7.7. Program javadoc .................................................................................................. 209Znaczniki javadoc ................................................................................................ 210Argumenty linii poleceń programu javadoc ............................................................. 213
7.8. Dziedziczenie....................................................................................................... 2157.9. Interfejsy i klasy abstrakcyjne ............................................................................... 2197.10. Pakiety, ścieżki dostępu do klas i archiwa JAR ..................................................... 226
Ścieżka do klas — CLASSPATH ............................................................................ 2297.11. Modyfikatory deklaracji ....................................................................................... 232
Modyfikatory widoczności ..................................................................................... 232Inne modyfikatory ................................................................................................ 233
7.12. Podsumowanie .................................................................................................. 235
Rozdział 8. Podstawowa składnia języka Java.....................................................................................237
8.1. Podstawowe informacje na temat składni .............................................................. 2388.2. Podstawowe typy danych ...................................................................................... 239
Konwersja typów prostych .................................................................................... 2428.3. Operatory, instrukcje warunkowe i pętle................................................................. 242
Operatory matematyczne...................................................................................... 243Instrukcje warunkowe .......................................................................................... 244Pętle .................................................................................................................. 249
8.4. Klasa Math ......................................................................................................... 252Stałe .................................................................................................................. 252Metody ogólnego przeznaczenia............................................................................ 252Metody trygonometryczne..................................................................................... 254Klasy BigInteger i BigDecimal ............................................................................... 254
8.5. Wprowadzanie i wyświetlanie danych ..................................................................... 256Wyprowadzanie danych na standardowe urządzenie wyjściowe ................................ 256Wyprowadzanie danych na standardowe wyjście informacji o błędach....................... 258Odczytywanie danych ze standardowego urządzenia wejściowego ............................ 258
8.6. Uruchamianie programów zewnętrznych ................................................................. 2588.7. Referencje........................................................................................................... 264
Przekazywanie argumentów w Javie....................................................................... 266Operator instanceof ............................................................................................. 266
8.8. Ciągi tekstowe..................................................................................................... 268Metody klasy String ............................................................................................. 268Konstruktory ....................................................................................................... 274
8.9. Tablice................................................................................................................ 274Dwuetapowa alokacja tablicy ................................................................................ 275Jednoetapowa alokacja tablicy.............................................................................. 276Tablice wielowymiarowe ....................................................................................... 277
8.10. Wektory............................................................................................................. 278Konstruktory ....................................................................................................... 278Metody ............................................................................................................... 278
8.11. Przykład — proste drzewo binarne....................................................................... 2808.12. Wyjątki .............................................................................................................. 284
Podstawy obsługi wyjątków................................................................................... 285Wielokrotne klauzule catch................................................................................... 287Klauzula Finally ................................................................................................... 288Generowanie wyjątków ......................................................................................... 288Niesprawdzane wyjątki ......................................................................................... 290
8.13. Podsumowanie .................................................................................................. 290
Spis treści 7
Rozdział 9. Aplety i podstawy operacji graficznych..............................................................................291
9.1. Czym są aplety? .................................................................................................. 2929.2. Budowanie apletu ................................................................................................ 293
Szablony apletów................................................................................................. 293Szablony HTML.................................................................................................... 294
9.3. Przykładowy aplet................................................................................................. 295Automatyczne odświeżanie wyglądu okna .............................................................. 296Odświeżanie kodu apletu podczas prac projektowych.............................................. 296
9.4. Poszczególne etapy pracy apletu ........................................................................... 2989.5. Inne metody apletów ............................................................................................ 2999.6. Znacznik HTML APPLET ........................................................................................ 3049.7. Odczyt parametrów apletu .................................................................................... 306
Przykład odczytu parametrów apletu...................................................................... 3079.8. Znacznik HTML OBJECT ........................................................................................ 3099.9. Rozszerzenie Javy ................................................................................................ 3119.10. Aplikacje graficzne ............................................................................................. 3139.11. Operacje graficzne ............................................................................................. 314
Rysowanie .......................................................................................................... 315Kolory i czcionki................................................................................................... 317Tryby kreślenia .................................................................................................... 318Współrzędne i obszary obcinania .......................................................................... 319
9.12. Wyświetlanie plików graficznych .......................................................................... 319Pobieranie rysunków określonych względnym adresem URL..................................... 320Pobieranie rysunków określonych bezwzględnym adresem URL................................ 322Pobieranie rysunków w aplikacjach Javy................................................................. 323
9.13. Buforowanie plików graficznych ........................................................................... 3259.14. Nadzorowanie procesu pobierania rysunków......................................................... 328
MediaTracker ...................................................................................................... 3309.15. Podsumowanie .................................................................................................. 334
Rozdział 10. Java 2D — grafika w Java 2.............................................................................................335
10.1. Podstawowe informacje o bibliotece Java 2D ....................................................... 336Najczęściej wykorzystywane metody klasy Graphics2D............................................ 339
10.2. Style kreślenia................................................................................................... 342Klasy kształtu...................................................................................................... 342
10.3. Style wypełnienia ............................................................................................... 346Klasy wypełniania ................................................................................................ 346Rysunki jako wzorce wypełnień ............................................................................. 349
10.4. Przezroczystość ................................................................................................. 35310.5. Korzystanie z czcionek lokalnych ......................................................................... 35510.6. Style kreślenia linii............................................................................................. 357
Atrybuty pióra ...................................................................................................... 35710.7. Transformacje współrzędnych ............................................................................. 362
Pochylenie .......................................................................................................... 36510.8. Pozostałe funkcje biblioteki Java 2D.................................................................... 36610.9. Podsumowanie .................................................................................................. 367
Rozdział 11. Obsługa zdarzeń myszy i klawiatury.................................................................................369
11.1. Niezależne klasy nasłuchu zdarzeń...................................................................... 370Rysowanie kół ..................................................................................................... 372
11.2. Implementacja interfejsów nasłuchu.................................................................... 373
8 Spis treści
11.3. Obsługa zdarzeń w klasach wewnętrznych............................................................ 37411.4. Obsługa zdarzeń w anonimowych klasach wewnętrznych ....................................... 37611.5. Standardowe interfejsy nasłuchu......................................................................... 37711.6. Za kulisami — niskopoziomowe przetwarzanie zdarzeń ......................................... 38211.7. Pole tekstowe poprawiające błędy ....................................................................... 38511.8. Klasa deski kreślarskiej ..................................................................................... 387
Ulepszona deska kreślarska................................................................................. 38911.9. Podsumowanie .................................................................................................. 390
Rozdział 12. Rozmieszczanie komponentów ...........................................................................................391
12.1. Menedżer rozmieszczenia FlowLayout .................................................................. 392Konstruktory menedżera FlowLayout...................................................................... 393Inne metody menedżera FlowLayout ...................................................................... 393
12.2. Menedżer rozmieszczenia BorderLayout............................................................... 394Konstruktory menedżera BorderLayout .................................................................. 396Inne metody menedżera BorderLayout................................................................... 396
12.3. Menedżer rozmieszczenia GridLayout................................................................... 397Konstruktory menedżera GridLayout ...................................................................... 397Inne metody menedżera GridLayout....................................................................... 399
12.4. Menedżer rozmieszczenia CardLayout.................................................................. 399Konstruktory menedżera CardLayout ..................................................................... 402Inne metody menedżera CardLayout...................................................................... 403
12.5. Menedżer rozmieszczenia GridBagLayout ............................................................. 403Obiekt GridBagConstraints ................................................................................... 404Przykład .............................................................................................................. 406Konstruktor menedżera GridBagLayout .................................................................. 409Inne metody menedżera GridBagLayout ................................................................. 409
12.6. Menedżer rozmieszczenia BoxLayout ................................................................... 410Konstruktor menedżera BoxLayout ........................................................................ 413Inne metody menedżera BoxLayout ....................................................................... 413
12.7. Wyłączenie menedżera rozmieszczenia ................................................................ 41412.8. Efektywne wykorzystanie menedżerów rozmieszczenia .......................................... 415
Wykorzystanie zagnieżdżanych kontenerów ............................................................ 416Wyłączenie menedżera rozmieszczenia w pracy z niektórymi kontenerami................. 419Operowanie wolną przestrzenią wokół komponentów .............................................. 420
12.9. Podsumowanie .................................................................................................. 423
Rozdział 13. Komponenty AWT.................................................................................................................425
13.1. Klasa Canvas .................................................................................................... 426Powoływanie i korzystanie z obiektu Canvas........................................................... 427Przykład — komponent Kolo................................................................................. 428
13.2. Klasa Component .............................................................................................. 43013.3. Lekkie komponenty języka Java 1.1..................................................................... 43613.4. Klasa Panel....................................................................................................... 438
Domyślny menedżer rozmieszczenia — FlowLayout................................................. 438Tworzenie i posługiwanie się obiektem Panel ......................................................... 439Przykład — zastosowanie obiektu Panel do grupowania komponentów..................... 439
13.5. Klasa Container ................................................................................................. 44113.6. Klasa Applet...................................................................................................... 44313.7. Klasa ScrollPane ............................................................................................... 443
Tworzenie i posługiwanie się obiektem ScrollPane.................................................. 443Przykład — obiekt ScrollPane zawierający panel o stu przyciskach........................... 443
Spis treści 9
13.8. Klasa Frame...................................................................................................... 444Domyślny menedżer rozmieszczenia — BorderLayout ............................................. 445Korzystanie z obiektu Frame................................................................................. 445Przykłady wykorzystania ramek.............................................................................. 446Zamykalna ramka ................................................................................................ 447Menu.................................................................................................................. 448Inne przydatne metody klasy Frame....................................................................... 450
13.9. Serializowanie okien........................................................................................... 451Zapis okna na dysku............................................................................................ 451Odczyt okna z dysku ............................................................................................ 452Przykład — zapisywana ramka .............................................................................. 452
13.10. Klasa Dialog.................................................................................................... 455Tworzenie i posługiwanie się obiektami Dialog ....................................................... 455Przykład — potwierdzenie zamknięcia okna ........................................................... 455
13.11. Klasa FileDialog............................................................................................... 457Przykład — wyświetlanie zawartości plików w polu tekstowym ................................. 457
13.12. Klasa Window.................................................................................................. 459Domyślny menedżer rozmieszczenia — BorderLayout ............................................. 460Tworzenie i posługiwanie się obiektem Window...................................................... 460
13.13. Obsługa zdarzeń kontrolek GUI.......................................................................... 461Rozproszone przetwarzanie zdarzeń ...................................................................... 462Scentralizowane przetwarzanie zdarzeń ................................................................. 463
13.14. Klasa Button ................................................................................................... 465Konstruktory ....................................................................................................... 465Przykład — aplet z trzema przyciskami .................................................................. 465Inne metody klasy Button..................................................................................... 466Obsługa zdarzeń przycisków ................................................................................. 467
13.15. Klasa Checkbox............................................................................................... 469Konstruktory ....................................................................................................... 470Przykład — zaznaczone pola wyboru...................................................................... 470Inne metody klasy Checkbox ................................................................................ 471Obsługa zdarzeń obiektu Checkbox ....................................................................... 472
13.16. Grupy pól wyboru (przyciski opcji) ...................................................................... 472Konstruktory ....................................................................................................... 473Przykład — pola wyboru a przyciski opcji................................................................ 473Inne metody klas CheckboxGroup i Checkbox ........................................................ 474Obsługa zdarzeń obiektu CheckboxGroup .............................................................. 474
13.17 Klasa Choice .................................................................................................... 475Konstruktor......................................................................................................... 475Przykład zastosowania list rozwijanych .................................................................. 475Inne metody klasy Choice..................................................................................... 476Obsługa zdarzeń obiektu Choice ........................................................................... 477
13.18. Klasa List........................................................................................................ 478Konstruktory ....................................................................................................... 479Przykład — listy pojedynczego i wielokrotnego wyboru ............................................ 479Inne metody klasy List ......................................................................................... 480Obsługa zdarzeń obiektu List ................................................................................ 482
13.19. Klasa TextField ................................................................................................ 486Konstruktory ....................................................................................................... 487Przykład — tworzenie obiektów TextField ............................................................... 487Inne metody klasy TextField.................................................................................. 488Obsługa zdarzeń obiektu TextField ........................................................................ 490
10 Spis treści
13.20. Klasa TextArea ................................................................................................ 491Konstruktory ....................................................................................................... 491Przykład — puste i wypełnione obszary tekstowe ................................................... 492Inne metody klasy TextArea .................................................................................. 492Obsługa zdarzeń obiektu TextArea......................................................................... 493
13.21. Klasa Label ..................................................................................................... 493Konstruktory ....................................................................................................... 494Przykład — cztery różne etykiety ........................................................................... 494Inne metody klasy Label....................................................................................... 495Obsługa zdarzeń obiektu Label ............................................................................. 496
13.22. Paski przewijania i suwaki ................................................................................ 497Konstruktory ....................................................................................................... 497Przykład — różnorodne paski kontrolki suwaków .................................................... 498Inne metody klasy Scrollbar.................................................................................. 499Obsługa zdarzeń obiektu Scrollbar ........................................................................ 501
13.23. Menu kontekstowe........................................................................................... 503Konstruktory ....................................................................................................... 503Przykład — menu kontekstowe apletu ................................................................... 503Inne metody klasy PopupMenu ............................................................................. 505Obsługa zdarzeń obiektu PopupMenu .................................................................... 505
13.24. Podsumowanie ................................................................................................ 506
Rozdział 14. Podstawy Swing..................................................................................................................507
14.1. Podstawy Swing................................................................................................. 508Różnice pomiędzy technologiami Swing i AWT ........................................................ 508
14.2. Komponent JApplet ............................................................................................ 51514.3. Komponent JFrame ............................................................................................ 51714.4. Komponent JLabel ............................................................................................. 518
Nowe funkcje — wyświetlanie grafiki, obramowania i treści HTML ........................... 519Konstruktory klasy JLabel..................................................................................... 520Najczęściej wykorzystywane metody klasy JLabel.................................................... 520
14.5. Komponent JButton............................................................................................ 522Nowe elementy — ikony, formatowanie, mnemonika .............................................. 523Kod HTML w opisie przycisku................................................................................ 524Konstruktory klasy JButton ................................................................................... 524Najczęściej wykorzystywane metody klasy JButton (AbstractButton) ......................... 524
14.6. Komponent JPanel ............................................................................................. 526Konstruktory klasy JPanel..................................................................................... 527Nowe elementy — obramowania........................................................................... 527Najczęściej wykorzystywane metody klasy BorderFactory ......................................... 528
14.7. Komponent JSlider............................................................................................. 530Nowe elementy — znaczniki przesunięcia i opisy.................................................... 531Konstruktory klasy JSlider .................................................................................... 531Najczęściej wykorzystywane metody klasy JSlider ................................................... 532
14.8. Komponent JColorChooser.................................................................................. 534Konstruktory klasy JColorChooser ......................................................................... 535Najczęściej wykorzystywane metody klasy JColorChooser ........................................ 535
14.9. Komponent JInternalFrame ................................................................................. 537Konstruktory klasy JInternalFrame......................................................................... 538Najczęściej wykorzystywane metody klasy JInternalFrame........................................ 538
14.10. Komponent JOptionPane .................................................................................. 541Najczęściej wykorzystywane metody klasy JOptionPane........................................... 541
Spis treści 11
14.11. Komponent JToolBar ........................................................................................ 545Konstruktory klasy JToolBar.................................................................................. 546Najczęściej wykorzystywane metody klasy JToolBar ................................................ 546
14.12 Komponent JEditorPane .................................................................................... 550Podążanie za odsyłaczami .................................................................................... 551Konstruktory klasy JEditorPane ............................................................................. 552Najczęściej wykorzystywane metody klasy JEditorPane............................................ 552Implementacja prostej przeglądarki internetowej .................................................... 553Obsługa kodu HTML i pakiet JavaHelp................................................................... 556
14.13. Inne komponenty Swing.................................................................................... 556Komponent JCheckBox......................................................................................... 557Komponent JRadioButton ..................................................................................... 558Komponent JTextField .......................................................................................... 559Komponent JTextArea .......................................................................................... 560Komponent JFileChooser...................................................................................... 560
14.14. Podsumowanie ................................................................................................ 561
Rozdział 15. Swing dla zaawansowanych ..............................................................................................56315.1. Wykorzystanie niestandardowych modeli danych i wyświetlaczy.............................. 56415.2. JList ................................................................................................................. 565
Kontrolka JList ze stałym zestawem opcji .............................................................. 565Kontrolka JList ze zmiennym zestawem opcji ......................................................... 570Kontrolka JList z niestandardowym modelem danych.............................................. 572Kontrolka JList z niestandardowym wyświetlaczem ................................................. 577
15.3. JTree ................................................................................................................ 581Proste drzewo JTree............................................................................................. 581Obsługa zdarzeń JTree ......................................................................................... 585Niestandardowe modele danych i dynamiczne drzewa............................................. 587Zastępowanie ikon dla wierzchołków drzewa .......................................................... 590
15.4. JTable ............................................................................................................... 592Prosta tabela JTable ............................................................................................ 592Modele danych tabeli........................................................................................... 596Wyświetlacze komórek tabeli ................................................................................ 601Obsługa zdarzeń tabeli......................................................................................... 603
15.5. Drukowanie komponentów Swing ........................................................................ 606Podstawowe zasady drukowania ........................................................................... 607Rola podwójnego buforowania .............................................................................. 609Ogólna procedura drukowania komponentów ......................................................... 609Drukowanie w JDK 1.3 ......................................................................................... 614
15.6. Wielowątkowość w Swing.................................................................................... 615Metody klasy SwingUtilities .................................................................................. 618
15.7. Podsumowanie .................................................................................................. 620
Rozdział 16. Programowanie równoległe z wykorzystaniem wielowątkowości ................................62116.1. Uruchamianie wątków ........................................................................................ 622
Metoda 1 — umieszczenie kodu w odrębnym obiekcie wątku .................................. 623Metoda 2 — umieszczenie kodu w klasie sterującej,implementującej interfejs Runnable ................................................................. 625
16.2. Sytuacje wyścigu................................................................................................ 62716.3. Synchronizacja................................................................................................... 630
Synchronizacja sekcji kodu................................................................................... 630Synchronizacja całej metody ................................................................................. 631Powszechny błąd przy synchronizacji ..................................................................... 631
12 Spis treści
16.4. Tworzenie metod wielowątkowych........................................................................ 63316.5. Metody klasy Thread .......................................................................................... 638
Konstruktory ....................................................................................................... 638Stałe .................................................................................................................. 639Metody ............................................................................................................... 640Zatrzymywanie wątku ........................................................................................... 644
16.6. Grupy wątków .................................................................................................... 646Konstruktory ....................................................................................................... 646Metody ............................................................................................................... 647
16.7. Wielowątkowa grafika i podwójne buforowanie...................................................... 648Odrysowywanie wszystkiego w metodzie paint........................................................ 649Zaimplementowanie elementów dynamicznych jako odrębnego komponentu............. 652Stworzenie odrębnych procedur bezpośrednio zajmujących się rysowaniem .............. 653Nadpisanie metody update i spowodowanie,aby paint wykonywało przyrostowe uaktualnianie............................................... 655
Wykorzystanie podwójnego buforowania ................................................................ 65916.8. Animowanie obrazków ........................................................................................ 66416.9. Czasomierze...................................................................................................... 668
Konstruktor......................................................................................................... 671Inne metody........................................................................................................ 671
16.10. Podsumowanie ................................................................................................ 673
Rozdział 17. Programowanie aplikacji sieciowych ...............................................................................675
17.1. Implementacja klienta ........................................................................................ 676Przykład — ogólny klient sieciowy ......................................................................... 679Rezultat — połączenie z serwerem FTP ................................................................. 681
17.2. Analiza składniowa łańcuchów za pomocą klasy StringTokenizer ............................ 682Klasa StringTokenizer .......................................................................................... 682Konstruktory ....................................................................................................... 682Metody ............................................................................................................... 683Przykład — interaktywny analizator składniowy....................................................... 683
17.3. Przykład — klient sprawdzający poprawność adresów poczty elektronicznej ............ 68417.4. Przykład — klient sieciowy pobierający dokumenty WWW ...................................... 687
Klasa pobierająca dokument wskazany przez adres URI na podanym serwerze ......... 688Klasa pobierająca dokument wskazany przez adres URL ......................................... 689Rezultat wykonania programu CzytnikUrl ................................................................ 690
17.5. Klasa URL ......................................................................................................... 691Pobieranie dokumentów za pomocą klasy URL ....................................................... 691Inne przydatne metody klasy URL.......................................................................... 693
17.6. Klient WWW — interaktywna komunikacja z serwerem WWW................................. 69417.7. Implementacja serwera ...................................................................................... 701
Przykład — ogólny serwer sieciowy........................................................................ 703Rezultat — obsługa połączenia z przeglądarki internetowej ..................................... 706Połączenie pomiędzy programami KlientSieciowy i SerwerSieciowy .......................... 706
17.8. Przykład — prosty serwer HTTP ........................................................................... 707Program WielowatkowySerwerEcho........................................................................ 710
17.9. RMI — zdalne wywoływanie metod ...................................................................... 712Etapy tworzenia aplikacji RMI................................................................................ 713Prosty przykład .................................................................................................... 714Praktyczny przykład — serwer wykonujący całkowanie numeryczne .......................... 718Praktyczny przykład czterech wymaganych klas....................................................... 720
Spis treści 13
Kompilacja i uruchomienie przykładu..................................................................... 724Konfiguracja RMI w dużych sieciach ...................................................................... 725Kompilacja i uruchomienie przykładu..................................................................... 728Przykład apletu RMI ............................................................................................. 730
17.10. Podsumowanie ................................................................................................ 732
Cześć III Programowanie aplikacji działających po stronie serwera 735
Rozdział 18. Formularze w języku HTML................................................................................................737
18.1. Sposób przesyłania danych w języku HTML .......................................................... 73818.2. Znacznik FORM.................................................................................................. 74118.3. Elementy tekstowe............................................................................................. 745
Pola edycyjne ...................................................................................................... 746Pola edycyjne do wprowadzania haseł ................................................................... 747Obszary tekstowe ................................................................................................ 748
18.4. Przyciski............................................................................................................ 750Przyciski typu Submit ........................................................................................... 750Przyciski typu Reset ............................................................................................. 753Przyciski wykorzystywane przez kod JavaScript ....................................................... 754
18.5. Pola wyboru oraz przełączniki .............................................................................. 755Pola wyboru ........................................................................................................ 755Przełączniki ......................................................................................................... 756
18.6 Listy rozwijane oraz zwykłe................................................................................... 75718.7. Wysyłanie plików do serwera............................................................................... 76018.8. Mapy obrazowe po stronie serwera...................................................................... 762
IMAGE — standardowe mapy obrazowe po stronie serwera..................................... 762ISMAP — alternatywne mapy obrazowe po stronie serwera ..................................... 764
18.9. Pola ukryte ........................................................................................................ 76618.10. Elementy grupujące.......................................................................................... 76618.11. Kolejność tabulacji........................................................................................... 76818.12. Podsumowanie ................................................................................................ 769
Rozdział 19. Programy w języku Java po stronie serwera — serwlety............................................771
19.1. Przewaga serwerów nad tradycyjnymi programami CGI .......................................... 773Wydajność .......................................................................................................... 773Wygoda............................................................................................................... 773Duże możliwości .................................................................................................. 773Przenośność ....................................................................................................... 774Bezpieczeństwo................................................................................................... 774Niski koszt .......................................................................................................... 774
19.2. Instalacja oraz konfiguracja serwera .................................................................... 775Pobieranie oprogramowania obsługującego serwlety oraz JSP.................................. 775Dokumentacja API serwletów oraz stron JSP .......................................................... 776Określanie klas wykorzystywanych przez kompilator Javy......................................... 777Umieszczanie klas w pakietach............................................................................. 777Konfiguracja serwera ........................................................................................... 777Kompilacja oraz instalacja serwletów .................................................................... 778Wywoływanie serwletów........................................................................................ 779
19.3. Podstawowa struktura serwletu........................................................................... 779Serwlet tworzący prosty tekst ............................................................................... 780Serwlet tworzący kod HTML .................................................................................. 781Proste narzędzia do tworzenia dokumentów HTML.................................................. 783
14 Spis treści
19.4. Czas życia serwletu............................................................................................ 785Metoda init ......................................................................................................... 785Metoda service ................................................................................................... 786Metody doGet, doPost oraz doXxx ......................................................................... 787Interfejs SingleThreadModel ................................................................................. 787Metoda destroy ................................................................................................... 788
19.5. Przykład wykorzystania parametrów inicjujących.................................................... 78819.6. Żądanie klienta — dostęp do danych formularza .................................................. 791
Odczytywanie danych formularza w programach CGI................................................ 791Odczytywanie danych formularza w serwletach ....................................................... 791Przykład — odczytywanie wartości trzech parametrów............................................. 792Filtrowanie danych zapytania ................................................................................ 794
19.7. Żądanie klienta — nagłówki żądania HTTP ........................................................... 796Odczytywanie nagłówków żądania w serwletach...................................................... 796Przykład — tworzenie tabeli zawierającej wszystkie nagłówki żądania....................... 798Nagłówki żądania protokołu HTTP 1.1.................................................................... 800Wysyłanie skompresowanych stron WWW .............................................................. 803
19.8. Odpowiedniki standardowych zmiennych CGI w przypadku serwletów...................... 80519.9. Odpowiedź serwera — kody stanu HTTP .............................................................. 808
Określanie kodów stanu....................................................................................... 808Kody stanu protokołu HTTP 1.1. ........................................................................... 810Interfejs użytkownika dla różnych wyszukiwarek internetowych................................. 815
19.10. Odpowiedź serwera — nagłówki odpowiedzi HTTP............................................... 819Ustawianie nagłówków odpowiedzi w serwletach .................................................... 819Nagłówki odpowiedzi protokołu HTTP 1.1............................................................... 820Trwały stan serwletu oraz automatyczne odświeżanie stron..................................... 826
19.11. Cookies .......................................................................................................... 834Korzyści wynikające ze stosowania cookies ........................................................... 835Niektóre problemy z plikami cookies ..................................................................... 836Interfejs programistyczny API obsługi plików Cookie w serwletach............................ 837Przykład ustawiania oraz odczytywania cookies ...................................................... 840Proste narzędzia do obsługi cookies...................................................................... 844Odszukiwanie cookies o określonych nazwach ....................................................... 844Tworzenie długotrwałych cookies........................................................................... 845
19.12. Śledzenie sesji ................................................................................................ 846Konieczność śledzenia sesji ................................................................................. 846Interfejs API służący do śledzenia sesji.................................................................. 848Kończenie sesji ................................................................................................... 851Serwlet ukazujący licznik odwiedzin ....................................................................... 852
19.13. Podsumowanie ................................................................................................ 854
Rozdział 20. Technologia JavaServer Pages ........................................................................................855
20.1. Podstawy technologii JSP ................................................................................... 85520.2. Korzyści wynikające ze stosowania technologii JSP............................................... 857
Porównanie z technologią Active Server Pages (ASP) oraz ColdFusion ...................... 857Porównanie z technologią PHP .............................................................................. 857Porównanie z serwletami...................................................................................... 858Porównanie z technologią Server-Side Includes (SSI) .............................................. 858Porównanie z językiem JavaScript ......................................................................... 858
20.3. Elementy skryptowe JSP ..................................................................................... 859Wyrażenia ........................................................................................................... 859Skryptlety............................................................................................................ 863
Spis treści 15
Deklaracje .......................................................................................................... 865Zmienne zdefiniowane ......................................................................................... 867
20.4. Dyrektywa JSP o nazwie page.............................................................................. 868Atrybut import ..................................................................................................... 869Atrybut contentType ............................................................................................. 871Atrybut isThreadSafe............................................................................................ 872Atrybut session ................................................................................................... 873Atrybut buffer ...................................................................................................... 874Atrybut autoflush ................................................................................................. 874Atrybut extends ................................................................................................... 874Atrybut info ......................................................................................................... 874Atrybut errorPage................................................................................................. 875Atrybut isErrorPage .............................................................................................. 875Atrybut language.................................................................................................. 875Składnia dyrektyw w postaci zgodnej z XML ........................................................... 875
20.5. Dołączanie apletów oraz plików w dokumentach JSP............................................. 876Dyrektywa include — dołączanie plików w czasie przekształcania stronydo postaci serwletu ........................................................................................ 876
Dołączanie plików w trakcie obsługi żądania .......................................................... 879Dołączanie apletów.............................................................................................. 880Znacznik jsp:fallback............................................................................................ 884
20.6. Wykorzystywanie w stronach JSP komponentów JavaBeans ................................... 888Prosty przykład wykorzystania klasy ziarna ............................................................. 889Prosty przykład ustawiania właściwości ziarna........................................................ 891Modyfikacja właściwości ziarna............................................................................. 893Współdzielenie ziaren .......................................................................................... 899
20.7. Definiowanie własnych znaczników JSP................................................................ 902Komponenty tworzące bibliotekę znaczników.......................................................... 903Definiowanie prostego znacznika .......................................................................... 906Przyporządkowanie znacznikom atrybutów.............................................................. 910Atrybuty znaczników — plik deskryptora biblioteki znaczników ................................. 911Dołączanie zawartości znacznika........................................................................... 913Opcjonalne dołączanie zawartości znacznika.......................................................... 917Modyfikacja zawartości znacznika ......................................................................... 920Znaczniki zagnieżdżone ........................................................................................ 926
20.8. Integrowanie serwletów ze stronami JSP.............................................................. 932Przekazywanie żądań ........................................................................................... 934Przykład — internetowe biuro podróży ................................................................... 937Przekazywanie żądań ze stron JSP ........................................................................ 943
20.9. Podsumowanie .................................................................................................. 944
Rozdział 21. Wykorzystywanie apletów w charakterze interfejsu programów
działających po stronie serwera...........................................................................................................945
21.1. Wysyłanie danych przy użyciu metody GET i wyświetlanie wynikowej strony.............. 94621.2. Interfejs użytkownika programu wyszukującego informacje
w wielu różnych wyszukiwarkach internetowych................................................. 94721.3. Wykorzystywanie metody GET oraz przetwarzanie wyników
w sposób bezpośredni (tunelowanie HTTP)....................................................... 951Odczytywanie danych binarnych oraz danych tekstowych ......................................... 952Odczytywanie struktur danych zachowanych przy użyciu serializacji .......................... 953
21.4. Przeglądarka żądań wysyłanych do serwera, używająca serializacji obiektóworaz tunelowania HTTP ................................................................................... 955
16 Spis treści
21.5. Wysyłanie danych przy użyciu metody POSTi przetwarzanie wyników wewnątrz apletu (tunelowanie HTTP) ............................ 962
21.6. Aplet wysyłający dane przy użyciu metody POST.................................................... 96521.7. Pomijanie serwera HTTP podczas komunikacji z programem po stronie serwera ...... 96921.8. Podsumowanie .................................................................................................. 969
Rozdział 22. Technologia JDBC ................................................................................................................971
22.1. Podstawowe czynności konieczne do wykonania w celu zastosowania JDBC ........... 972Załadowanie sterownika JDBC .............................................................................. 972Określanie adresu URL służącego do nawiązania połączenia ................................... 973Ustanawianie połączenia z bazą danych ................................................................ 974Tworzenie instrukcji SQL ...................................................................................... 974Wykonywanie zapytania ........................................................................................ 975Przetwarzanie wyników zapytania .......................................................................... 975Zamykanie połączenia.......................................................................................... 976
22.2. Prosty przykład wykorzystujący JDBC.................................................................... 97622.3. Kilka narzędzi JDBC ........................................................................................... 98122.4. Stosowanie utworzonych narzędzi JDBC ............................................................... 98922.5. Interaktywna przeglądarka zapytań ...................................................................... 993
Kod przeglądarki zapytań...................................................................................... 99522.6. Zapytania prekompilowane ................................................................................. 99922.7. Podsumowanie ................................................................................................ 1003
Rozdział 23. Przetwarzanie dokumentów XML w języku Java......................................................... 1005
23.1. Analiza dokumentów XML przy użyciu modelu DOM (poziom 2)............................. 1006Instalacja oraz konfiguracja ................................................................................ 1007Analiza dokumentu ............................................................................................ 1008
23.2. Przykład wykorzystania modelu DOM — wyświetlenie dokumentu XMLw postaci obiektu JTree................................................................................ 1009
23.3. Przetwarzanie dokumentów XML za pomocą interfejsu SAX 2.0............................ 1020Instalacja oraz konfiguracja ................................................................................ 1020Analiza dokumentu ............................................................................................ 1021
23.4. Pierwszy przykład użycia interfejsu SAX — wyświetlanie struktury dokumentu XML ....102323.5. Drugi przykład użycia interfejsu SAX — zliczanie zamówień książek ...................... 102923.6. Przekształcanie dokumentu XML za pomocą transformacji XSLT .......................... 1033
Instalacja oraz konfiguracja ................................................................................ 1034Transformacja ................................................................................................... 1035
23.7. Pierwszy przykład XSLT — edytor dokumentów XSLT ........................................... 103923.8. Drugi przykład XSLT — własny zdefiniowany znacznik JSP.................................... 104723.9. Podsumowanie ................................................................................................ 1054
Część IV JavaScript 1055
Rozdział 24. JavaScript — wzbogacanie stron WWW o elementy dynamiczne.............................. 1057
24.1. Dynamiczne generowanie kodu HTML ................................................................ 1059Zachowanie zgodności z wieloma przeglądarkami................................................. 1062
24.2. Monitorowanie zdarzeń użytkownika .................................................................. 106424.3. Poznawanie składni JavaScript.......................................................................... 1065
Dynamiczne określanie typu ............................................................................... 1065Deklarowanie funkcji .......................................................................................... 1066Klasy i obiekty................................................................................................... 1067Tablice ............................................................................................................. 1071
Spis treści 17
24.4. Wykorzystanie JavaScript do przekształcania stron WWW .................................... 1072Dostosowanie do rozmiaru okna przeglądarki....................................................... 1073Sprawdzanie, jakie moduły rozszerzające są dostępne.......................................... 1075
24.5. Wykorzystanie JavaScript do umieszczenia na stronie elementów dynamicznych ... 1077Dynamiczna zmiana obrazków............................................................................. 1077Przemieszczanie warstw..................................................................................... 1084
24.6. Wykorzystanie JavaScript do sprawdzania poprawności formularzy ....................... 1087Sprawdzanie pojedynczych wartości .................................................................... 1088Sprawdzanie wartości przed odesłaniem formularza ............................................. 1090
24.7. Wykorzystanie JavaScript do zapisywania i sprawdzaniaznaczników kontekstu klienta........................................................................ 1094
24.8. Wykorzystanie JavaScript do współdziałania z ramkami ....................................... 1098Pokierowanie ramką, aby wyświetliła podany URL................................................. 1099Sprawianie aby ramka była aktywna .................................................................... 1102
24.9. Wywoływanie Javy z poziomu JavaScript ............................................................. 1102Bezpośrednie wywoływanie metod Javy................................................................ 1103Wykorzystanie apletów do wykonywania operacji dla JavaScript ............................. 1104Sterowanie apletami przy użyciu JavaScript.......................................................... 1107
24.10. Dostęp do obiektów JavaScript z poziomu Javy................................................. 1110Przykład — dopasowanie koloru tła apletu do koloru strony .................................. 1112Przykład — aplet sterujący wartościami formularza HTML ..................................... 1113Metody klasy JSObject ....................................................................................... 1122
24.11. Podsumowanie .............................................................................................. 1123
Rozdział 25. Krótki podręcznik JavaScript ......................................................................................... 1125
25.1. Obiekt Array..................................................................................................... 1125Konstruktory ..................................................................................................... 1126Właściwości ...................................................................................................... 1126Metody ............................................................................................................. 1126Zdarzenia.......................................................................................................... 1129
25.2. Obiekt Button .................................................................................................. 1129Właściwości ...................................................................................................... 1129Metody ............................................................................................................. 1129Zdarzenia.......................................................................................................... 1130
25.3. Obiekt Checkbox.............................................................................................. 1130Właściwości ...................................................................................................... 1131Metody ............................................................................................................. 1131Zdarzenia.......................................................................................................... 1131
25.4. Obiekt Date..................................................................................................... 1132Konstruktory ..................................................................................................... 1132Właściwości ...................................................................................................... 1132Metody ............................................................................................................. 1133Zdarzenia.......................................................................................................... 1135
25.5. Obiekt Document ............................................................................................. 1135Właściwości ...................................................................................................... 1135Metody ............................................................................................................. 1137Zdarzenia.......................................................................................................... 1138
25.6. Obiekt Element ................................................................................................ 1138Właściwości ...................................................................................................... 1138Metody ............................................................................................................. 1139Zdarzenia.......................................................................................................... 1140
18 Spis treści
25.7. Obiekt FileUpload............................................................................................. 1140Właściwości ...................................................................................................... 1140Metody ............................................................................................................. 1141Zdarzenia.......................................................................................................... 1141
25.8. Obiekt Form..................................................................................................... 1141Właściwości ...................................................................................................... 1141Metody ............................................................................................................. 1142Zdarzenia.......................................................................................................... 1142
25.9. Obiekt Function ............................................................................................... 1143Konstruktor....................................................................................................... 1143Właściwości ...................................................................................................... 1143Metody ............................................................................................................. 1144Zdarzenia.......................................................................................................... 1144
25.10. Obiekt Hidden................................................................................................ 1144Właściwości ...................................................................................................... 1144Metody ............................................................................................................. 1144Zdarzenia.......................................................................................................... 1145
25.11. Obiekt History................................................................................................ 1145Właściwości ...................................................................................................... 1145Metody ............................................................................................................. 1145Zdarzenia.......................................................................................................... 1146
25.12. Obiekt Image................................................................................................. 1146Konstruktor....................................................................................................... 1146Właściwości ...................................................................................................... 1146Metody ............................................................................................................. 1147Zdarzenia.......................................................................................................... 1147
25.13. Obiekt JavaObject .......................................................................................... 114825.14. Obiekt JavaPackage ....................................................................................... 114825.15. Obiekt Layer .................................................................................................. 1148
Konstruktory ..................................................................................................... 1149Właściwości ...................................................................................................... 1149Metody ............................................................................................................. 1150Zdarzenia.......................................................................................................... 1151
25.16. Obiekt Link.................................................................................................... 1152Właściwości ...................................................................................................... 1152Metody ............................................................................................................. 1153Zdarzenia.......................................................................................................... 1153
25.17. Obiekt Location ............................................................................................. 1154Właściwości ...................................................................................................... 1154Metody ............................................................................................................. 1155Zdarzenia.......................................................................................................... 1155
25.18. Obiekt Math .................................................................................................. 1155Właściwości ...................................................................................................... 1155Metody ............................................................................................................. 1156Zdarzenia.......................................................................................................... 1157
25.19. Obiekt MimeType ........................................................................................... 1158Właściwości ...................................................................................................... 1158Metody ............................................................................................................. 1158Zdarzenia.......................................................................................................... 1158
Spis treści 19
25.20. Obiekt Navigator ............................................................................................ 1159Właściwości ...................................................................................................... 1159Metody ............................................................................................................. 1161Zdarzenia.......................................................................................................... 1161
25.21. Obiekt Number .............................................................................................. 1161Konstruktor....................................................................................................... 1162Właściwości ...................................................................................................... 1162Metody ............................................................................................................. 1162Zdarzenia.......................................................................................................... 1164
25.22. Obiekt Object................................................................................................. 1164Konstruktory ..................................................................................................... 1164Właściwości ...................................................................................................... 1164Metody ............................................................................................................. 1165Zdarzenia.......................................................................................................... 1165
25.23. Obiekt Option ................................................................................................ 1165Konstruktory ..................................................................................................... 1165Właściwości ...................................................................................................... 1166Metody ............................................................................................................. 1166Zdarzenia.......................................................................................................... 1166
25.24. Obiekt Password............................................................................................ 1166Właściwości ...................................................................................................... 1167Metody ............................................................................................................. 1167Zdarzenia.......................................................................................................... 1167
25.25. Obiekt Plugin ................................................................................................. 1168Właściwości ...................................................................................................... 1168Metody ............................................................................................................. 1169Zdarzenia.......................................................................................................... 1169
25.26. Obiekt Radio ................................................................................................. 1169Właściwości ...................................................................................................... 1169Metody ............................................................................................................. 1170Zdarzenia.......................................................................................................... 1170
25.27. Obiekt RegExp ............................................................................................... 1170Konstruktory ..................................................................................................... 1170Właściwości ...................................................................................................... 1172Metody ............................................................................................................. 1173Zdarzenia.......................................................................................................... 1174Wzorce specjalne w wyrażeniach regularnych ....................................................... 1174
25.28. Obiekt Reset ................................................................................................. 1174Właściwości ...................................................................................................... 1174Metody ............................................................................................................. 1174Zdarzenia.......................................................................................................... 1176
25.29. Obiekt Screen................................................................................................ 1176Właściwości ...................................................................................................... 1177Metody ............................................................................................................. 1177Zdarzenia.......................................................................................................... 1177
25.30. Obiekt Select................................................................................................. 1177Właściwości ...................................................................................................... 1178Metody ............................................................................................................. 1179Zdarzenia.......................................................................................................... 1179
20 Spis treści
25.31. Obiekt String ................................................................................................. 1179Konstruktor....................................................................................................... 1180Właściwości ...................................................................................................... 1180Metody ............................................................................................................. 1180Zdarzenia.......................................................................................................... 1184
25.32. Obiekt Submit ............................................................................................... 1184Właściwości ...................................................................................................... 1184Metody ............................................................................................................. 1185Zdarzenia.......................................................................................................... 1185
25.33. Obiekt Text.................................................................................................... 1186Właściwości ...................................................................................................... 1186Metody ............................................................................................................. 1186Zdarzenia.......................................................................................................... 1187
25.34. Obiekt Textarea ............................................................................................. 1187Właściwości ...................................................................................................... 1187Metody ............................................................................................................. 1188Zdarzenia.......................................................................................................... 1188
25.35. Obiekt Window............................................................................................... 1189Właściwości ...................................................................................................... 1189Metody ............................................................................................................. 1192Zdarzenia.......................................................................................................... 1196Przykład użycia metody open .............................................................................. 1198
25.36. Podsumowanie .............................................................................................. 1200
Dodatki 1201
Skorowidz .............................................................................................................................................. 1203
Wykorzystywanie apletóww charakterze interfejsuprogramów działających
po stronie serwera
W tym rozdziale:
� Wysyłanie danych przy użyciu metody GET i wyświetlanie wynikóww przeglądarce
� Wysyłanie danych przy użyciu metody GET i przetwarzanie wyników wewnątrzapletu (tunelowanie HTTP)
� Wykorzystanie serializacji obiektów do wymiany struktur danych wysokiegopoziomu pomiędzy apletami a serwletami
� Wysyłanie danych przy użyciu metody POST i przetwarzanie wyników wewnątrzapletu (tunelowanie HTTP)
� Pomijanie serwera HTTP podczas komunikacji z programem po stronie serwera
Omówione w rozdziale 18. formularze HTTP stanowią prosty, lecz ograniczony sposóbpobierania danych wejściowych od użytkownika i przekazywania ich do serwletów lubprogramów CGI. Niekiedy jednak wymagane jest zastosowanie bardziej skomplikowanegointerfejsu użytkownika. Aplety umożliwiają większą kontrolę na rozmiarem, kolorem orazczcionką elementów graficznego interfejsu użytkownika, jak również udostępniają więcejmożliwości obsługiwanych przez dostarczone obiekty (paski postępu, przewijania, rysowa-nie linii, okna modalne itp.), pozwalają śledzić zdarzenia myszy oraz klawiatury, obsługi-wać definiowane własne formularze (przeciągane ikony, klawiatury do wybierania nume-rów itp.), a także pozwalają wysłać żądanie pochodzące od jednego użytkownika do wieluprogramów działających po stronie serwera. Te dodatkowe możliwości mają jednak swoją
946 Część III � Programowanie aplikacji działających po stronie serwera
cenę, ponieważ stworzenie interfejsu użytkownika w języku Java pociąga za sobą więcejwysiłku, niż ma to miejsce w przypadku formularzy HTML, szczególnie wtedy, gdy inter-fejs zawiera tekst formatowany. Dlatego też wybór pomiędzy formularzami HTML a aple-tami zależy od rodzaju tworzonej aplikacji.
W formularzach HTML żądania typu ��� oraz ���� obsługiwane są w prawie ten sam sposób.Wszystkie elementy interfejsu użytkownika służące do wprowadzania danych są identyczne.Zmieniana jest jedynie wartość atrybutu ����� znacznika ���. Natomiast w przypadkuapletów istnieją trzy różne podejścia do problemu. Pierwsze z nich, opisane w podrozdziale21.1, polega na naśladowaniu przez aplety formularzy HTML używających metody ���, copowoduje wysłanie danych do serwera właśnie przy użyciu tej metody i wyświetlenie wyni-ków w przeglądarce. W podrozdziale 21.2, „Interfejs użytkownika programu wyszukującegoinformacje w wielu różnych wyszukiwarkach internetowych”, przedstawiony zostanie przy-kład tego rodzaju podejścia. Druga metoda zostanie opisana w podrozdziale 21.3. i polegana wykorzystaniu apletu wysyłającego dane do serwletu, a następnie samodzielnie przetwa-rzającego uzyskane wyniki. Przykład prezentujący zastosowanie tej metody przedstawionybędzie w podrozdziale 21.4, „Przeglądarka żądań wysyłanych do serwera używająca seria-lizacji obiektów oraz tunelowania HTTP”. Trzecie podejście, opisane w podrozdziale 21.5,polega na wykorzystaniu apletu wysyłającego dane do serwletu przy użyciu metody POST,a następnie samodzielnie przetwarzającego uzyskane wyniki. Przykład tej metody zamiesz-czony jest w podrozdziale 21.6, „Aplet wysyłający dane przy użyciu metody POST”. W pod-rozdziale 21.7. przedstawiony zostanie sposób całkowitego pominięcia przez aplet serweraHTTP i bezpośredniej komunikacji z programem działającym na tym samym komputerze,z którego pobrany został aplet.
W rozdziale tym założono, że Czytelnik w stopniu podstawowym zna sposoby tworzeniapodstawowych apletów (rozdział 9.) i dlatego skoncentrowano się jedynie na technikachumożliwiających komunikację apletów z programami działającymi po stronie serwera.
21.1. Wysyłanie danych przy użyciu metody GETi wyświetlanie wynikowej strony
Metoda � ��������� nakazuje przeglądarce wyświetlenie dokumentu umieszczonego podokreślonym adresem URL. Dzięki dołączeniu do adresu URL programu danych, umiesz-czonych po znaku zapytania (?), możliwe jest przesłanie ich przy użyciu metody ��� doserwletu lub innego programu CGI. Dzięki temu w celu wysłania danych z apletu koniecznejest jedynie dołączenie ich do łańcucha znakowego, służącego do tworzenia adresu URL,a następnie w normalny sposób utworzenie obiektu URL i wywołanie metody � ����������. Poniżej przedstawiony został prosty szablon, pozwalający na zastosowanie tej metodyw apletach. Zakłada on, że �������������� zawiera łańcuch znakowy, reprezentujący adresURL programu po stronie serwera, zaś zmienna ������� zawiera informacje, które majązostać wysłane wraz z żądaniem.
�������������� �������������������������������������������������������� ��!����"���#�$����%��������� ��������&�%�%$��' (�������)"%���*����������###�&
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 947
Kiedy dane przesyłane są przez przeglądarkę, zostaną zakodowane przy użyciu metodyURL encode, co oznacza, że spacje konwertowane są na znaki plusa (!), zaś wszystkie niealfanumeryczne znaki zmieniane są na znak procenta ("), po którym występują dwie cyfryszesnastkowe, określające kod znaku w używanym zestawie. Zostało to dokładnie opisanew podrozdziale 18.2, „Znacznik FORM”. W poprzednim przykładzie założono, że łańcuchznakowy ������� jest już zakodowany poprawnie. W przeciwnym wypadku wystąpiłbybłąd działania programu. W JDK 1.1 oraz w wersjach późniejszych występuje specjalnaklasa o nazwie ����������, posiadająca zdefiniowaną statyczną metodę o nazwie ������,której wywołanie powoduje wykonanie omówionego kodowania. Jeśli więc aplet komuni-kuje się z programem po stronie serwera, który normalnie otrzymywałby dane ��� z for-mularzy HTML, aplet musi zakodować każdą przesyłaną wartość, lecz musi również użyćznaku równości (#) pomiędzy każdą nazwą zmiennej a stowarzyszoną z nią wartością, jakrównież znaku ($) w celu oddzielenia od siebie każdej takiej pary. Dlatego też nie możnawykorzystać wspomnianej metody ����������%������& �������' dla całego łańcuchaznakowego zawierającego dane (wówczas zostałyby zakodowane również te znaki specjal-ne — przyp. tłum.), lecz w zamian selektywnie zakodować każdą część pary. Czynność tamoże zostać wykonana na przykład w poniższy sposób:
+��*����������������,������������)�%���#��%��������%,�����-������.������������)�%���#��%��������%.�����-���###���/������������)�%���#��%��������%/���������������� �������������������������������������������������������� ��!����"���#�$����%��������� ��������&�%�%$��' (�������)"%���*����������###�&
Cały przykład zostanie przedstawiony w kolejnym podrozdziale.
21.2. Interfejs użytkownika programuwyszukującego informacje w wielu różnychwyszukiwarkach internetowych
Na listingu 21.1 przedstawiony został aplet tworzący pole tekstowe, służące do pobieraniadanych wejściowych od użytkownika. Po zatwierdzeniu danych, aplet koduje je używającmetody URL-encode i tworzy trzy różne adresy URL, z dołączanymi do nich danymi prze-syłanymi za pomocą metody ���. Każdy z nich przeznaczony jest dla innej wyszukiwarkiinternetowej: Google, Infoseek oraz Lycos. Następnie, w celu nakazania przeglądarce wy-świetlenia rezultatów wyszukiwania w trzech różnych obszarach ramki, aplet używa meto-dy � ���������. Formularze HTML nie mogą zostać wykorzystane do wykonania tego ro-dzaju zadania, ponieważ mogą one przesyłać dane jedynie do pojedynczego adresu URL.Na listingu 21.2 przedstawiona została klasa o nazwie ���������(����)*���*�, wykorzy-stywana przez aplet do tworzenia określonych adresów URL, niezbędnych do przekierowa-nia żądań do różnych wyszukiwarek internetowych. Jak wspomniano w rozdziale 19., klasa���������(����)*���*�+może być również wykorzystywana przez serwlety. Wyniki dzia-łania apletu przedstawiają rysunki 21.2 – 21.2.
948 Część III � Programowanie aplikacji działających po stronie serwera
Na listingu 21.3 zaprezentowany został główny dokument HTML, zaś na listingu 21.4 do-kument HTML wykorzystywany do osadzenia apletu. Zainteresowanych dokładną budowątych trzech niewielkich plików HTML, służących do utworzenia początkowej zawartościtrzech komórek ramki, ukazanych na rysunku 21.1, odsyłamy do kodu źródłowego umiesz-czonego w archiwum znajdującym się po adresem: ftp://ftp.helion.pl/przyklady/serinp.zip.
Listing 21.1. ApletWyszukiwania.java
*������01#�� ��#��� ���*������01#��#2�*������01#��#�1���#2�*������01#���#2�
322��� ����%����04%������56���*���%���4����� ����%�0���7�2������8��*�������4%�������0�0��9�%*��������:9������������2����*��04%������������;)<=����0����� ������>*���>�;��� �7�?�(����>�������%��#�2��/��8��*��������������>�������4�������� 4�>*�2����5�*�� 04%�0����*>*������>*��*�������%$���*� ��%$���>%$#�2��@��:6����87�9�����>A��(���� ����B<'���*���4������*��������:��������%����2������A6��*� ��0���%�����%$�����C#�2��D E�2�F����%�����*8������� �>*�0���%0*�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ����� ��G����>*��*��"�������� ����������������������������*�� ��������%�*���*������������*1���<�"�J*� ��� �@����*�����*1���I����������%*�>@��*���0%��
����� *%�1�*�*�*������������I%>������!� ��#�$*�����������J��������J�����+��*(�7�J���#IK��7�,L��������������� �� ����>*����%*4�=���������� �@����*�������<�"�J*� �MH�������� �@����*#�%�*���*��������$*���������� �@����*����������%*�>@��*���0%��������I�������G�5 *0��������>*���>�����������%*�>@��*���0%�#�%�*���*��������$*������������%*�>@��*���0%�����&
��322�G���A�����������>���%*5�*8%*�����%*�>��DIE ��D3IE���2���9�%*�> �*�������������� ����>������#���23
����� *%�1�*�%�*�� ��(������%�*��)1�����1����������+��*��������*�������)�%���#��%����� �@����*#���<�"��������� ������G����>*��*�NO�� ������������ ������G����>*��*#���*���; ����������������33� ��*�*8�������A�����B��I���������*���*��7����*��9���%� ����5�*�� ��*����*>:�����33������>*��>����9���>�����0���>��P1+%�*��#�� �������9����*9�0�����8��0��������9��*�� ����$Q,�#����(���*���*�H��*D� ���������# ����$Q,��*����������������
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 949
Rysunek 21.1.
ApletSearchAppletpozwalaużytkownikomna wprowadzeniejednegoposzukiwanegociągu znaków,wykorzystanegonastępniew trzech różnychwyszukiwarkachinternetowych
Rysunek 21.2.
Zatwierdzeniezapytaniapowodujewyświetlenieobok siebiewynikówwyszukiwania,pochodzącychz trzech różnychwyszukiwarek
�������� ������G����>*��*�������� ���������N*O���������33�F ��+��%$+��%������������������������33�������%*�������0�������>* >��:9��%$�������%$�*���9����%$������>�*��>��������*����������%$#���������������%$�����������������#�������������������*�7��,H������������+��*��������>*�������� ������*��������������� ��!����"���#�$����%���������%$���7������>*��������&�%�%$�' (�������)"%���*���������&����&��&&
Listing 21.2. ParametryWyszukiwania.java
322��A�> ���>��5 04%�����:���������*������>*������%*4���2����>��������������������>���>��5 ���0������>*��>*#�2��D E�2�F����%�����*8������� �>*�0���%0*
950 Część III � Programowanie aplikacji działających po stronie serwera
�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ��� ������G����>*��*������*1���+��*������7�������7���%��*>�*%���G��*>���
����*1������*%� ������G����>*��*NO�� ��������������������� ������G����>*��*������ ��7����������������������$���=33���#���� �#%��3���%$�R��7����������������������-������7���������� ������G����>*��*��*�(����>�7����������������������$���=33*�(����>#��#%��3<*� ���R���7����������������������-�$���7���������� ������G����>*��*�� �%���7����������������������$���=33 �%�����# �%��#%��3%�*Q�*�3���������������������������������*��R������7����������������������-�"$*�����7���������� ������G����>*��*��$������7����������������������$���=33���#$�����#%��3�'<��7����������������������-�!�������&�
����� *%� ������G����>*��*�+��*������7��������������������+��*���������7��������������������+��*�����%��*>�*%���G��*>����������$*�#���������������$*�#���������������������$*�#��%��*>�*%���G��*>�������%��*>�*%���G��*>�����&
����� *%�+��*�����������������+��*������%$+��*��7������������������������+��*��� *%��G��*>����������������������������%$+��*�����������������%��*>�*%���G��*>����� *%��G��*>������&
����� *%�+��*������*���/�������������������������&
����� *%����*%� ������G����>*��*NO����*���; ������������������������� �������������&&
Listing 21.3. RownolegleWyszukiwania.html
DS�K!<T )�B<'�� �I�?!��Q33GU!33�<��B<'��M#H�J������33)/�EDB<'�EDB)��E��D<?<�)EG��*>*��:��� �� ����>����%$�����C����*� �������>*���>*����������%$D3<?<�)ED3B)��E
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 951
DJ��')+)<��KG+��,.H72�E��DJ��')�+�!����>�� ���#$�� ��+!�K��?/;��/K�E��DJ��')+)<�!K�+��27272�E����DJ��')�+�!����>;��� �#$�� ��/�')������ ��H�E����DJ��')�+�!����>?�(����>#$�� ��/�')������ ��,�E����DJ��')�+�!����>��%��#$�� ��/�')������ ��.�E��D3J��')+)<ED3J��')+)<E
Listing 21.4. RamkaApletu.html
DS�K!<T )�B<'�� �I�?!��Q33GU!33�<��B<'��M#H�<���*�*�� 33)/�EDB<'�EDB)��E��D<?<�)E��>�� �����A�94%�����������>*��*�*�(���%0*D3<?<�)ED3B)��E
DIK�T�I;!K�K���GB?<)�ED!)/<)�ED� �)<�!K�)���� ��G����>*��*#% ����G?�<B�VHH�B)?;B<�,HHE��DIE<�������>A�������9�%*������ 4�>*����A���04%�0�08��>�P1#D3IED3� �)<ED3!)/<)�ED3IK�TED3B<'�E
21.3. Wykorzystywanie metody GEToraz przetwarzanie wynikóww sposób bezpośredni (tunelowanie HTTP)
W poprzednim przykładzie aplet informował przeglądarkę o konieczności wyświetleniaw określonej ramce danych wynikowych pochodzących z programu działającego po stronieserwera. Wykorzystywanie przeglądarki do wyświetlania wyników jest całkiem rozsądnepodczas korzystania z już działających usług, ponieważ większość programów CGI zostałaskonfigurowana w celu zwracania wyników w postaci dokumentów HTML. Tym niemniej,jeśli tworzy się zarówno aplikację klienta, jak też część obsługującą proces po stronie ser-wera, marnotrawstwem wydaje się wysyłanie wyników w postaci całego dokumentu HTML.W niektórych wypadkach ogromnym udogodnieniem byłaby możliwość wysyłania danychdo już działającego apletu. Aplet mógłby następnie zaprezentować otrzymane dane w for-mie wykresu lub w innej dowolnej postaci. Takie podejście niekiedy jest nazywane tunelo-waniem HTTP, ponieważ własny protokół używany do komunikacji osadzony jest we-wnątrz pakietów HTTP stosowanych podczas przekazywania przez serwery pośrednicząceszyfrowania, przekierowywania przez serwer, przekazywania przez zapory sieciowe itp.
Istnieją dwie główne odmiany takiej metody. Obie wykorzystują klasę ���,������*�� w celuotwarcia strumienia wejściowego przy użyciu danego adresu URL. Różnica tkwi w rodzajuwykorzystywanego strumienia. Pierwszą możliwością jest użycie strumienia -�..����/� ��
952 Część III � Programowanie aplikacji działających po stronie serwera
������� lub innego strumienia niskopoziomowego, pozwalającego na odczytanie danychbinarnych lub danych w postaci kodu ASCII, pochodzących z dowolnego programu dzia-łającego po stronie serwera. Ta metoda zostanie opisana w pierwszym punkcie tego pod-rozdziału. Druga możliwość polega na wykorzystaniu strumienia ��0���/� �������� w celubezpośredniego odczytania wysokopoziomowych struktur danych. Zostanie ona opisanaw drugim punkcie tego podrozdziału. Metoda ta jest możliwa do wykorzystania jedyniewtedy, gdy program działający po stronie serwera jest również napisany przy użyciu językaprogramowania Java.
Odczytywanie danych binarnych oraz danych tekstowych
Aplet może odczytywać dane przesłane przez serwer. W tym celu musi zostać najpierwutworzony obiekt klasy ���,������*��, używającej adresu URL programu działającego postronie serwera. Następnie musi dołączony zostać do niego strumień klasy -�..����/� ���������. W celu zaimplementowania tej metody w aplikacji klienta konieczne jest wykona-nie siedmiu głównych czynności, opisanych po kolei poniżej. W przedstawionym opisiepominięty został kod znajdujący się po stronie serwera, ponieważ zdefiniowany kod klientadziała z dowolnym programem pracującym na serwerze lub ze statyczną stroną WWW.
Zwróć uwagę, że wiele operacji na strumieniach generuje wyjątek klasy /��1�� �*��, dla-tego też przedstawione poniżej instrukcje muszą być umieszczone w bloku ���+2+���� .
1. Utworzenie obiektu URL wskazującego na domowy serwer apletu
Do konstruktora URL można przekazać bezwzględny adres URL (na przykładw postaci http://serwer/sciezka), jednak, z tego względu, że ograniczeniaspowodowane zabezpieczeniami uniemożliwiają połączenia wykonywane z apletówdo serwerów innych niż ten, na którym są one umieszczone, bardziej sensownewydaje się utworzenie adresu URL bazującego na nazwie serwera, z którego zostałon pobrany.
�����*��%+����������!��I�����+��*��������>� ����*��%+����#��� ����%� ���+��*�������������*��%+����#���B������*�����������*��%+����#��� ������+��*������������>���������3���1 ��3 ��*��+��� ������������������������������>� 7�������7�����7����������>�������
2. Utworzenie obiektu URLConnection Metoda � ��,������*��, zdefiniowanaw klasie URL, powoduje zwrócenie obiektu ���,������*��. Obiekt ten będzienastępnie wykorzystany w celu pobrania strumieni wykorzystywanych dokomunikacji.
���!����%�*����� %���*����������#����!����%�*�����
3. Nakazanie przeglądarce, aby nie umieszczała danych dołączonych do adresu
URL w swojej pamięci podręcznej Pierwszą czynnością konieczną do wykonania,wykorzystując obiekt ���,������*�� jest wskazanie, aby dane przekazywaneza jego pomocą nie były nigdy umieszczane przez przeglądarkę w pamięcipodręcznej. Tego rodzaju podejście gwarantuje uzyskanie za każdym razemnajświeższych wyników.
�� %���*�#������!%$���( ����
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 953
4. Ustawienie wszystkich pożądanych nagłówków HTTP Jeśli chce się ustawićnagłówki żądania HTTP (patrz podrozdział 19.7.), można wykorzystać metodęo nazwie �����3������� ����.
�� %���*�#�����R���� ����������� ���>�7�������%���
5. Utworzenie strumienia wejściowego Istnieje szereg odpowiednich strumieni,lecz najpowszechniej wykorzystywanym jest strumień -�..����������. Połączeniez serwerem WWW ustanawiane jest w chwili tworzenia strumienia wejściowego.
I�((�������������*��G�0�%*����������I�((�����������?����+����������� %���*�#���?����+���������
6. Odczytanie wszystkich wierszy dokumentu Specyfikacja HTTP wymagazamknięcia przez serwer połączenia po zakończeniu wysyłania dokumentu.W wypadku zamknięcia połączenia, użycie metody o nazwie �����*�� powodujezwrócenie wartości ��44. Dlatego też należy zwyczajnie odczytywać danewejściowe, aż do czasu uzyskania wartości ��44.
+��*����*������$* �����*������������*��G�0�%*���#���*������S���� ���������!�� ������%*���*������&
7. Zamknięcie strumienia wejściowego
�����*��G�0�%*���#% ������
Odczytywanie struktur danych zachowanych przy użyciu serializacji
Przedstawione w poprzednich rozdziałach pomysły prezentowały sposoby wymiany infor-macji pomiędzy apletem a dowolnym programem działającym po stronie serwera lub też zestatyczną stroną WWW. Niemniej jednak, kiedy aplet komunikuje się z serwletem, istniejejeszcze lepszy sposób wymiany danych. Zamiast wysyłania ich w postaci binarnej lub tek-stowej, serwlet może przesyłać dowolne struktury danych używając w tym celu mechanizmuserializacji, udostępnianego standardowo przez język Java. Aplet następnie może odczytaćte dane za pomocą jednego wywołania metody ������0���. Nie wymagana jest w takimwypadku żmudna analiza danych. Poniżej przedstawione zostały czynności konieczne doimplementacji tunelowania HTTP
Aplikacja działająca po stronie klienta
W celu odczytania struktur danych, zachowanych przy użyciu mechanizmu serializacji,przesyłanych przez serwlet, aplet musi wykonać siedem poniżej przedstawionych czynności.Jedynie czynności przedstawione w punktach 5. oraz 6. różnią się od tych, wymaganychpodczas odczytywania danych tekstowych opisanych poprzednio. Opis czynności zostałznacznie uproszczony, dzięki pominięciu bloków ���+2+���� .
1. Utworzenie obiektu URL wskazującego na domowy serwer apletu Podobnie jakpoprzednio, ponieważ adres URL musi wskazywać na serwer, z którego pobranyzostał aplet, bardziej sensowne jest określenie adresu względnego i pozwoleniena skonstruowanie go w sposób automatyczny.
954 Część III � Programowanie aplikacji działających po stronie serwera
�����*��%+����������!��I�����+��*��������>� ����*��%+����#��� ����%� ���+��*�������������*��%+����#���B������*�����������*��%+����#��� ������+��*������������>���������3���1 ��3 ��*��+��� ������������������������������>� 7�������7�����7����������>�������
2. Utworzenie obiektu URLConnection Metoda � ��,������*��, zdefiniowanaw klasie URL, powoduje zwrócenie obiektu ���,������*��. Obiekt ten będzienastępnie wykorzystany w celu pobrania strumieni wykorzystywanychdo komunikacji.
���!����%�*����� %���*����������#����!����%�*�����
3. Nakazanie przeglądarce, aby nie umieszczała danych dołączonych do adresu
URL w swojej pamięci podręcznej Pierwszą czynnością konieczną do wykonaniajest wskazanie, dzięki wykorzystaniu obiektu ���,������*��, aby dane przekazywaneza jego pomocą nie były nigdy umieszczane przez przeglądarkę w pamięci podręcznej.Tego rodzaju podejście gwarantuje uzyskanie najświeższych wyników za każdymrazem.
�� %���*�#������!%$���( ����
4. Ustawienie wszystkich pożądanych nagłówków HTTP Jeśli chce się ustawićnagłówki żądania HTTP (patrz podrozdział 19.7), można w tym celu użyć metodyo nazwie �����3������� ����.
�� %���*�#�����R���� ����������� ���>�7�������%���
5. Utworzenie strumienia wejściowego klasy ObjectInputStream Konstruktor tejklasy pobiera strumień danych nieprzetworzonych, udostępniany przez obiekt klasy���,������*��. Połączenie z serwerem WWW ustanawiane jest w momencieutworzenia strumienia wejściowego.
K�0�%�?����+����������*��G�0�%*������������K�0�%�?����+������� %���*�#���?����+��������
6. Odczytanie struktur danych przy użyciu metody readObject Metoda ta zwracaobiekt klasy ��0���, dlatego też konieczne jest wykonanie rzutowania na bardziejokreśloną klasę obiektu przesyłanego w rzeczywistości przez serwer.
���F �������%���� ���F �������*��G�0�%*���#��K�0�%����������!�� ������%*�������%��
7. Zamknięcie strumienia wejściowego
�����*��G�0�%*���#% ������
Aplikacja działająca po stronie serwera
Aby wysłać do apletu struktury danych zachowane przy użyciu serializacji, serwlet musiwykonać cztery poniżej przedstawione czynności. Założono, że metody ����� oraz ������dysponują przekazanymi w postaci argumentów obiektami ��3���� oraz ��� ���� klas��� ���54����3���� oraz ��� ���54����� ����. Podobnie jak poprzednio, przedstawioneczynności zostały uproszczone przez pominięcie wymaganych bloków ���+2+���� .
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 955
1. Zasygnalizowanie przesyłania danych binarnych Jako typ MIME przesyłanejodpowiedzi konieczne jest określenie � 4*���*��61�0�5�����*�4*������0���.Jest to standardowy typ MIME wskazujący obiekty zakodowane za pomocąstrumienia ��0������ ��������. Jednak w praktyce, z tego względu, że to aplet(a nie przeglądarka) odczytuje dane, określenie tego typu nie jest tak bardzo ważne.Więcej informacji na temat typów MIME zostało przedstawionych w podrozdziale19.10, „Odpowiedź serwera: Nagłówki odpowiedzi HTTP”.
+��*������0@�����%*������ *%�*��3"Q01Q���* *��Q��0�%�����������#���!������<�������0@�����%*��
2. Utworzenie obiektu klasy ObjectOutputStream
K�0�%�K�����+�������G�0�%*���������K�0�%�K�����+�������������#���K�����+��������
3. Zapisanie struktury danych wykorzystując metodę writeObject Większość,obsługiwanych wewnętrznie przez język Java, struktur danych może być wysłanychprzy użyciu metody ��*����0���. Jednakże klasy utworzone samodzielnie musząimplementować interfejs ���*�4*���4�. To dość proste do spełnienia wymaganie,ponieważ interfejs ten nie definiuje żądanych metod. Zwyczajnie należyzadeklarować klasę implementującą wspomniany interfejs.
���F �������%������� ���F ��###����G�0�%*���#��*��K�0�%�������%��
4. Opróżnienie strumienia w celu zagwarantowania wysłania całej zawartości
do aplikacji klienta
��G�0�%*���#( ��$���
W kolejnym podrozdziale przedstawimy przykład zastosowania tunelowania HTTP.
21.4. Przeglądarka żądań wysyłanych do serwera,
używająca serializacji obiektów
oraz tunelowania HTTP
Wielu ludzi interesuje się rodzajem zapytań wysyłanych do najpopularniejszych wyszuki-warek internetowych. Wynika to po części z ciekawości („Czy naprawdę aż 64 procent za-pytań zadanych w wyszukiwarce AltaVista pochodzi od pracodawców poszukujących pro-gramistów znających technologię Java?”), a po części z dążeń programistów do dostosowaniazawartości tworzonych przez nich witryn do najczęściej zadawanych zapytań, co powodujezazwyczaj zwiększenie ich pozycji w rankingu wyszukiwarek.
W tym podrozdziale przedstawiono wykorzystanie połączenia aplikacji apletu oraz serwle-tu, służącego do zaprezentowania fikcyjnej wyszukiwarki o nazwie super-wyszukiwarka-internetowa.com, która na bieżąco wyświetla przykładowe zapytania wysyłane przez użyt-kowników. Na listingu 21.5 pokazany został główny aplet wykorzystujący zewnętrzną klasę
956 Część III � Programowanie aplikacji działających po stronie serwera
(przedstawioną na listingu 21.6) do pobierania zapytań w wątku działającym w tle. Po za-inicjowaniu procesu przez użytkownika, co pół sekundy aplet umieszcza w przewijanymobszarze tekstowym przykładowe zapytanie. Zostało to przedstawione na rysunku 21.3. Nakoniec listing 21.7. prezentuje kod aplikacji serwletu tworzącego zapytania po stronie ser-wera. Powoduje on wygenerowanie losowego przykładu rzeczywistych, zadawanych przezużytkownika zapytań i podczas każdego żądania wysyła do klienta 50 z nich. Niektóreszczegóły dotyczące zastosowanych metod zostały omówione w rozdziale 19.
Osoby, które będą chciały pobrać kod źródłowy apletu oraz serwletu z archiwum umiesz-czonego pod adresem: ftp://ftp.helion.pl/przyklady/serinp.zip i będą próbowały uruchomićaplikację samodzielnie, muszą wiedzieć, że będzie ona działać jedynie wtedy, gdy wyświe-tlona zostanie główna strona HTML przy wykorzystaniu protokołu HTTP (na przykładużywając w tym celu adresu URL postaci http://…). Pobranie strony bezpośrednio z dyskuzakończy się niepowodzeniem, ponieważ aplet w celu komunikowania się z serwletem łączysię ze swoim katalogiem domowym. Poza tym, mówiąc ogólnie, próba nawiązania połą-czenia przy użyciu obiektu ���,������*�� w wypadku apletów, które nie korzystają z połą-czenia HTTP, nie powiedzie się.
Listing 21.5. PokazZapytania.java
*������01#�� ��#��� ���*������01#��#2�*������01#��#�1���#2�*������01#*�#2�*������01#���#2�
322��� ����%����04%���� *%8�AC%�%$:����>���%$�2����������4���������*�>��> ���W����!� �%�*���*���*���%�04%��04�����������2��<�"����#�F ��W����!� �%�*���������A����������9�%*�����* *�%0*#�2��D E�2�F����%�����*8������� �>*�0���%0*�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ��� �>�@����*��"�������� ���������������������������*�� ��������%�*���*������7������ �������*1���<�"����������@���������*1���I����������%*�>+���7�����%*�>+���7�����%*�>!���%�����*1���F� �>%0@������*��%�@����*�����*1���F� �>%0@�����>� �0��@����*�����*1������ ���*����%$��*������( �������*1���+��*�������������3���1 ��3%��#;�������@����������*1��������*��%+�����
����� *%�1�*�*�*������������I%>������!� ��#�$*���������������������I����������������������@�����������<�"����������������@����#���J��������J�����+��*(�7�J���# ��?/7�,M�������������@����7�I���������#!)/<)������� �� ���� ���%*�>��������� �� ���
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 957
Rysunek 21.3.
Wynik działaniaapletuPokazZapytania
����J����%�%*��> ���%*�>��������J�����+��+��*(�7�J���#IK��7�,V����������%*�>+����������I�������+��������������%*�>+���#���J����%�%*��> ���%*�>�����������%*�>+���#�%�*���*��������$*���������� ���%*�>��#�����%*�>+�������������%*�>+����������I�������+��������������%*�>+���#���J����%�%*��> ���%*�>�����������%*�>+���#�%�*���*��������$*���������� ���%*�>��#�����%*�>+�������������%*�>!���%�������I�������!���%�����������%*�>!���%#���J����%�%*��> ���%*�>�����������%*�>!���%#�%�*���*��������$*���������� ���%*�>��#�����%*�>!���%���������� ���%*�>��7�I���������#+K�<B�������*��%+����������!��I���������33�X4������������>A���%$�����C#�+4��������*��������33�������9�%*���4�>���*A04%������� �7��5�� ��������7�%���0�����*A�*�����33�����A���>�C%��������33��������08%*�����:��������*�AC%�%$:����>���%$#�����*��%�@����*�������F� �>%0@��������7��*��%+����������>� �0��@����*�������F� �>%0@��������7��*��%+��������&
��322�P�5 *������*���%*5�*8�������%*�>��+��������������2�����%$��*��4��>��*A04%����� ����5�*�� 04%�������*�������������2����>������#�G%*5�*8%*���+�������2���������0���*A�*�����%���7��5��!��56�����:9�*���2����������>�����#���23
958 Część III � Programowanie aplikacji działających po stronie serwera
����� *%�1�*�%�*�� ��(������%�*��)1�����1����������*(���1���#���+���%�����������%*�>+������������*(��S*����%$��*��������������<$������%��G���*�� 0%��������<$����$*�����������*����%$��*������������������������@����#���<�"�����������������%��G���*�� 0%�#����������������$��+������ ��%�����5�*�� 04%�������*�����A����%$��*���###���������&�� �������������$��+������ ��%�����5�*�� 04%�������*�0�9��*A###���������&����&�� ���*(���1���#���+���%�����������%*�>+������������*����%$��*������( ����������$��+������ ��%�����5�*�� 04%�������*�����A���������###�������&�� ���*(���1���#���+���%�����������%*�>!���%��������������@����#���<�"����������&��&
��322� ��%����*A04%����� �����*�����*�>���*��%�@����*���2��*�%���:A���>������*���%��0����������%$������%$����*������C���2����� �����������>�������#� ����5�*�� ��*��������>*%$�����C7���2���4��>�>��*�0�������56���*�>�����2��>� �0��@����*������*�>�����2���*��%�@����*7�����A������94�*�������������2����%� ���������������A�*��*���*�>���>� �0��@����*�*��������%A�����%�����23
����� *%�1�*�������������$* ��*����%$��*��������������>�@����*��*��%�@����*���������*��%�@����*���>� �0��@����*�������>� �0��@����*�������F� �>%0@��������7��*��%+����������&��&
����*1���1�*���>�@����*�F� �>%0@�������*��@�����������33�P�5 *�94�*������A�����A�����������7� �%���*�����:%*A����0���%������*>:�7����33������� �9�������6�%����>��87�%�����*������A���>�C%����#����33� ��*�������6��*8��56���>�7� �%����9������8���6��������>��������� ��%$����33���A4%��C��*�%*���%$� �������%*49���%$�������:�#�����$* ��S��*��@����#*�F��*�%������������$��+������K%��>*��*���������������###�������������,������&�����$��+������K�������������������###�������+��*��NO������*����� ����������������������*�����*��@����#���*���@����*�������&�%�%$��?K)"%���*�������&����+��*�����>>��%�*��������Y�������33���*�56������%*4�������*�������������>�������%���:A���>���#����(���*���*�H��*D�����*# ����$��*�����������*(��S*����%$��*���������������������������&�����������@����#����������*N*O�������������@����#�������>>��%�*������
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 959
����������H#Z������&��&
����� *%�1�*�������� ����%���������������������<$��#� ����� �������%���2,HHH�������&�%�%$�?���������)"%���*���*����&��&&
Listing 21.6. KolekcjaZapytan.java
*������01#���#2�*������01#*�#2�
322� ����������*����0�> ��7����%�������%$�*�������567�2���������>�����������@����*�0�����������56��� 7�������������>�*�@>��%���������56�( ���2��G��*8��%��*������0�������������4��>��A�94%���������*�%*4�:������C����������2���%�������%$���0�������%$���������9�%*����*�>���> ���2��K�0�%�?����+����#� �������*��%*4�:������C��4�������*���%��������*����0�2���%�������0�����������8����@����*7�2���5�����56���%��*>�*�@>��%���������0����*��*���������#�2��F ����>����������������� ���+$��W���*��#�2��D E�2�F����%�����*8������� �>*�0���%0*�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ���F� �>%0@�����*�� ������������ �������*1���+��*��NO������*�����*1���+��*��NO����%�����@����*�����*1������ ���*�F��*�%���( �������*1������������������
����� *%�F� �>%0@�����+��*������������>���7������*��%+����������������������33�F��*�%����0�����>��5 ��*��0���*����������>���������7�0>��9�������33� ���%�856�������>��5 ��0�����������*���*�94%�0�������#������+��*��������>� ����*��%+����#��� ����%� ���������+��*���$�������*��%+����#���B������������*�����������*��%+����#��� ��������������������������������������>� 7�$���7�����7����������>�����������<$������> ��*��0%�@����*�������<$����$*������������> ��*��0%�@����*#�����������&�%�%$�' (�������)"%���*����(����������*�F��*�%������������&��&
����� *%�1�*��������������������������%�����@����*������*���@����*���
960 Część III � Programowanie aplikacji działających po stronie serwera
�����������*������%�����@����*�����&�%�%$�?K)"%���*���*��������������%�����@����*����� ������������*����� �����&����*�F��*�%����������&
����� *%�+��*��NO����@����*��������������������*����&
����� *%���� ���*�F��*�%���������������*�F��*�%����&
������������� ����������������������������������������� !"��������������������#�$���%$���� !&����"����������'����((�)���*����+�������,-�*�������.$�/�������0�������������$����� !�����0�+�����$+����1����((�2�����0��������*�����/�,�3*������������$���/�*$����*.$����&��������������&�����"������4�����'����((�)���*���*�,���1���������0��/-�����0�*�������5��1�$���������$������������ �������1���������0����#������������1���������0�����������&���������0���'�������������((�0��$����$��1�������������/-������((�$������/���������1������������������������������/���������� ��������������#������ ����&��$��1����'����������������������'����6������"����)�7���$�����������4�������������������'����6��6&
Listing 21.7. GeneratorZapytan.java
�%>���%���
*������01#*�#2�*������01"#���1 ��#2�*������01"#���1 ��#$���#2�
322�+��� ��������4%���� *%��AC%�%$:����>���%$��������*�*�2��*�����A04%��0��������9�%*����*�>���> ���K�0�%�K�����+�������� ����2�� ���*������> *������*��������0���>��P1#�2��D E�2�F����%�����*8������� �>*�0���%0*�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ���;�������@������"�����B���+��1 ��������� *%�1�*��;���B���+��1 ����R�������R����7��������������������B���+��1 ��������������������
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 961
�������$�����+��1 ��)"%���*��7�?K)"%���*����������� ������0/�������*������������+��*�����%��*>/�������*����������R����#��� �����������/�����*���������*(�����%��*>/�������*������ ��[[����������%��*>/�������*#�R� ���( ����������������0/�������*���( �������&��������������������#������8����������(�91�:�9��������$9��1��8'�����������&��"����;���������������'������1���������0����#������������1���������0��������&���������0���'�������� �����������#���������������1)�0��������'����33�P�5 *�����A��*8��*�������������>�������%$7�� �9�������*6��*87�9�����33��>��5 �������A�*�� �����%0�*����(�0������* *�%0*��*�� �������+��* *�� ��#������&�����1������������'������&4������'��&
����� *%�1�*�� ����B���+��1 ����R�������R����7���������������������B���+��1 ���������������������������$�����+��1 ��)"%���*��7�?K)"%���*���������;�����R����7�������������&
����*1���+��*��NO����@����*���� ������0/�������*�������+��*��NO������*�������+��*��NZHO�����(���*���*�H��*D�����*# ����$��*����������������*N*O��� �����@����*����������*(�����0/�������*����������������*N*O���������*�,�����=����������*N*O�������&����&����������������*����&
��33����%���*���������*�����A��������� ��*�=Q�
����*1���+��*��� �����@����*���������+��*��NO��� ����*�������;�*����7��G�0>*����������&�����+��*��NO�%������%��������������������>%��7��������� ��%��7�����������%���&�����+��*��NO���� ������������*�(���%0���7���������7������7����� �*���&�����+��*��NO�����*��>��������������7�������%���*�����7�����%�%����&�����+��*��NO����������������>�*�>*�+���*���*����������# ��������*��7�����������>������*��0%�������� ���������������P+ �7������������� ���������������P1+��1��� ����7������������� ���������������P+ �7���������>�*�>*�+���*���*����������# ��������*���G��*��.��7����������+���*���*����������# ��������*���G��*��.��7������������������*����� �����7����%$�� ��**�P1+��1��� ����7��������P+ �7��������� ������������������������*�!;?���������%*��0���>�P1�7��������������������0���>��P1��* 0%�%$���������*����������&�����+��*��NO��>��%���*���������7����7����7���S�7���SSS���&�����+��*��NONO���� ���@���
962 Część III � Programowanie aplikacji działających po stronie serwera
���������� ����*�7�%������%7���� �7������������*��>7�����7��>��%���*��&�����+��*��������*�����������(���*���*�H��*D��� ���@�# ����$��*����������������*���������*���� �����) ��������� ���@�N*O������&����������������*�����&
����*1���+��*��� �����) ������+��*��NO� �%�%$��������*���*��>�����*����'�$#������2 �%�%$�# ����$������������� �%�%$�N*��>�O����&&
21.5. Wysyłanie danych przy użyciu metody POST
i przetwarzanie wyników wewnątrz apletu
(tunelowanie HTTP)
Podczas przesyłania danych przy użyciu metody ���, aplet ma dwie możliwości wyświetleniawyników. Może on nakazać wykonanie tej czynność przeglądarce (utworzyć odpowiedniobiekt adresu URL, a następnie wywołać metodę � 4��,����1�&'%� ���������) lub teżprzetworzyć dane samodzielnie (utworzyć obiekt adresu URL, pobrać obiekt klasy ���,�������*��, otworzyć strumień wejściowy i odczytać dane). Metody te zostały omówione, od-powiednio, w podrozdziale 21.1. oraz 21.3. W przypadku wykorzystywania danych ����możliwe jest wykorzystanie tylko drugiej metody, ponieważ konstruktor obiektu URL niezawiera metody pozwalającej na skojarzenie z nim danych przesyłanych przy użyciu metody����. Przekazywanie danych w ten sposób ma kilka zalet, ale też niedogodności w porów-naniu z używaniem metody ���. Do dwóch najważniejszych niedogodności należą: koniecz-ność umieszczenia programu działającego po stronie serwera na tym samym komputerze coaplet oraz konieczność wyświetlania danych przy użyciu apletu. Nie istnieje bowiem moż-liwość przekazania kodu HTML do przeglądarki. Do zalet natomiast należy to, że programdziałający po stronie serwera może być prostszy (nie trzeba umieszczać wyników w kodzieHTML), zaś aplet może odświeżać wyświetlane dane bez potrzeby ponownego odczytywa-nia strony. Co więcej, aplety wykorzystujące do komunikacji metodę ����, mogą stosowaćw celu wysyłania danych do serwletu strumienie przekazujące dane zapisane za pomocą se-rializacji, oprócz już opisanej wcześniej, analogicznej metody podczas pobierania danychz serwletu. To poważny plus, ponieważ wykorzystywanie danych serializowanych oraz tu-nelowania HTTP pozwala na ominięcie zabezpieczeń stosowanych na zaporach sieciowych,aby uniemożliwić bezpośrednie połączenia pomiędzy gniazdami. Aplety wykorzystującemetodę ��� mogą odczytywać dane zapisywane w ten sposób (patrz podrozdział 21.4), lecznie są w stanie ich wysyłać, gdyż niemożliwe jest dołączenie do adresów URL dowolnychdanych binarnych.
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 963
Aby umożliwić wysyłanie z apletów do serwera danych przy użyciu metody ���� oraz od-czytywanie wyników, wymagane jest wykonanie trzynastu czynności przedstawionych po-niżej. Chociaż ich liczba jest dość duża, to jednak każda z czynności jest względnie prosta.Kod został znacznie uproszczony dzięki pominięciu bloków postaci ���+2+���� , w któ-rych powinny zostać umieszczone wszystkie instrukcje.
1. Utworzenie obiektu URL wskazującego na domowy serwer apletu Podobniejak poprzednio, ze względu na to, że adres URL musi wskazywać na serwer,z którego pobrany został aplet, bardziej sensowne jest określenie adresuwzględnego i pozwolenie na skonstruowanie go w sposób automatyczny.
�����*��%+����������!��I�����+��*��������>� ����*��%+����#��� ����%� ���+��*�������������*��%+����#���B������*�����������*��%+����#��� ������+��*������������>���������3���1 ��3 ��*��+��� ������������������������������>� 7�������7�����7����������>�������
2. Utworzenie obiektu URLConnection Obiekt ten będzie następnie wykorzystanyw celu pobrania strumieni wykorzystywanych do komunikacji.
���!����%�*����� %���*����������#����!����%�*�����
3. Nakazanie przeglądarce, aby nie umieszczała danych dołączonych do adresu
URL w swojej pamięci podręcznej
�� %���*�#������!%$���( ����
4. Uzyskanie od serwera pozwolenia na wysyłanie danych, a nie jedynie
odbieranie wyników
�� %���*�#�����K������������
5. Utworzenie strumienia ByteArrayOutputStream, wykorzystywanego
do buforowania danych, które będą wysyłane do serwera
Strumień ByteArrayOutputStream wykorzystywany jest w celu określenia rozmiarudanych wyjściowych, tak aby aplet był w stanie wysłać nagłówek ,����������7� ,wymagany podczas żądań typu ����. Konstruktor klasy -����������� ��������wskazuje początkowy rozmiar bufora danych, lecz jego podanie nie jest wymagane,gdyż rozmiar bufora będzie zwiększany w razie potrzeby w sposób automatyczny.
I�������K�����+���������*��I*�����������I�������K�����+�����Z,.��
6. Skojarzenie strumienia wyjściowego z obiektem klasy
ByteArrayOutputStream
Wysłając normalne dane formularza, należy wykorzystać obiekt klasy��*��(�*���. W celu wysłania struktur danych zachowanych przy użyciuserializacji, trzeba wykorzystać w zamian obiekt klasy ��0������ ��������.
�*��G�*������G�0�%*���������� �*��G�*���������*��I*����7�������
7. Umieszczenie danych w buforze W przypadku normalnych danych formularzanależy wykorzystać metodę �*��. Natomiast w celu wysłania obiektów wysokiegopoziomu, zachowanych przy użyciu serializacji, metodę ��*����0���.
964 Część III � Programowanie aplikacji działających po stronie serwera
+��*�����,������)�%���#��%��� ���G����%,��+��*�����.������)�%���#��%��� ���G����%.��+��*������������,�������,����-���.�������.���33@���%����������>�-��G�0�%*���#��*��������33���:6����8����9�%*����������*��7���*����*�� ���G�0�%*���#( ��$����33�9�%*����0�������0����>��*�%�������*��9��*������A��>���������������*�� �
8. Ustawienie nagłówka o nazwie Content-Length Nagłówek ten jest wymaganyw przypadku danych przesyłanych przy użyciu metody ����, nawet jeśli nie jest onużywany w przypadku metody ���.
�� %���*�#�����R���� ���������!������Q�����$�7���+��*��#1 ��K(������*��I*����#�*�������
9. Ustawienie nagłówka o nazwie Content-Type Przeglądarka Netscape używadomyślnie typu ��4�* ���%.��������, jednak przesyłanie regularnych danychformularza wymaga ustawienia nagłówka o wartości � 4*���*��61�����.������4�������, który z kolei jest domyślny w przypadku przeglądarki Internet Explorer.Dlatego też, w celu umożliwienia przenoszenia programów, w przypadku wysyłaniazwykłych danych formularza, wartość ta powinna zostać ustawiona w sposóbjawny. W przypadku wysyłania danych zapisanych przy użyciu serializacji wartośćta nie jest istotna.
�� %���*�#�����R���� ���������!������Q<����7���� *%�*��3"Q���Q(���Q�� ��%�����
10. Wysłanie rzeczywistych danych
�����*��I*����#��*��<���� %���*�#���K�����+��������
11. Utworzenie strumienia wejściowego W przypadku danych tekstowych (ASCII)oraz binarnych zazwyczaj wykorzystywany jest obiekt klasy -�..����������,natomiast w przypadku danych serializowanych obiekt klasy ��0���/� ��������.
I�((����������G�0�%*����������I�((���������������?����+����������� %���*�#���?����+���������
12. Odczytanie wyniku
Szczegółowy opis wymaganych czynności zależy od rodzaju danych wysyłanychprzez serwer. Poniżej przedstawiony został przykład wykonujący pewne nieokreślonebliżej czynności z każdym wierszem danych przesyłanych przez serwer:
+��*����*������$* ����*���������G�0�%*���#���*������S���� ���������!�� ������%*���*������&
13. Pogratulowanie sobie Procedura obsługi danych przesyłanych przy użyciu metody���� jest długa i zawiła. Na szczęście, jest to dość standardowy proces. Oprócz tegomożna zawsze pobrać kod źródłowy umieszczony pod adresem ftp://ftp.helion.pl/przyklady/serinp.zip i wykorzystać go w charakterze szablonu, od którego możnarozpocząć tworzenie własnych programów.
W kolejnym podrozdziale przedstawiony zostanie przykład apletu, wykonującego wszyst-kie opisane czynności.
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 965
21.6. Aplet wysyłający dane
przy użyciu metody POST
Na listingu 21.8. przedstawiony został aplet wykorzystujący metodę opisaną w poprzednimpodrozdziale. Aplet ten w celu wysłania danych przy użyciu metody POST pod wskazanyadres URL wykorzystuje obiekt klasy ���,������*�� oraz -����������� ��������. Używaon również klasy o nazwie ���)*���������4���)�����, która umieszczona została w archi-wum znajdującym się pod adresem: ftp://ftp.helion.pl/przyklady/serinp.zip.
Na rysunku 21.4. przedstawiony został wynik przesłania danych do serwletu o nazwie ���)��8�74��)*, który jest niezwykle prosty i tworzy stronę WWW, zawierającą wszystkie pa-rametry przesłanego żądania. Szczegółowe informacje na ich temat umieszczone zostaływ podrozdziale 19.6, „Żądanie klienta: Dostęp do danych formularza”.
Listing 21.8. WyslijPost.java
*������01#�� ��#��� ���*������01#��#2�*������01#��#�1���#2�*������01#���#2�*������01#*�#2�
322��� ����%����04%���������������%$�(*���/��7� ��/�������2����* �����7�����8��*������A04%��0��������������*���%�������2������>�������������7����%*���������*����?�������9�%*�������� K+<#�2��D E�2�F����%�����*8������� �>*�0���%0*�2�>�*49>*�+���*���*����������#� ��������*��2�G���*%����B� *��7�; *�*%�7�2�(��=33(��#$� *��#� 3����> �3���*��#�*��2�.HH,�'����B ��������I������23
��� *%�% ���G�� *0 �����"�������� ������������������������*�� ��������%�*���*������������*1���)��>*������ � �<�>�������� �?�*��*7��� �/��*�>7����������������������������� ������)�* 7��� �/���+�����7����������������������������� �/����� ����7��� ��������?�����*1���I����������%*�>G�� *0�����*1���<�"����������G��*>���������*��%+�����
����� *%�1�*�*�*������������I%>������!� ��#�$*���������������������I����������������� �� ���� G�0�%*���������� �� ���������� G�0�%*���#�������������;�*������\7�,���������� G�0�%*���#���J��������J�����+��*(�7�J���#IK��7�,M��������� �?�*��*������������)��>*������ � �<�>�������?�*�=�7�,Z��������� G�0�%*���#��� �?�*��*�������� �/��*�>��
966 Część III � Programowanie aplikacji działających po stronie serwera
Rysunek 21.4.
Wynik działaniaapletu o nazwieWyslijPost,wysyłającegoprzy użyciumetody POSTdane do serwletuPokazNaglowki
����������)��>*������ � �<�>�������/��*�>�=�7�,Z��������� G�0�%*���#��� �/��*�>�������� ������)�* ������������)��>*������ � �<�>������������)�* =�7�UH��������� G�0�%*���#��� ������)�* ������!�1���������,�������!�1����������� G�0�%*���#��������,�������� �/���+�����������������)��>*������ � �<�>�������+�����=�7�,Z��
����33��� �����%�����������������*�6����4�>����*>��6��*8�0���*������������7����33���>�:���������A��������#������ �/���+�����#��0 � �<�>�������#���)*�� ��( ����
�����*��%+����������!��I���������33���������B�������%�������AC%�%$���>�����������>��� ��:���%�����%$��������>�� �> ����#����+��*�������������*��%+����#���B����������+��*���>����*>�G��*>�������G������*�0�%����>���������*��>����*>�###������*(��������# ����$������H���������>����*>�G��*>�������IA=�<���� ������*�����%��%������Y���������������������������������%���*�������������GGG�������9�%*�������>�A��B<< 7�Y������������������������������*���� �> �������>��������%4��>��5 ��*���������Y��������������������������������%*�](* �=]#�'�9 *���0����0��>����%$��*��*���������GGGY������������������������������ �> ������������#�����������)�� ��( ��������&
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 967
������ �/���+�����#��0 � �<�>�������#���<�"����������������� G�0�%*���#��� �/���+������������� �/����� ����������������)��>*������ � �<�>������� �����Q,����%����������� ���=�7�M������+��*�������+��*�����+��*��#1 ��K(��*��%+����#��� ������������� �/����� ����#��0 � �<�>�������#���<�"������+��*����������� G�0�%*���#��� �/����� ������������ ��������?������������)��>*������ � �<�>���������?=�7�MH������+��*������� ��������?����3���1 ��3%��#+$�� ��������������� ��������?#��0 � �<�>�������#���<�"������ ��������?��������� G�0�%*���#��� ��������?������!�1���������.�������!�1����������� G�0�%*���#��������.����������%*�>G�� *0�������I�������G�� 0��������������%*�>G�� *0#�%�*���*��������$*������� �� ������� �� ������� �� ������������� �� #�����%*�>G�� *0��������� G�0�%*���#������� �� ���������� G�0�%*���7�I���������#/K�<B�����������G��*>��������<�"����������������G��*>�#���J��������J�����'�����%��7�J���# ��?/7�,M������������G��*>�#���<�"��>����*>�G��*>���������������G��*>�7�I���������#!)/<)�����&
����� *%�1�*�%�*�� ��(������%�*��)1�����1���������������������+��*��������>� ����*��%+����#��� ����%� ���������+��*�������������� �/���+�����#��0 � �<�>�������#���<�"����������+��*���%*� ��������� �/����� ����#��0 � �<�>�������#���<�"����������*����������������������������������?������#����?���%*� ������������&�%�%$�/�����J����)"%���*����(�������������������Q,��33����5 ������������������LH������&������+��*�����*����� ��������?#��0 � �<�>�������#���<�"����������� !�$���� !�#������ !����/��-�����-���-����'������� !"��������������������#�$���� !&����"����������'
������33�/ �9���*8������*67�9������� 4�>��*����*���%���������������(������������*8%*����8%���0#����������������&�����"������4�����'
������33�/ �9���>�6������ 4�%�����9 *�*��*������A�*���%$���������#����������������&��<���������'
������=��%���������0���0���=������#������������=��%���������0�>?@�'�((� ���������4���������������������33�+����*�C���*��04%������(��������2��A������#�����2��A�����0���=�����-����'�����������$���2���#��������84��)�0�#8�B��������/�$�����������0�������B��������8C���)�0�#8�B��������/�$����������)�����/���B��������8C�0���%$$���#8�B��������/�$����������%$����0����'
968 Część III � Programowanie aplikacji działających po stronie serwera
������33�@�*������������A���������%4������� K+<��� �> �������(�����%$��������&����$���2���'��������&4������'�((�������1���4��1�����������������/���������������0��$����������-������������
������33�X4�*� K+<�����04��>��5 ��*���A:�>�!������Q�����$���������������<��������#������������&:�����4���0���=�����&�������'����������������&�� �D���2�������������8"����9!����8-�����<��������'
������33� ���� 4�>�/���%�������*�������%��*����A:��>�!������Q<����*��0��������������56��� �*���3(���Q�������33�P�5 *��*8%�������A����4����>A�����(���� ��7����*�����*��*6�0��������56������33����� *%�*��3"Q���Q(���Q�� ��%��7�%����>� �*������33������*�����56����5 �4�����*�4������������ 4�>8�?��������)"� ����#������P�5 *�������A��*8������33���� K+<���*����������9�%*�������*��*�K�0�%�K�����+����7������33�����56���A:�>�!������Q<�����*��0��������������87� �������9������33���9��������*�46#����������������&�� �D���2�������������8"����9;���8-�8����������(�9���94�09������$�$8�'
������33�/ �9����*�6���� K+<������%���*�����������*��*���05%*�������������0���=�����&���;������������&���������0���'
������=�44��$ ��$�����#������������=�44��$ ��$�������������0 ��$�����������������������������������������&���������0����'����������������'��������������/E����A������#�8F�8'�����������A���/�&��;���88�'�������������������#���&��$!�������G#���������������������A���/�&�����$�������'�������������A���/�&�����$����/E����A������'������6����&�%�%$�?K)"%���*���*�����������33�/ �9����*�6�*�(���%0������������>���� *�P1�������+�����#���#��*�� ���?K)"%���*��=�����*��������&��&
��33�K�*�>��> ������ �<�"�J*� �0���������%���*����%*���*�>����> ��� �� ��33�����*���%�������C���*�>��*�> ������ ������33�<�"�J*� #� ��*9�����������*�������56���*���%���4����� ����>������7��33����8��*��>��0��04�������9�%*�����������Q��%���*����%�����>������*>#
����*1���+��*��������%@>�����)��>*������ � �<�>�������� ��������+��*��������%K���*� ������ �#��0 � �<�>�������#���<�"������������������)�%���#��%��������%K���*� ������&
&
Rozdział 21. � Wykorzystywanie apletów w charakterze interfejsu... 969
21.7. Pomijanie serwera HTTP podczas komunikacji
z programem po stronie serwera
Chociaż aplety mogą utworzyć połączenia sieciowe jedynie z tym samym komputerem,z którego zostały wczytane, nie muszą używać w tym celu koniecznie tego samego portu(na przykład portu 80 w przypadku połączeń HTTP). W celu komunikacji z różnymi klien-tami działającymi na tym samym serwerze mogą one używać zwykłych gniazd, JDBC orazRMI.
Wykonanie tych czynności w apletach przebiega dokładnie tak samo, jak w przypadkuzwykłych programów utworzonych w języku Java, dlatego też można użyć metod wykorzy-stania gniazd, JDBC oraz RMI, które są już znane, pod warunkiem, że używa się tego samegoserwera sieciowego, z którego pobrany został aplet.
21.8. Podsumowanie
Formularze HTML stanowią najprostszy oraz najpowszechniej stosowany interfejs użytkow-nika programów działających po stronie serwera. Tym niemniej, aplety dostarczają bogat-szego zestawu elementów interfejsu użytkownika, umożliwiają utworzenie ekranów z ciągleodświeżaną zawartością oraz upraszczają zdecydowanie przesyłanie dużych złożonychstruktur danych. Generalną zasadą jest używanie formularzy wszędzie tam, gdzie jest to tylkomożliwe. Jednak wygodnie jest dysponować możliwością użycia apletów w przypadku, gdyformularze HTML stają się zbyt ograniczone.