• Wykorzystaj język XML w aplikacjach bazodanowych
• Zaimplementuj obsługę protokołu SOAP
• Zbuduj aplikacje w oparciu o serwlety i JSP
• Zastosuj w projektach technologię Enterprise Java Beans

Platforma Java 2 Enterprise Edition zdobyła już mocną pozycję na rynku serwerów aplikacji. Dzięki niej możliwe stało się tworzenie aplikacji korporacyjnych zgodnych z podstawowym założeniem przyświecającym twórcom Javy -- "pisz raz, uruchamiaj wszędzie". Najnowsza wersja platformy J2EE została znacznie rozbudowana i zmodernizowana w porównaniu z poprzednimi. Dodano do niej możliwość obsługi usług WWW, rozszerzono i unowocześniono implementacje technologii serwletów i JSP oraz poprawiono wiele komponentów przydatnych przy tworzeniu aplikacji korporacyjnych.

"J2EE. Vademecum profesjonalisty. Wydanie II" to kompletny przewodnik po najnowszej wersji Java 2 Enterprise Edition, napisany przez członków zespołu zajmującego się rozwojem platformy J2EE, zatrudnionych w firmie Sun. Opisuje kluczowe komponenty Java 2 Platform, Enterprise Edition (J2EE) w wersji 1.4. Prezentuje rozwiązania konkretnych problemów napotykanych przez programistów, zilustrowane licznymi przykładami. W książce przedstawiono nie tylko komponenty J2EE, ale również współpracujące z nią technologie: JavaServer Pages Standard Tag Library (JSTL) oraz JavaServer Faces.

• Tworzenie aplikacji internetowej wykorzystującej język XML
• Stosowanie parsera SAX
• Analiza i przetwarzanie hierarchii DOM w dokumentach
• Korzystanie z XPath
• Implementacja usług WWW oraz obsługi protokołu SOAP
• Tworzenie aplikacji z wykorzystaniem serwletów i JSP
• Stosowanie technologii JavaServer Faces
• Projektowanie z wykorzystaniem Enterprise Java Beans

Jeśli chcesz zaprojektować i stworzyć aplikację z wykorzystaniem J2EE, w tej książce znajdziesz wszystkie informacje, jakie mogą Ci być do tego potrzebne.

Osoby które kupowały "J2EE. Vademecum profesjonalisty. Wydanie II", wybierały także:

• Spring Web MVC. Kurs video. Programowanie aplikacji webowych 69,00 zł, (31,05 zł -55%)
• Java EE 6. Tworzenie aplikacji w NetBeans 7 58,98 zł, (29,49 zł -50%)
• Java EE 6. Programowanie aplikacji WWW 37,00 zł, (18,50 zł -50%)
• Java EE 6. Programowanie aplikacji WWW. Wydanie II 49,00 zł, (29,40 zł -40%)
• Spring. Receptury 119,00 zł, (71,40 zł -40%)

Spis treści

J2EE. Vademecum profesjonalisty. Wydanie II -- spis treści

O autorach (23)

Słowo wstępne (25)

O książce (27)

Rozdział 1. Przegląd (35)

• Rozproszone aplikacje wielowarstwowe (36)
  
  • Komponenty J2EE (37)
  • Klienty J2EE (37)
  • Komponenty internetowe (39)
  • Komponenty biznesowe (40)
  • Warstwa korporacyjnych systemów informacyjnych (EIS) (40)
• Kontenery J2EE (41)
  
  • Usługi kontenerów (41)
  • Typy kontenerów (42)
• Wsparcie ze strony usług internetowych (43)
  
  • XML (44)
  • Protokół transportowy SOAP (44)
  • Standardowy format WSDL (44)
  • Standardowe formaty UDDI oraz ebXML (45)
• Pakowanie aplikacji (45)
  
• Role procesu tworzenia aplikacji (46)
  
  • Dostawca produktu J2EE (47)
  • Dostawca narzędzi (47)
  • Dostawca komponentów aplikacji (47)
  • Konstruktor aplikacji (48)
  • Wdrożeniowiec oraz administrator aplikacji (48)
• Interfejsy programowania aplikacji platformy J2EE 1.4 (49)
  
  • Technologia Enterprise JavaBeans (50)
  • Technologia Java Servlet (50)
  • Technologia JavaServer Pages (50)
  • Java Message Service API (50)
  • Java Transaction API (51)
  • JavaMail API (51)
  • JavaBeans Activation Framework (51)
  • Java API for XML Processing (51)
  • Java API for XML-Based RPC (52)
  • SOAP with Attachments API for Java (52)
  • Java API for XML Registries (52)
  • Architektura J2EE Connector (53)
  • JDBC API (53)
  • Java Naming and Directory Interface (54)
  • Java Authentication and Authorization Service (54)
  • Uproszczona integracja systemów (55)
• Sun Java System Application Server Platform Edition 8 (55)
  
  • Technologie (56)
  • Narzędzia (57)
  • Uruchamianie i zatrzymywanie serwera (58)
  • Uruchamianie konsoli administracyjnej (58)
  • Uruchamianie narzędzia deploytool (59)
  • Uruchamianie i zatrzymywanie serwera bazy danych PointBase (59)
  • Uruchamianie aplikacji J2EE (59)

Rozdział 2. Zrozumieć XML (63)

• Wprowadzenie do języka XML (63)
  
  • Czym jest XML? (63)
  • Dlaczego XML jest taki ważny? (67)
  • Jak można używać języka XML? (70)
• Generacja danych XML (72)
  
  • Tworzenie prostego pliku XML (72)
  • Definiowanie elementu głównego (73)
  • Tworzenie instrukcji przetwarzania (77)
  • Błąd popełniony celowo (78)
  • Zastępowanie i wstawianie tekstu (79)
  • Tworzenie definicji typu dokumentu (DTD) (81)
  • Dokumenty i dane (86)
  • Definiowanie atrybutów i encji w DTD (86)
  • Odwołania do encji binarnych (92)
  • Definiowanie encji parametrów oraz sekcji warunkowych (94)
  • Rozwiązywanie konfliktów nazw (97)
  • Stosowanie przestrzeni nazw (98)
• Projektowanie struktury danych XML (100)
  
  • Oszczędzanie pracy (101)
  • Atrybuty i elementy (101)
  • Normalizacja danych (103)
  • Normalizacja DTD (104)
• Podsumowanie (105)

Rozdział 3. Podstawowe sposoby tworzenia aplikacji internetowych (107)

• Cykl istnienia aplikacji internetowej (109)
  
• Moduły internetowe (111)
  
  • Pakowanie modułów internetowych (112)
  • Wdrażania modułu internetowego (114)
  • Wyświetlanie listy wdrożonych modułów (117)
  • Aktualizacja modułów internetowych (117)
  • Usuwanie modułów internetowych (119)
• Konfiguracja aplikacji internetowych (120)
  
  • Odwzorowania adresów URL na komponenty internetowe (120)
  • Deklarowanie plików powitalnych (122)
  • Określanie parametrów inicjalizacyjnych (123)
  • Kojarzenie błędów ze stronami informacyjnymi (123)
  • Deklarowanie odwołań do zasobów (124)
