JBuilder. Vademecum profesjonalisty

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

JBuilder. VademecumprofesjonalistyAutorzy: Michael Landy, Saleem Siddiqui, Jeff SwisherT³umaczenie: Adam Majczak (rozdz. 1 - 9, 30, 31), TomaszMiszkiel (rozdz. 17, 19, 20 - 24), Pawe³ Ro�czak(rozdz. 25, 28, 29), Marcin Samodulski (rozdz. 10 - 16),Krzysztof Wo³owski (rozdz. 18, 26, 27)ISBN: 83-7361-139-8Tytu³ orygina³u: JBuilder Developer's GuideFormat: B5, stron: 856

JBuilder firmy Borland to ulubione �rodowisko programistyczne wielu programistów Javy, pozwalaj¹ce na efektywne tworzenie z³o¿onych aplikacji.

O technikach programowania w jêzyku Java i zwi¹zanych z nim specyficznych zagadnieniach traktuje wiele ksi¹¿ek. Ta, któr¹ trzymasz w rêku, koncentruje siê bardziej na opisie JBuildera — wbudowanych w niego mo¿liwo�ci, automatycznych kreatorów i narzêdzi — ni¿ na samych kodach Javy. Opisuje wiele zaawansowanych zagadnieñ, takich jak: testowanie modu³ów, refaktoring, Java Server Pages, Enterprise JavaBeans, CORBA i dostêp do baz danych. Opisano miêdzy innymi:

• �rodowisko JBuilder, jego interfejs i mo¿liwo�ci dostosowania do w³asnych potrzeb • Kreatory JBuildera: Screen Designer i Menu Designer • Modelowanie w �rodowisku JBuildera, UML • Testowanie modu³ów, debugowanie programów • Refaktoring • Przygotowanie aplikacji do wdro¿enia • Korzystanie z AWT i Swing • Tworzenie formatek i elementów graficznych • Korzystanie z plików i relacyjnych baz danych, DataExpress • Tworzenie aplikacji sieciowych i JSP, korzystanie ze Struts • Korzystanie z XML w JBuilderze • Pisanie aplikacji opartych na EJB • Tworzenie i wdra¿anie oprogramowania z u¿yciem serwerów WebLogic i WebSphere • Tworzenie aplikacji WWW (webservices), protokó³ SOAP • Pisanie midletów • Zespo³owe tworzenie aplikacji

Jest to ksi¹¿ka dla �rednio zaawansowanych programistów Javy. Dziêki praktycznemu podej�ciu do omawianych tematów sprawi, ¿e w szybkim tempie poznasz niuanse JBuildera i bêdziesz tworzy³ zaawansowane aplikacje efektywniej ni¿ do tej pory.

http://helion.pl/view/2547w



http://helion.pl/add/2547w/jbuilv




mailto:[email protected]

http://helion.pl/view/2547w/jbuilv.htm

http://www.amazon.com/exec/obidos/ASIN/067232427X

��

��

��

�� Od Oak do J2EE — krótka historia Javy...............................................................................28Pierwszy rzut oka na JBuildera..............................................................................................30I co dalej?...............................................................................................................................31Podsumowanie .......................................................................................................................32

�� !��"��#��!�� $$Zintegrowane środowisko projektowe JBuildera ..................................................................33Główne menu.........................................................................................................................35

Menu File.........................................................................................................................35Menu Edit, Search i View................................................................................................35Polecenia formatujące z menu Edit .................................................................................36Menu Project....................................................................................................................39Menu narzędzi — Tools ..................................................................................................48Pozostałe menu ................................................................................................................52

Listwa narzędziowa — Toolbar.............................................................................................53Część praktyczna ...................................................................................................................53

Projekt Welcome .............................................................................................................53Projekt Hello World.........................................................................................................54

Podsumowanie .......................................................................................................................58Tematy do przemyśleń.....................................................................................................59

��$� %�� "�&'��'��#��!�� (�Screen Designer .....................................................................................................................61

Uruchomienie edytora graficznego .................................................................................62Implementacja metod obsługujących zdarzenia ....................................................................67

Jak przebiega obsługa zdarzenia......................................................................................68Stosowanie adaptera anonimowego.................................................................................69Stosowanie adapterów standardowych............................................................................70Zmiana ustawień adaptera ...............................................................................................70

Menu Designer.......................................................................................................................71Przyciski Menu Designera...............................................................................................72Budowanie menu za pomocą Menu Designera ...............................................................72Obsługa poleceń z menu — implementacja ....................................................................73Utworzenie menu kontekstowego ...................................................................................74

6 JBuilder. Vademecum profesjonalisty

Część praktyczna ...................................................................................................................75Utworzenie szkieletu aplikacji.........................................................................................76


�� !��"� ��!��#$

��)� *��!�� +�Szybki przegląd UML............................................................................................................81

Elementy języka UML.....................................................................................................82Diagram klas w UML......................................................................................................83Pokazywanie pakietów na diagramach klas ....................................................................84

JBuilder a UML .....................................................................................................................86Diagramy klas JBuildera .................................................................................................86Diagram zależności dla pakietu (Package Diagram) w środowisku JBuilder .................88

Wskazówki.............................................................................................................................88„Unikać zagnieżdżonych zależności”..............................................................................89„Rób tylko jedną rzecz, za to dobrze” .............................................................................90„Hermetyzacja: pokaż operacje, a ukryj dane” ...............................................................91„Myśl na odpowiednim poziomie abstrakcji” .................................................................91

Część praktyczna ...................................................................................................................91Modelowanie serwera......................................................................................................93Modelowanie klienta .......................................................................................................95


��,� -� ��&��.�� Opcje testowe JBuildera ......................................................................................................100Środowisko testowe JUnit Testing Framework ...................................................................102

Tworzymy test za pomocą JUnit ...................................................................................103Uruchomienie testu za pomocą JUnit ............................................................................104

Tworzenie testów i zbiorów testów, uruchamianie w środowisku JBuildera......................105Jak budować obiekty Test Case za pomocą JBuildera? ................................................106Utworzenie obiektu Test Suite za pomocą JBuildera....................................................109

Funkcje pomocnicze dla testowania JDBC, JNDI i porównawczego .................................111Wspomaganie porównywania........................................................................................112Funkcje pomocnicze do testowania JDBC ....................................................................114Funkcje pomocnicze do testowania JNDI .....................................................................116

Część praktyczna .................................................................................................................117Krok 1.: otwieramy projekt z przykładowymi testami ..................................................117Krok 2.: dodajemy do projektu kod testujący Unit Test Case.......................................118Krok 3.: dodajemy do projektu porównywanie — Comparison fixture........................119

Podsumowanie .....................................................................................................................122Tematy do przemyśleń...................................................................................................122

��(� -� ��&��/��'!��0�1�� $Zintegrowany debuger .........................................................................................................123

Przyciski sterujące debugera .........................................................................................124Zakładki diagnostyczne Debug Views ..........................................................................126Sesja diagnostyczna i status...........................................................................................127

Podstawy debugowania........................................................................................................128Kontrola błędów w czasie rzeczywistym ......................................................................128Komunikaty o błędach kompilatora ..............................................................................129Wstawianie punktów kontrolnych .................................................................................129

Spis treści 7

Więcej o opcjach debugera ..................................................................................................132Opcje dotyczące punktów kontrolnych .........................................................................133Śledzenie klas ................................................................................................................134

Część praktyczna .................................................................................................................135Krok 1.: otwarcie sesji diagnostycznej przykładowego projektu ..................................136Krok 2.: poprawiamy błędy składniowe........................................................................136Krok 3.: poprawiamy błędy występujące podczas kompilacji ......................................137Krok 4.: poprawiamy błędy występujące podczas działania,wstawiamy punkty kontrolne, dokonujemy oceny i modyfikacji zmiennych............138


�� 2��1�� ),Co to jest refaktoring?..........................................................................................................146Proces Move Refactor..........................................................................................................146Zmiana nazwy Rename Refactor .........................................................................................149

Zmiana nazwy pakietu...................................................................................................150Zmiana nazwy klasy lub interfejsu................................................................................152Zmiana nazwy metody...................................................................................................154Zmiana nazwy pola lub nazwy zmiennej ......................................................................155Zmiana nazwy własności...............................................................................................156

Zmiana parametrów .............................................................................................................156Wyodrębnienie metody........................................................................................................157Wprowadzenie zmiennej......................................................................................................158Optymalizacja importu ........................................................................................................160Obejmowanie obsługą wyjątków.........................................................................................162Część praktyczna .................................................................................................................163

Krok 1.: otwieramy przykładowy projekt i przeglądamy kod.......................................163Krok 2.: przenosimy klasę moveExample.....................................................................163Krok 3.: zmieniamy nazwę klasy moveExample ..........................................................164Krok 4.: zmiana nazwy zmiennej ..................................................................................165


��+� 3��&��4�� #��!�� (�Dodawanie komentarzy .......................................................................................................168Znaczniki Javadoc................................................................................................................168Javadoc to nie tylko dokumentacja ......................................................................................169Dokumentacja niezgodna z kodem ......................................................................................170Automatyczne szablony Javadoc .........................................................................................171Zastosowanie kreatora Javadoc Wizard...............................................................................171Wskazówki...........................................................................................................................179

Skoncentrujmy się na zastosowaniu dokumentacji .......................................................179Porady dotyczące stylu ..................................................................................................180


�� 3��!�'&��5��'1��6�� +$Pliki archiwalne Javy ...........................................................................................................184Plik manifestu ......................................................................................................................184Archiwizator Javy ................................................................................................................185

Przeglądanie archiwum..................................................................................................186Uaktualnianie archiwum................................................................................................186Rozpakowanie plików z archiwum................................................................................187


Moduł Archive Builder JBuildera........................................................................................187Szybkie przygotowanie dystrybucji...............................................................................193

Wskazówki...........................................................................................................................194Pieczętowanie pakietów ................................................................................................195

Część praktyczna .................................................................................................................196Podsumowanie .....................................................................................................................197

Tematy do przemyśleń...................................................................................................197

�� !��%�� &$$

��7� ��-�� 7�Podstawy AWT....................................................................................................................201Aplikacje a aplety ................................................................................................................202

Podstawowy szkielet graficznego interfejsu użytkownika (GUI) .................................202Prosty przykład ..............................................................................................................203

Użycie kontenerów AWT ....................................................................................................204Tworzenie kontenera .....................................................................................................206Wspólne metody kontenerów ........................................................................................207

Użycie komponentów AWT ................................................................................................208Przycisk (Button)...........................................................................................................209Płótno (Canvas) .............................................................................................................211Pole wyboru (Checkbox) ...............................................................................................213Grupa pól wyboru (CheckboxGroup)............................................................................214Lista rozwijana (Choice) ...............................................................................................214Etykieta (Label) .............................................................................................................215Lista (List) .....................................................................................................................215Pasek przewijania (Scrollbar)........................................................................................217Pole tekstowe (TextField)..............................................................................................217Wielowierszowe pole tekstowe (TextArea) ..................................................................218Wspólne metody komponentów ....................................................................................218Oddzielanie interfejsu użytkownika od implementacji .................................................218

Część praktyczna .................................................................................................................219Tworzenie apletu za pomocą kreatora apletów (Applet Wizard) ..................................219Budowa interfejsu..........................................................................................................220Obsługa wejścia.............................................................................................................221


�� %��1 �� $Dlaczego Swing zamiast AWT? ..........................................................................................223Wskazówki dotyczące projektowania — architektura model-widok-kontroler ..................225

Uproszczona architektura MVC z semantyką typu „pobierz”.......................................225Architektura MVC z semantyką typu „wyślij”..............................................................226MVC a Swing ................................................................................................................228

Hierarchia komponentów Swing .........................................................................................228Użycie komponentów Swing w JBuilderze .........................................................................232Część praktyczna .................................................................................................................235

Tworzenie projektu i aplikacji .......................................................................................235Budowa interfejsu użytkownika na podstawie ramki JFrame i paneli JPanel...............236Tworzenie pakietów i klas opisujących dane — obiekty typu dataobject.....................239Tworzenie klasy CommonOperations ...........................................................................242Dowiązanie interfejsu użytkownika do klasy CommonOperations ..............................243


Spis treści 9

�� 86'��&��6��.�� )�Czym jest menedżer układu? ...............................................................................................248Dostępne typy menedżerów.................................................................................................249Użycie menedżera układu....................................................................................................251

Modyfikacja właściwości menadżera układu ................................................................251Spotkanie komponentu z menedżerem układu ..............................................................251

Użycie menedżera XYLayout..............................................................................................251Kiedy używać menedżera XYLayout............................................................................252Układanie komponentów...............................................................................................252Przykład użycia menedżera XYLayout .........................................................................253

Użycie menedżera BorderLayout ........................................................................................253Kiedy używać menedżera BorderLayout ......................................................................254Przykład użycia menedżera BorderLayout....................................................................254

Użycie menedżera FlowLayout ...........................................................................................255Kiedy używać menedżera FlowLayout .........................................................................255Istotne właściwości........................................................................................................255Przykład użycia menedżera FlowLayout.......................................................................256

Użycie menedżera VerticalFlowLayout ..............................................................................256Kiedy używać menedżera VerticalFlowLayout ............................................................256Właściwości...................................................................................................................256Przykład użycia menedżera VerticalFlowLayout..........................................................257

Użycie menedżera BoxLayout2...........................................................................................258Użycie menedżera GridLayout ............................................................................................258

Kiedy używać menedżera GridLayout ..........................................................................258Właściwości...................................................................................................................259Przykład użycia menedżera GridLayout........................................................................259

Użycie menedżera CardLayout............................................................................................260Kiedy używać menedżera CardLayout..........................................................................260Właściwości...................................................................................................................261

