Kompendium wiedzy dla każdego programisty, projektanta i kierownika projektu
- Nowoczesne metodyki wytwarzania oprogramowania
- Narzędzia do modelowania aplikacji i automatycznego generowania kodu
- Koncepcja architektury sterowanej modelami
- Sposoby zapewnienia jakości aplikacji
Tworzenie aplikacji korporacyjnych to wyścig z czasem. Organizacje zmieniają się podobnie jak otoczenie biznesowe, w którym działają. Zbyt długi okres przygotowania aplikacji może sprawić, że po wdrożeniu okaże się ona bezużyteczna. Z drugiej jednak strony, zbyt duży pośpiech przy tworzeniu aplikacji powoduje, że pomija się fazę modelowania i testowania, pisząc kod źródłowy bez jakiejkolwiek koncepcji i planu. Efektem takiego pośpiechu są aplikacje niedostosowane do wymagań użytkowników i pracujące niestabilnie. Sposobem na stworzenie odpowiedniego systemu informatycznego dla korporacji jest wykorzystywanie odpowiednich metodyk projektowych i nowoczesnych narzędzi ułatwiających zarówno pisanie, jak i testowanie aplikacji.
Książka "J2EE. Podstawy programowania aplikacji korporacyjnych" przedstawia najlepsze praktyki projektowe stosowane przy tworzeniu systemów informatycznych z wykorzystaniem platformy J2EE. Opisano w niej kolejne etapy projektu oraz narzędzia i metodyki, dzięki którym przeprowadzenie każdego z nich będzie szybsze i efektywniejsze. Czytając ją, poznasz metodyki RUP i XP, typy architektur systemów oraz sposoby modelowania aplikacji i narzędzia do automatycznego generowania szkieletu kodu źródłowego. Dowiesz się, jak optymalnie skonfigurować środowiska programistyczne i jak testować kolejne moduły aplikacji. Nauczysz się korzystać z nowoczesnych metodyk i narzędzi.
- Podstawowe wiadomości o błyskawicznym wytwarzaniu aplikacji (RAD)
- Metodyki projektowe Rational Unified Process (RUP) oraz Extreme Programming (XP)
- Wielowarstwowe architektury systemów
- Modelowanie systemów za pomocą języka UML
- Automatyczne generowanie kodu
- Stosowanie narzędzi XDoclet i Hibernate
- Komunikacja z bazami danych
- Zasady programowania aspektowego
- Testowanie aplikacji
Wiadomości zawarte w tej książce sprawią, że będziesz w stanie szybciej projektować i tworzyć aplikacje korporacyjne.
O autorze (13)Przedmowa (15)
Część I Procesy adaptacyjne (21)
Rozdział 1. Fundamenty adaptacyjne technologii J2EE (23)
- Potrzeba błyskawicznego wytwarzania oprogramowania (24)
- Wyzwania na poziomie przedsiębiorstw (25)
- Platforma J2EE (26)
- Definiowanie fundamentu adaptacyjnego (27)
- Dlaczego fundament? (27)
- Dlaczego adaptacyjny? (27)
- Przygotowywanie fundamentów pod błyskawiczne wytwarzanie oprogramowania (28)
- Ludzie (29)
- Narzędzia (29)
- Szkielety (29)
- Praktyki (30)
- Standardy (30)
- Procesy i procedury (30)
- Szkolenia (30)
- Ustawiczne doskonalenie (31)
- Korzyści wynikające z inwestycji w fundamenty adaptacyjne (32)
- Kluczowe czynniki decydujące o sukcesie (33)
- Pozyskiwanie przychylności projektantów i programistów (34)
- Edukacja (35)
- Wsparcie zarządu (36)
- Podsumowanie (37)
- Informacje dodatkowe (38)
- Wspólne elementy koncepcji RAD (40)
- Metoda skrzynki czasowej (40)
- Języki właściwe dla określonych dziedzin (41)
- Wielokrotne wykorzystywanie oprogramowania (42)
- Narzędzia zapewniające produktywność (44)
- Błyskawiczne tworzenie prototypów (44)
- Praca z prototypami (45)
- Typy prototypów i techniki ich budowy (46)
- Wybór pomiędzy trybem odrzucania a trybem ewoluowania (48)
- Podsumowanie (49)
- Informacje dodatkowe (49)
- Po co w ogóle stosować metodyki? (52)
- Metodyka RAD dla platformy J2EE (52)
- Metody adaptacyjne kontra metody predyktywne (53)
- Kaskadowy model cyklu życia projektu (54)
- Klasyczny model kaskadowy (54)
- Zalety i wady (55)
- Studium przypadku (56)
- Wytwarzanie iteracyjne (59)
- Zalety podejścia iteracyjnego (60)
- Procesy iteracyjne (63)
- Wprowadzenie do procesu RUP (63)
- Proces oparty na przypadkach użycia (65)
- Iteracyjne wytwarzanie oprogramowania w ramach procesu RUP (68)
- Etapy procesu RUP (69)
- Dziedziny (70)
- Elementy procesu RUP (72)
- Planowanie (73)
- Wsparcie dla projektów na poziomie korporacyjnym (75)
- Wady procesu RUP (75)
- Metody zwinne (76)
- Wprowadzenie do metodyki XP (77)
- Praktyki procesu XP (77)
- Planowanie (80)
- Projektowanie (81)
- Kodowanie (82)
- Testowanie (84)
- Role w procesie XP (84)
- Stosowanie metodyki XP dla projektów korporacyjnych opartych na platformie J2EE (86)
- Podsumowanie (88)
- Informacje dodatkowe (89)
Rozdział 4. Projektowanie zapewniające błyskawiczność wytwarzania (93)
- Cele architektur i projektów (94)
- Architektura i projekt w koncepcji RAD (96)
- Wykorzystanie mocnych stron zespołu projektowego (96)
- Wykorzystuj najlepsze dostępne szkielety (97)
- Myśl o przyszłości (100)
- Wystrzegaj się projektowania na rzecz wielokrotnego wykorzystywania kodu (102)
- Stosowanie projektów prostopadłych (103)
- Stosuj architektury wielowarstwowe (104)
- Różne podejścia do architektury J2EE (106)
- Architektury dwuwarstwowe kontra architektury wielowarstwowe (106)
- Enterprise JavaBeans (108)
- Perspektywy klientów zdalnych i lokalnych (109)
- Rozproszone komponenty (110)
- Wybór właściwego projektu (113)
- Architektura zorientowana na interfejs WWW (113)
- Architektura zorientowana na komponenty EJB (116)
- Podsumowanie (118)
- Informacje dodatkowe (119)
- Po co w ogóle modelować? (122)
- Komunikacja (122)
- Weryfikacja poprawności (124)
- Perspektywy architektury (125)
- Zunifikowany język modelowania (UML) (126)
- Diagramy przypadków użycia (127)
- Diagramy aktywności (129)
- Diagramy klas (130)
- Diagramy interakcji (132)
- Diagramy stanów (134)
- Diagramy wdrożenia i diagramy komponentów (135)
- Najczęstsze błędy (135)
- Oprogramowanie tworzone w warunkach kultu cargo (137)
- Narzędzia modelujące (137)
- Wybór narzędzia modelującego (138)
- Obsługa języka UML (139)
- Sprawdzanie poprawności modelu (140)
- Inżynieria normalna i inżynieria odwrotna (140)
- Obsługa wzorców projektowych (142)
- Dlaczego narzędzia projektowe nie zdają egzaminu? (145)
- Syndrom szczeniaka pod choinką (145)
- Metody skutecznego korzystania z narzędzi modelujących (148)
- Podsumowanie (150)
- Informacje dodatkowe (150)
- Czym właściwie jest generowanie kodu? (154)
- Pasywne generatory kodu (155)
- Generowanie kodu za pomocą narzędzia Apache Velocity (156)
- Zalety pasywnego generowania kodu (159)
- Aktywne generatory kodu (160)
- Zalety aktywnego generowania kodu (160)
- Aktywne generatory kodu i wzorce kodu (162)
- Programowanie atrybutowe (163)
- Czym są atrybuty? (163)
- Atrybuty kontra dyrektywy preprocesora (164)
- Przypisy platformy J2SE 5.0 kontra atrybuty (165)
- Wprowadzenie do narzędzia XDoclet (166)
- Instalacja narzędzia XDoclet (167)
- Przygotowywanie pliku kompilacji narzędzia Ant (167)
- Utworzenie komponentu sesyjnego (171)
- Praca z aktywnie generowanym kodem (177)
- Wskazówki dotyczące generowania kodu (177)
- Podsumowanie (181)
- Informacje dodatkowe (181)
- Problem baz danych (184)
- Dane są cenną wartością korporacji (184)
- Problem odwzorowania obiektowo-relacyjnego (187)
- Możliwości w zakresie dostępu do danych (190)
- Interfejs Java Database Connectivity (JDBC) (191)
- Narzędzia do odwzorowywania obiektowo-relacyjnego (192)
- Komponenty encyjne (194)
- Obiekty danych Javy (196)
- Generowanie kodu i odwzorowywanie obiektowo-relacyjne (197)
- Wprowadzenie do narzędzia Hibernate (198)
- Wprowadzenie do narzędzia Middlegen (199)
- Przygotowanie bazy danych (200)
- Wprowadzenie do systemu MySQL (201)
- Utworzenie schematu bazy danych (201)
- Uruchamianie skryptu bazy danych (204)
- Generowanie warstwy utrwalania danych (204)
- Uruchamianie narzędzia Middlegen z poziomu programu Ant (206)
- Graficzny interfejs użytkownika programu Middlegen (207)
- Dokumenty odwzorowania obiektowo-relacyjnego narzędzia Hibernate (208)
- Od dokumentów odwzorowań do kodu źródłowego Javy (212)
- Dokończenie całego procesu (213)
- Podsumowanie (215)
- Informacje dodatkowe (216)
- Założenia technologii MDA (217)
- Wyjaśnienie podstawowych założeń koncepcji architektury sterowanej modelami (219)
- Platforma (220)
- Modele (220)
- Odwzorowanie (223)
- Architektura MDA kontra tradycyjne techniki modelowania (224)
- Zalety (225)
- Wady (227)
- Narzędzia zgodne z architekturą MDA (229)
- Wprowadzenie do narzędzia AndroMDA (230)
- Architektura MDA i program AndroMDA (230)
- Wymiana modeli reprezentowanych w formacie XMI (232)
- Znaczniki modelu PIM (233)
- Wymienne wkłady MDA (236)
- Budowa wymiennego wkładu (238)
- Szablony wymiennych wkładów MDA (240)
- AndroMDA w praktyce (242)
- AndroMDA 3.0 (244)
- Podsumowanie (244)
- Informacje dodatkowe (245)
Rozdział 9. Skrypty (249)
- Po co w ogóle używać języków skryptowych? (249)
- Cechy języków skryptowych (251)
- Doświadczenie zespołu projektowego (251)
- Wieloplatformowość (252)
- Integracja z klasami Javy (252)
- Wprowadzenie do języka Jython (253)
- Instalacja Jythona (255)
- Uruchamianie skryptów (255)
- Język Jython (256)
- Integracja z językiem Java (258)
- Tworzenie prototypów interfejsu użytkownika (261)
- Tworzenie serwletów w języku Jython (262)
- Alternatywa - język Groovy (264)
- Podsumowanie (265)
- Informacje dodatkowe (265)
- Reguły biznesowe (267)
- Czym jest reguła biznesowa? (268)
- Struktura reguły biznesowej (268)
- Dynamiczna natura reguł biznesowych (269)
- Reguły biznesowe w oprogramowaniu (269)
- Reguły definiowane z góry (270)
- Język definiowania reguł (270)
- Ścisłe wiązanie logiki systemowej z logiką biznesową (270)
- Powielanie reguł (271)
- Mechanizmy regułowe (271)
- Systemy regułowe (272)
- Mechanizmy regułowe w systemach korporacyjnych (273)
- Wprowadzenie do języka Jess (274)
- Instalacja Jessa (275)
- Przykład użycia języka Jess (275)
- Jess i Java (279)
- Interfejs API mechanizmu regułowego Javy (282)
- Mechanizmy regułowe stosowane na poziomie korporacyjnym (283)
- Cechy korporacyjnych mechanizmów regułowych (284)
- Kryteria oceny mechanizmów regułowych (286)
- Podsumowanie (287)
- Informacje dodatkowe (288)
- Dlaczego programowanie aspektowe? (290)
- Obszary przecinające (290)
- Mieszanie i rozpraszanie kodu (291)
- Tradycyjne podejścia do problemu obszarów przecinających (292)
- Wyjaśnienie koncepcji programowania aspektowego (295)
- Pojęcia i terminologia (295)
- Garbaci i smoki (297)
- Metody tkania (297)
- Wprowadzenie do narzędzia AspectJ (298)
- AspectJ i Eclipse (299)
- Kompilator języka AspectJ (299)
- Przykład użycia języka AspectJ (300)
- Język kontra szkielet (306)
- Implementacje szkieletu programowania aspektowego (307)
- Wprowadzenie do szkieletu AspectWerkz (308)
- Definicja aspektu w formacie XML (309)
- Aspekty w postaci przypisów metadanych (310)
- Opcje tkania w szkielecie AspectWerkz (311)
- Aspektowe oprogramowanie pośredniczące (312)
- Wdrażanie aspektów (313)
- Aspekty wytwarzania (313)
- Aspekty produkcyjne (314)
- Programowanie aspektowe w zestawieniu z innymi koncepcjami wytwarzania oprogramowania (315)
- Podsumowanie (316)
- Informacje dodatkowe (317)
Rozdział 12. Optymalne kompilowanie systemów (321)
- Czas i ruch (322)
- Linia produkcji oprogramowania (322)
- Czas i ruch w kontekście wytwarzania oprogramowania (323)
- Proces kompilacji (323)
- Projektowanie procesu kompilacji (324)
- Wymagania platformy J2EE w zakresie kompilacji (325)
- Czym jest wdrażanie "na gorąco"? (327)
- Wprowadzenie do narzędzia Ant (328)
- Kompilacje minimalne w programie Ant (330)
- Znaczenie zależności kompilacji (330)
- Definiowanie zależności kompilacji w plikach Anta (333)
- Praca z podprojektami (336)
- Przeglądanie zależności kompilacji (337)
- Standardowe zadania kompilacji (339)
- Organizacja projektu (341)
- Katalog źródłowy (source) (341)
- Katalog bibliotek (lib) (343)
- Katalog plików skompilowanych (build) (343)
- Katalog plików gotowych do wdrożenia (344)
- Integracja ze środowiskami IDE (345)
- Rozszerzanie Anta o obsługę języka Jython (347)
- Tworzenie nowego zadania Anta (347)
- Kompilowanie klas Jythona (348)
- Testowanie nowego zadania (349)
- Podsumowanie (350)
- Informacje dodatkowe (350)
- Po co używać zintegrowanego środowiska wytwarzania? (354)
- Podstawowe funkcje środowisk IDE (354)
- Wprowadzenie do platformy Eclipse (358)
- Czym jest Eclipse? (358)
- Instalacja i uruchamianie środowiska Eclipse (359)
- Obszar roboczy platformy Eclipse (360)
- Platforma Eclipse jako warsztat pracy programisty (360)
- Rozszerzanie warsztatu pracy za pomocą dodatkowych modułów (362)
- Funkcjonalność środowisk IDE w kontekście wytwarzania oprogramowania korporacyjnego (364)
- Kreatory kodu (365)
- Obsługa edycji wielu typów plików (367)
- Integracja z narzędziem Ant (369)
- Praca z generatorami kodu (370)
- Sterowanie pracą serwera i wdrażanie aplikacji (372)
- Obsługa technik modelowania (374)
- Dostęp do bazy danych (374)
- Diagnozowanie aplikacji J2EE w ramach platformy Eclipse (375)
- Architektura programu uruchomieniowego platformy Javy (JPDA) (376)
- Diagnozowanie aplikacji J2EE (378)
- Wymiana "na gorąco" (380)
- Diagnozowanie stron JSP (382)
- Wskazówki dotyczące diagnozowania aplikacji (382)
- Podsumowanie (385)
- Informacje dodatkowe (385)
- Testowanie jako część procesu wytwarzania (388)
- Zalety wytwarzania sterowanego testami (389)
- Koszt wytwarzania sterowanego testami (390)
- Wprowadzenie do narzędzia JUnit (391)
- Wykonywanie testów szkieletu JUnit w środowisku Eclipse (395)
- Generowanie testów jednostkowych (397)
- Generowanie testów jednostkowych w środowisku Eclipse (397)
- Testy jednostkowe i architektura MDA (400)
- Generowanie przypadków testowych (401)
- Testowanie "od podszewki" (403)
- Czym jest obiekt pozorny? (404)
- Praca z obiektami pozornymi (406)
- Rodzaje obiektów pozornych (406)
- Ratunek w postaci dynamicznych obiektów pozornych (407)
- Wybór pomiędzy statycznymi a dynamicznymi obiektami pozornymi (411)
- Podsumowanie (412)
- Informacje dodatkowe (413)
- Zapewnianie jakości (416)
- Środowisko projektowe (417)
- Proces testowania (418)
- Testowanie projektów RAD (419)
- Automatyzacja testów (420)
- Testowanie rozwiązań J2EE (422)
- Narzędzia automatyzujące testy (423)
- Testy funkcjonalne (425)
- Wprowadzenie do narzędzia HttpUnit (426)
- HttpUnit i JUnit (427)
- Pisanie testów z wykorzystaniem interfejsu HttpUnit API (427)
- Testy obciążeniowe i wytrzymałościowe (431)
- Problematyka wydajności (432)
- Wprowadzenie do narzędzia JMeter (432)
- Testowanie aplikacji MedRec za pomocą szkieletu JMeter (433)
- Tworzenie grupy wątków (435)
- Element konfiguracyjny (436)
- Kontrolery logiczne (437)
- Elementy próbkujące (439)
- Elementy nasłuchujące (442)
- Wykonywanie planu testu (443)
- Analiza wyników (443)
- Wskazówki dotyczące korzystania ze szkieletu JMeter (445)
- Podsumowanie (447)
- Informacje dodatkowe (448)
Dodatek A Akronimy (451)
Dodatek B Bibliografia (455)
Skorowidz (459)