• Przykład - Księgarnia Duke'a (124)
  
• Korzystanie z baz danych w aplikacjach internetowych (125)
  
  • Zapisywanie informacji w przykładowej bazie danych (125)
  • Tworzenie źródła danych w serwerze Application Server (126)
  • Określanie odwołania do zasobu aplikacji (127)
  • Kojarzenie odwołania do zasobu ze źródłem danych (128)
• Dodatkowe informacje (128)

Rozdział 4. Interfejs API do przetwarzania danych XML (129)

• JAXP API (129)
  
• Przegląd pakietów (130)
  
• SAX API (131)
  
  • Pakiety SAX (133)
• DOM API (133)
  
  • Pakiety DOM (134)
• XSLT API (134)
  
  • Pakiety XSLT (135)
• Stosowanie bibliotek JAXP (136)
  
• Co dalej? (136)

Rozdział 5. Prosty interfejs programowania aplikacji do obsługi XML-a (137)

• Kiedy używać mechanizmu SAX? (138)
  
• Wyświetlanie zawartości pliku XML przy wykorzystaniu parsera SAX (139)
  
  • Tworzenie szkieletu aplikacji (140)
  • Importowanie klas (140)
  • Przygotowania do operacji wejścia-wyjścia (140)
  • Implementacja interfejsu ContentHandler (141)
  • Przygotowanie parsera (142)
  • Generacja danych wynikowych (143)
  • Formatowanie danych wynikowych (143)
  • Obsługa zdarzeń związanych z zawartością danych XML (144)
  • Kompilacja i uruchamianie programu (148)
  • Sprawdzanie wyników (148)
  • Identyfikacja zdarzeń (149)
  • Generacja bardziej zwartych danych wynikowych (151)
  • Sprawdzanie wyników (153)
  • Dokumenty i dane (154)
• Dodawanie obsługi innych zdarzeń (154)
  
  • Określanie lokalizacji dokumentu (154)
  • Obsługa instrukcji przetwarzania (156)
  • Podsumowanie (157)
• Obsługa błędów w przypadku stosowania parsera nieweryfikującego (157)
  
  • Obsługa wyjątków SAXParseException (158)
  • Obsługa wyjątków SAXException (159)
  • Poprawa obsługi wyjątków SAXParseException (160)
  • Obsługa wyjątków ParserConfigurationException (161)
  • Obsługa wyjątków IOException (162)
  • Obsługa błędów niekrytycznych (162)
  • Obsługa ostrzeżeń (163)
• Wyświetlanie danych specjalnych oraz danych CDATA (164)
  
  • Obsługa znaków specjalnych (164)
  • Obsługa tekstu o składni przypominającej XML (164)
  • Obsługa danych CDATA oraz innych znaków (165)
• Analiza syntaktyczna w przypadku zastosowania DTD (166)
  
  • Wpływ DTD na parser nieweryfikujący (166)
  • Znaki odstępu, które można ignorować (167)
  • Porządki (169)
  • Elementy puste raz jeszcze (169)
  • Generacja odwołań do encji (169)
  • Generacja encji zewnętrznych (170)
  • Podsumowanie informacji o encjach (170)
• Wybór implementacji parsera (171)
  
• Wykorzystanie parsera weryfikującego (171)
  
  • Konfiguracja klasy fabrykującej (171)
  • Weryfikacja przy wykorzystaniu schematów XML (172)
  • Eksperymenty z błędami weryfikacji (174)
  • Obsługa błędów w parserach weryfikujących (176)
• Analiza sparametryzowanej DTD (176)
  
  • Ostrzeżenia DTD (177)
• Obsługa zdarzeń leksykalnych (178)
  
  • Sposób działania interfejsu LexicalHandler (179)
  • Posługiwanie się interfejsem LexicalHandler (180)
• Zastosowanie interfejsów DTDHandler oraz EntityResolver (184)
  
  • Interfejs DTDHandler (185)
  • Interfejs EntityResolver (186)
• Dalsze informacje (186)

Rozdział 6. Obiektowy model dokumentu (187)

• Kiedy używać DOM? (187)
  
  • Dokumenty a dane (188)
  • Model zawartości mieszanej (188)
  • Prostszy model (189)
  • Zwiększenie stopnia złożoności (190)
  • Wybór modelu (192)
• Wczytywanie danych XML do DOM (193)
  
  • Tworzenie programu (193)
  • Dodatkowe informacje (197)
  • Co dalej? (199)
• Wyświetlanie hierarchii DOM (199)
  
  • Zmiana aplikacji DomEcho w aplikację GUI (199)
  • Utworzenie adapterów w celu wyświetlenia DOM w komponencie JTree (204)
  • Dopracowanie kodu aplikacji (212)
• Badanie struktury DOM (212)
  
  • Wyświetlanie prostego drzewa DOM (212)
  • Wyświetlanie bardziej złożonego drzewa DOM (214)
  • Zakończenie (219)
• Prezentowanie struktury DOM w sposób optymalny (219)
  
  • Kompresja zawartości drzewa (219)
  • Operacje na zaznaczonych elementach drzewa JTree (224)
  • Obsługa modyfikacji (232)
  • Zakończenie (232)
• Tworzenie i modyfikowanie DOM (232)
  
  • Pobieranie DOM z obiektu fabrykującego (233)
  • Normalizacja DOM (236)
  • Inne operacje (237)
  • Zakończenie (240)
• Weryfikacja przy użyciu schematów XML (240)
  
  • Ogólne informacje o procesie weryfikacji (241)
  • Konfiguracja obiektu fabrykującego DocumentBuilder (241)
  • Weryfikacja w przypadku stosowania wielu przestrzeni nazw (242)
• Dalsze informacje (245)

Rozdział 7. Przekształcenia rozszerzalnego języka arkuszy stylów (247)

• Przedstawienie XSL, XSLT oraz XPath (247)
  
  • Pakiety JAXP związane z obsługą przekształceń (248)
• Jak działa XPath? (249)
  
  • Wyrażenia XPath (249)
  • Model danych XSLT i XPath (250)
  • Szablony i konteksty (250)
  • Proste adresowanie przy użyciu XPath (250)
  • Proste wyrażenia XPath (251)
  • Łączenie adresów indeksowych (252)
  • Znaki wieloznaczne (253)
  • Adresowanie przy użyciu ścieżki rozszerzonej (253)
  • Typy danych i operatory XPath (253)
  • Wartość łańcuchowa elementu (254)
  • Funkcje XPath (254)
  • Podsumowanie (257)
• Zapis DOM w pliku XML (257)
  
  • Odczyt XML (257)
  • Tworzenie obiektu przekształcenia (259)
  • Zapis XML (261)
  • Zapis fragmentu drzewa DOM (261)
  • Podsumowanie (263)
• Generacja XML na podstawie dowolnych danych (263)
  
  • Tworzenie prostego pliku danych (263)
  • Tworzenie prostego parsera (265)
  • Modyfikacja parsera, by generował zdarzenia SAX (267)
  • Użycie parsera jako obiektu SAXSource (272)
  • Wykonanie konwersji (274)
