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 jednak 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.
1. IDZ DO
PRZYK£ADOWY ROZDZIA£
JBuilder. Vademecum
SPIS TRE CI
profesjonalisty
KATALOG KSI¥¯EK Autorzy: Michael Landy, Saleem Siddiqui, Jeff Swisher
T³umaczenie: Adam Majczak (rozdz. 1 - 9, 30, 31), Tomasz
KATALOG ONLINE Miszkiel (rozdz. 17, 19, 20 - 24), Pawe³ Ro czak
(rozdz. 25, 28, 29), Marcin Samodulski (rozdz. 10 - 16),
ZAMÓW DRUKOWANY KATALOG Krzysztof Wo³owski (rozdz. 18, 26, 27)
ISBN: 83-7361-139-8
Tytu³ orygina³u: JBuilder Developer's Guide
TWÓJ KOSZYK Format: B5, stron: 856
DODAJ DO KOSZYKA 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
CENNIK I INFORMACJE 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
ZAMÓW INFORMACJE kreatorów i narzêdzi — ni¿ na samych kodach Javy. Opisuje wiele zaawansowanych
O NOWO CIACH zagadnieñ, takich jak: testowanie modu³ów, refaktoring, Java Server Pages, Enterprise
JavaBeans, CORBA i dostêp do baz danych.
ZAMÓW CENNIK Opisano miêdzy innymi:
• rodowisko JBuilder, jego interfejs i mo¿liwo ci dostosowania
do w³asnych potrzeb
CZYTELNIA • Kreatory JBuildera: Screen Designer i Menu Designer
• Modelowanie w rodowisku JBuildera, UML
FRAGMENTY KSI¥¯EK ONLINE • 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
Wydawnictwo Helion • Tworzenie aplikacji WWW (webservices), protokó³ SOAP
ul. Chopina 6 • Pisanie midletów
44-100 Gliwice • Zespo³owe tworzenie aplikacji
tel. (32)230-98-63 Jest to ksi¹¿ka dla rednio zaawansowanych programistów Javy. Dziêki praktycznemu
e-mail: helion@helion.pl 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.
2. 5RKU VTG EK
1 #WVQTCEJ
9RTQYCFGPKG
%ú è + CE[PCO[ RKGTYU[ TWV QMC PC TQFQYKUMQ ,$WKNFGT
4QFKC 8KXC ,CXC
Od Oak do J2EE — krótka historia Javy ...............................................................................28
Pierwszy rzut oka na JBuildera..............................................................................................30
I co dalej?...............................................................................................................................31
Podsumowanie .......................................................................................................................32
4QFKC 2QEæVGM GMURNQTCELK ,$WKNFGTC
Zintegrowane środowisko projektowe JBuildera ..................................................................33
Główne menu .........................................................................................................................35
Menu File.........................................................................................................................35
Menu Edit, Search i View................................................................................................35
Polecenia formatujące z menu Edit .................................................................................36
Menu Project....................................................................................................................39
Menu narzędzi — Tools ..................................................................................................48
Pozostałe menu ................................................................................................................52
Listwa narzędziowa — Toolbar.............................................................................................53
Część praktyczna ...................................................................................................................53
Projekt Welcome .............................................................................................................53
Projekt Hello World.........................................................................................................54
Podsumowanie .......................................................................................................................58
Tematy do przemyśleń.....................................................................................................59
4QFKC 5VQUWLGO[ MTGCVQT[ ,$WKNFGTC
Screen Designer .....................................................................................................................61
Uruchomienie edytora graficznego .................................................................................62
Implementacja metod obsługujących zdarzenia ....................................................................67
Jak przebiega obsługa zdarzenia......................................................................................68
Stosowanie adaptera anonimowego.................................................................................69
Stosowanie adapterów standardowych............................................................................70
Zmiana ustawień adaptera ...............................................................................................70
Menu Designer.......................................................................................................................71
Przyciski Menu Designera...............................................................................................72
Budowanie menu za pomocą Menu Designera ...............................................................72
Obsługa poleceń z menu — implementacja ....................................................................73
Utworzenie menu kontekstowego ...................................................................................74
3. 6 JBuilder. Vademecum profesjonalisty
Część praktyczna ...................................................................................................................75
Utworzenie szkieletu aplikacji.........................................................................................76
Podsumowanie .......................................................................................................................77
Tematy do przemyśleń.....................................................................................................77
%ú è ++ 2TQLGMVQYCPKG OQFGNQYCPKG K VGUVQYCPKG CRNKMCELK
Y TQFQYKUMW ,$WKNFGT
4QFKC /QFGNQYCPKG
Szybki przegląd UML............................................................................................................81
Elementy języka UML.....................................................................................................82
Diagram klas w UML ......................................................................................................83
Pokazywanie pakietów na diagramach klas ....................................................................84
JBuilder a UML .....................................................................................................................86
Diagramy klas JBuildera .................................................................................................86
Diagram 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 ...................................................................................................................91
Modelowanie serwera......................................................................................................93
Modelowanie klienta .......................................................................................................95
Podsumowanie .......................................................................................................................96
Tematy do przemyśleń.....................................................................................................97
4QFKC 6GUVQYCPKG OQFW ÎY
Opcje testowe JBuildera ......................................................................................................100
Środowisko testowe JUnit Testing Framework ...................................................................102
Tworzymy test za pomocą JUnit ...................................................................................103
Uruchomienie testu za pomocą JUnit............................................................................104
Tworzenie testów i zbiorów testów, uruchamianie w środowisku JBuildera......................105
Jak budować obiekty Test Case za pomocą JBuildera? ................................................106
Utworzenie obiektu Test Suite za pomocą JBuildera....................................................109
Funkcje pomocnicze dla testowania JDBC, JNDI i porównawczego .................................111
Wspomaganie porównywania........................................................................................112
Funkcje pomocnicze do testowania JDBC ....................................................................114
Funkcje pomocnicze do testowania JNDI .....................................................................116
Część praktyczna .................................................................................................................117
Krok 1.: otwieramy projekt z przykładowymi testami ..................................................117
Krok 2.: dodajemy do projektu kod testujący Unit Test Case.......................................118
Krok 3.: dodajemy do projektu porównywanie — Comparison fixture........................119
Podsumowanie .....................................................................................................................122
Tematy do przemyśleń...................................................................................................122
4QFKC 6GUVQYCPKG K WTWEJCOKCPKG E[NK FGDWIQYCPKG
Zintegrowany debuger .........................................................................................................123
Przyciski sterujące debugera .........................................................................................124
Zakładki diagnostyczne Debug Views ..........................................................................126
Sesja diagnostyczna i status...........................................................................................127
Podstawy debugowania........................................................................................................128
Kontrola błędów w czasie rzeczywistym ......................................................................128
Komunikaty o błędach kompilatora ..............................................................................129
Wstawianie punktów kontrolnych .................................................................................129
4. Spis treści 7
Więcej o opcjach debugera ..................................................................................................132
Opcje dotyczące punktów kontrolnych .........................................................................133
Śledzenie klas ................................................................................................................134
Część praktyczna .................................................................................................................135
Krok 1.: otwarcie sesji diagnostycznej przykładowego projektu ..................................136
Krok 2.: poprawiamy błędy składniowe........................................................................136
Krok 3.: poprawiamy błędy występujące podczas kompilacji ......................................137
Krok 4.: poprawiamy błędy występujące podczas działania,
wstawiamy punkty kontrolne, dokonujemy oceny i modyfikacji zmiennych............138
Podsumowanie .....................................................................................................................144
Tematy do przemyśleń...................................................................................................144
4QFKC 4GHCMVQTKPI
Co to jest refaktoring?..........................................................................................................146
Proces Move Refactor..........................................................................................................146
Zmiana nazwy Rename Refactor .........................................................................................149
Zmiana nazwy pakietu...................................................................................................150
Zmiana nazwy klasy lub interfejsu................................................................................152
Zmiana nazwy metody...................................................................................................154
Zmiana nazwy pola lub nazwy zmiennej ......................................................................155
Zmiana nazwy własności...............................................................................................156
Zmiana parametrów .............................................................................................................156
Wyodrębnienie metody........................................................................................................157
Wprowadzenie zmiennej......................................................................................................158
Optymalizacja importu ........................................................................................................160
Obejmowanie obsługą wyjątków.........................................................................................162
Część praktyczna .................................................................................................................163
Krok 1.: otwieramy przykładowy projekt i przeglądamy kod.......................................163
Krok 2.: przenosimy klasę moveExample.....................................................................163
Krok 3.: zmieniamy nazwę klasy moveExample ..........................................................164
Krok 4.: zmiana nazwy zmiennej ..................................................................................165
Podsumowanie .....................................................................................................................166
Tematy do przemyśleń...................................................................................................166
4QFKC QMWOGPVQYCPKG Y TQFQYKUMW ,$WKNFGT
Dodawanie komentarzy .......................................................................................................168
Znaczniki Javadoc................................................................................................................168
Javadoc to nie tylko dokumentacja ......................................................................................169
Dokumentacja niezgodna z kodem ......................................................................................170
Automatyczne szablony Javadoc .........................................................................................171
Zastosowanie kreatora Javadoc Wizard...............................................................................171
Wskazówki...........................................................................................................................179
Skoncentrujmy się na zastosowaniu dokumentacji .......................................................179
Porady dotyczące stylu ..................................................................................................180
Podsumowanie .....................................................................................................................182
Tematy do przemyśleń...................................................................................................182
4QFKC GRNQ[OGPV RT[IQVQYCPKG FQ YFTQ GPKC
Pliki archiwalne Javy ...........................................................................................................184
Plik manifestu ......................................................................................................................184
Archiwizator Javy ................................................................................................................185
Przeglądanie archiwum..................................................................................................186
Uaktualnianie archiwum................................................................................................186
Rozpakowanie plików z archiwum................................................................................187
5. 8 JBuilder. Vademecum profesjonalisty
Moduł Archive Builder JBuildera........................................................................................187
Szybkie przygotowanie dystrybucji...............................................................................193
Wskazówki...........................................................................................................................194
Pieczętowanie pakietów ................................................................................................195
Część praktyczna .................................................................................................................196
Podsumowanie .....................................................................................................................197
Tematy do przemyśleń...................................................................................................197
%ú è +++ ,$WKNFGT C CRNKMCELG MNKGPEMKG Y ,CXKG
4QFKC #96
Podstawy AWT....................................................................................................................201
Aplikacje a aplety ................................................................................................................202
Podstawowy szkielet graficznego interfejsu u ytkownika (GUI) .................................202
Prosty przykład ..............................................................................................................203
U ycie kontenerów AWT ....................................................................................................204
Tworzenie kontenera .....................................................................................................206
Wspólne metody kontenerów ........................................................................................207
U ycie komponentów AWT ................................................................................................208
Przycisk (Button)...........................................................................................................209
Płótno (Canvas) .............................................................................................................211
Pole wyboru (Checkbox) ...............................................................................................213
Grupa pól wyboru (CheckboxGroup)............................................................................214
Lista rozwijana (Choice) ...............................................................................................214
Etykieta (Label) .............................................................................................................215
Lista (List) .....................................................................................................................215
Pasek przewijania (Scrollbar)........................................................................................217
Pole tekstowe (TextField)..............................................................................................217
Wielowierszowe pole tekstowe (TextArea) ..................................................................218
Wspólne metody komponentów ....................................................................................218
Oddzielanie interfejsu u ytkownika od implementacji .................................................218
Część praktyczna .................................................................................................................219
Tworzenie apletu za pomocą kreatora apletów (Applet Wizard) ..................................219
Budowa interfejsu..........................................................................................................220
Obsługa wejścia.............................................................................................................221
Podsumowanie .....................................................................................................................222
Tematy do przemyśleń...................................................................................................222
4QFKC 5YKPI
Dlaczego Swing zamiast AWT? ..........................................................................................223
Wskazówki dotyczące projektowania — architektura model-widok-kontroler ..................225
Uproszczona architektura MVC z semantyką typu „pobierz”.......................................225
Architektura MVC z semantyką typu „wyślij”..............................................................226
MVC a Swing ................................................................................................................228
Hierarchia komponentów Swing .........................................................................................228
U ycie komponentów Swing w JBuilderze .........................................................................232
Część praktyczna .................................................................................................................235
Tworzenie projektu i aplikacji.......................................................................................235
Budowa interfejsu u ytkownika na podstawie ramki JFrame i paneli JPanel...............236
Tworzenie pakietów i klas opisujących dane — obiekty typu dataobject.....................239
Tworzenie klasy CommonOperations ...........................................................................242
Dowiązanie interfejsu u ytkownika do klasy CommonOperations ..............................243
Podsumowanie .....................................................................................................................245
Tematy do przemyśleń...................................................................................................246
6. Spis treści 9
4QFKC 7 [YCPKG OGPGF GTÎY WM CFW
Czym jest mened er układu? ...............................................................................................248
Dostępne typy mened erów.................................................................................................249
U ycie mened era układu ....................................................................................................251
Modyfikacja właściwości menad era układu ................................................................251
Spotkanie komponentu z mened erem układu ..............................................................251
U ycie mened era XYLayout..............................................................................................251
Kiedy u ywać mened era XYLayout............................................................................252
Układanie komponentów...............................................................................................252
Przykład u ycia mened era XYLayout .........................................................................253
U ycie mened era BorderLayout ........................................................................................253
Kiedy u ywać mened era BorderLayout ......................................................................254
Przykład u ycia mened era BorderLayout....................................................................254
U ycie mened era FlowLayout ...........................................................................................255
Kiedy u ywać mened era FlowLayout .........................................................................255
Istotne właściwości........................................................................................................255
Przykład u ycia mened era FlowLayout.......................................................................256
U ycie mened era VerticalFlowLayout ..............................................................................256
Kiedy u ywać mened era VerticalFlowLayout ............................................................256
Właściwości...................................................................................................................256
Przykład u ycia mened era VerticalFlowLayout..........................................................257
U ycie mened era BoxLayout2...........................................................................................258
U ycie mened era GridLayout ............................................................................................258
Kiedy u ywać mened era GridLayout ..........................................................................258
Właściwości...................................................................................................................259
Przykład u ycia mened era GridLayout........................................................................259
U ycie mened era CardLayout............................................................................................260
Kiedy u ywać mened era CardLayout..........................................................................260
Właściwości...................................................................................................................261
U ycie mened era OverlayLayout2.....................................................................................261
U ycie mened era PaneLayout............................................................................................261
U ycie mened era GridBagLayout......................................................................................261
Kiedy u ywać mened era GridBagLayout....................................................................262
Ustawianie właściwości komponentów na formatce GridBagLayout...........................262
Menu kontekstowe mened era GridBagLayout ............................................................264
Przykład u ycia mened era GridBagLayout .................................................................264
Tworzenie dowolnego mened era układu ...........................................................................267
Implementacja niestandardowego mened era układu ...................................................268
Dodawanie nowego mened era układu do JBuildera....................................................271
Wskazówki...........................................................................................................................271
Nie obawiaj się przekształcania układu XYLayout.......................................................271
Zagnie d anie paneli .....................................................................................................272
Część praktyczna .................................................................................................................273
Podsumowanie .....................................................................................................................274
Tematy do przemyśleń...................................................................................................274
4QFKC 6YQTGPKG GNGOGPVÎY ITCHKEP[EJ Y ,CXKG
Przegląd interfejsu Java2D API...........................................................................................275
Generowanie grafiki ............................................................................................................276
Drukowanie przy u yciu interfejsu Java2D...................................................................278
Część praktyczna .................................................................................................................279
Kopiowanie plików........................................................................................................279
Dodanie listy rozwijanej do panelu CoursePanel ..........................................................279
Dołączenie funkcji obsługi zdarzeń do pozycji listy rozwijanej ...................................280
7. 10 JBuilder. Vademecum profesjonalisty
Implementacja interfejsu Print w panelu CoursePanel..................................................281
Uruchomienie gotowej aplikacji....................................................................................282
Podsumowanie .....................................................................................................................283
Tematy do przemyśleń...................................................................................................283
4QFKC 2NKMK UVTWOKGPKG K UGTKCNKCELC
Klasa File .............................................................................................................................286
Strumienie wejścia i wyjścia................................................................................................295
Klasy Reader i Writer ..........................................................................................................300
Klasa StreamTokenizer........................................................................................................301
Serializacja obiektów ...........................................................................................................304
Część praktyczna .................................................................................................................307
Krok 1.: otwarcie przykładu i zapoznanie się z treścią klasy........................................308
Krok 2.: dopisanie konstruktora otwierającego lub tworzącego plik konfiguracyjny...309
Krok 3.: otwieranie strumienia wyjściowego i zapisywanie właściwości do pliku ......311
Krok 4.: uruchamianie aplikacji i analiza pliku konfiguracyjnego ...............................312
Podsumowanie .....................................................................................................................312
Tematy do przemyśleń...................................................................................................312
4QFKC 1DU WIC DC FCP[EJ
Wprowadzenie do baz danych, SQL-a, JDBC i DataExpress .............................................314
Bazy danych ..................................................................................................................314
SQL................................................................................................................................314
JDBC .............................................................................................................................315
DataExpress ...................................................................................................................317
U ycie interfejsu JDBC .......................................................................................................317
Krok 1.: zarejestruj sterownik za pomocą obiektu DriverManager...............................319
Krok 2.: ustanawianie połączenia z bazą danych ..........................................................320
Krok 3.: formułowanie polecenia do wykonania...........................................................320
Krok 4.: wykonanie zapytania SQL ..............................................................................321
Krok 5.: zwróć zestaw krotek, czyli obiekt klasy ResultSet .........................................322
Krok 6.: przerwanie połączenia z bazą danych .............................................................323
Krok 7.: przechwytywanie wyjątków SQL ...................................................................323
Najczęściej u ywane metody klasy java.sql.Connection ..............................................324
Najczęściej u ywane metody klasy java.sql.PreparedStatement...................................326
Najczęściej u ywane metody klasy java.sql.ResultSet .................................................326
Konfiguracja sterowników bazy danych w JBuilderze .................................................328
U ycie szkieletu DataExpress..............................................................................................330
Wprowadzenie do szkieletu DataExpress......................................................................331
Tworzenie połączenia z bazą danych ............................................................................333
Metody i właściwości komponentu Database ...............................................................334
Wykonywanie zapytań ..................................................................................................337
Formułowanie wyra eń SQL.........................................................................................338
Budowa interfejsu u ytkownika bazy danych ...............................................................343
Modyfikowanie bazy danych.........................................................................................344
Tworzenie modułów danych — technologia Data Modules ...............................................346
Część praktyczna .................................................................................................................350
Krok 1.: otwarcie przykładu i zapoznanie się z zawartością klasy ...............................350
Krok 2.: odszukanie metody browseCourses ................................................................350
Krok 3.: usuwanie istniejącego kodu.............................................................................351
Krok 4.: wstawienie obiektów Database i QueryDataSet..............................................351
Krok 5.: wstawienie kodu do metody browseCourses ..................................................354
Krok 6.: uruchamianie aplikacji ....................................................................................354
Podsumowanie .....................................................................................................................354
Tematy do przemyśleń...................................................................................................355
8. Spis treści 11
%ú è +8 ,$WKNFGT K CRNKMCELG UKGEKQYG
4QFKC 5GTYNGV[
Czym jest aplikacja sieciowa? .............................................................................................360
Czym są serwlety? ...............................................................................................................361
Dlaczego serwlety? ..............................................................................................................362
Interfejs Java Servlet API ....................................................................................................362
Cykl ycia serwletu .......................................................................................................366
Obsługa ądań klienckich..............................................................................................367
Śledzenie sesji................................................................................................................372
Obsługa ciasteczek ........................................................................................................374
Debugowanie .......................................................................................................................375
Wdra anie ............................................................................................................................378
Część praktyczna .................................................................................................................379
Tworzenie projektu i aplikacji sieciowej.......................................................................379
Projektowanie serwletu View Course List ....................................................................380
Projektowanie serwletu Login .......................................................................................383
Projektowanie filtra .......................................................................................................385
Przystosowanie aplikacji sieciowej do u ywania filtra .................................................386
Podsumowanie .....................................................................................................................389
Tematy do przemyśleń...................................................................................................389
4QFKC ,CXC 5GTXGT 2CIGU
Miejsce stron JSP w aplikacji WWW..................................................................................392
JSP API ................................................................................................................................392
Cykl ycia strony JSP ....................................................................................................393
Obsługa ądań klienta....................................................................................................394
JSP i JavaBeans .............................................................................................................400
JSP i serwlety.................................................................................................................404
Debugowanie .......................................................................................................................406
Uruchamianie.......................................................................................................................408
Część praktyczna .................................................................................................................410
Tworzenie projektu i aplikacji sieciowej.......................................................................410
Projektowanie strony JSP wyświetlającej wykaz kursów .............................................411
Projektowanie strony logującej JSP ..............................................................................414
Projektowanie serwletu logującego ...............................................................................415
Konfiguracja aplikacji sieciowej ...................................................................................418
Podsumowanie .....................................................................................................................420
Tematy do przemyśleń...................................................................................................420
4QFKC $KDNKQVGMK PCEPKMÎY
Co to jest biblioteka znaczników? .......................................................................................421
Integracja biblioteki znaczników z aplikacją WWW...........................................................422
Wdro enie biblioteki znaczników .................................................................................423
Odwołanie do biblioteki znaczników w aplikacji WWW .............................................423
Plik deskryptora wdro enia aplikacji WWW web.xml .................................................424
Odwołanie do biblioteki znaczników na stronie JSP.....................................................425
Plik deskryptora biblioteki znaczników TLD ......................................................................425
API biblioteki znaczników...................................................................................................427
Kontrola poprawności niestandardowych znaczników .................................................430
Cykl ycia klasy obsługi znacznika...............................................................................431
Projekt klasy obsługi znacznika ....................................................................................434
Wskazówki do tworzenia serwletów i stron JSP .................................................................441
Część praktyczna .................................................................................................................442
Utworzenie projektu i aplikacji WWW .........................................................................442
Utworzenie klas obsługi znaczników dla biblioteki znaczników..................................443
9. 12 JBuilder. Vademecum profesjonalisty
Utworzenie pliku TLD...................................................................................................448
Konfiguracja pliku deskryptora wdro enia aplikacji (web.xml) ...................................450
Projektowanie strony JSP Login....................................................................................453
Projektowanie strony JSP View Course List.................................................................454
Podsumowanie .....................................................................................................................455
Tematy do przemyśleń...................................................................................................456
4QFKC +PVGTPGV$GCP 'ZRTGUU
Opis komponentów InternetBeans Express .........................................................................457
Wykorzystywanie komponentów InternetBeans Express z serwletami ..............................458
Wykorzystywanie komponentów InternetBeans Express ze stronami JSP .........................466
Wskazówki...........................................................................................................................467
Korzystanie z istniejących plików HTML.....................................................................467
Wykorzystywanie modułów danych .............................................................................468
Podsumowanie .....................................................................................................................468
Tematy do przemyśleń...................................................................................................468
%ú è 8 ,$WKNFGT FNC CRNKMCELK MQTRQTCE[LP[EJ
4QFKC :/.
Strukturalny graficzny język znaczników SGML (Structured Graphical Markup Language)....471
HTML ..................................................................................................................................472
Własności języka XML .......................................................................................................473
Korzystanie z typów dokumentów XML ......................................................................475
Parsery ...........................................................................................................................479
Narzędzia XML w środowisku JBuilder .............................................................................481
Tworzenie dokumentu XML w środowisku JBuilder ...................................................481
Prezentacja dokumentów XML .....................................................................................482
Modyfikowanie plików XML w środowisku JBuilder..................................................486
Interfejsy do dokumentów XML ...................................................................................497
Wskazówki...........................................................................................................................499
Jeśli coś nie jest potrzebne, nie będziemy z tego korzystać ..........................................499
Nie próbujmy wyszukiwać danych bezpośrednio w XML-u ........................................500
Problemy z generowaniem podsumowań ......................................................................500
Prezentacja danych ........................................................................................................500
XML a dotychczasowe systemy ....................................................................................501
Standardowe implementacje XML................................................................................502
Część praktyczna .................................................................................................................502
Tworzenie przykładowego dokumentu XML................................................................503
Tworzenie DTD.............................................................................................................504
Tworzenie prostej prezentacji........................................................................................504
Konwertowanie HTML na XSLT..................................................................................505
Podsumowanie .....................................................................................................................508
Tematy do przemyśleń...................................................................................................508
4QFKC #TEJKVGMVWTC U[UVGOÎY MQORQPGPVCOK ',$
'PVGTRTKUG ,CXC$GCPU
Trochę historii......................................................................................................................510
Nadejście architektury klient-serwer ...................................................................................511
Serwery aplikacji .................................................................................................................512
EJB i warstwa pośrednia oparta na komponentach .............................................................513
Cele architektury Enterprise JavaBeans ..............................................................................514
Zasady działania systemów z komponentami EJB ..............................................................514
Komponent Enterprise JavaBean.........................................................................................515
10. Spis treści 13
Kontener Enterprise JavaBeans ...........................................................................................516
Interfejs zdalny ....................................................................................................................516
Interfejs bazowy...................................................................................................................516
Dostęp do klasy obiektu EJB ...............................................................................................517
Typy komponentów Enterprise JavaBeans..........................................................................517
Komponent sesyjny: Session Bean................................................................................518
Komponent encji: Entity Bean ......................................................................................518
Komponent sterowany komunikatami: Message-Driven Bean .....................................519
W jaki sposób to działa? ......................................................................................................520
Podsumowanie .....................................................................................................................521
Tematy do przemyśleń...................................................................................................521
4QFKC 6YQTGPKG MQORQPGPVÎY UGU[LP[EJ 5GUUKQP $GCP
Szczegółowe informacje dotyczące komponentów Session Bean.......................................524
Komponenty Session Bean stanowe (stateful) ..............................................................524
Komponenty Session Bean bezstanowe (stateless) .......................................................524
Cykl ycia komponentu Session Bean...........................................................................525
Tworzenie klienta ................................................................................................................527
Tworzenie kodu komponentu typu Session Bean................................................................530
Przygotowanie środowiska ............................................................................................532
Tworzenie komponentu .................................................................................................535
Wskazówki...........................................................................................................................550
Dostęp do danych — tylko poprzez Session Bean ........................................................551
Wykorzystywanie delegacji...........................................................................................552
Łączenie kilku komponentów Session Bean .................................................................553
Obiekty reprezentujące wartości ...................................................................................555
Część praktyczna .................................................................................................................557
Przygotowanie projektu.................................................................................................558
Tworzenie interfejsu sesji..............................................................................................558
Tworzenie interfejsu do obiektów wartości...................................................................558
Integrowanie usług biznesowych z obiektami wartości ................................................559
Wdra anie komponentu.................................................................................................560
Tworzenie klienta testowego .........................................................................................560
Podsumowanie .....................................................................................................................561
Tematy do przemyśleń...................................................................................................561
4QFKC 6YQTGPKG MQORQPGPVÎY 'PVKV[ $GCP
Bli sze spojrzenie na komponenty Entity Bean ..................................................................564
Cykl ycia komponentu .................................................................................................564
Komponenty CMP i BMP .............................................................................................565
Ró nice pomiędzy specyfikacjami EJB 2.0 a EJB 1.1 ..................................................567
Klucze główne ...............................................................................................................567
Interfejs..........................................................................................................................568
Tworzenie komponentu CMP..............................................................................................569
Definiowanie interfejsu bazowego ................................................................................570
Definiowanie interfejsu komponentu ............................................................................571
Implementowanie komponentu .....................................................................................572
Deskryptor wdro enia....................................................................................................574
Wdra anie komponentu Entity Bean.............................................................................578
Wykorzystywanie komponentu Entity Bean .................................................................579
Tworzenie komponentów Entity Bean ..........................................................................584
Tworzenie komponentu typu BMP......................................................................................587
Definiowanie interfejsu bazowego ................................................................................588
Definiowanie interfejsu zdalnego..................................................................................588
Implementowanie komponentu .....................................................................................589
11. 14 JBuilder. Vademecum profesjonalisty
Deskryptor wdro enia....................................................................................................595
Wdra anie komponentu Entity Bean.............................................................................595
Wykorzystywanie komponentu Entity Bean .................................................................596
Zaawansowane zarządzanie obiektami trwałymi przez kontener........................................599
Język zapytań Enterprise JavaBeans Query Language..................................................599
Metody wyszukujące .....................................................................................................602
Definiowanie relacji ......................................................................................................603
Metody biznesowe w interfejsie bazowym (Home) ......................................................608
Transakcje ............................................................................................................................609
Atrybuty transakcji ........................................................................................................610
Wykorzystanie transakcji ..............................................................................................610
Bezpieczeństwo kontenera...................................................................................................612
Uwierzytelnienie............................................................................................................613
Autoryzacja....................................................................................................................613
Zabezpieczenie komunikacji .........................................................................................613
Bezpieczeństwo w środowisku JBuilder .......................................................................614
Wskazówki...........................................................................................................................615
Korzystanie z interfejsu lokalnego ................................................................................615
Korzystanie z komponentów CMP przed BMP ............................................................615
Część praktyczna .................................................................................................................616
Tworzenie warstwy zarządzania danymi.......................................................................616
Konfiguracja komponentu Entity Bean .........................................................................617
Tworzenie fabryki połączeń EJB...................................................................................617
Tworzenie komponentu zarządzającego typu JavaBean ...............................................618
Dołączenie Session Facade do komponentów zarządzających .....................................620
Testowanie i implementacja ..........................................................................................621
Podsumowanie .....................................................................................................................621
Tematy do przemyśleń...................................................................................................622
4QFKC -QORQPGPV[ UVGTQYCPG YKCFQOQ EKCOK
Punkt-punkt czy wydawca-subskrybent?.............................................................................624
Tworzenie komponentów MDB ..........................................................................................626
Implementacja interfejsów ............................................................................................626
Implementacja wymaganych metod ..............................................................................626
Przetwarzanie wiadomości ............................................................................................627
Deskryptor wdro enia....................................................................................................629
Testowanie komponentu MDB ............................................................................................629
Tworzenie komponentów MDB w środowisku JBuilder ....................................................631
Wskazówki...........................................................................................................................632
Kiedy korzystać z MDB? ..............................................................................................632
Korzystanie z komponentów MDB zamiast z JMS.......................................................632
Część praktyczna .................................................................................................................634
Tworzenie komponentu MDB .......................................................................................635
Implementacja procesu przetwarzania wiadomości ......................................................635
Tworzenie klienta JMS..................................................................................................636
Podsumowanie .....................................................................................................................638
Tematy do przemyśleń...................................................................................................638
4QFKC %14$#
Definicja specyfikacji CORBA ...........................................................................................640
ORB nad IIOP ...............................................................................................................641
Trzony klienta i szkielety serwera .................................................................................642
OA — adapter obiektu...................................................................................................642
IOR i serwis nazw..........................................................................................................643
12. Spis treści 15
IDL — język definiowania interfejsu ..................................................................................644
Podstawy CORBA ...............................................................................................................646
Konfiguracja JBuildera i CORBA .......................................................................................649
Tworzenie serwera CORBA ................................................................................................652
Zdefiniowanie interfejsu w IDL ....................................................................................652
Kompilowanie interfejsu do postaci pliku szkieletu serwera ........................................653
Implementacja serwera CORBA przy u yciu kreatora .................................................656
Uruchamianie serwisu nazw..........................................................................................658
Uruchamianie serwera CORBA ....................................................................................659
Sprawdzanie czy serwer CORBA działa .......................................................................659
Tworzenie klienta CORBA..................................................................................................660
Generowanie klasy opakowującej klienta CORBA.......................................................660
Tworzenie instancji klasy opakowującej klienta CORBA ............................................662
Wywoływanie metody klasy opakowującej klienta CORBA........................................663
Część praktyczna .................................................................................................................664
Krok 1.: otwórz przykład i przejrzyj klasę ....................................................................664
Krok 2.: znajdź metodę..................................................................................................665
Krok 3.: utwórz plik IDL...............................................................................................665
Krok 4.: implementowanie kodu serwera......................................................................667
Krok 5.: implementowanie kodu klienta .......................................................................669
Krok 6.: wystartowanie aplikacji...................................................................................671
Podsumowanie .....................................................................................................................671
Tematy do przemyśleń...................................................................................................671
4QFKC 7UWYCPKG D úFÎY CRNKMCELK MNCU[ GPVGTRTKUG
Pojęcie zdalnego usuwania błędów .....................................................................................674
Przygotowanie środowiska do usuwania błędów ................................................................675
Usuwanie błędów zdalnej aplikacji .....................................................................................676
Uruchamiamy zdalną aplikację z opcjami debugowania ..............................................676
Kopiujemy pliki zdalnej aplikacji na komputer klienta.................................................677
Określamy konfigurację uruchomieniową dla odległego serwera ................................677
Ustawiamy punkty kontrolny w kodzie.........................................................................680
Międzyprocesowe punkty kontrolne....................................................................................681
Parametry konfiguracyjne serwerów aplikacji ....................................................................682
Inprise Application Server 5.x.......................................................................................683
WebLogic Server 7.0.....................................................................................................683
WebSphere Server 4 ......................................................................................................685
iPlanet Server.................................................................................................................685
Inne serwery ..................................................................................................................685
Część praktyczna .................................................................................................................686
Instalacja aplikacji serwerowej na komputerze serwera................................................686
Instalacja aplikacji klienta na komputerze klienta.........................................................687
Debugowanie aplikacji serwera z komputera klienta ....................................................689
Podsumowanie .....................................................................................................................691
Tematy do przemyśleń...................................................................................................691
4QFKC 6YQTGPKG K YFTC CPKG QRTQITCOQYCPKC
W [EKGO UGTYGTÎY 9GD.QIKE K 9GD5RJGTG
Budowanie w JBuilderze przy u yciu serwera WebLogic ..................................................693
Instalacja serwera aplikacji WebLogic..........................................................................694
Konfiguracja JBuildera dla WebLogic ..........................................................................695
Tworzenie serwletów i stron JSP przy u yciu serwera WebLogic ...............................696
Praca z komponentami EJB...........................................................................................697
Wdra anie aplikacji .......................................................................................................700
Zdalne usuwanie błędów ...............................................................................................701
13. 16 JBuilder. Vademecum profesjonalisty
Budowanie w JBuilderze przy u yciu serwera IBM WebSphere........................................703
Instalacja serwera aplikacji WebSphere ........................................................................703
Konfiguracja JBuildera dla WebSphere ........................................................................703
Tworzenie serwletów i stron JSP przy u yciu serwera WebSphere..............................705
Tworzenie komponentów EJB przy u yciu WebSphere ...............................................706
Wdra anie aplikacji .......................................................................................................712
Usuwanie błędów aplikacji WebSphere ........................................................................712
Podsumowanie .....................................................................................................................713
Tematy do przemyśleń...................................................................................................713
4QFKC 9GD 5GTXKEGU
SOAP — prosty protokół dostępu do obiektów ..................................................................716
Koperta SOAP ...............................................................................................................716
Kodowanie.....................................................................................................................717
Typy danych ..................................................................................................................719
Błędy SOAP ..................................................................................................................720
SOAP RPC ....................................................................................................................721
Komponent WSDL technologii Web Services ....................................................................721
Komponent UDDI technologii Web Services .....................................................................723
Narzędzia JBuilder Web Services Toolkit...........................................................................724
Apache Axis ..................................................................................................................724
Podstawowy przykład....................................................................................................725
Część praktyczna .................................................................................................................726
Budowa usługi Web Services ........................................................................................726
Udostępnianie klasy Javy jako usługi Web Services.....................................................727
Tworzenie nowego serwera SOAP................................................................................730
Testowanie nowej usługi Web Services ........................................................................732
Analiza nowej usługi Web Services ..............................................................................733
Analiza mechanizmu testowego ....................................................................................734
Wykorzystywanie Monitora TCP..................................................................................735
Rozszerzanie mo liwości usługi Web Services.............................................................736
Konsumowanie usługi Web Services ............................................................................738
Podsumowanie .....................................................................................................................742
4QFKC -QT[UVCPKG ,/' Y TQFQYKUMW ,$WKNFGT
Wprowadzenie do wersji Micro Edition ..............................................................................743
Nowa wirtualna maszyna...............................................................................................744
Nowe i zmienione klasy ................................................................................................744
Konfiguracje i profile ....................................................................................................745
KVM..............................................................................................................................746
Miejsce dla MIDP..........................................................................................................746
Środowisko JBuilder MobileSet ..........................................................................................747
Tworzenie Aplikacji MIDP ...........................................................................................747
Projektowanie i tworzenie MIDP ..................................................................................749
Tworzenie ekranu MIDP ...............................................................................................751
Przegląd komponentów .................................................................................................752
Wskazówki...........................................................................................................................754
Część praktyczna .................................................................................................................755
Tworzenie projektu dla MIDletu ...................................................................................756
Tworzenie plików MIDletu ...........................................................................................757
Tworzenie menu głównego (MainMenu) ......................................................................758
Tworzenie ClassListDisplay..........................................................................................759
Podsumowanie .....................................................................................................................760
Tematy do przemyśleń...................................................................................................761
14. Spis treści 17
4QFKC 2TQITCOQYCPKG GURQ QYG Y ,$WKNFGTG
Dlaczego projektowanie zespołowe jest tak istotne ............................................................763
Poradnik projektanta: struktura zespołu i podział odpowiedzialności.................................764
Stosowanie JBuildera z systemem kontroli wersji ..............................................................765
Zasady posługiwania się systemem kontroli wersji ......................................................767
JBuilder a system CVS ..................................................................................................767
JBuilder a system Microsoft Visual Source Safe ..........................................................779
Podsumowanie .....................................................................................................................785
Tematy do przemyśleń...................................................................................................785
4QFKC ,$WKNFGT K 5VTWVU
Biblioteki znaczników Struts ...............................................................................................788
Biblioteka Bean Tag Library .........................................................................................788
Biblioteka HTML Tag Library ......................................................................................789
Biblioteka Logic Tag Library ........................................................................................789
Biblioteka Template Tag Library ..................................................................................790
Tworzenie aplikacji JBuildera z zastosowaniem środowiska Struts ...................................790
Rozpoczynamy nowy projekt z zastosowaniem Struts..................................................790
Plik web.xml..................................................................................................................792
Plik struts-config.xml ....................................................................................................793
Budujemy stronę Java Server Page ...............................................................................797
Konstruowanie kodu klasy ActionForm........................................................................799
Konstruowanie kodu klasy Action ................................................................................801
Wskazówki...........................................................................................................................802
Stosowanie walidacji .....................................................................................................803
Stosowanie akcji przekazujących sterowanie dla statycznych stron .............................804
Połączenie ActionMappings we wspólną strukturę.......................................................805
Wysyłamy raz, sprawdzamy dwa razy ..........................................................................806
Zalecany cykl projektowania.........................................................................................806
Część praktyczna .................................................................................................................807
Podsumowanie .....................................................................................................................812
Tematy do przemyśleń...................................................................................................812
QFCVMK
15. Rozdział 16.
5GTYNGV[
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ące
komponenty, 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 przez
serwer 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 Apache
Tomcat lub pełny serwer aplikacji J2EE (Java 2, Enterprise Edition), na przykład Bor-
land Enterprise Application Server. Wraz z instalacją środowiska JBuilder 7 Enterprise
instalowane 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.
16. 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 naszej
aplikacji ChalkTalk. W JBuilderze serwlety tworzymy wewnątrz struktury o nazwie
Web application, która stanowi środowisko uruchomieniowe i testowe aplikacji siecio-
wej. Przed serwletami omówimy ideę aplikacji sieciowej jako szkieletu dla serwletów.
%[O LGUV CRNKMCELC UKGEKQYC!
Kluczową zaletą programowania w języku Java jest to, e piszemy i kompilujemy kod
na jednej platformie, spodziewając się, e będzie on działał z podobnym rezultatem na
innej 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ęzyk
Java 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łównego
zawierającego wszystkie potrzebne do jej uruchomienia zasoby. Wszystkie strony HTML
i 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 dla
danej zawartości.
W katalogu głównym nale y stworzyć specjalny katalog o nazwie WEB-INF zawierający
następujące elementy:
Plik: web.xml — jest to plik deskryptora wdro enia aplikacji sieciowej
w formacie XML opisujący wiele szczegółów wymaganych przez serwer
do prawidłowego wdro enia aplikacji.
Podkatalog: classes/ — ten katalog zawiera wszystkie samodzielne klasy Javy
wymagane do uruchomienia przez aplikację sieciową, w tym wszystkie pliki
z klasami serwletowymi razem z plikami zawierającymi poboczne klasy.
Podkatalog: lib/ — ten katalog zawiera wszystkie biblioteki z klasami w formacie
JAR wymagane do prawidłowego działania aplikacji sieciowej.
Jako przykład omawianej struktury, na listingu 16.1 przedstawiliśmy część hierarchii
katalogów aplikacji sieciowej zawierającej interfejs sieciowy dla aplikacji ChalkTalk,
który zostanie rozbudowany w tym rozdziale. Przykład ten nosi nazwę chalktalkweb.
.KUVKPI Struktura katalogów aplikacji sieciowej
-CVCNQI I ÎYP[ CRNKMCELK
EJCNMVCNMYGD
EJCNMVCNMYGDKPFGZJVON
17. Rozdział 16. Serwlety 361
EJCNMVCNMYGD9'$+0(
EJCNMVCNMYGD9'$+0(YGDZON
EJCNMVCNMYGD9'$+0(ENCUUGU
EJCNMVCNMYGD9'$+0(ENCUUGUEQOUCOUEJCNMVCNMENKGPVYGDEQWTUGNKUVENCUU
EJCNMVCNMYGD9'$+0(ENCUUGUEQOUCOUEJCNMVCNMENKGPVYGDNQIKPENCUU
EJCNMVCNMYGD9'$+0(NKD
Struktura katalogów mo e pozostać w takiej postaci lub mo e zostać skompresowana
do 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 pliku
web.xml.
%[O Uæ UGTYNGV[!
Witryny internetowe i związane z nimi aplikacje sieciowe stanowią zwykle połączenie
zawartoś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 formie
stron HTML w oknach przeglądarek. W przypadku wielu aplikacji sieciowych istnieje
potrzeba 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 dynamicznej
razem z zawartością statyczną. Jedną z takich technik było stworzenie interfejsu Servlet
API jako rozszerzenia języka Java.
Na wielu witrynach internetowych u ytkownik wysyła ądania pobrania zawartości
z 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 architekturze
serwlety wykonywane są po stronie serwera WWW, analizują ądania klienta i dyna-
micznie budują na nie odpowiedź.
Rysunek 16.1 przedstawia architekturę ądanie-odpowiedź.
4[UWPGM
Architektura typu
żądanie-odpowiedź