Użycie menedżera OverlayLayout2.....................................................................................261Użycie menedżera PaneLayout............................................................................................261Użycie menedżera GridBagLayout......................................................................................261

Kiedy używać menedżera GridBagLayout....................................................................262Ustawianie właściwości komponentów na formatce GridBagLayout...........................262Menu kontekstowe menedżera GridBagLayout ............................................................264Przykład użycia menedżera GridBagLayout .................................................................264

Tworzenie dowolnego menedżera układu ...........................................................................267Implementacja niestandardowego menedżera układu ...................................................268Dodawanie nowego menedżera układu do JBuildera....................................................271

Wskazówki...........................................................................................................................271Nie obawiaj się przekształcania układu XYLayout.......................................................271Zagnieżdżanie paneli .....................................................................................................272



��$� -��!�&��.��1��2��'�� ,Przegląd interfejsu Java2D API...........................................................................................275Generowanie grafiki ............................................................................................................276

Drukowanie przy użyciu interfejsu Java2D...................................................................278Część praktyczna .................................................................................................................279

Kopiowanie plików........................................................................................................279Dodanie listy rozwijanej do panelu CoursePanel ..........................................................279Dołączenie funkcji obsługi zdarzeń do pozycji listy rozwijanej ...................................280


Implementacja interfejsu Print w panelu CoursePanel..................................................281Uruchomienie gotowej aplikacji....................................................................................282


��)� �!��/� ��&�� !��"� �� +,Klasa File .............................................................................................................................286Strumienie wejścia i wyjścia................................................................................................295Klasy Reader i Writer ..........................................................................................................300Klasa StreamTokenizer........................................................................................................301Serializacja obiektów...........................................................................................................304Część praktyczna .................................................................................................................307

Krok 1.: otwarcie przykładu i zapoznanie się z treścią klasy........................................308Krok 2.: dopisanie konstruktora otwierającego lub tworzącego plik konfiguracyjny...309Krok 3.: otwieranie strumienia wyjściowego i zapisywanie właściwości do pliku ......311Krok 4.: uruchamianie aplikacji i analiza pliku konfiguracyjnego ...............................312


��,� �0 ��1��0��'�� $�$Wprowadzenie do baz danych, SQL-a, JDBC i DataExpress .............................................314

Bazy danych ..................................................................................................................314SQL................................................................................................................................314JDBC .............................................................................................................................315DataExpress ...................................................................................................................317

Użycie interfejsu JDBC .......................................................................................................317Krok 1.: zarejestruj sterownik za pomocą obiektu DriverManager...............................319Krok 2.: ustanawianie połączenia z bazą danych ..........................................................320Krok 3.: formułowanie polecenia do wykonania...........................................................320Krok 4.: wykonanie zapytania SQL ..............................................................................321Krok 5.: zwróć zestaw krotek, czyli obiekt klasy ResultSet .........................................322Krok 6.: przerwanie połączenia z bazą danych .............................................................323Krok 7.: przechwytywanie wyjątków SQL ...................................................................323Najczęściej używane metody klasy java.sql.Connection ..............................................324Najczęściej używane metody klasy java.sql.PreparedStatement...................................326Najczęściej używane metody klasy java.sql.ResultSet .................................................326Konfiguracja sterowników bazy danych w JBuilderze .................................................328

Użycie szkieletu DataExpress..............................................................................................330Wprowadzenie do szkieletu DataExpress......................................................................331Tworzenie połączenia z bazą danych ............................................................................333Metody i właściwości komponentu Database ...............................................................334Wykonywanie zapytań ..................................................................................................337Formułowanie wyrażeń SQL.........................................................................................338Budowa interfejsu użytkownika bazy danych ...............................................................343Modyfikowanie bazy danych.........................................................................................344

Tworzenie modułów danych — technologia Data Modules ...............................................346Część praktyczna .................................................................................................................350

Krok 1.: otwarcie przykładu i zapoznanie się z zawartością klasy ...............................350Krok 2.: odszukanie metody browseCourses ................................................................350Krok 3.: usuwanie istniejącego kodu.............................................................................351Krok 4.: wstawienie obiektów Database i QueryDataSet..............................................351Krok 5.: wstawienie kodu do metody browseCourses ..................................................354Krok 6.: uruchamianie aplikacji ....................................................................................354


Spis treści 11

��' ��!�� (�#

��(� %��!��'�� $, Czym jest aplikacja sieciowa? .............................................................................................360Czym są serwlety? ...............................................................................................................361Dlaczego serwlety? ..............................................................................................................362Interfejs Java Servlet API ....................................................................................................362

Cykl życia serwletu .......................................................................................................366Obsługa żądań klienckich..............................................................................................367Śledzenie sesji................................................................................................................372Obsługa ciasteczek ........................................................................................................374

Debugowanie .......................................................................................................................375Wdrażanie ............................................................................................................................378Część praktyczna .................................................................................................................379

Tworzenie projektu i aplikacji sieciowej.......................................................................379Projektowanie serwletu View Course List ....................................................................380Projektowanie serwletu Login .......................................................................................383Projektowanie filtra .......................................................................................................385Przystosowanie aplikacji sieciowej do używania filtra .................................................386


�� %��1� �� $ �Miejsce stron JSP w aplikacji WWW..................................................................................392JSP API ................................................................................................................................392

Cykl życia strony JSP....................................................................................................393Obsługa żądań klienta....................................................................................................394JSP i JavaBeans .............................................................................................................400JSP i serwlety.................................................................................................................404

Debugowanie .......................................................................................................................406Uruchamianie.......................................................................................................................408Część praktyczna .................................................................................................................410

Tworzenie projektu i aplikacji sieciowej.......................................................................410Projektowanie strony JSP wyświetlającej wykaz kursów .............................................411Projektowanie strony logującej JSP ..............................................................................414Projektowanie serwletu logującego ...............................................................................415Konfiguracja aplikacji sieciowej ...................................................................................418


��+� #�0!��.� �� )��Co to jest biblioteka znaczników? .......................................................................................421Integracja biblioteki znaczników z aplikacją WWW...........................................................422

Wdrożenie biblioteki znaczników .................................................................................423Odwołanie do biblioteki znaczników w aplikacji WWW .............................................423Plik deskryptora wdrożenia aplikacji WWW web.xml .................................................424Odwołanie do biblioteki znaczników na stronie JSP.....................................................425

Plik deskryptora biblioteki znaczników TLD......................................................................425API biblioteki znaczników...................................................................................................427

Kontrola poprawności niestandardowych znaczników .................................................430Cykl życia klasy obsługi znacznika...............................................................................431Projekt klasy obsługi znacznika ....................................................................................434

Wskazówki do tworzenia serwletów i stron JSP .................................................................441Część praktyczna .................................................................................................................442

Utworzenie projektu i aplikacji WWW.........................................................................442Utworzenie klas obsługi znaczników dla biblioteki znaczników..................................443


Utworzenie pliku TLD...................................................................................................448Konfiguracja pliku deskryptora wdrożenia aplikacji (web.xml) ...................................450Projektowanie strony JSP Login....................................................................................453Projektowanie strony JSP View Course List.................................................................454


�� 9��#��:;�� ),�Opis komponentów InternetBeans Express .........................................................................457Wykorzystywanie komponentów InternetBeans Express z serwletami ..............................458Wykorzystywanie komponentów InternetBeans Express ze stronami JSP .........................466Wskazówki...........................................................................................................................467

Korzystanie z istniejących plików HTML.....................................................................467Wykorzystywanie modułów danych .............................................................................468


��' ��!��!��)��*+$

��7� <*= �� )��Strukturalny graficzny język znaczników SGML (Structured Graphical Markup Language)....471HTML ..................................................................................................................................472Własności języka XML .......................................................................................................473

Korzystanie z typów dokumentów XML ......................................................................475Parsery ...........................................................................................................................479

Narzędzia XML w środowisku JBuilder .............................................................................481Tworzenie dokumentu XML w środowisku JBuilder ...................................................481Prezentacja dokumentów XML.....................................................................................482Modyfikowanie plików XML w środowisku JBuilder..................................................486Interfejsy do dokumentów XML ...................................................................................497

Wskazówki...........................................................................................................................499Jeśli coś nie jest potrzebne, nie będziemy z tego korzystać ..........................................499Nie próbujmy wyszukiwać danych bezpośrednio w XML-u ........................................500Problemy z generowaniem podsumowań ......................................................................500Prezentacja danych ........................................................................................................500XML a dotychczasowe systemy....................................................................................501Standardowe implementacje XML................................................................................502

Część praktyczna .................................................................................................................502Tworzenie przykładowego dokumentu XML................................................................503Tworzenie DTD.............................................................................................................504Tworzenie prostej prezentacji........................................................................................504Konwertowanie HTML na XSLT..................................................................................505


�� ' ��&.��&��&��:�#>:�� #�� ? �� ,7 Trochę historii......................................................................................................................510Nadejście architektury klient-serwer ...................................................................................511Serwery aplikacji .................................................................................................................512EJB i warstwa pośrednia oparta na komponentach .............................................................513Cele architektury Enterprise JavaBeans ..............................................................................514Zasady działania systemów z komponentami EJB ..............................................................514Komponent Enterprise JavaBean.........................................................................................515

Spis treści 13

Kontener Enterprise JavaBeans ...........................................................................................516Interfejs zdalny ....................................................................................................................516Interfejs bazowy...................................................................................................................516Dostęp do klasy obiektu EJB ...............................................................................................517Typy komponentów Enterprise JavaBeans..........................................................................517

Komponent sesyjny: Session Bean................................................................................518Komponent encji: Entity Bean ......................................................................................518Komponent sterowany komunikatami: Message-Driven Bean .....................................519

W jaki sposób to działa? ......................................................................................................520Podsumowanie .....................................................................................................................521


�� -��&��.�� '"�'�5�%� ��#�� ,�$Szczegółowe informacje dotyczące komponentów Session Bean.......................................524

Komponenty Session Bean stanowe (stateful) ..............................................................524Komponenty Session Bean bezstanowe (stateless) .......................................................524Cykl życia komponentu Session Bean...........................................................................525

Tworzenie klienta ................................................................................................................527Tworzenie kodu komponentu typu Session Bean................................................................530

Przygotowanie środowiska ............................................................................................532Tworzenie komponentu .................................................................................................535

Wskazówki...........................................................................................................................550Dostęp do danych — tylko poprzez Session Bean ........................................................551Wykorzystywanie delegacji...........................................................................................552Łączenie kilku komponentów Session Bean .................................................................553Obiekty reprezentujące wartości ...................................................................................555

Część praktyczna .................................................................................................................557Przygotowanie projektu.................................................................................................558Tworzenie interfejsu sesji ..............................................................................................558Tworzenie interfejsu do obiektów wartości...................................................................558Integrowanie usług biznesowych z obiektami wartości ................................................559Wdrażanie komponentu.................................................................................................560Tworzenie klienta testowego .........................................................................................560


��$� -��&��.��:��'�#�� ,($Bliższe spojrzenie na komponenty Entity Bean ..................................................................564

Cykl życia komponentu .................................................................................................564Komponenty CMP i BMP .............................................................................................565Różnice pomiędzy specyfikacjami EJB 2.0 a EJB 1.1 ..................................................567Klucze główne ...............................................................................................................567Interfejs..........................................................................................................................568

Tworzenie komponentu CMP..............................................................................................569Definiowanie interfejsu bazowego ................................................................................570Definiowanie interfejsu komponentu ............................................................................571Implementowanie komponentu .....................................................................................572Deskryptor wdrożenia....................................................................................................574Wdrażanie komponentu Entity Bean.............................................................................578Wykorzystywanie komponentu Entity Bean .................................................................579Tworzenie komponentów Entity Bean ..........................................................................584

Tworzenie komponentu typu BMP......................................................................................587Definiowanie interfejsu bazowego ................................................................................588Definiowanie interfejsu zdalnego..................................................................................588Implementowanie komponentu .....................................................................................589


Deskryptor wdrożenia....................................................................................................595Wdrażanie komponentu Entity Bean.............................................................................595Wykorzystywanie komponentu Entity Bean .................................................................596

Zaawansowane zarządzanie obiektami trwałymi przez kontener........................................599Język zapytań Enterprise JavaBeans Query Language..................................................599Metody wyszukujące .....................................................................................................602Definiowanie relacji ......................................................................................................603Metody biznesowe w interfejsie bazowym (Home) ......................................................608

Transakcje ............................................................................................................................609Atrybuty transakcji ........................................................................................................610Wykorzystanie transakcji ..............................................................................................610

Bezpieczeństwo kontenera...................................................................................................612Uwierzytelnienie............................................................................................................613Autoryzacja....................................................................................................................613Zabezpieczenie komunikacji .........................................................................................613Bezpieczeństwo w środowisku JBuilder .......................................................................614

Wskazówki...........................................................................................................................615Korzystanie z interfejsu lokalnego ................................................................................615Korzystanie z komponentów CMP przed BMP ............................................................615

Część praktyczna .................................................................................................................616Tworzenie warstwy zarządzania danymi.......................................................................616Konfiguracja komponentu Entity Bean .........................................................................617Tworzenie fabryki połączeń EJB...................................................................................617Tworzenie komponentu zarządzającego typu JavaBean ...............................................618Dołączenie Session Facade do komponentów zarządzających .....................................620Testowanie i implementacja ..........................................................................................621


��)� @�&��'� ��&�4��&� �� (�$Punkt-punkt czy wydawca-subskrybent?.............................................................................624Tworzenie komponentów MDB ..........................................................................................626

Implementacja interfejsów ............................................................................................626Implementacja wymaganych metod ..............................................................................626Przetwarzanie wiadomości ............................................................................................627Deskryptor wdrożenia....................................................................................................629