• Przekształcanie danych XML przy użyciu XSLT (275)
  
  • Definiowanie prostego typu dokumentu - <article> (275)
  • Tworzenie dokumentu testowego (277)
  • Tworzenie przekształcenia XSLT (278)
  • Przetwarzanie podstawowych elementów struktury (279)
  • Tworzenie prostego programu (282)
  • Usuwanie znaków odstępu (284)
  • Przetwarzanie pozostałych elementów struktury (286)
  • Przetwarzanie elementów wewnątrzwierszowych (treści) (290)
  • Drukowanie kodu HTML (294)
  • Jakie są pozostałe możliwości XSLT? (294)
• Zastosowanie pakietu Xalan do wykonywania przekształceń z poziomu wiersza poleceń (296)
  
• Łączenie przekształceń przy użyciu łańcucha filtrów (296)
  
  • Pisanie programu (296)
  • Rozumienie sposobu działania łańcucha filtrów (299)
  • Testowanie programu (300)
  • Wnioski (302)
• Dalsze informacje (303)

Rozdział 8. Tworzenie usług WWW przy użyciu JAX-RPC (305)

• Określanie portu (306)
  
• Tworzenie prostej usługi WWW oraz klienta przy wykorzystaniu JAX-RPC (306)
  
  • Kodowanie interfejsu punktu końcowego usługi oraz klas implementacji (307)
  • Przygotowanie usługi (308)
  • Pakowanie usługi (310)
  • Określanie adresu punktu końcowego (311)
  • Wdrażanie usługi (311)
  • Klient używający statycznego pieńka (312)
• Obsługiwane typy danych (314)
  
  • Typy J2SE SDK (315)
  • Typy podstawowe (315)
  • Tablice (315)
  • Typy wartości (315)
  • Komponenty JavaBeans (316)
• Klienty usług WWW (316)
  
  • Klient używający dynamicznego pośrednika (316)
  • Klient DII (319)
  • Klient aplikacji (322)
  • Pozostałe klienty JAX-RPC (325)
• Współpraca usług WWW (WS-I) a JAX-RPC (326)
  
• Dodatkowe informacje (326)

Rozdział 9. Interfejs programowania aplikacji do obsługi protokołu SOAP z załącznikami (327)

• Przegląd SAAJ (328)
  
  • Komunikaty (328)
  • Połączenia (331)
• Informator (332)
  
  • Tworzenie i wysyłanie prostego komunikatu (333)
  • Dodawanie zawartości do nagłówka (341)
  • Dodawanie zawartości do obiektu SOAPPart (342)
  • Dodawanie dokumentu do treści komunikatu SOAP (343)
  • Operacje na zawartości komunikatów przy użyciu interfejsów programowania aplikacji SAAJ oraz DOM (343)
  • Dodawanie załączników (343)
  • Dodawanie atrybutów (346)
  • Stosowanie usterek SOAP (350)
• Przykłady (354)
  
  • Program Request.java (355)
  • Program MyUddiPing.java (356)
  • Program HeaderExample.java (362)
  • Programy DOMExample.java oraz DOMSrcExample.java (363)
  • Program Attachments.java (366)
  • Program SOAPFaultTest.java (368)
• Dodatkowe informacje (369)

Rozdział 10. Interfejs programowania aplikacji do obsługi rejestrów XML (371)

• Podstawowe informacje o JAXR (371)
  
  • Czym jest rejestr? (371)
  • Czym jest JAXR? (372)
  • Architektura JAXR (373)
• Implementacja klienta JAXR (374)
  
  • Nawiązywanie połączenia (375)
  • Przeszukiwanie rejestru (380)
  • Zarządzanie danymi rejestru (384)
  • Zastosowanie typologii w klientach JAXR (390)
• Uruchamiania przykładowych klientów (394)
  
  • Zanim skompilujemy przykłady (396)
  • Kompilacja przykładów (398)
  • Uruchamianie przykładów (398)
• Stosowanie klientów JAXR w aplikacjach J2EE (403)
  
  • Tworzenie kodu klienta aplikacji - MyAppClient.java (403)
  • Tworzenie kodu komponentu sesyjnego PubQuery (404)
  • Kompilacja plików źródłowych (404)
  • Importowanie certyfikatów (405)
  • Uruchamianie serwera Application Server (406)
  • Tworzenie zasobów JAXR (406)
  • Tworzenie i pakowanie aplikacji (407)
  • Wdrażanie aplikacji (409)
  • Uruchamianie klienta aplikacji (409)
• Dodatkowe informacje (410)

Rozdział 11. Technologia serwletów Java (411)

• Czym jest serwlet? (411)
  
• Przykład serwletów (412)
  
  • Rozwiązywanie problemów (415)
• Cykl życia serwletu (416)
  
  • Obsługa zdarzeń związanych z cyklem życia serwletu (416)
  • Obsługa błędów (418)
• Współdzielenie informacji (418)
  
  • Wykorzystanie obiektów zakresu (418)
  • Kontrola współbieżnego dostępu do współdzielonych zasobów (419)
  • Dostęp do baz danych (420)
• Inicjalizacja serwletu (421)
  
• Implementacja metody usługowej (422)
  
  • Pobieranie informacji z żądania (422)
  • Tworzenie odpowiedzi (424)
• Filtrowanie żądań i odpowiedzi (426)
  
  • Programowanie filtrów (427)
  • Programowanie niestandardowych żądań i odpowiedzi (428)
  • Specyfikacja odwzorowań filtrów (430)
• Wywoływanie innych zasobów (432)
  
  • Dołączanie innych zasobów do odpowiedzi (432)
  • Przekazywanie sterowania innemu komponentowi (433)
• Dostęp do kontekstu (434)
  
• Przechowywanie stanu klienta (435)
  
  • Dostęp do sesji (435)
  • Wiązanie obiektów z sesją (435)
  • Zarządzanie sesjami (436)
  • Śledzenie sesji (437)
• Finalizacja serwletu (437)
  
  • Śledzenie żądań usługi (438)
  • Powiadamianie metod o zakończeniu działania serwletu (439)
  • Poprawna implementacja czasochłonnych metod (439)
• Dalsze informacje (440)

Rozdział 12. Technologia stron JSP (441)

• Czym jest strona JSP? (441)
  
  • Przykład (442)
• Przykład stron JSP (444)
  
• Cykl życia strony JSP (449)
  
  • Tłumaczenie i kompilacja (450)
  • Wykonanie (451)
• Tworzenie treści statycznej (453)
  
  • Kodowanie strony i odpowiedzi (453)
• Tworzenie treści dynamicznej (454)
  
  • Zastosowanie obiektów na stronach JSP (454)
• Język wyrażeń (455)
  
  • Wyłączanie wartościowania wyrażeń (456)
  • Używanie wyrażeń (456)
  • Zmienne (457)
  • Obiekty niejawne (458)
  • Literały (459)
  • Operatory (459)
  • Słowa kluczowe (460)
  • Przykłady (460)
  • Funkcje (461)
