okladka

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.


O Autorach (19)
Wprowadzenie (21)
Część I Zaczynamy - pierwszy rzut oka na środowisko JBuilder (25)
Rozdział 1. Viva Java (27)
  • Od Oak do J2EE - krótka historia Javy (28)
  • Pierwszy rzut oka na JBuildera (30)
  • I co dalej? (31)
  • Podsumowanie (32)
Rozdział 2. Początek eksploracji JBuildera (33)
  • 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)
Rozdział 3. Stosujemy kreatory JBuildera (61)
  • 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)
  • Część praktyczna (75)
    • Utworzenie szkieletu aplikacji (76)
  • Podsumowanie (77)
    • Tematy do przemyśleń (77)
Część II Projektowanie, modelowanie i testowanie aplikacji w środowisku JBuilder (79)
Rozdział 4. Modelowanie (81)
  • 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)
Rozdział 5. Testowanie modułów (99)
  • 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)
Rozdział 6. Testowanie i uruchamianie, czyli debugowanie (123)
  • 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)
  • 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)
Rozdział 7. Refaktoring (145)
  • 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)
Rozdział 8. Dokumentowanie w środowisku JBuilder (167)
  • 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)
Rozdział 9. Deployment - przygotowanie do wdrożenia (183)
  • Pliki archiwalne Javy (184)
  • Plik manifestu (184)
  • Archiwizator Javy (185)
    • Przeglądanie archiwum (186)
    • Uaktualnianie archiwum (186)
    • Rozpakowanie plików z archiwum (187)
  • 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)
Część III JBuilder a aplikacje klienckie w Javie (199)
Rozdział 10. AWT (201)
  • 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)
Rozdział 11. Swing (223)
  • 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)
Rozdział 12. Używanie menedżerów układu (247)
  • 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)
Rozdział 13. Tworzenie elementów graficznych w Javie (275)
  • 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)
    • Implementacja interfejsu Print w panelu CoursePanel (281)
    • Uruchomienie gotowej aplikacji (282)
  • Podsumowanie (283)
    • Tematy do przemyśleń (283)
Rozdział 14. Pliki, strumienie i serializacja (285)
  • 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)
Rozdział 15. Obsługa baz danych (313)
  • 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)
Część IV JBuilder i aplikacje sieciowe (357)
Rozdział 16. Serwlety (359)
  • 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)
Rozdział 17. Java Server Pages (391)
  • 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)
Rozdział 18. Biblioteki znaczników (421)
  • 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)
    • 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)
Rozdział 19. InternetBean Express (457)
  • 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)
Część V JBuilder dla aplikacji korporacyjnych (469)
Rozdział 20. XML (471)
  • 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)
Rozdział 21. Architektura systemów z komponentami EJB (Enterprise JavaBeans) (509)
  • 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)
  • 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)
Rozdział 22. Tworzenie komponentów sesyjnych - Session Bean (523)
  • 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)
Rozdział 23. Tworzenie komponentów Entity Bean (563)
  • 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)
    • 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)
Rozdział 24. Komponenty sterowane wiadomościami (623)
  • 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)
Rozdział 25. CORBA (639)
  • Definicja specyfikacji CORBA (640)
    • ORB nad IIOP (641)
    • Trzony klienta i szkielety serwera (642)
    • OA - adapter obiektu (642)
    • IOR i serwis nazw (643)
  • 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)
Rozdział 26. Usuwanie błędów aplikacji klasy enterprise (673)
  • 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)
Rozdział 27. Tworzenie i wdrażanie oprogramowania z użyciem serwerów WebLogic i WebSphere (693)
  • 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)
  • 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)
Rozdział 28. Web Services (715)
  • 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)
Rozdział 29. Korzystanie z J2ME w środowisku JBuilder (743)
  • 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)
Rozdział 30. Programowanie zespołowe w JBuilderze (763)
  • 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)
Rozdział 31. JBuilder i Struts (787)
  • 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)
Dodatki (813)
Skorowidz (815)