Testowanie komponentu MDB............................................................................................629Tworzenie komponentów MDB w środowisku JBuilder ....................................................631Wskazówki...........................................................................................................................632

Kiedy korzystać z MDB? ..............................................................................................632Korzystanie z komponentów MDB zamiast z JMS.......................................................632

Część praktyczna .................................................................................................................634Tworzenie komponentu MDB.......................................................................................635Implementacja procesu przetwarzania wiadomości ......................................................635Tworzenie klienta JMS..................................................................................................636


��,� A��#�� ($ Definicja specyfikacji CORBA ...........................................................................................640

ORB nad IIOP ...............................................................................................................641Trzony klienta i szkielety serwera .................................................................................642OA — adapter obiektu...................................................................................................642IOR i serwis nazw..........................................................................................................643

Spis treści 15

IDL — język definiowania interfejsu ..................................................................................644Podstawy CORBA ...............................................................................................................646Konfiguracja JBuildera i CORBA .......................................................................................649Tworzenie serwera CORBA ................................................................................................652

Zdefiniowanie interfejsu w IDL ....................................................................................652Kompilowanie interfejsu do postaci pliku szkieletu serwera ........................................653Implementacja serwera CORBA przy użyciu kreatora .................................................656Uruchamianie serwisu nazw..........................................................................................658Uruchamianie serwera CORBA ....................................................................................659Sprawdzanie czy serwer CORBA działa .......................................................................659

Tworzenie klienta CORBA..................................................................................................660Generowanie klasy opakowującej klienta CORBA.......................................................660Tworzenie instancji klasy opakowującej klienta CORBA ............................................662Wywoływanie metody klasy opakowującej klienta CORBA........................................663

Część praktyczna .................................................................................................................664Krok 1.: otwórz przykład i przejrzyj klasę ....................................................................664Krok 2.: znajdź metodę..................................................................................................665Krok 3.: utwórz plik IDL...............................................................................................665Krok 4.: implementowanie kodu serwera......................................................................667Krok 5.: implementowanie kodu klienta .......................................................................669Krok 6.: wystartowanie aplikacji...................................................................................671