• Komponenty JavaBeans (462)
  
  • Konwencje projektowania komponentów JavaBeans (462)
  • Tworzenie i używanie komponentów JavaBeans (463)
  • Konfigurowanie właściwości komponentów JavaBeans (464)
  • Pobieranie właściwości komponentu JavaBeans (465)
• Stosowanie znaczników niestandardowych (466)
  
  • Deklarowanie bibliotek znaczników (466)
  • Dołączanie implementacji biblioteki znaczników (468)
• Ponowne użycie treści na stronach JSP (469)
  
• Przekazywanie sterowania do innego komponentu (470)
  
  • Element jsp:param (470)
• Dołączanie apletu (471)
  
• Konfigurowanie właściwości grup stron JSP (473)
  
  • Wyłączanie wyznaczania wartości wyrażeń (473)
  • Deklarowanie kodowania strony (474)
  • Definiowanie niejawnego dołączania (474)
• Dalsze informacje (475)

Rozdział 13. Dokumenty JSP (477)

• Przykład dokumentu JSP (477)
  
• Tworzenie dokumentu JSP (482)
  
  • Deklarowanie bibliotek znaczników (484)
  • Umieszczanie dyrektyw w dokumentach JSP (486)
  • Tworzenie treści statycznych i dynamicznych (487)
  • Zastosowanie elementu jsp:root (489)
  • Zastosowanie elementu jsp:output (490)
• Identyfikacja dokumentu JSP przez kontener (493)

Rozdział 14. Biblioteka JSTL (495)

• Przykład stron JSP (495)
  
• Korzystanie z biblioteki JSTL (498)
  
  • Współpraca znaczników (499)
• Biblioteka znaczników podstawowych (500)
  
  • Znaczniki obsługi zmiennych (500)
  • Znaczniki sterowania przepływem (501)
  • Znaczniki URL (504)
  • Pozostałe znaczniki (505)
• Biblioteka znaczników XML (505)
  
  • Znaczniki podstawowe (507)
  • Znaczniki sterowania przepływem (508)
  • Znaczniki przekształceń (508)
• Biblioteka znaczników internacjonalizacji (509)
  
  • Konfiguracja lokalizacji (509)
  • Znaczniki komunikatów (510)
  • Znaczniki formatowania (510)
• Biblioteka znaczników SQL (511)
  
  • Interfejs Result znacznika query (513)
• Funkcje (514)
  
• Dalsze informacje (515)

Rozdział 15. Niestandardowe znaczniki JSP (517)

• Czym jest niestandardowy znacznik? (518)
  
• Przykład stron JSP (518)
  
• Typy znaczników (522)
  
  • Znaczniki z atrybutami (522)
  • Znaczniki posiadające ciało (524)
  • Znaczniki definiujące zmienne (525)
  • Komunikacja między znacznikami (525)
• Zastosowanie plików znaczników do hermetyzacji treści w celu wielokrotnego użycia (526)
  
  • Położenie plików znaczników (528)
  • Dyrektywy plików znaczników (528)
  • Przetwarzanie fragmentów przekazywanych plikom znaczników (534)
  • Przykłady (534)
• Deskryptory bibliotek znaczników (537)
  
  • Elementy nadrzędne deskryptora biblioteki znaczników (538)
  • Deklarowanie plików znaczników (539)
  • Deklarowanie obiektów obsługi znaczników (541)
  • Deklarowanie atrybutów znacznika dla obiektu obsługi znacznika (542)
  • Deklarowanie zmiennych znacznika dla obiektu obsługi znacznika (543)
• Implementacja obiektów obsługi znaczników prostych (545)
  
  • Dołączanie obiektów obsługi znaczników do aplikacji internetowych (545)
  • Wywołania obiektu obsługi znacznika prostego (545)
  • Obiekty obsługi dla znaczników prostych (546)
  • Obiekty obsługi dla znaczników posiadających atrybuty (546)
  • Obiekty obsługi znaczników prostych posiadających ciało (548)
  • Obiekty obsługi znaczników definiujących zmienne (549)
  • Współpraca znaczników (551)
  • Przykłady (553)

Rozdział 16. Skrypty na stronach JSP (561)

• Przykład stron JSP (561)
  
• Posługiwanie się elementami skryptów (563)
  
• Wyłączanie skryptów (563)
  
• Deklaracje (564)
  
  • Inicjalizacja i finalizacja strony JSP (564)
• Skryptlety (564)
  
• Wyrażenia (565)
  
• Implementacja znaczników akceptujących elementy skryptów (566)
  
  • Elementy TLD (566)
  • Obiekty obsługi znaczników (566)
  • Znaczniki posiadające ciało (568)
  • Współpraca znaczników (570)
  • Znaczniki definiujące zmienne (571)

Rozdział 17. Technologia JavaServer Faces (573)

• Korzyści związane ze stosowaniem technologii JavaServer Faces (574)
  
• Czym jest aplikacja JavaServer Faces? (575)
  
• Role użytkowników szkieletu (576)
  
• Prosta aplikacja JavaServer Faces (577)
  
  • Etapy tworzenia aplikacji (577)
  • Tworzenie stron (579)
  • Definiowanie nawigacji (581)
  • Tworzenie komponentów (582)
  • Dodawanie deklaracji komponentów zarządzanych (583)
• Model interfejsu użytkownika oparty na komponentach (584)
  
  • Klasy komponentów interfejsu użytkownika (585)
  • Model wyświetlania komponentów (587)
  • Model konwersji (590)
  • Model odbiornika i zdarzenia (591)
  • Model kontroli poprawności (592)
• Model nawigacji (593)
  
• Zarządzanie komponentami pomocniczymi (594)
  
• Współpraca elementów aplikacji (597)
  
• Cykl życia strony JavaServer Faces (599)
  
  • Scenariusze cyklu przetwarzania żądania (600)
  • Standardowy cykl przetwarzania żądania (601)
• Dalsze informacje (605)

Rozdział 18. Stosowanie technologii JavaServer Faces na stronach JSP (607)

• Przykład aplikacji JavaServer Faces (607)
  
• Tworzenie strony (611)
  
• Stosowanie znaczników podstawowych (613)
  
• Stosowanie znaczników komponentów HTML (613)
  
  • Atrybuty znaczników komponentów interfejsu użytkownika (615)
  • Komponent UIForm (617)
  • Komponent UIColumn (618)
  • Komponent UICommand (618)
  • Komponent UIData (620)
  • Komponent UIGraphic (623)
  • Komponenty UIInput i UIOutput (623)
  • Komponent UIPanel (626)
  • Komponent UISelectBoolean (628)
  • Komponent UISelectMany (629)
  • Komponenty UIMessage i UIMessages (630)
  • Komponent UISelectOne (630)
  • Komponenty UISelectItem, UISelectItems i UISelectItemGroup (631)
• Stosowanie zlokalizowanych komunikatów (634)
  
  • Odwołania do zestawu zasobów ResourceBundle (634)
  • Odwołania do zlokalizowanego komunikatu (635)
