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)
- 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)
- 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)
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)
- 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)
- 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)
- 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)
- 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)
- 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)
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)
- 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)
- 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)
- 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)
- 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)
- 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)
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)
- 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)
- 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)
- 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)
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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
Skorowidz (815)