��(� 8 ��0�B�.��!��"��!� '�� (�$Pojęcie zdalnego usuwania błędów .....................................................................................674Przygotowanie środowiska do usuwania błędów ................................................................675Usuwanie błędów zdalnej aplikacji .....................................................................................676

Uruchamiamy zdalną aplikację z opcjami debugowania ..............................................676Kopiujemy pliki zdalnej aplikacji na komputer klienta.................................................677Określamy konfigurację uruchomieniową dla odległego serwera ................................677Ustawiamy punkty kontrolny w kodzie.........................................................................680

Międzyprocesowe punkty kontrolne....................................................................................681Parametry konfiguracyjne serwerów aplikacji ....................................................................682

Inprise Application Server 5.x.......................................................................................683WebLogic Server 7.0.....................................................................................................683WebSphere Server 4 ......................................................................................................685iPlanet Server.................................................................................................................685Inne serwery ..................................................................................................................685

Część praktyczna .................................................................................................................686Instalacja aplikacji serwerowej na komputerze serwera................................................686Instalacja aplikacji klienta na komputerze klienta.........................................................687Debugowanie aplikacji serwera z komputera klienta ....................................................689


�� -��6��1��&��6'��&� ��.��0=�1��0%�� ( $Budowanie w JBuilderze przy użyciu serwera WebLogic ..................................................693

Instalacja serwera aplikacji WebLogic..........................................................................694Konfiguracja JBuildera dla WebLogic ..........................................................................695Tworzenie serwletów i stron JSP przy użyciu serwera WebLogic ...............................696Praca z komponentami EJB...........................................................................................697Wdrażanie aplikacji .......................................................................................................700Zdalne usuwanie błędów ...............................................................................................701


Budowanie w JBuilderze przy użyciu serwera IBM WebSphere........................................703Instalacja serwera aplikacji WebSphere ........................................................................703Konfiguracja JBuildera dla WebSphere ........................................................................703Tworzenie serwletów i stron JSP przy użyciu serwera WebSphere..............................705Tworzenie komponentów EJB przy użyciu WebSphere ...............................................706Wdrażanie aplikacji .......................................................................................................712Usuwanie błędów aplikacji WebSphere ........................................................................712


��+� ��0�%�� ,SOAP — prosty protokół dostępu do obiektów ..................................................................716

Koperta SOAP ...............................................................................................................716Kodowanie.....................................................................................................................717Typy danych ..................................................................................................................719Błędy SOAP ..................................................................................................................720SOAP RPC ....................................................................................................................721

Komponent WSDL technologii Web Services ....................................................................721Komponent UDDI technologii Web Services .....................................................................723Narzędzia JBuilder Web Services Toolkit...........................................................................724

Apache Axis ..................................................................................................................724Podstawowy przykład....................................................................................................725

Część praktyczna .................................................................................................................726Budowa usługi Web Services ........................................................................................726Udostępnianie klasy Javy jako usługi Web Services.....................................................727Tworzenie nowego serwera SOAP................................................................................730Testowanie nowej usługi Web Services ........................................................................732Analiza nowej usługi Web Services ..............................................................................733Analiza mechanizmu testowego ....................................................................................734Wykorzystywanie Monitora TCP..................................................................................735Rozszerzanie możliwości usługi Web Services.............................................................736Konsumowanie usługi Web Services ............................................................................738

Podsumowanie .....................................................................................................................742

�� @��' ��*:��4�� #��!�� )$Wprowadzenie do wersji Micro Edition ..............................................................................743

Nowa wirtualna maszyna...............................................................................................744Nowe i zmienione klasy ................................................................................................744Konfiguracje i profile ....................................................................................................745KVM..............................................................................................................................746Miejsce dla MIDP..........................................................................................................746

Środowisko JBuilder MobileSet ..........................................................................................747Tworzenie Aplikacji MIDP ...........................................................................................747Projektowanie i tworzenie MIDP ..................................................................................749Tworzenie ekranu MIDP ...............................................................................................751Przegląd komponentów .................................................................................................752

Wskazówki...........................................................................................................................754Część praktyczna .................................................................................................................755

Tworzenie projektu dla MIDletu ...................................................................................756Tworzenie plików MIDletu ...........................................................................................757Tworzenie menu głównego (MainMenu) ......................................................................758Tworzenie ClassListDisplay..........................................................................................759


Spis treści 17

��$7� ��1��&�� #��!�� ($Dlaczego projektowanie zespołowe jest tak istotne ............................................................763Poradnik projektanta: struktura zespołu i podział odpowiedzialności.................................764Stosowanie JBuildera z systemem kontroli wersji ..............................................................765

Zasady posługiwania się systemem kontroli wersji ......................................................767JBuilder a system CVS..................................................................................................767JBuilder a system Microsoft Visual Source Safe ..........................................................779


��$�� #��!��%�� +�Biblioteki znaczników Struts ...............................................................................................788

Biblioteka Bean Tag Library .........................................................................................788Biblioteka HTML Tag Library ......................................................................................789Biblioteka Logic Tag Library ........................................................................................789Biblioteka Template Tag Library ..................................................................................790

Tworzenie aplikacji JBuildera z zastosowaniem środowiska Struts ...................................790Rozpoczynamy nowy projekt z zastosowaniem Struts..................................................790Plik web.xml..................................................................................................................792Plik struts-config.xml ....................................................................................................793Budujemy stronę Java Server Page ...............................................................................797Konstruowanie kodu klasy ActionForm........................................................................799Konstruowanie kodu klasy Action ................................................................................801

Wskazówki...........................................................................................................................802Stosowanie walidacji .....................................................................................................803Stosowanie akcji przekazujących sterowanie dla statycznych stron .............................804Połączenie ActionMappings we wspólną strukturę.......................................................805Wysyłamy raz, sprawdzamy dwa razy ..........................................................................806Zalecany cykl projektowania.........................................................................................806



,��-&(

Rozdział 16.

��W tym rozdziale:

� Czym jest aplikacja sieciowa?

� Czym są serwlety?

� Dlaczego serwlety?

� Interfejs Java Servlet API

� Debugowanie

� Wdrażanie

Na polu aplikacji sieciowych opartych na języku Java serwlety są technologią kluczowąupraszczającą projektowanie i tworzenie zawartości dynamicznej. Na przestrzeni ostat-nich lat rola serwletów zmieniała się od mechanizmu dostarczającego dynamiczną treśćHTML do głównego rdzenia aplikacji sieciowych wytwarzającego dynamiczną treśćw różnych formatach (WHL, HTML, XML), które są samodzielne, i które łatwo wdrożyć.

Aplikacja sieciowa definiuje sztywną organizację katalogów zawierającą następującekomponenty, które mogą być czytane przez dowolny serwer obsługujący tak zdefinio-waną strukturę:

� serwlety Javy

� Java Server Pages (JSP)

� Java Custom Tag Library

� biblioteki klas Javy

� Deskryptor wdrożenia

� Zawartość statyczna (strony HTML, obrazy, itd.)

� Dowolne inne wymagane zasoby

Jeżeli aplikacja sieciowa zawiera serwlety, strony JSP lub Custom Tag Library, to przezserwer wymagane będzie, aby kontener Servlet-JSP dostępny był jako część wykonywa-nego kodu. Może to być kontener obsługujący tylko serwlety i JSP, na przykład ApacheTomcat lub pełny serwer aplikacji J2EE (Java 2, Enterprise Edition), na przykład Bor-land Enterprise Application Server. Wraz z instalacją środowiska JBuilder 7 Enterpriseinstalowane są również serwery Apache Tomcat 3.3 i 4.0, których można używać za-równo do uruchamiania, jak i debugowania serwletów i stron JSP.

360 Część IV � JBuilder i aplikacje sieciowe

W tym rozdziale przeanalizujemy podstawową strukturę serwletów Javy oraz omówi-my, jak JBuilder 7 wspomaga tworzenie serwletów. W następnych rozdziałach zajmie-my się technologiami JSP i Custom Tag Library, będącymi częścią zagadnienia aplika-cji sieciowych.

To, czego się nauczymy wykorzystamy, tworząc prosty interfejs użytkownika naszejaplikacji ChalkTalk. W JBuilderze serwlety tworzymy wewnątrz struktury o nazwieWeb application, która stanowi środowisko uruchomieniowe i testowe aplikacji siecio-wej. Przed serwletami omówimy ideę aplikacji sieciowej jako szkieletu dla serwletów.

��

Kluczową zaletą programowania w języku Java jest to, że piszemy i kompilujemy kodna jednej platformie, spodziewając się, że będzie on działał z podobnym rezultatem nainnej platformie.

Jedną z ról aplikacji sieciowej jest definiowanie samodzielnej struktury katalogów za-wierającej wszystkie pliki i definicje opisujące sposób osadzania i uruchamiania aplika-cji. W ten sposób dokonuje się próba rozszerzenia przenośności oferowanej przez językJava na całą aplikację sieciową obejmującą statyczne strony HTML, obrazy i zawartośćgenerowaną dynamicznie, tak aby zapewnić samodzielną prezentację na wielu platfor-mach serwerowych.

Infrastruktura aplikacji sieciowej wymaga utworzenia specjalnego katalogu głównegozawierającego wszystkie potrzebne do jej uruchomienia zasoby. Wszystkie strony HTMLi JSP, obrazy i inne zasoby z wyjątkiem klas i bibliotek Javy tworzące aplikację sieciowąmuszą zostać umieszczone w katalogu głównym struktury katalogów odpowiedniej dladanej zawartości.

W katalogu głównym należy stworzyć specjalny katalog o nazwie WEB-INF zawierającynastępujące elementy:

� Plik: web.xml — jest to plik deskryptora wdrożenia aplikacji sieciowejw formacie XML opisujący wiele szczegółów wymaganych przez serwerdo prawidłowego wdrożenia aplikacji.

� Podkatalog: classes/ — ten katalog zawiera wszystkie samodzielne klasy Javywymagane do uruchomienia przez aplikację sieciową, w tym wszystkie plikiz klasami serwletowymi razem z plikami zawierającymi poboczne klasy.

� Podkatalog: lib/ — ten katalog zawiera wszystkie biblioteki z klasami w formacieJAR wymagane do prawidłowego działania aplikacji sieciowej.

Jako przykład omawianej struktury, na listingu 16.1 przedstawiliśmy część hierarchiikatalogów aplikacji sieciowej zawierającej interfejs sieciowy dla aplikacji ChalkTalk,który zostanie rozbudowany w tym rozdziale. Przykład ten nosi nazwę chalktalkweb.

�� Struktura katalogów aplikacji sieciowej

��

Rozdział 16. � Serwlety 361

�� !"�� !"�� !"��##�#�� !"��##�#��#��#��$%#��#��##�� !"��##�#��#��#��##�� !"��

Struktura katalogów może pozostać w takiej postaci lub może zostać skompresowanado pojedynczego pliku znanego jako plik Web Application Archive (WAR). Niezależ-nie od tego, czy aplikacja sieciowa została skompresowana do pojedynczego pliku,czy katalogi pozostawiono w postaci rozwiniętej, jej osadzenie powinno polegać je-dynie na jej przekopiowaniu do miejsca docelowego określonego przez serwer ser-wletów lub serwer J2EE.

JBuilder automatyzuje budowę aplikacji sieciowych, oferując kreatory i ekrany in-formacyjne pomocne podczas tworzenia wymaganych katalogów i konfiguracji plikuweb.xml.

��

Witryny internetowe i związane z nimi aplikacje sieciowe stanowią zwykle połączeniezawartości statycznej (która się nie zmienia) i dynamicznej. Serwery WWW są dosko-nale przystosowane do wyświetlania na każde żądanie zawartości statycznej w formiestron HTML w oknach przeglądarek. W przypadku wielu aplikacji sieciowych istniejepotrzeba wyświetlania zawartości przystosowanej do konkretnego użytkownika, kon-kretnego żądania lub zawartości odzwierciedlającej zmieniające się w bazie danych in-formacje.

Przez lata rozwinięto wiele technologii i metod dostarczania zawartości dynamicznejrazem z zawartością statyczną. Jedną z takich technik było stworzenie interfejsu ServletAPI jako rozszerzenia języka Java.

Na wielu witrynach internetowych użytkownik wysyła żądania pobrania zawartościz serwera WWW. Serwer WWW odczytuje żądanie wraz z dostarczonymi z nim para-metrami, a następnie wysyła pożądaną treść do użytkownika jako odpowiedź na żądanie.Serwer przesyła istniejący plik lub wykorzystuje informacje pobrane w żądaniu i zapi-sane po stronie serwera, aby wygenerować przystosowaną treść. W takiej architekturzeserwlety wykonywane są po stronie serwera WWW, analizują żądania klienta i dyna-micznie budują na nie odpowiedź.

Rysunek 16.1 przedstawia architekturę żądanie-odpowiedź.

�� Architektura typużądanie-odpowiedź


Aby realizować żądania klienta za pomocą serwletów Javy, serwer WWW musi obsłu-giwać interfejs Javy Servlet API. Serwer WWW musi zatem posiadać wbudowaną ob-sługę serwletów albo zintegrowany z nim zewnętrzny mechanizm obsługujący wyko-nywanie serwletów Javy. W obu tych przypadkach po utworzeniu i przetestowaniuw środowisku JBuilder aplikacji sieciowej opartej na serwletach skopiuj plik WAR lubstrukturę katalogów zaczynającą się od katalogu głównego aplikacji do miejsca okre-ślonego podczas konfiguracji serwera w celu wdrożenia aplikacji.

Gdy serwer WWW otrzyma żądanie pobrania zasobu będącego serwletem, serwlet jestwykonywany i przekazywane jest do niego żądanie otrzymane przez serwer. Serwletprzetwarza żądanie i buduje odpowiedź, którą zwraca do serwera WWW. Serwer wy-syła otrzymaną odpowiedź do klienta WWW, który wcześniej przesłał żądanie.

��

Poznawszy rolę serwletów Javy, musielibyśmy ustalić, czy są one właściwym wyboremdla aplikacji sieciowej. Omówimy kilka zalet wynikających z faktu wykorzystywaniaserwletów Javy do obsługi żądań klientów WWW.

Podobnie jak w przypadku większości aplikacji i klas Javy, serwlety Javy są przenośnepomiędzy różnymi platformami. Jeśli tylko na platformie docelowej znajduje się serwerobsługujący interfejs Java Servlet API, serwlety napisane i zbudowane w jednym śro-dowisku powinny zostać wykonane w innym środowisku. Zakładamy, że wymagane bi-blioteki Javy dostępne są na obu platformach. Jeśli o to zadbamy, serwlety powinnydziałać bez problemów.

Ponieważ serwlety Javy napisane są w Javie, mają dostęp do pełnego zestawu funkcjizaimplementowanych w bibliotekach klas Javy i bibliotekach opracowanych dodatkowo.To tyczy się całego środowiska Java 2 Standard Edition (J2SE), jak również całego śro-dowiska Java 2 Enterprise Edition (J2EE). Jeśli w przyszłości pojawią się nowe interfejsy,serwlet będzie mógł z nich skorzystać, pod warunkiem, że nowe biblioteki klas będądostępne dla serwletu zarówno w czasie jego tworzenia, jak i w czasie jego wykonania.

Struktura kodu serwletu Javy jest bardzo prosta i nadaje się do implementacji wieluprotokołów komunikacyjnych typu klient-serwer. Interfejs Servlet API opracowany zo-stał jako niezależny od konkretnych protokołów sieciowych. Zakłada jedynie istnieniepodstawowej architektury typu żądanie-odpowiedź. Oznacza to, że niezależnie od pro-tokołu, jaki wykorzystuje aplikacja sieciowa do komunikacji z klientem sieciowym,prawdopodobnie będzie można użyć serwletów jako podstawy tej komunikacji.

��

W chwili gdy architekt aplikacji zdecyduje, że aplikacja sieciowa ma generować za-wartość dynamiczną przy wykorzystaniu serwletów, istotne staje się poznanie interfejsuJava Servlet API. Wszystkie tworzone serwlety muszą dziedziczyć zdefiniowany w pa-kietach javax.servlet i javax.servlet.http zestaw funkcji oraz wykorzystywać określonąw tych pakietach architekturę.


Zaczniemy od omówienia klas i interfejsów zdefiniowanych w tych pakietach i krótkoprzedyskutujemy rolę, jaką odgrywają podczas budowy serwletu. Pakiet javax.servletzawiera klasy i interfejsy wymagane do budowy niezależnych od protokołów serwletów.Bazując na pakiecie javax.servlet, możemy utworzyć dowolny serwlet, również obsłu-gujący różne protokoły sieciowe. Pakiet javax.servlet.http jest pakietem klas i interfejsówułatwiających tworzenie serwletów komunikujących się za pomocą protokołu HTTP.

Na potrzeby omówienia interfejsu Servlet API w następnych podrozdziałach koncentru-jemy się głównie na tworzeniu serwletów opartych na protokole HTTP przy wykorzystaniupakietu javax.servlet.http. Na początku w tabeli 16.1 wymienimy klasy i interfejsy skła-dające się na pakiet javax.servlet, które służą jako fundamenty interfejsu Servlet API.

�� Pakiet javax.servlet

Nazwa Rola

&�%'�� Wszystkie serwlety muszą implementować ten interfejs. Kontener serwletuwykorzystuje ten interfejs do wywoływania metod inicjalizujących, metododpowiadających na żądania i metod usuwających serwlet.

(��%��&�%'�� Implementacja interfejsu &�%'�� przeznaczona dla serwletów niezależnychod protokołu. Ta klasa służy za punkt startowy ułatwiający tworzenie serwletów,lecz jej implementowanie nie jest wymagane.

&��)�%��*�� Zaimplementowanie tego interfejsu gwarantuje, że serwlet będzie obsługiwałjedno żądanie jednocześnie.

&�%'��+��,�� Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest do pobieraniainformacji inicjalizacyjnych, na przykład parametrów. Referencję do tego obiektuuzyskujemy przez interfejs &�%'��.

&�%'��+�� Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przezkontener serwletu. Obiekt implementujący ten interfejs wykorzystywany jestdo komunikacji z kontenerem serwletu. Referencję do tego obiektu uzyskujemyprzez interfejs &�%'��+��,��.

-�.$�#�/�#��% Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest przez serwlet doprzesyłania żądań do innego znanego zasobu lub włączania rezultatów przesłanychprzez inny zasób w odpowiedzi na żądanie. Referencję do tego obiektu uzyskujemypoprzez wywołanie metody ��-�.$�#�/�#��% interfejsu &�%'��+��.

&�%'��-�.$�#� Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest przez serwletdo pobierania informacji o żądaniu przesłanym do serwletu przez użytkownikasieci. Referencję do tego obiektu uzyskujemy w momencie, gdy kontener serwletuwywołuje metodę �� interfejsu &�%'��.

&�%'��-�#��#� Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest przez serwletdo budowania odpowiedzi, która zostanie zwrócona do użytkownika sieciowegowysyłającego żądanie. Referencję do tego obiektu uzyskujemy w momencie,gdy kontener serwletu wywołuje metodę service interfejsu &�%'��.

&�%'��-�.$�#��%��% Ta klasa jest implementacją interfejsu &�%'��-�.$�#�, której można użyćdo opakowania obiektu &�%'��-�.$�#� i dodania do niego własnych funkcji.Aby użyć tej klasy, przekaż istniejący obiekt &�%'��-�.$�#� jako parametrdo konstruktora klasy.


�� Pakiet javax.servlet — ciąg dalszy

Nazwa Rola

&�%'��-�#��#��%��% Ta klasa jest implementacją interfejsu &�%'��-�#��#�, której można użyćdo opakowania obiektu &�%'��-�#��#� i dodania do niego własnych funkcji.Aby użyć tej klasy, przekaż istniejący obiekt &�%'��-�#��#� jako parametrdo konstruktora klasy.

&�%'�� $�&�%�� Ta klasa, zamiast przez twórcę serwletu, implementowana jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest przezserwlet do odczytywania danych binarnych, które zostały przysłane przezużytkownika sieciowego. Referencję do tego obiektu uzyskujemy poprzezwywołanie metody �� $�&�%�� interfejsu &�%'��-�#��#�.

&�%'��0$��$�&�%�� Ta klasa, zamiast przez twórcę serwletu, implementowana jest przez kontenerserwletu. Obiekt implementujący ten interfejs wykorzystywany jest przez serwletdo zapisywania danych binarnych, które mają zostać zwrócone do użytkownikasieciowego, w odpowiedzi na jego żądanie. Referencję do tego obiektu uzyskujemypoprzez wywołanie metody ��0$��$�&�%�� interfejsu &�%'��-�#��#�.

"��% Obiekt implementujący ten interfejs może przechwytywać obiekty klas&�%'��-�.$�#� i &�%'��-�#��#� przeznaczone dla określonego zasobuna serwerze. Obiekt klasy "��% może przetworzyć żądanie i przesłać jedalej lub zatrzymać, aby nie dotarło do docelowego zasobu.

"��%+��,�� Ten interfejs, zamiast przez twórcę filtra klasy "��%, implementowany jestprzez kontener serwletu. Obiekt klasy "��% wykorzystuje ten obiekt do pobieraniainformacji inicjalizacyjnych i parametrów. Referencję do tego obiektu uzyskujemyw momencie, gdy kontener serwletu wywołuje metodę �� interfejsu "��%.

"��%+�� Ten interfejs, zamiast przez twórcę filtra klasy "��%, implementowany jestprzez kontener serwletu. Obiekt klasy "��% wykorzystuje ten obiekt do przesyłaniaobiektów klas &�%'��-�.$�#� i &�%'��-�#��#� do zasobów określonychpierwotnie przez użytkownika sieciowego. Referencję do tego obiektu uzyskujemyw momencie, gdy kontener serwletu wywołuje metodę ��"��% interfejsu "��%.

&�%'��+��1�#��% Gdy wymagana jest informacja o gotowości serwletu do przyjmowania żądańlub informacja o usunięciu serwletu, klasa implementująca ten interfejs musizostać zarejestrowana jako odbiorca zdarzeń w pliku deskryptora wdrożenia(web.xml) danej aplikacji sieciowej.

&�%'��+��2��%��$��1�#��%

Gdy wymagana jest informacja o dodaniu, usunięciu lub zastąpieniu atrybutuw kontekście serwletu, klasa implementująca ten interfejs musi zostaćzarejestrowana jako odbiorca zdarzeń w pliku deskryptora osadzania (web.xml)danej aplikacji sieciowej.

&�%'��+��'�� Obiekt tej klasy rozsyłany jest do wszystkich zarejestrowanych odbiorcówimplementujących interfejs &�%'��+��1�#��%. Obiekt ten zawierareferencję do obiektu &�%'��+��, który wywołał to zdarzenie.

&�%'��+��2��%��$��'��

Obiekt zdarzenia tej klasy rozsyłany jest do wszystkich zarejestrowanychodbiorców implementujących interfejs &�%'��+��2��%��$��1�#��%.Obiekt ten zawiera referencję do obiektu &�%'��+�� oraz nazwę i wartośćatrybutu, który wywołał to zdarzenie.

&�%'�� Gdy serwer napotka problem, z którym nie może sobie poradzić, możewygenerować wyjątek &�%'��, aby o tym poinformować.

3��'�� Gdy serwlet jest niedostępny zarówno w ogóle, jak i tymczasowo,aby poinformować o tej sytuacji, generowany jest ten wyjątek.


Jako przykład obsługi określonych protokołów komunikacyjnych na bazie interfejsu Se-rvlet API, w tabeli 16.2 umieszczono listę klas i interfejsów znajdujących się w pakieciejavax.servlet.http. Klasy i interfejsy tego pakietu rozszerzają klasy i interfejsy zdefinio-wane w pakiecie javax.servlet package.

�� Pakiet javax.servlet.http

Nazwa Rola

4��&�%'�� Implementacja interfejsu &�%'��, którą można wykorzystać do obsługiżądań w komunikacji opartej na bazie protokołu HTTP, na przykładkomunikacji z witrynami WWW. Ta klasa służy za fundamentpodczas tworzenia serwletów opartych na protokole HTTP i posiadazdefiniowane, przeciążalne metody dla każdego polecenia HTTP.

4��&�%'��-�.$�#� Ten interfejs rozszerza interfejs &�%'��-�.$�#� i, zamiast przez twórcęserwletu, implementowany jest przez kontener serwletu. Obiektimplementujący ten interfejs wykorzystywany jest do pobieraniainformacji o żądaniu przesłanym przez użytkownika sieciowego.Referencja do tego obiektu przekazywana jest przez parametr(przekazywanie przez referencję) jednej z metod klasy 4��&�%'��wywoływanej przez kontener serwletu.

4��&�%'��-�#��#� Ten interfejs rozszerza interfejs &�%'��-�#��#� i, zamiast przez twórcęserwletu, implementowany jest przez kontener serwletu. Obiektimplementujący ten interfejs wykorzystywany jest do budowaniaodpowiedzi dla użytkownika sieciowego wysyłającego żądanie.Referencja do tego obiektu przekazywana jest przez parametr(przekazywanie przez referencję) jednej z metod klasy 4��&�%'��wywoływanej przez kontener serwletu.

4��&�%'��-�.$�#��%��% Ta klasa jest implementacją interfejsu 4��&�%'��-�.$�#�, którą możnawykorzystać do opakowania obiektu 4��&�%'��-�.$�#� i dodania doniego własnych funkcji. Aby użyć tej klasy, przekaż istniejący obiekt4��&�%'��-�.$�#� jako parametr do jej konstruktora.

4��&�%'��-�#��#��%��% Ta klasa jest implementacją interfejsu 4��&�%'��-�#��#�, którą możnawykorzystać do opakowania obiektu 4��&�%'��-�#��#� i dodaniado niego własnych funkcji. Aby użyć tej klasy, przekaż istniejącyobiekt 4��&�%'��-�#��#� jako parametr do jej konstruktora.

4��&�##�� Ten interfejs, zamiast przez twórcę serwletu, implementowany jest przezkontener serwletu. Obiekt implementujący ten interfejs wykorzystywanyjest przez serwlet do przechowywania informacji o danym użytkownikusieciowym na przestrzeni wielu wywołań HTTP. Referencję do tegoobiektu uzyskujemy poprzez wywołanie metody ��&�##�� interfejsu4��&�%'��-�.$�#�.

+�� Ta klasa zawiera niewielkie porcje informacji, które wysyłane sądo użytkownika sieciowego jako część odpowiedzi i pobierane sąod użytkownika jako część żądania. Klasy tej używa się razem z klasą4��&�##�� w celu zachowania informacji o konkretnym użytkownikuw czasie pomiędzy żądaniami.

4��&�##��1�#��% Gdy wymagana jest informacja o utworzeniu lub zamknięciu sesji HTTP,klasa implementująca ten interfejs musi zostać zarejestrowana jako odbiorcazdarzeń w pliku deskryptora wdrożenia (web.xml) danej aplikacji sieciowej.


�� Pakiet javax.servlet.http — ciąg dalszy

Nazwa Rola

4��&�##��2��%��$��1�#��% Gdy wymagana jest informacja o dodaniu, usunięciu lub zastąpieniuatrybutu sesji HTTP, klasa implementująca ten interfejs musi zostaćzarejestrowana jako odbiorca zdarzeń w pliku deskryptora wdrożenia(��) danej aplikacji sieciowej.

4��&�##��1�#��% Dowolny obiekt, który zaimplementuje ten interfejs uzyska informacjęo włączeniu do sesji HTTP i wyłączeniu z sesji HTTP.

4��&�##��2��'��1�#��% Dowolny obiekt włączony do sesji, który zaimplementuje ten interfejsuzyska odpowiednią informację tuż przed dezaktywacją sesji i tuż poaktywacji sesji. Kontener serwletu może w różnych chwilach tymczasowousuwać sesję z pamięci, aby następnie reaktywować ją do ponownego użycia.

&�##��'�� Ten obiekt zawiera wszystkie informacje wysyłane do zarejestrowanychodbiorców implementujących interfejsy 4��&�##��2��'��1�#��%lub 4��&�##��1�#��%. Obiekt ten zawiera również referencjędo obiektu 4��&�##��, który wywołał zdarzenie.

&�##��'�� Ten obiekt zawiera wszystkie informacje wysyłane do zarejestrowanychodbiorców implementujących interfejs 4��&�##��1�#��%.Obiekt ten zawiera również referencję do obiektu 4��&�##�� oraznazwę atrybutu, który wywołał zdarzenie.

4��3��# Niezalecana. Ten obiekt został usunięty z API i powinno się unikać jegoużywania.

4��&�##��+�� Niezalecana. Ten obiekt został usunięty z API i powinno się unikać jegoużywania.

��

Wykonanie serwletów odbywa się w kontekście kontenera, który odpowiedzialny jestza zarządzanie ich cyklem życia. Cykl życia serwletu to następująca sekwencja zdarzeń,które pociągają za sobą wywołania poszczególnych metod interfejsu ��:

� Tworzenie egzemplarza serwletu i jego inicjalizacja — gdy kontener serwletuotrzymuje żądanie przeznaczone dla określonego serwletu i nie jest dostępnażadna jego instancja, musi zostać utworzony i zainicjalizowany egzemplarzserwletu. Po utworzeniu serwletu, kontener serwletu wywołuje metodę initinterfejsu ��. Metoda init służy do przygotowania lub inicjalizacji serwletuprzed rozpoczęciem przetwarzania żądań i jest wykonywana tylko raz. Jeżeliz jakiegoś powodu wykonanie metody �� zakończy się niepowodzeniem,serwlet powinien wygenerować i zgłosić do swojego kontenera wyjątek�� , informując w ten sposób, żeby kontener nie używałserwletu do przetwarzania żądań.

� Obsługa żądań klienckich — po utworzeniu serwletu i jego pomyślnej inicjalizacjijest on gotowy do obsługi i przetwarzania żądań. Dla każdego otrzymanegożądania kontener serwletu wywołuje metodę service dostępnego egzemplarzawskazanego serwletu. Jeżeli z jakiegoś powodu wykonanie metody servicezakończy się niepowodzeniem, serwlet powinien wygenerować i zgłosić


do swojego kontenera wyjątek ��. Jeśli wystąpi błądwejścia-wyjścia, serwlet wygeneruje wyjątek �� i zgłosi godo kontenera serwletu.

� Zamknięcie i usunięcie serwletu — gdy kontener serwletu ma zamiar zlikwidowaćserwlet, wywołuje metodę destroy interfejsu ��. W ten sposób serwletma możliwość uprzątnięcia zasobów, z których korzystał. Metoda destroywywoływana jest tylko raz, tuż przed usunięciem serwletu.

Oprócz zdarzeń składających się na sekwencję cyklu życia serwletu kontener serwletuprzez cały cykl jego życia wysyła informacje o następujących zdarzeniach do odpo-wiednio zarejestrowanych obiektów-odbiorców. Klasy implementujące te interfejsy od-biorców muszą zostać zarejestrowane w pliku deskryptora osadzania (web.xml) aplika-cji sieciowej.

� Kontekst serwletu aplikacji sieciowej jest gotowy do otrzymywania żądań(��).

� Kontekst serwletu aplikacji sieciowej jest gotowy do zamknięcia(��).

� Dodano, usunięto lub zastąpiono atrybut w kontekście serwletu aplikacjisieciowej (�� ).

� Utworzono lub usunięto sesję HTTP dla aplikacji sieciowej(��).

� Dodano, usunięto lub zastąpiono atrybut sesji HTTP dla aplikacji sieciowej(�� ).

Poszczególne obiekty włączone do sesji HTTP i implementujące odpowiedni interfejsodbiorcy otrzymują następujące informacje od kontenera serwletu:

� Obiekt zostanie włączony do sesji HTTP lub z niej wyłączony(��).

� Sesja HTTP zostanie dezaktywowana (��).

� Sesja HTTP została aktywowana (��).

��

W tym rozdziale skupimy się na obsłudze przez serwlet żądań HTTP z uwzględnieniemnastępujących interfejsów:

� ��

� ��

� �� !��

� ��"��

W kolejnych podrozdziałach omówimy dodatkowe klasy i interfejsy pakietu Java Serv-let API.


Większość czynności wykonywanych przez serwlet odbywa się, gdy kontener serwletuotrzymuje żądanie klienckie i przesyła je dalej do serwletu poprzez wywołanie metodyservice. W przypadku serwletów wyprowadzonych z klasy �� metoda servicetłumaczona jest na wywołania określonych metod odpowiadających wywołaniom poleceńHTTP przesłanym przez klienta. Oto te metody wraz z odpowiadającymi poleceniamiHTTP:

� ��!�� — odpowiada poleceniu HTTP DELETE

� ��#� — odpowiada poleceniu HTTP GET

� �� — odpowiada poleceniu HTTP HEAD

� �� — odpowiada poleceniu HTTP OPTIONS

� ��$�� — odpowiada poleceniu HTTP POST

� ��$� — odpowiada poleceniu HTTP PUT

� ��%�� — odpowiada poleceniu HTTP TRACE

Większość serwletów rozszerzających klasę �� musi jedynie przeciążyć jednąz siedmiu wymienionych metod, aby stanowić w pełni działający serwlet. Nagłówekkażdej z wymienionych metod zawiera zarówno obiekt �� , jak i obiekt��. Obiekt �� umożliwia dostęp do zawartości żą-dania aktualnie przesłanego do serwletu. Obiekt �� umożliwia przy-gotowanie zawartości odpowiedzi, która zostanie zwrócona do klienta.

��

Obiekt �� udostępnia wiele metod analizujących składnię żądania prze-słanego przez klienta. Oto częściowa lista głównych metod wykorzystywanych do prze-twarzania żądania HTTP:

� ��$��&��'��( — pobiera wartość parametru o zadanej nazwie.

� ��)��'( — pobiera sesję HTTP dla tegożądania. Jeśli sesja nie istnieje, tworzy nową. Metoda ta wykorzystywana jestdo śledzenia sesji, co omówimy w dalszej części rozdziału.

� ��**��)�� '( — pobiera adres URL, pod którywysłano żądanie. Nie zawiera żadnych znaków, będących częścią łańcuchażądania, umieszczonych na końcu adresu URL.