• Stosowanie standardowych konwerterów (635)
  
  • Stosowanie konwertera DateTimeConverter (637)
  • Stosowanie konwertera NumberConverter (638)
• Rejestracja odbiorników (639)
  
  • Rejestracja odbiornika zdarzeń zmiany wartości (639)
  • Rejestracja odbiornika zdarzeń akcji (640)
• Stosowanie walidatorów standardowych (640)
  
  • Wartość wymagana (641)
  • Stosowanie walidatora LongRangeValidator (641)
• Wiązanie wartości i instancji komponentów z zewnętrznymi źródłami danych (642)
  
  • Wiązanie wartości komponentu z właściwością (643)
  • Wiązanie wartości komponentu z obiektem niejawnym (644)
  • Wiązanie instancji komponentu z właściwością komponentu pomocniczego (645)
• Odwołania do metody komponentu pomocniczego (646)
  
  • Odwołanie do metody nawigacji (647)
  • Odwołania do metody obsługi zdarzenia akcji (647)
  • Odwołania do metody kontroli poprawności (648)
  • Odwołania do metody obsługi zdarzenia zmiany wartości (648)
• Stosowanie obiektów niestandardowych (649)
  
  • Stosowanie niestandardowego konwertera (650)
  • Stosowanie niestandardowego walidatora (650)
  • Stosowanie niestandardowego komponentu (651)

Rozdział 19. Programowanie dla JavaServer Faces (653)

• Implementacja właściwości komponentu (653)
  
  • Implementacja właściwości wiązanych z wartościami komponentów (654)
  • Implementacja właściwości związanych z instancjami komponentów (661)
• Lokalizacja (662)
  
  • Tworzenie zestawu zasobów (662)
  • Lokalizacja danych dynamicznych (662)
  • Lokalizacja komunikatów (663)
• Implementacja niestandardowego konwertera (665)
  
• Implementacja odbiornika zdarzeń (667)
  
  • Implementacja odbiorników zmiany wartości (667)
  • Implementacja odbiorników zdarzeń akcji (668)
• Implementacja niestandardowego walidatora (669)
  
  • Implementacja interfejsu Validator (670)
  • Implementacja niestandardowego znacznika (672)
• Implementacja metod komponentu pomocniczego (674)
  
  • Implementacja metody nawigacji (674)
  • Implementacja metody obsługi zdarzenia akcji (675)
  • Implementacja metody kontroli poprawności (676)
  • Implementacja metody obsługi zdarzenia zmiany wartości (677)

Rozdział 20. Implementacja niestandardowych komponentów interfejsu użytkownika (679)

• Jak ustalić, czy potrzebujemy niestandardowego komponentu? (680)
  
  • Kiedy używać niestandardowego komponentu? (680)
  • Kiedy używać niestandardowego obiektu wyświetlania? (681)
  • Kombinacje komponentów, obiektów wyświetlania i znaczników (682)
• Przykład mapy graficznej (683)
  
  • Implementacja mapy graficznej przy użyciu technologii JavaServer Faces (683)
  • Wyświetlanie strony HTML (683)
  • Strona JSP (684)
  • Konfigurowanie danych modelu (685)
  • Podsumowanie klas aplikacji (687)
• Etapy implementacji niestandardowego komponentu (687)
  
• Implementacja obiektu obsługi znacznika komponentu (688)
  
• Definiowanie niestandardowego znacznika komponentu przez deskryptor biblioteki znaczników (692)
  
• Implementacja klas niestandardowych komponentów (693)
  
  • Kodowanie (696)
  • Dekodowanie (698)
  • Umożliwianie wiązania wartości właściwościom komponentu (698)
  • Przechowywanie i odtwarzanie stanu (699)
• Delegowanie wyświetlania do klasy wyświetlania (700)
  
  • Implementacja klasy wyświetlania (701)
  • Identyfikacja typu obiektu wyświetlania (702)
• Obsługa zdarzeń dla niestandardowych komponentów (702)

Rozdział 21. Konfigurowanie aplikacji JavaServer Faces (705)

• Plik konfiguracyjny zasobów aplikacji (705)
  
• Konfigurowanie komponentów (706)
  
  • Stosowanie elementu managed-bean (707)
  • Inicjalizacja właściwości za pomocą elementu managed-property (708)
  • Inicjalizacja map i list (713)
• Rejestracja komunikatów (714)
  
• Rejestracja niestandardowego walidatora (715)
  
• Rejestracja niestandardowego konwertera (716)
  
• Konfigurowanie reguł nawigacji (716)
  
• Rejestracja niestandardowej klasy wyświetlania w pakiecie wyświetlania (719)
  
• Rejestracja niestandardowego komponentu (720)
  
• Podstawowe wymagania aplikacji JavaServer Faces (721)
  
  • Konfigurowanie aplikacji za pomocą programu deploytool (722)
  • Dołączanie wymaganych plików JAR (725)
  • Dołączanie klas, stron i innych zasobów (726)

Rozdział 22. Internacjonalizacja i lokalizacja aplikacji internetowych (727)

• Klasy lokalizacji na platformie Java (727)
  
• Przygotowywanie zlokalizowanych komunikatów i etykiet (728)
  
  • Określanie lokalizacji (728)
  • Wybór zestawu zasobów (729)
  • Pobieranie zlokalizowanych komunikatów (729)
• Formatowanie dat i liczb (730)
  
• Zbiory znaków i ich kodowanie (731)
  
  • Zbiory znaków (731)
  • Kodowanie znaków (731)
• Dalsze informacje (734)

Rozdział 23. Enterprise Beans (735)

• Czym jest komponent Enterprise Bean? (735)
  
  • Korzyści płynące z używania komponentów EJB (735)
  • Kiedy należy używać komponentów EJB? (736)
  • Rodzaje komponentów Enterprise Beans (736)
• Komponenty sesyjne (736)
  
  • Tryby zarządzania stanem (737)
  • Kiedy używać komponentów sesyjnych? (738)
• Komponenty encyjne (738)
  
  • Co odróżnia komponenty encyjne od sesyjnych? (739)
  • Trwałość zarządzana przez kontener (740)
  • Kiedy używać komponentów encyjnych? (743)
• Komponenty sterowane komunikatami (743)
  
  • Jaka jest różnica między komponentami sterowanymi komunikatami a sesyjnymi i encyjnymi obiektami EJB? (743)
  • Kiedy używać komponentów sterowanych komunikatami? (744)
• Definiowanie dostępu do komponentów za pomocą interfejsów (745)
  
  • Klient zdalny (745)
  • Klient lokalny (746)
  • Interfejsy lokalne a trwałość zarządzana przez kontener (746)
  • Wybór pomiędzy dostępem zdalnym i lokalnym (747)
  • Klient usługi internetowej (748)
  • Rodzaj dostępu a parametry metod (748)
• Składniki komponentu EJB (749)
  
• Konwencja nazw przyjęta dla komponentów EJB (750)
  
• Cykl życia komponentów Enterprise Beans (750)
  
  • Cykl życia stanowego komponentu sesyjnego (751)
  • Cykl życia bezstanowego komponentu sesyjnego (752)
  • Cykl życia komponentu encyjnego (752)
  • Cykl życia komponentu sterowanego komunikatami (754)