� ��)��'��( — pobiera wartość związanąz określonym nagłówkiem.

� ��&)��&'( — pobiera ciało żądaniaHTTP w postaci binarnej. Metoda ta jest bardzo użyteczna do pobierania danychw przypadku poleceń HTTP POST i PUT, kiedy dane nie są znakami.

� �� !��)�� !��)'��(

— pobiera referencję określonego zasobu, na przykład innego serwletu.To żądanie może zostać przesłane do zasobu lub wynik wygenerowanyprzez zasób może być uwzględniony w odpowiedzi na to żądanie.


� ��**��)��'()— pobiera treść żądania HTTP w postacitekstowej.

Dostępnych jest wiele innych metod służących do dalszej analizy składniowej parame-trów, nagłówków, adresów URL i autentykacji. Więcej informacji na temat dodatko-wych metod znajdziesz w pomocy JBuildera.

��

Obiekt �� udostępnia wiele metod pomagających w budowie odpo-wiedzi na żądanie klienta. Oto częściowa lista głównych metod wykorzystywanych doprzetwarzania żądania HTTP:

� ��)��'�)��+)��)&��( — informuje, że serwerpowinien wygenerować stronę HTML z określonym kodem stanu i danąinformacją i zwrócić ją jako odpowiedź.

� ��)��'��)��( — wysyła do klienta odpowiedźinformującą, że przeglądarka powinna załadować stronę określoną przez parametrlocation.

� ��)��'��)�&�+)��)��(

— ustawia wartość nagłówka odpowiedzi, która ma zostać wysłana do klienta.

� ��&)��&'( — pobiera egzemplarzobiektu ��&, którego można użyć do wysyłania do klientadanych binarnych w ramach odpowiedzi. Może to służyć do wysyłania do klientaobrazów.

� ��**��)��,��'( — pobiera obiekt ��$��,��,którego można użyć do wysyłania klientowi danych znakowych.

Dostępnych jest kilka innych metod służących do precyzyjnego sterowania wartościaminagłówków i śledzenia sesji. Zagadnienie śledzenia sesji omówimy w dalszej części tegorozdziału, natomiast informacje na temat innych dostępnych metod znajdziesz w pomocyJBuildera.

Na listingu 16.2 znajduje się prosty serwlet o nazwie !��-$��&��, który odczytujeparametr z obiektu �� i za pomocą obiektu �� two-rzy stronę HTML będącą odpowiedzią dla klienta.

�� Serwlet DisplayParameter.java

��#�5��%��'��#�%'��65��%��'��#�%'��65��%��'��65��%��'��$��65�$��##�/�#�� 7�%��%��#�4��&�%'��8#��,��%�'��&�%��+0!)�!)9):7��;�<��<5��7%=��%=��>?��4))7�(��$��'��(��4��&�%'��-�.$�#��%�.$�#�@�4��&�%'��-�#��#��%�#��#��%��#�&�%'��@� 0��8


%�#��#��#��+��) ��+0!)�!)9):7��57%��%��%��$��;�%�#��#��%��%��5�$��%��<A��B<�5�$��%��<A��BA��B� C��%��%$A��BA��B<�5�$��%��<A�� B<�5�$��%��<A�B��%��CD��%��%$��<�E%�.$�#��7�%��%�<��%��F<��E<A��B<�5�$��%��<A�� BA��B<�5GG

Rysunek 16.2 przedstawia wynik wprowadzenia następującego adresu URL jako para-metru serwletu !��-$��&�� z listingu 16.2.

��H��#�HIJIJ��#�� %��%K��%��F;��#��

Zwróć uwagę na łańcuch zapytania ��&./��0��, który został przekazany jakoczęść adresu URL. Serwlet otrzymał wartość ��&. jako parametr i umieścił na stronieHTML utworzonej jako odpowiedź.

�� Wynik działaniaserwletuDisplayParameterz listingu 16.2

��

Obiekt �� !�� umożliwia wielokrotne użycie serwletów, stron JSP i HTMLoraz innych zasobów do generowania zawartości odpowiedzi na żądania klienta. Po-przez wywołanie metody *��0�� żądania mogą być przesyłane do innych zasobóww celu wygenerowania odpowiedzi. Poprzez wywołania metody �� wynik wyge-nerowany przez inny zasób może zostać wykorzystany podczas generowania odpowie-dzi. Inny zasób to zwykle inny serwlet w kontekście tej samej aplikacji sieciowej, leczmoże to być dowolny zasób, do którego uzyskujemy dostęp zarówno przez użycie jego


nazwy (określonej w pliku deskryptora osadzania web.xml), jak i przez użycie jego ad-resu URL w kontekście tej samej aplikacji sieciowej. Obiekt �� !�� możemyotrzymać, wykorzystując następujące metody:

� ��1�&��!��'��(

� �� !��'��(

��

Obiekt klasy "�� może być dowolną klasą Javy implementującą interfejs "�� i za-rejestrowaną w pliku deskryptora wdrożenia (web.xml) aplikacji sieciowej. Listing 16.3przedstawia składnię wpisu rejestrującego filtr o nazwie ��!��-"��, który prze-chwytuje wszystkie żądania klienckie skierowane do serwletu ��!��-$��&��w celu ich dodatkowego przetworzenia.

�� Deklaracja filtra w pliku web.xml

A,��%BA,��%��B��#�� ,��%A�,��%��BA,��%��##B��#��/�#�� "��%A�,��%��##BA�,��%BA,��%��BA,��%��B��#�� ,��%A�,��%��BA#�%'��B��#�� %��%A�#�%'��BA�,��%��B

Przed przetworzeniem żądania przez serwlet kontener serwletu może przepuścić jeprzez dowolną liczbę zarejestrowanych filtrów. Wszystkie filtry zarejestrowane dla tegosamego serwletu stają się fragmentami łańcucha filtrów, na którego końcu znajduje sięserwlet. Kolejność filtrów w łańcuchu jest taka sama jak kolejność deklaracji w plikudeskryptora wdrożenia.

Podobnie jak w przypadku cyklu życia serwletu, kontener serwletu wywołuje metodę�� interfejsu Filter tuż przed jego pierwszym użyciem w celu wykonania niezbędnychczynności inicjalizacyjnych. Przed zniszczeniem obiektu "�� kontener serwletu wy-wołuje metodę ��- interfejsu w celu umożliwienia dokonania niezbędnego sprząta-nia. Metoda ta wywoływana jest tylko raz. Za każdym razem, gdy żądanie od klientaprzekazywane jest do filtra, wywoływana jest metoda ��"�� w celu przetworzeniaobiektu �� .

Każde wywołanie metody ��"�� otrzymuje referencję do następnego filtra lub ser-wletu w łańcuchu filtrów dla określonego serwletu. Aby przekazywać żądanie klientawzdłuż łańcucha w kierunku serwletu, należy wykonać metodę ��"�� obiektu "��2��.

Na listingu 16.4 znajduje się kod klasy !��-"�� stworzonej przez kreatoraServlet Wizard dostępnego w JBuilderze. Do metody ��"�� dodaliśmy dwie linie kodu,które dołączają powitanie „Witaj Świecie!” na górze strony HTML zwróconej przez do-celowy serwlet, w tym przypadku ��!��-$��&��. Zwróć uwagę, że kreator Serv-let Wizard dostępny w JBuilderze tworzy obiekt klasy "�� jako serwlet rozszerzający


klasę ��. Klasa ��!��-"�� mogłaby rozszerzać dowolną klasę, w tym�� , ponieważ jedynym wymaganiem dla filtra jest to, aby implementowałinterfejs "��.

�� Klasa DisplayFilter.java

��#�5��%��'��#�%'��65��%��'��#�%'��65��%��'��65��%��'��$��65�$��##�/�#�� "��%��#�4��&�%'��#�"��%�8�%�'��"��%+��,��,��%+��,��5��0�#$��%=��= ��,��$%��,��%$�$��'��"��%+��,��,��%+��,��8��#�,��%+��,��;�,��%+��,��5G��7%=��%=��>?��=��$��'��"��%�&�%'��-�.$�#��%�.$�#�@&�%'��-�#��#��%�#��#�@"��%+��,��%+��8�% �87%��%��%��$��;�%�#��#��%��%��5�$��%��<A��BA�� B��L��MA��BA�� B<�5,��%+��"��%�%�.$�#�@�%�#��#��5G��&�%'��#��8,��%+��,��&�%'��+��#��*�##��5G�� 0��8,��%+��,��&�%'��+��*�##��5GG��&�%=?��$��'��#�%� ��8GG

��

Większość aplikacji sieciowych swoje działanie opiera na możliwości interaktywnejkomunikacji z użytkownikiem. Aby zapewnić niezbędną interakcję, aplikacja musi prze-chowywać różne zmienne i stałe związane ze stanem tej specyficznej konwersacji. Pro-tokół HTTP, często spotykany w wielu aplikacjach sieciowych, standardowo nie obsłu-guje interaktywnej komunikacji i z tego powodu bez dodatkowego zewnętrznego wsparciajego zdolność do obsługi transakcji jest ograniczona. W przypadku interfejsu ServletAPI czynność przechowywania informacji o stanie interakcji nazywa się śledzeniem se-sji i jest obsługiwana przez obiekt �� utworzony przez kontener serwletu.

Każde żądanie klienckie otrzymane przez kontener serwletu związane jest z obiektemsesji posiadającym niepowtarzalny identyfikator. Obiekt sesji służy do przechowywaniainformacji o użytkowniku, na przykład informacji o stanie koszyka w sklepie interne-


towym, i zarządzania nimi lub do konwersacji z użytkownikiem. Po zakończeniu kon-wersacji obiekt sesji jest niszczony lub treść konwersacji przechowywana jest do chwiliodbycia następnej konwersacji z tym samym użytkownikiem.

Omówimy dwie metody szeroko obsługiwane przez kontenery serwletów (inne metodysą również dostępne):

� ciasteczka (cookies),

� przepisywanie adresów URL.

W obu metodach przyjmujemy, że klient razem z każdym żądaniem przesyła równieżinformacje identyfikacyjne, dzięki którym serwlet może przypisać danego użytkownikado istniejącej sesji lub utworzyć nową sesję. Metody te różnią się mechanizmami prze-kazywania tych informacji od klienta do serwletu i z serwletu do klienta.

Ciasteczka są niewielkimi porcjami informacji, które można przekazywać do klienta jakoczęść odpowiedzi. Klient może przechowywać ciasteczko i wysyłać je wraz z każdymnastępnym żądaniem do serwera, dopóki ciasteczko nie straci ważności. W celu prze-prowadzenia sesji kontener tworzy na serwerze mały plik ciasteczka zawierający identy-fikator sesji, który wysyłany jest do klienta w nagłówku odpowiedzi. Gdy serwerotrzyma kolejne żądanie od klienta, z pliku ciasteczka pobierany jest identyfikator sesjii na tej podstawie ustalony zostaje obiekt sesji klasy �� znajdujący się na ser-werze, związany z danym użytkownikiem.

Jeśli klient nie obsługuje ciasteczek lub ich nie akceptuje, nie można ich użyć do prze-prowadzenia sesji. W takich przypadkach, kiedy nie można użyć ciasteczek, stosuje siętechnikę przepisywania adresów URL. Przepisywanie adresów URL polega na tym, żew zwracanym do klienta adresie URL zakodowany jest identyfikator sesji. Gdy użyt-kownik wysyła kolejne żądania przy użyciu zakodowanego adresu URL, kontener ser-wletu dekoduje numer sesji z adresu i wiąże go z trwającą na serwerze sesją.

Aby kontener serwletu rozpoczął śledzenie sesji, należy wywołać metodę ��2�� obiektu �� przed zwróceniem odpowiedzi do klienta. Na-stępujące wyrażenie tworzy zmienną o nazwie ��, która zawiera obiekt sesji klasy��:

4��&�##��#�##�;�%�.$�#��&�##��5

Ta metoda inicjuje sesję, jeśli sesja jeszcze nie istnieje i odświeża sesję, jeśli sesja ist-nieje i nie chcemy, aby została zniszczona z powodu przeterminowania (czas przetermi-nowania określany jest dla każdej sesji). Jeżeli istnieje potrzeba prowadzenia sesjii prawdopodobieństwo, że klient nie obsługuje ciasteczek, każdy adres URL zwracanydo klienta w ramach odpowiedzi powinien zostać zakodowany za pomocą jednej z na-stępujących metod obiektu ��:

� ��'��(

� ��'��(


Metody te zwracają adres URL z zakodowanym numerem sesji. Jeżeli klient akceptujeciasteczka i mają one zostać użyte do prowadzenia sesji, nie należy zmieniać adresuURL poprzez wywoływanie wymienionych metod.

��

Jak wiemy, podczas sesji mogą być tworzone pliki ciasteczek, dodawane następnie donagłówka odpowiedzi serwletu bez potrzeby osobnego zajmowania się ciasteczkamiprzez programistę. Zdarza się, że ciasteczka potrzebne są w innym celu niż prowadzeniesesji. Dla takich przypadków interfejs ��) �$� zawiera klasę ��3��, którą można wykorzystać do tworzenia dodatkowych ciasteczek zwraca-nych do klienta. Przed zwróceniem odpowiedzi do klienta, serwlet może, wykorzystująctę klasę, stworzyć dodatkowe ciasteczka:

+��;��+��<!�=��<@<��%��CD<�

To wyrażenie tworzy nowe ciasteczko o nazwie 41�50�4 i wartości 4,��674. Ciasteczkoto może być następnie dołączone do odpowiedzi poprzez wywołanie metody ��2��3�� i zwrócone do klienta jako dodatkowa wartość w nagłówkupodczas obsługi kolejnych żądań. Listę ciasteczek wysłanych do klienta i zwróconychpodczas obsługi żądań klienckich można uzyskać przez wywołanie metody ��3��klasy �� .

Tabela 16.3 przedstawia listę różnych atrybutów, które można ustawiać jako część cia-steczka, i ich znaczenia.

�� Właściwości ciasteczek określone przez interfejs Servlet API

Właściwość

ciasteczka

Znaczenie

+�� Łańcuch zawierający informację tekstową, która ma zostać dostarczona z ciasteczkiem.Często jest to opis roli ciasteczka.

/�� Nazwa domenowa serwera, do którego klient powinien wysłać to ciasteczko.Domyślnie ciasteczko zwracane jest do serwera, który przekazał je klientowi.

*��2�� Liczba sekund istnienia ciasteczka przed przeterminowaniem. Jeśli liczba *��2��jest ujemna, ciasteczko wygasa, gdy klient zostanie zamknięty.

!�� Nazwa ciasteczka. Nazwa ustalana jest w czasie tworzenia ciasteczka.

7�� Ścieżka na serwerze reprezentująca zasób, do którego należy wysłać ciasteczkow ramach odpowiedzi.

N��$� Wartość związana z ciasteczkiem. Wartość ustalana jest w czasie tworzeniaciasteczka i może zostać w dowolnym czasie zmieniona.

N�%#�� Wersja specyfikacji, z jaką ciasteczko jest zgodne.

&��$%� Wartość typu �� informująca klienta, czy dane ciasteczko powinno być przesyłanetylko za pomocą bezpiecznych protokołów.


��

Po utworzeniu przynajmniej jednego serwletu w naszym projekcie, jesteśmy gotowi dojego debugowania. Uruchomienie i debugowanie aplikacji sieciowej w JBuilderze jestzbliżone do uruchamiania i debugowania dowolnej aplikacji Javy. Jest kilka różnici należy o nich wspomnieć.

Na początek musimy powiedzieć, że serwer, którego JBuilder używa do uruchamianiaserwletów musi być prawidłowo skonfigurowany. Rysunek 16.3 przedstawia zakładkęServer w oknie Project Properties.

�� Właściwości projektu.Konfiguracjaserwerów

Na zakładce Server możemy skonfigurować serwery wykorzystywane przez JBuilderado uruchamiania różnych komponentów projektu. W naszym przypadku do omówieniazagadnienia debugowania serwletów w JBuilderze musimy określić serwer JSP/Servlet,który będzie wykorzystywany do uruchamiania naszych serwletów. Razem z JBuilde-rem instalowany jest serwer Apache Tomcat prekonfigurowany do wykonywania ser-wletów, dlatego musimy upewnić się, czy Tomcat 4.0 jest prawidłowo skonfigurowanyna naszym komputerze. Patrząc na rysunek 16.3, widzimy, że tak jest. Jeśli dostępne sąinne serwery, oczywiście możemy ich użyć. Ponieważ Tomcat 4.0 stanowi implementa-cję referencyjną interfejsu Servlet API 2.3 i jest standardowo instalowany razem z JBu-ilderem, stanowi łatwo dostępny i prosty w użyciu serwer na potrzeby tworzenia i te-stowania aplikacji.

Po skonfigurowaniu serwerów na potrzeby naszego projektu, musimy ustawić domyślnąkonfigurację uruchomieniową dla naszej aplikacji. Konfiguracja uruchomieniowa za-pewnia mechanizm ustawiania kodu, który ma zostać uruchomiony lub debugowanyw JBuilderze i nie wpływa na proces wykonywania aplikacji poza JBuilderem. Rysunek16.4 przedstawia zakładkę Run w oknie Project Properties, na której znajdują sięwszystkie konfiguracje uruchomieniowe ustawione dla bieżącego projektu. Znajduje siętam tylko jedna konfiguracja o nazwie chalktalkweb.


�� Okno ProjectProperties,zakładka Runtimeconfiguration,na której znajduje siękonfiguracja o nazwiechalktalkweb.

Dla każdego projektu można zdefiniować wiele konfiguracji. Rysunek 16.4 przedstawiadwie opcje po lewej stronie typu serwera na liście konfiguracji uruchomieniowych. Jeślidostępnych jest wiele konfiguracji, podczas uruchamiania aplikacji zostanie użyta kon-figuracja oznaczona jako domyślna (opcja default). Druga opcja to Context Menu. Każdakonfiguracja z aktywną opcją Context Menu będzie umieszczona w oknie dialogowymwyświetlanym podczas uruchamiania aplikacji, z którego użytkownik będzie mógł wy-brać określoną konfigurację, jeśli nie istnieje konfiguracja domyślna. Rysunek 16.5przedstawia okno dialogowe Runtime Properties dla konfiguracji chalktalkweb. To oknozostanie wyświetlone po wybraniu określonej konfiguracji uruchomieniowej i kliknięciuklawisza Edit na zakładce Run przedstawionej na rysunku 16.4.

Zwróć uwagę, że na rysunku 16.5 na zakładce Server wybrano kategorię JSP/Servletz listy Category. Pola tekstowe po prawej stronie listy Category określają numer portu,którego będzie używał serwer Tomcat 4.0 oraz początkowy adres URL wykorzystywanydo otwierania początkowej strony naszej aplikacji. Te opcje pozwalają ustalić, któryserwlet (lub strona WWW) ma zostać wyświetlony jako pierwszy podczas debugowanialub uruchamiania projektu w środowisku JBuilder.

Po ustawieniu konfiguracji uruchomieniowej i serwera JSP/Servlet, możemy uruchomićlub debugować aplikację tak jak każdy inny projekt w JBuilderze, wybierając polecenieProject\Run lub Project\Debug. Rysunek 16.6 przedstawia projekt uruchomiony na ser-werze JSP/Servlet Tomcat 4.0. Uzyskujemy dostęp do serwletu, który wyświetla komu-nikat: The servlet has received a GET. This is the reply.

Zakładka na dole ekranu z napisem Tomcat 4.0 http:8080 reprezentuje serwer WWW,za pośrednictwem którego uzyskujemy dostęp do aplikacji sieciowej. Czerwony przy-cisk tuż nad zakładką służy do zatrzymywania serwera i może zostać użyty w dowolnejchwili.


�� Okno dialogoweProject Properties,zakładka RuntimeProperties

�� JBuilder wykonującyaplikację sieciową naserwerze Tomcat 4.0

Zakładka CourseList przedstawiona na rysunku 16.6 reprezentuje uruchomioną lub de-bugowaną aplikację. Zakładka Web View wewnątrz tej zakładki jest w pełni funkcjonu-jącą przeglądarką WWW, której możemy używać do testowania działania całej aplikacjirazem z wszystkimi serwletami. Zakładka Web View Source obok zakładki Web Viewzawiera listing kodu źródłowego treści wyświetlanej na zakładce Web View.


Jeśli zachodzi potrzeba debugowania serwletu, umieść punkt kontrolny w wybranymmiejscu kodu źródłowego i normalnie debuguj aplikację. Ważne jest, aby pamiętać, żejeśli kod źródłowy serwletów ulegnie zmianie, aby zmiany weszły w życie, przed po-nownym uruchomieniem aplikacji należy zatrzymać serwer Tomcat.

!"��#��

Po utworzeniu i przetestowaniu aplikacji sieciowej przyszedł czas na wdrożenie i uru-chomienie aplikacji sieciowej poza środowiskiem JBuilder. Istnieją dwie metodywdrażania aplikacji sieciowej, które zostały omówione na początku tego podrozdziału.

� Hierarchia podkatalogów rozpoczynających się od głównego katalogu aplikacji.

� Pojedynczy plik archiwum aplikacji sieciowej (WAR).

Pierwsza metoda wymaga przekopiowania katalogu głównego aplikacji sieciowej z wszyst-kimi podkatalogami do miejsca określonego przez docelowy serwer. Druga metodawymaga spakowania katalogu głównego i jego podkatalogów do postaci pojedynczegopliku z rozszerzeniem .war. Niezależnie od metody wdrażania, zarówno pojedynczyplik WAR, jak i struktura katalogów muszą zostać przekopiowane do określonego miej-sca zgodnie z instrukcjami dla danego serwera sieciowego.

JBuilder dostarcza mechanizm do automatycznego tworzenia plików WAR na potrzebywdrażania za każdym razem, gdy projekt zostanie przebudowany. Rysunek 16.7 przed-stawia okno Properties dla aplikacji sieciowej. Okno to wyświetlane jest po kliknięciuprawym przyciskiem myszy węzła chalktalkweb w oknie Project widocznym na rysunku16.6 i wybraniu z menu pozycji Properties.

�� Okno Properties dlaaplikacji sieciowej


Okno na rysunku 16.7 zawiera nazwę pliku WAR, który zostanie utworzony oraz ścieżkędo katalogu głównego aplikacji. Informacja o docelowym położeniu tworzonego plikuWAR znajduje się w polu tekstowym WAR. Dwie dostępne opcje określają, czy i kiedyma być tworzony plik WAR dla danej aplikacji.

Opcja Compress the contents of the archive określa, czy zawartość katalogu głównegopowinna zostać skompresowana, w celu zaoszczędzenia miejsca na dysku i serwerze.

Opcja Always create archive when building the project steruje procesem tworzeniapliku WAR. Jeśli jest włączona, podczas budowania projektu zostanie utworzony plikWAR i umieszczony w określonym miejscu.

�$%&��

Teraz, gdy już zapoznaliśmy się ze strukturą interfejsu Java Servlet API i wiemy, czymsą serwlety, stworzymy sieciowy interfejs użytkownika naszej aplikacji ChalkTalk.

Interfejs sieciowy będzie prostą aplikacją sieciową o nazwie chalktalkweb, na podstawiektórej zademonstrujemy poszczególne kroki tworzenia aplikacji sieciowej w JBuilderzeopartej na serwletach. Aplikacja ta wyświetla wyniki zwrócone przez metodę ��0��klasy)��&��&��3��3��)��&&�� na stronie WWW. Aby po-kazać implementację sesji, stworzymy serwlet, który wywołuje zawarte w klasie metody�� i ��.

Oto lista kroków do wykonania w tym ćwiczeniu.

�� Utworzyć projekt i aplikację sieciową.

�� Zaprojektować serwlet View Course.

�� Zaprojektować serwlet Login.

�� Zaprojektować filtr.

�� Skonfigurować aplikację sieciową tak, aby używała filtra.

� ��

Zaczniemy od stworzenia nowego projektu w JBuilderze i wstawienia nowej aplikacjisieciowej o nazwie chalktalkweb. Serwlety i klasy Javy utworzone w miarę wykonywa-nia ćwiczenia zostaną umieszczone w kontekście tej aplikacji sieciowej.

�� Skopiuj podkatalog chalktalkapp z katalogu Rozdział16 na dysk twardy. PakietyJavy w katalogu chalktalkapp reprezentują bibliotekę klas, z której będzie korzystałanasza aplikacja sieciowa w celu dostarczenia podstawowego zestawu funkcji.

�� Wybierz polecenie File\New Project.

�� Na pierwszym ekranie kreatora Project Wizard wprowadź rozdzial16 jako nazwęprojektu i nazwę C:\Projekty\Helion\Aplikacja\rozdzial16 jako nazwę katalogu.Pozostaw .jpx jako typ pliku, pozycję (Default Project) w polu Template


i zaznacz opcję Generate project notes file. Swój projekt możesz umieścićw innym katalogu, lecz pozostaw chociaż ostatni człon nazwy, rozdzial16.W ten sposób łatwiej porządkować pliki. Kliknij przycisk Next.

�� Na drugim ekranie kreatora Project Wizard dodaj referencję do plików źródłowychistniejącej aplikacji ChalkTalk. Kliknij przycisk Add znajdujący się obok zakładkiSource, aby wyświetlić okno dialogowe i odszukaj miejsce, do którego skopiowałeśkatalog chalktalkapp w kroku 1. Po zlokalizowaniu katalogu kliknij przycisk OK,aby zamknąć okno dialogowe. Katalog chalktalkapp powinien zostać umieszczonyna liście na zakładce Source. Kliknij przycisk Next.

�� Na trzecim ekranie wprowadź swoje nazwisko w polu @author i nazwę Twojejfirmy w polu Company. Kliknij przycisk Finish.

�� Wybierz polecenie File\New, aby wyświetlić okno dialogowe Object Gallery.Na zakładce Web kliknij dwukrotnie ikonę Web Application, aby wyświetlićkreatora Web Application Wizard. Jeżeli serwer nie został wcześniej skonfigurowanydo wykonywania stron JSP i serwletów, ta ikona będzie niedostępna. W podrozdziale„Debugowanie” wcześniej w tym rozdziale omówiliśmy proces konfiguracjiserwera JSP-Servlet na potrzeby naszego projektu.

�� Na wyświetlonym ekranie wprowadź nazwę chalktalkweb jako nazwę aplikacjiw polu Name i C:\Projekty\Helion\Aplikacja\rozdzial16\chalktalkweb jako nazwękatalogu w polu Directory. Kliknij przycisk OK.

Mamy już pustą aplikację sieciową służącą za podstawę dla naszego interfejsu siecio-wego istniejącej aplikacji ChalkTalk. Następnie stworzymy serwlet wyświetlający re-zultaty zwracane przez metodę ��0�� klasy ��&��&��3��3��&&��.

�� !��

Zaprojektowany przez nas serwlet View Course List będzie podzielony na dwie części.Górna część będzie przedstawiać menu łączy do innych elementów aplikacji sieciowej,natomiast dolna część będzie wyświetlać listę kursów. Na potrzeby aplikacji ChalkTalkzaprojektujemy interfejs sieciowy składający się z pojedynczej strony WWW, umiesz-czając w menu jedno łącze, View Course List.

�� Wybierz polecenie File\New, aby wyświetlić okno dialogowe Object Gallery.Na zakładce Web kliknij dwukrotnie ikonę Servlet, aby uruchomić kreatoraServlet Wizard.

�� Na pierwszym ekranie kreatora Servlet Wizard wprowadź ��&��&��3��3��0� jako nazwę pakietu (Package) oraz �� jako nazwę klasyserwletu. Zaznacz opcję Check the Generate header comments. Zaznacz opcjęSingle Thread Model. Upewnij się, że na liście Web App wybrana jest pozycjachalktalkweb. Wybierz opcję Standard servlet. Kliknij przycisk Next.

�� Na drugim ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.

�� Na trzecim ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.


�� Na czwartym ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.

�� Na piątym ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Finish.

�� Spróbuj uruchomić projekt poprzez wybranie polecenia Run\Run project(klawisz skrótu to F9), aby upewnić się, że wszystkie ustawienia są prawidłowe.Wynik uruchomienia projektu to wynik wyświetlany przez serwlet CourseList.

� Po zapoznaniu się z wynikami i sprawdzeniu, że aplikacja działa, zatrzymaj jejdziałanie przez przejściem do następnego kroku. Aplikację zatrzymujemykliknięciem czerwonego przycisku znajdującego się w dolnym lewym narożnikuekranu, tuż nad napisem Tomcat 4.0.

Mamy podstawową aplikację sieciową, która działa. Następnie przystosujemy ten ser-wlet, tak aby wyświetlał listę kursów:

�� Otwórz plik serwletu CourseList na panelu Content i przejdź do zakładki Sourceznajdującej się na dole ekranu.

�� Dodaj następujące polecenia import poniżej innych poleceń import. Dzięki tymklasom serwlet ma dostęp do istniejących funkcji odpowiedzialnych za działanieaplikacji ChalkTalk.

��%��#��#��$#�%#�%'��#�+��0��%��#5��%��#��#��#�+�$%#�/��5

�� Dodaj następującą linię poniżej deklaracji zmiennej ��1%�1%8%9$�:

�%�'��+��0��%��#��0�#5

�� Zmodyfikuj ciało metody �� tak, aby wyglądało następująco:

�$��'��%��#�&�%'��8��0�#�;��+��0��%��#��5G

�� Zmodyfikuj ciało metody ��#�, aby wyglądało jak na listingu 16.5 (uwaga:serwlet Login utworzymy w następnym punkcie).

�� Metoda doGet wewnątrz klasy File CourseList.java

�$��'��(��4��&�%'��-�.$�#��%�.$�#�@�4��&�%'��-�#��#��%�#��#��%��#�&�%'��@� 0��8%�#��#��#��+��) ��+0!)�!)9):7��57%��%��%��$��;�%�#��#��%��%��5�$��%��<A��B<�5�$��%��<A��BA��B1�#��$%#�A��BA��B<�5�$��%��<A�� B<�5��)��%=��$��#�O�� %��$��%��<A2�4-�";P<<�E%�#��#��3-1�<��K&$��;1��$�<��E<P<B� ��A�2B�<�5�$��%��<A2�4-�";P<<�E%�#��#��3-1�<��$%#��#�<��E<P<B� C��#�O��$%#�A�2B<�5�$��%��<A4-B<�5


��$��#� ��$%#��$��%��<A��%��%;FB<�5�$��%��<A�%BA��B �A��B<�5�$��%��<A��B!�=��A��B<�5�$��%��<A��B0��#A��BA��%B<�5,�%�� %��%��%�;��0�#��%��#�+�$%#�#��$��%��%��5��%��#!��5��8+�$%#�/��$%#��;��+�$%#�/��%��5�,��$%#��M;��$��8�$��%��<A�%BA��B<E��$%#�� E<A��B<�5�$��%��<A��B<E��$%#��)��E<A��B<�5�$��%��<A��B<E��$%#��/�#�%��E<A��BA��%B<�5G5G�$��%��<A��B<�5��#� ��$%#��$��%��<A�� BA��B<�5G

�� Uruchom projekt, aby sprawdzić, czy po dokonaniu zmian wszystko działa.Rysunek 16.8 przedstawia ekran wynikowy serwletu CourseList po uruchomieniuprojektu w JBuilderze.

�� Ekran wynikowyserwletuCourseList.java

�� Po zapoznaniu się z wynikami i sprawdzeniu, że aplikacja działa, zatrzymaj jejdziałanie przed przejściem do następnego kroku. Aplikację zatrzymujemykliknięciem czerwonego przycisku znajdującego się w dolnym lewym narożnikuekranu, tuż nad napisem „Tomcat 4.0”.

Aplikacja sieciowa wyświetla teraz rezultaty wywołania metody ��0�� klasy��&&��.


�� !��

Stworzymy serwlet �� implementujący zarówno metodę ��, jak i �� klasy��&&��. Implementując te metody, zademonstrujemy użycie sesji do prze-chowywania pewnych informacji pomiędzy wywołaniami serwletu i adresu URL, z któregoz powodzeniem zalogowano się do aplikacji. Serwlet �� będzie wykonywał nastę-pujące zadania:

� obsługa żądań zalogowania i wylogowania,

� wyświetlenie strony logowania.

Gdy wartość parametru żądania otrzymanego przez serwer to �� lub ��, serwletwykonuje operacje, natomiast w przeciwnym razie serwlet wyświetla stronę logowania.

�� Wybierz polecenie File\New, aby wyświetlić okno dialogowe Object Gallery.Na zakładce Web kliknij dwukrotnie ikonę Servlet, aby wyświetlić kreatoraServlet Wizard.

�� Na pierwszym ekranie kreatora wprowadź ��&��&��3��3�� jakonazwę pakietu (Package) oraz Login jako nazwę klasy serwletu (Name). Zaznaczopcje Generate header comments i Single Thread Model. Upewnij się, że z listyWeb App wybrana jest pozycja chalktalkweb. Wybierz opcję Standard Servlet.Kliknij przycisk Next.

�� Na drugim ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.

�� Na trzecim ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.

�� Na czwartym ekranie kreatora Servlet Wizard nie potrzeba dokonywać żadnychzmian. Kliknij przycisk Next.

�� Na piątym ekranie kreatora Servlet Wizard zaznacz opcję Create a runtimeconfiguration. Wprowadź nazwę �� jako nazwę konfiguracji uruchomienioweji pozostaw opcję Base configuration ustawioną na none. Kliknij przycisk Finish.

�� Otwórz plik serwletu Login na panelu Content i przejdź do zakładki Sourceznajdującej się na dole ekranu.

� Dodaj następujące polecenia import poniżej innych poleceń import. Dzięki tymklasom serwlet ma dostęp do istniejących funkcji odpowiedzialnych za działanieaplikacji ChalkTalk.

��%��#��#��$#�%#�%'��#�+��0��%��#5

� Dodaj następującą linię poniżej deklaracji zmiennej ��1%�1%8%9$�:

�%�'��+��0��%��#��0�#5

�� Zmodyfikuj ciało metody �� tak, aby wyglądało następująco:

�$��'��%��#�&�%'��8��0�#�;��+��0��%��#��5G

�� Zmodyfikuj ciało metody ��#�, aby wyglądało jak na listingu 16.6.


�� Metoda doGet w pliku Login.java

�$��'��(��4��&�%'��-�.$�#��%�.$�#�@�4��&�%'��-�#��#��%�#��#��%��#�&�%'��@� 0��8%�#��#��#��+��) ��+0!)�!)9):7��57%��%��%��$��;�%�#��#��%��%��5��3��%=��=��#�#��4��&�##��#�##�;�%�.$�#��&�##��5��-�=��=��%�� %=�=��&�%��#0��%��;��&�%��%�.$�#��7�%��%�<&$��<�5�,��#0��%��;;��$��8G��#��,��#0��%��.$��#�<1��<��8��0�#��5%�#��#��#��-��%��%�#��#��-��%��3-1��&�%��#�##��2��%��$��<��%��<��5#�##�#��2��%��$��<1�� <@��%$��5%��$%�5G��#��,��#0��%��.$��#�<1��$�<��8��0�#��$��5%�#��#��#��-��%��%�#��#��-��%��3-1��&�%��#�##��2��%��$��<��%��<��5#�##��'��5%��$%�5G��#��8G��%=��#�%�� 4)*1�$��%��<A��B<�5�$��%��<A��BA��B1��%��#�%$�?��$%# A��BA��B<�5�$��%��<A�� B<�5��)��%=��$��%��$��%��<A,�%��;P<<�E%�#��#��3-1�%�.$�#��-�.$�#�3- ��E<P<��;P<(�)P<B<�5�$��%��<!�=��3> ��H�A��$��;P<$#�%��P<BA�%B<�5�$��%��<4�#�H�A��$�� ;P<��##��%�P<��;P<��##��%�P<BA�%B<�5�$��%��<A��$�� ;P<#$��P<��;P<&$��P<�'��$�;P<1��P<B<�5�$��%��<A��$�� ;P<%�#��P<�'��$�;P<-�#��P<B<�5�$��%��<A�,�%�B<�5�$��%��<A�� BA��B<�5G

�� Uruchom projekt i sprawdź, czy serwlet �� wykonuje się bez błędów. W okniedialogowym Choose Runtime Configuration wybierz pozycję Login RuntimeConfiguration, aby wyświetlić wynik działania serwletu ��. Wynik działaniaserwletu przedstawiony jest na rysunku 16.9.

�� Po sprawdzeniu wyników działania serwletu zatrzymaj aplikację sieciową przedprzejściem do następnego kroku. Aplikację zatrzymujemy kliknięciem czerwonegoklawisza znajdującego się w dolnym lewym narożniku ekranu, tuż nad napisemTomcat 4.0.

Aplikacja sieciowa składa się teraz z dwóch serwletów, które wspólnie wykonują metodyzawarte w klasie ��&&��.


�� Wynik działaniaserwletu Login.java

�� "��

W ramach naszej aplikacji sieciowej zaprojektujemy filtr, którego można użyć do prze-kierowywania użytkownika do ekranu logowania, jeśli nie jest on jeszcze zalogowanyi próbuje uzyskać dostęp do serwletu ��:

�� Wybierz File\New, aby wyświetlić okno dialogowe Object Gallery. Na zakładceGeneral kliknij dwukrotnie ikonę Class, aby wyświetlić kreatora Class Wizard.

�� Na pierwszym ekranie kreatora Class Wizard wprowadź��&��&��3��3��0� jako nazwę pakietu (Package) i LoginFilter jakonazwę klasy. Pozostaw �� jako klasę bazową. Pozostaw wszystkieopcje w domyślnym stanie. Kliknij przycisk OK.

�� Otwórz klasę ��"�� na panelu Content i przejdź do zakładki Sourceznajdującej się na dole ekranu.

�� Dodaj następujące polecenia import poniżej innych poleceń import:

��%��'��#�%'��65��%��'��#�%'��65��%��'��65

�� Zmodyfikuj klasę ��"�� tak, aby była zgodna z definicją przedstawionąna listingu 16.7.

�� Klasa LoginFilter Class w pliku LoginFilter.java

�$��##�1��"��%��#�"��%�8�%�'��"��%+��,��,��%+��,��5��0�#$��%=��=��,��$%��,��%��$��'��"��%+��,��,��%+��,��8


��#�,��%+��,��;�,��%+��,��5G��0�#$��>?��Q��=��$��'��"��%�&�%'��-�.$�#��%�.$�#�@&�%'��-�#��#��%�#��#�@"��%+��,��%+��8G��&�%=?��$��'��#�%� ��8GG

�� Zmodyfikuj metodę ��"�� tak, aby była zgodna z listingiem 16.8.

�� Metoda doFilter w pliku LoginFilter.java

�$��'��"��%�&�%'��-�.$�#��%�.$�#�@&�%'��-�#��#��%�#��#�@"��%+��,��%+��8�% �84��&�%'��-�.$�#��%�.�;��4��&�%'��-�.$�#��%�.$�#�54��&�%'��-�#��#��%�#�;��4��&�%'��-�#��#��%�#��#�5��3��%=��=��#�#��4��&�##��#�##�;�%�.��&�##��5��&�%��=��= �=�� 1�� ;��#�##��2��%��$��<1�� <�5��R�>��=�� @��%=��%$��#�%��$�1��,��1�� ;;��$��SS�M�1�� N��$��8#�##�#��2��%��$��<��%��<@%�.��-�.$�#�3-1��&�%��5%�#�#��-��%��%�#��-��%��3-1�<��<��5%��$%�5G,��%+��"��%�%�.$�#�@�%�#��#��5G��&�%'��#��8,��%+��,��&�%'��+��#��*�##��5G�� 0��8,��%+��,��&�%'��+��*�##��5GG

�� "��

W tym punkcie zmodyfikujemy plik deskryptora wdrożenia aplikacji sieciowej, abyupewnić się, że filtr ��"�� przechwytuje każde żądanie skierowane do serwletu��, który stworzyliśmy.

�� Otwórz plik deskryptora wdrożenia danej aplikacji sieciowej. Rysunek 16.10przedstawia edytor WebApp DD.

�� Kliknij prawym przyciskiem myszy panel Structure i wybierz z menu polecenieAdd Filter. Wprowadź LoginFilter jako nazwę filtra w oknie dialogowym NewFilter. W ten sposób utworzysz węzeł opatrzony napisem LoginFilter, któryznajdzie się poniżej węzła Filters.


�� Edytor WebApp DD

�� Ustaw mapowanie, czyli określ, jakie żądania klienta będą przechwytywane przezten filtr. Kliknij węzeł Filters na panelu Structure, aby wyświetlić na paneluContent listę mapowań Filter Mappings, jak pokazano na rysunku 16.11.Na panelu Content kliknij przycisk Add, aby utworzyć nowe mapowanie.Wprowadź CourseList jako nazwę serwletu i LoginFilter jako nazwę filtra.

�� Edytor WebApp DD:mapowanie filtra

�� Ustaw właściwości filtra. Kliknij węzeł LoginFilter na panelu Structure, abyna panelu Content wyświetlić właściwości filtra, jak przedstawiono na rysunku16.12. Jako klasę filtra (Filter class) ustaw ��&��&��3��3��0� ��"��.


�� Edytor WebApp DD:właściwości filtra

�� Utwórz dodatkowe mapowanie serwletu, aby ustawić domyślnie wykonywanyserwlet. Ten serwlet będzie wykonywany, gdy adres URL wskaże serwlet, którynie występuje w zasobach aplikacji chalktalkweb. Kliknij węzeł Servlets napanelu Structure, aby wyświetlić listę mapowań Servlet Mappings, jak pokazanona rysunku 16.13. Kliknij przycisk Add, aby utworzyć dodatkowe mapowaniei wprowadź znak / jako wzór adresu URL, i courselist jako serwlet.

�� Edytor WebApp DD:mapowanieserwletu

�� Przebuduj projekt poprzez wybranie polecenia Project\Rebuild Project"roz16.jpx" z menu.


Trwałość sesji

W naszej aplikacji chalktalkweb śledzimy sesję, aby sprawdzić, czy klient się zalogował. Gdysprawdzamy, czy użytkownik jest zalogowany, możemy ograniczyć dostęp do chronionego zasobudo grona użytkowników mających takie prawo. Jak zademonstrowaliśmy na przykładzie chalktal-kweb, to działa.

Podczas testowania aplikacji chalktalkweb, może się okazać, że gdy aplikacja działa, klient niezawsze jest prawidłowo przekierowywany do strony logowania. Serwer Tomcat 4.0 i JBuilder za-chowują sesję pomiędzy kolejnymi uruchomieniami aplikacji i w czasie pomiędzy istnienieminstancji serwera Tomcat 4.0. Jeśli aplikacja sieciowa zostanie zatrzymana lub serwer Tomcatzostanie zamknięty, generowany jest plik session.ser, w którym zawarte są informacje o bieżącejsesji w formacie umożliwiającym serializację. JBuilder i Tomcat wykorzystują informacje zawartew tym pliku do utrwalenia sesji związanej z aplikacją, którą uruchamiasz.

Z tego wynika niespodziewane zachowanie naszej aplikacji. Jeśli aplikacja chalktalkweb zostaniezamknięta w czasie, gdy użytkownik jest nadal zalogowany, po następnym jej uruchomieniuklient sieciowy będzie nadal zalogowany. Oznacza to, że klient nie zostanie automatycznie prze-kierowany do strony logowania Login, jak by się tego można spodziewać, lecz uzyska dostęp dostrony CourseList.

Informacja o sesji przechowywana jest przez cały czas uruchomienia tego samego egzemplarzaJBuildera. Gdy zostanie otwarty nowy egzemplarz JBuildera, informacja o sesji pochodząca z po-przednich uruchomień nie zostanie wykorzystana. Natomiast w czasie uruchomienia tego same-go egzemplarza JBuildera sposobem na skasowanie informacji o sesji jest usunięcie kataloguTomcat z projektu chalktalkweb.

�� Uruchom projekt, aby sprawdzić, czy filtr działa. Wybierz konfiguracjęuruchomieniową courselist z okna dialogowego Choose Runtime Configuration.Każda próba dostępu do serwletu �� powinna zakończyć się przekierowaniemdo serwletu Login, jeśli użytkownik nie zalogował się podczas sesji.

��" ��

Interfejs Java Servlet API jest potężnym mechanizmem do tworzenia aplikacji siecio-wych charakteryzujących się funkcjami ułatwiającymi ich przenoszenie i wdrażanie.JBuilder zawiera wiele kreatorów i edytorów ułatwiających tworzenie aplikacji siecio-wych, spośród których wiele poznaliśmy w tym rozdziale.

��#��#�$��

� Jak wiemy, serwlety mogą być potężnym środkiem do generowania dynamicznejzawartości dla aplikacji sieciowych. Jakie są inne zastosowania serwletów opróczgenerowania kodu HTML?

� W podrozdziale „Część praktyczna” korzystaliśmy z filtra jako środkazabezpieczającego serwlet �� przed nieautoryzowanym dostępem.Jakie są inne zastosowania filtra lub łańcucha filtrów?

� Interfejs Servlet API udostępnia obiekt typu �� !��, który możezostać użyty to przekierowywania żądań klienckich do innych zasobów lubdo włączania odpowiedzi pochodzącej z innego zasobu jako części odpowiedzidla klienta. Jaki można z tego zrobić użytek?

JBuilder. Vademecum profesjonalisty

Technology

Transcript of JBuilder. Vademecum profesjonalisty