• Dalsze informacje (754)

Rozdział 24. Komponenty Enterprise Beans - pierwsze kroki (755)

• Tworzenie aplikacji J2EE (756)
  
• Tworzenie komponentu EJB (756)
  
  • Przygotowanie kodu źródłowego komponentu (756)
  • Kompilacja plików z kodem źródłowym (758)
  • Pakowanie komponentu EJB (758)
• Tworzenie aplikacji klienta (759)
  
  • Kodowanie aplikacji klienta (760)
  • Kompilacja programu klienta (762)
  • Pakowanie aplikacji klienta (762)
  • Określenie nazwy komponentu, do którego odwołuje się klient (763)
• Tworzenie klienta sieciowego (764)
  
  • Kodowanie klienta sieciowego (764)
  • Kompilacja klienta sieciowego (765)
  • Pakowanie klienta sieciowego (765)
  • Określenie nazwy komponentu, do którego odwołuje się klient sieciowy (766)
• Przyporządkowanie komponentowi nazwy (767)
  
• Określenie ścieżki bazowej kontekstu klienta sieciowego (767)
  
• Wdrożenie aplikacji J2EE (768)
  
• Uruchomienie aplikacji klienta (769)
  
• Uruchomienie klienta sieciowego (769)
  
• Modyfikowanie aplikacji J2EE (770)
  
  • Zmiany w pliku klasy komponentu (770)
  • Dodanie pliku (771)
  • Modyfikacja ustawień wdrożenia (771)

Rozdział 25. Przykłady komponentów sesyjnych (773)

• Przykład CartBean (773)
  
  • Klasa komponentu sesyjnego (774)
  • Interfejs domowy (777)
  • Interfejs zdalny (778)
  • Klasy pomocnicze (779)
  • Kompilacja przykładu CartBean (779)
  • Przygotowanie aplikacji (779)
  • Pakowanie komponentu EJB (779)
  • Pakowanie programu klienta (780)
• Przykład usługi sieciowej - HelloServiceBean (782)
  
  • Interfejs punktu końcowego usługi sieciowej (783)
  • Klasa implementująca bezstanowy komponent sesyjny (783)
  • Kompilacja HelloServiceBean (783)
  • Tworzenie klienta usługi internetowej (786)
  • Uruchomienie klienta usługi internetowej (787)
• Inne cechy komponentów EJB (787)
  
  • Dostęp do parametrów zewnętrznych (787)
  • Porównywanie komponentów EJB (788)
  • Przekazanie referencji wskazującej komponent EJB (788)
• Usługa timera (789)
  
  • Tworzenie timera (790)
  • Wyłączanie i zapamiętywanie timerów (790)
  • Pobranie informacji na temat timera (791)
  • Timery a transakcje (791)
  • Przykładowy komponent TimerSessionBean (791)
  • Przygotowanie komponentu TimerSessionBean (792)
• Obsługa wyjątków (797)

Rozdział 26. Przykłady komponentów encyjnych bezpośrednio zarządzających trwałością (799)

• Przykładowy komponent SavingsAccountBean (799)
  
  • Klasa komponentu encyjnego (800)
  • Interfejs domowy (808)
  • Interfejs zdalny (809)
  • Uruchomienie przykładu SavingsAccountBean (810)
• Odwzorowanie relacji w komponentach bezpośrednio zarządzających trwałością (812)
  
  • Relacje "jeden do jednego" (812)
  • Relacje "jeden do wielu" (815)
  • Relacje "wiele do wielu" (821)
• Klucze główne komponentów bezpośrednio zarządzających trwałością (823)
  
  • Klasa klucza głównego (823)
  • Klucze główne w klasie komponentu encyjnego (824)
  • Pobranie klucza głównego (825)
• Rady dotyczące narzędzia deploytool i komponentów encyjnych bezpośrednio zarządzających trwałością (826)

Rozdział 27. Przykłady komponentów encyjnych o trwałości zarządzanej przez kontener (827)

• Opis aplikacji RosterApp (827)
  
• Komponent PlayerBean (828)
  
  • Klasa komponentu (828)
  • Lokalny interfejs domowy (832)
  • Interfejs lokalny (833)
• Funkcje realizowane przez aplikację RosterApp (834)
  
  • Tworzenie obiektu gracza (834)
  • Dopisanie gracza do zespołu (835)
  • Usunięcie obiektu gracza (836)
  • Usunięcie gracza z drużyny (836)
  • Pobranie listy wszystkich graczy drużyny (837)
  • Pobranie kopii listy graczy drużyny (839)
  • Wyszukiwanie graczy na podstawie zajmowanych przez nich pozycji (840)
  • Wyszukiwanie dyscyplin uprawianych przez zawodnika (841)
• Stworzenie i uruchomienie przykładowej aplikacji RosterApp (842)
  
  • Tworzenie tabel bazy danych (842)
  • Tworzenie źródła danych (843)
  • Schemat przyporządkowania pól (843)
  • Kompilacja komponentów EJB (844)
  • Tworzenie aplikacji (844)
  • Pakowanie komponentów EJB (844)
  • Pakowanie aplikacji klienta (852)
  • Wdrożenie aplikacji (853)
  • Uruchomienie aplikacji klienta (853)
• Przewodnik po ustawieniach aplikacji RosterApp (854)
  
  • RosterApp (854)
  • RosterClient (855)
  • RosterJAR (856)
  • TeamJAR (856)
• Klucz główny a trwałość zarządzana przez kontener (861)
  
  • Klasa klucza głównego (861)
• Zaawansowane zagadnienia związane z CMP - przykład OrderApp (864)
  
  • Struktura aplikacji OrderApp (864)
  • Relacje pomiędzy komponentami aplikacji OrderApp (865)
  • Klucze główne komponentów encyjnych aplikacji OrderApp (867)
  • Komponent encyjny przyporządkowany więcej niż jednej tabeli bazy danych (869)
  • Metody wyszukujące i metody selekcji (869)
  • Metody domowe (870)
  • Kaskadowe usuwanie w aplikacji OrderApp (870)
  • Pola typu BLOB i CLOB w aplikacji OrderApp (870)
  • Przygotowanie i uruchomienie przykładu OrderApp (871)
• Rady dotyczące narzędzia deploytool i komponentów encyjnych o trwałości zarządzanej przez kontener (877)
  
  • Wybór pól stanu i abstrakcyjnego schematu trwałości (877)
  • Definicja zapytań EJB QL związanych z metodami wyszukującymi i metodami selekcji (878)
  • Definicja relacji (878)
  • Tworzenie tabel bazy danych w czasie wdrażania aplikacji (879)

Rozdział 28. Przykład komponentu sterowanego komunikatami (881)

• Ogólna charakterystyka przykładowej aplikacji (881)
  
• Program klienta (882)
  
• Klasa komponentu sterowanego komunikatami (882)
  
  • Metoda onMessage (883)
  • Metody ejbCreate i ejbRemove (884)
• Wdrożenie i uruchomienie aplikacji SimpleMessageApp (884)
  
  • Stworzenie zasobów obsługujących komunikację (884)
  • Wdrożenie aplikacji (885)
  • Uruchomienie programu klienta (886)
  • Usunięcie zasobów obsługujących komunikację (886)
• Rady dotyczące narzędzia deploytool i komponentów sterowanych komunikatami (886)
  
  • Określenie typu komponentu (886)
  • Konfiguracja właściwości komponentu sterowanego komunikatami (887)
• Rady dotyczące narzędzia deploytool i komponentów wysyłających komunikaty (888)
  
  • Ustalenie nazwy zasobów (888)
  • Ustalenie nazwy celu komunikatu (889)
  • Ustalenie celu komunikatu (889)

Rozdział 29. Język zapytań EJB QL (891)

• Terminologia (891)
  
• Uproszczona składnia EJB QL (892)
  
• Przykłady zapytań (892)
  
  • Proste zapytania wyszukujące (893)
  • Zapytania wyszukujące odwołujące się do komponentów będących w relacji (894)
  • Wyrażenia warunkowe w zapytaniach wyszukujących (895)
  • Zapytania selekcji (896)
• Kompletna składnia EJB QL (897)
  
  • Symbole notacji BNF (897)
  • Gramatyka języka EJB QL w notacji BNF (898)
  • Klauzula FROM (900)
  • Wyrażenia nawigujące (903)
  • Klauzula WHERE (905)
  • Klauzula SELECT (911)
  • Klauzula ORDER BY (913)
• Ograniczenia języka SQL (914)

Rozdział 30. Transakcje (915)

• Czym jest transakcja? (915)
  
• Transakcje zarządzane przez kontener (916)
  
  • Atrybuty transakcji (916)
  • Wycofywanie transakcji zarządzanej przez kontener (919)
  • Synchronizacja zmiennych instancyjnych komponentu sesyjnego (920)
  • Kompilacja przykładu BankBean (921)
  • Pakowanie przykładu BankBean (922)
  • Metody niedozwolone podczas posługiwania się transakcjami zarządzanymi przez kontener (925)
• Transakcje zarządzane przez komponent (925)
  
  • Transakcje JDBC (926)
  • Przygotowanie i uruchomienie przykładu WarehouseBean (927)
  • Kompilacja przykładu WarehouseBean (927)
  • Pakowanie przykładu WarehouseBean (927)
  • Transakcje JTA (930)
  • Przygotowanie i uruchomienie przykładu TellerBean (931)
  • Kompilacja przykładu TellerBean (931)
  • Pakowanie przykładu TellerBean (932)
  • Powrót z metody bez zatwierdzenia transakcji (935)
  • Metody niedozwolone podczas posługiwania się transakcjami zarządzanymi przez komponent (935)
• Podsumowanie możliwości obsługi transakcji w komponentach encyjnych (936)
  
• Limity czasowe transakcji (936)
  
• Poziomy izolacji (937)
  
• Aktualizacja wielu baz danych (938)
  
• Transakcje w komponentach sieciowych (939)

Rozdział 31. Łączenie z zasobami (941)

• Usługa nazw JNDI (941)
  
• Źródła danych i pule połączeń (942)
  
• Połączenia z bazą danych (943)
  
  • Kodowanie połączenia z bazą (943)
  • Określenie nazwy obiektu (944)
  • Tworzenie źródła danych (944)
• Połączenia z usługą pocztową (945)
  
  • Uruchomienie przykładu ConfirmerBean (946)
• Połączenia URL (948)
  
  • Uruchomienie przykładu HTMLReaderBean (949)
• Dalsze informacje (950)

Rozdział 32. Bezpieczeństwo (951)

• Podstawy (951)
  
• Dziedziny, użytkownicy, grupy i role (952)
  
  • Zarządzanie użytkownikami (953)
  • Ustalanie ról bezpieczeństwa (953)
  • Przyporządkowanie ról użytkownikom i grupom (954)
• Bezpieczeństwo warstwy sieciowej (955)
  
  • Ochrona zasobów sieciowych (956)
  • Konfigurowanie wymagań i reguł bezpieczeństwa (957)
  • Konfiguracja bezpiecznego połączenia (960)
  • Bezpieczeństwo programowe w warstwie sieciowej (960)
• Metody uwierzytelnienia (962)
  
  • Podstawowe uwierzytelnienie HTTP (962)
  • Uwierzytelnienie na podstawie formularza (963)
  • Uwierzytelnienie na podstawie certyfikatu (964)
  • Uwierzytelnienie wzajemne (964)
  • Uwierzytelnienie typu Digest (966)
  • Konfiguracja uwierzytelnienia (966)
  • Przykład. Uwierzytelnienie za pomocą formularza (967)
• Instalacja i konfiguracja protokołu SSL (974)
  
  • Na czym polega protokół bezpiecznej transmisji danych? (974)
  • Certyfikaty cyfrowe (975)
  • Konfiguracja łącznika SSL (980)
• Bezpieczeństwo usług internetowych i XML (983)
  
  • Przykład. Podstawowe uwierzytelnienie aplikacji JAX-RPC (984)
  • Przykład. Uwierzytelnienie aplikacji JAX-RPC na podstawie certyfikatu i przy użyciu transmisji HTTP/SSL (990)
• Bezpieczeństwo warstwy komponentów EJB (998)
  
  • Deklaracja praw dostępu do metody (998)
  • Konfiguracja bezpieczeństwa na poziomie adresu IOR (999)
  • Bezpieczeństwo programowe w warstwie komponentów EJB (1000)
  • Nieuwierzytelniona nazwa użytkownika (1001)
• Bezpieczeństwo warstwy aplikacji klienta (1001)
  
• Bezpieczeństwo korporacyjnej warstwy informacyjnej (1002)
  
  • Logowanie na poziomie kontenera (1002)
  • Logowanie na poziomie komponentu (1002)
  • Konfiguracja bezpieczeństwa adaptera zasobów (1003)
• Propagowanie tożsamości (1004)
  
  • Konfiguracja propagowanej tożsamości komponentu (1004)
  • Konfiguracja uwierzytelnienia klienta (1005)
• Czym jest JACC? (1005)
  
• Dalsze informacje (1005)

Rozdział 33. Interfejs Java Message Service (1007)

• Wprowadzenie (1007)
  
  • Na czym polega wymiana komunikatów w obrębie aplikacji? (1007)
  • Czym jest interfejs JMS API? (1008)
  • Kiedy można korzystać z interfejsu JMS? (1009)
  • Jak interfejs JMS współdziała z platformą J2EE? (1010)
• Podstawowe elementy interfejsu JMS (1011)
  
  • Architektura JMS API (1011)
  • Dziedziny wymiany komunikatów (1012)
  • Pobieranie komunikatów (1014)
• Model programistyczny interfejsu JMS (1014)
  
  • Obiekty administracji (1015)
  • Połączenia (1017)
  • Sesje (1017)
  • Wytwórcy komunikatów (1018)
  • Konsumenty komunikatów (1019)
  • Komunikaty (1021)
  • Obsługa wyjątków (1023)
• Prosta aplikacja klienta JMS (1024)
  
  • Przykład prostego synchronicznego odbioru komunikatów (1024)
  • Przykład prostego asynchronicznego odbioru komunikatów (1033)
  • Uruchamianie programów-klientów JMS w wielu systemach (1037)
• Niezawodność wymiany w aplikacjach JMS (1041)
  
  • Podstawowe mechanizmy pewności wymiany (1042)
  • Zaawansowane mechanizmy pewności wymiany (1048)
• Stosowanie interfejsu JMS w aplikacji J2EE (1058)
  
  • Komponenty sesyjne i encyjne w synchronicznym odbiorze komunikatów (1058)
  • Stosowanie komponentów sterowanych komunikatami (1060)
  • Zarządzanie transakcjami rozproszonymi (1062)
  • Stosowanie interfejsu JMS z klientami aplikacji i komponentami WWW (1064)
• Dalsze informacje (1065)

Rozdział 34. Interfejs JMS w aplikacjach J2EE - przykłady (1067)

• Aplikacja J2EE korzystająca z JMS z komponentem sesyjnym (1068)
  
  • Pisanie komponentów aplikacji (1068)
  • Tworzenie i pakowanie aplikacji (1070)
  • Wdrażanie aplikacji (1074)
  • Uruchamianie klienta aplikacji (1074)
• Aplikacja J2EE korzystająca z JMS z komponentem encyjnym (1075)
  
  • Aplikacja działu kadr (1076)
  • Pisanie komponentów aplikacji (1077)
  • Tworzenie i pakowanie aplikacji (1079)
  • Instalacja aplikacji (1081)
  • Uruchamianie klienta (1081)
• Aplikacja J2EE konsumująca komunikaty ze zdalnego serwera J2EE (1082)
  
  • Przegląd aplikacji (1083)
  • Programowanie komponentów aplikacji (1084)
  • Tworzenie aplikacji i pakietów (1084)
  • Wdrażanie aplikacji (1086)
  • Uruchamianie klienta aplikacji (1087)
• Aplikacja J2EE wdrażająca komponent sterowany komunikatami na dwóch serwerach J2EE (1088)
  
  • Przegląd aplikacji (1088)
  • Programowanie komponentów aplikacji (1089)
  • Tworzenie aplikacji i pakietów (1091)
  • Wdrażanie aplikacji (1093)
  • Uruchamianie klienta aplikacji (1094)

Rozdział 35. Aplikacja Coffee Break (1097)

• Wspólna część kodu serwerów (1098)
  
• Usługa JAX-RPC dostawcy (1098)
  
  • Interfejs usługi (1099)
  • Implementacja usługi (1099)
  • Rejestrowanie usługi dostawcy (1100)
  • Usuwanie usługi z rejestru (1103)
• Usługa SAAJ dostawcy (1105)
  
  • Klient SAAJ (1106)
  • Usługa SAAJ (1112)
• Serwer Coffee Break (1117)
  
  • Strony JSP (1118)
  • Komponenty JavaBeans (1119)
  • RetailPriceListServlet (1121)
• Serwer Coffee Break - wersja z JavaServer Faces (1121)
  
  • Strony JSP (1122)
  • Komponenty JavaBeans (1124)
  • Konfiguracja zasobów (1125)
• Kompilacja, pakowanie, wdrażanie i uruchamianie aplikacji (1126)
  
  • Konfiguracja portu (1126)
  • Konfiguracja serwera rejestracji (1126)
  • Stosowanie gotowych plików WAR przykładu (1127)
  • Kompilacja klas wspólnych aplikacji (1127)
  • Kompilacja, pakowanie i wdrażanie usługi JAX-RPC (1127)
  • Kompilacja, pakowanie i wdrażanie usługi SAAJ (1129)
  • Kompilacja, pakowanie i wdrażanie serwera Coffee Break (1130)
  • Kompilacja, pakowanie i wdrażanie serwera Coffee Break w wersji wykorzystującej JavaServer Faces (1131)
  • Uruchamianie klienta aplikacji Coffee Break (1132)
  • Usuwanie aplikacji Coffee Break (1134)

Rozdział 36. Bezpieczna Kasa Duke'a (1135)

• Komponenty korporacyjne (1136)
  
  • Komponenty sesyjne (1136)
  • Komponenty encyjne (1139)
  • Klasy pomocnicze (1139)
  • Tabele bazy danych (1140)
  • Ochrona komponentów korporacyjnych (1141)
• Klient aplikacyjny (1142)
  
  • Klasy i powiązania pomiędzy nimi (1143)
  • Klasa BankAdmin (1144)
  • Klasa EventHandle (1145)
  • Klasa DataModel (1146)
• Klient WWW (1149)
  
  • Strategie projektowe (1150)
  • Składowe klienta WWW (1151)
  • Przetwarzanie żądania (1153)
  • Ochrona zasobów klienta WWW (1154)
• Umiędzynarodowienie aplikacji (1156)
  
• Kompilacja, pakowanie, wdrażanie i uruchamianie aplikacji (1157)
  
  • Konfigurowanie serwerów (1158)
  • Kompilowanie kodu aplikacji (1159)
  • Pakowanie i wdrażanie Bezpiecznej Kasy Duke'a (1159)
  • Przegląd nazw JNDI (1164)
• Uruchamianie klientów (1165)
  
  • Uruchamianie klienta aplikacyjnego (1165)
  • Uruchamianie klienta WWW (1166)

Dodatek A Kodowanie znaków w języku Java (1169)

• Dalsze informacje (1170)

Dodatek B XML i reszta - alfabet specyfikacji (1171)

• Standardy podstawowe (1172)
  
  • SAX (1172)
  • StAX (1172)
  • DOM (1173)
  • JDOM i dom4j (1173)
  • DTD (1173)
  • Przestrzenie nazw (1174)
  • XSL (1174)
  • XSLT (i XPath) (1175)
• Schematy (1175)
  
  • XML Schema (1176)
  • RELAX NG (1176)
  • SOX (1176)
  • Schematron (1177)
• Standardy łączenia i prezentacji dokumentów (1177)
  
  • Łączenie dokumentów XML (1177)
  • XHTML (1178)
• Standardy wiedzy (1178)
  
  • RDF (1178)
  • RDF Schema (1179)
  • XTM (1179)
• Standardy oparte na XML-u (1179)
  
  • Standardy dokumentów specjalizowanych (1179)
  • Standardy handlu elektronicznego (1180)
• Podsumowanie (1181)

Dodatek C Wstęp do HTTP (1183)

• Żądania HTTP (1183)
  
• Odpowiedzi HTTP (1184)

Dodatek D Architektura Connector platformy J2EE (1185)

• Adaptery zasobów (1185)
  
• Kontrakty adaptera zasobu (1186)
  
  • Kontrakty systemowe (1186)
  • Kontrakty wyjściowe (1188)
  • Kontrakty wejściowe (1188)
• Interfejs CCI (1189)
  
• Dalsze informacje (1190)

Dodatek E Słowniczek (1191)

Skorowidz (1229)