• Poznaj sprawdzone metodologie i procesy
• Naucz się stosować praktyczne technologie i narzędzia
• Twórz w Javie kompletne rozwiązania w optymalny sposób

Chciałbyś tworzyć rozbudowane aplikacje w języku Java szybciej i w prostszy sposób? Liczne narzędzia i technologie budowania programów w Javie często ułatwiają wykonywanie niektórych zadań, ale jednocześnie niepotrzebnie komplikują i wydłużają proces powstawania gotowych produktów. Jak dobrać odpowiednie techniki i zastosować metodologię, która usprawni i przyspieszy pracę? Niektórzy już to wiedzą -- Ty też możesz skorzystać z ich doświadczeń!

"Java. Tworzenie aplikacji sieciowych za pomocą Spring, Hibernate i Eclipse" to praktyczny poradnik opisujący wydajną i sprawdzoną metodologię szybkiego pisania oprogramowania w języku Java. Dzięki tej książce poznasz techniki programowania ekstremalnego oraz metodologii Agile i nauczysz się stosować je podczas pracy nad programami. Dowiesz się, jak zaprojektować aplikację, przygotować środowisko i korzystać z wiersza poleceń oraz proponowanego zestawu narzędzi -- platformy Spring, mechanizmu odwzorowań Hibernate i IDE Eclipse -- co pozwoli Ci w prosty sposób użyć zaawansowanych rozwiązań.

• Techniki programowania ekstremalnego (XP)
• Wprowadzenie do metodologii Agile
• Korzystanie z platformy Spring
• Utrwalanie obiektów za pomocą Hibernate
• Praca w IDE Eclipse
• Debugowanie oprogramowania
• Monitorowanie i profilowanie aplikacji
• Refaktoryzacja kodu

Zwiększ swą wydajność dzięki zastosowaniu efektywnych procesów i narzędzi do tworzenia oprogramowania w języku Java.

Osoby które kupowały "Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse", wybierały także:

• Zrozum struktury danych. Algorytmy i praca na danych w Javie 39,67 zł, (11,90 zł -70%)
• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Java. Najlepsze rozwiązania zadań programistycznych. Receptury. Wydanie IV 115,81 zł, (35,90 zł -69%)
• Programowanie w Javie. Solidna wiedza w praktyce. Wydanie XI 173,87 zł, (53,90 zł -69%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)

Spis treści

Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse -- spis treści

Przedmowa (13)

O autorze (17)

Podziękowania (19)

Wstęp (23)

Część I Wprowadzenie (31)

Rozdział 1. Wstęp (33)

• Co jest omawiane w tym rozdziale? (34)
  
• Technologie użyte w tej książce (34)
  
  • Technologie uruchomieniowe (36)
  • Narzędzia programistyczne (38)
• Metodologie wytwarzania oprogramowania użyte w tej książce (42)
  
• Podsumowanie (43)
  
• Rekomendowane źródła (43)

Rozdział 2. Przykładowa aplikacja: Time Expression (45)

• Co jest omawiane w tym rozdziale? (46)
  
• Wymagania biznesowe (47)
  
• Metodologie wytwarzania oprogramowania (48)
  
  • Informacje wstępne o XP i AMDD (48)
  • Etap badań (50)
  • Etap planowania (51)
  • Etap wydania a iteracje (etapowe wytwarzanie oprogramowania) (52)
  • Zakres projektu (52)
  • Utrzymanie (53)
• Stosujemy XP i AMDD w naszej przykładowej aplikacji (53)
  
  • Model domenowy (53)
  • Prototyp interfejsu użytkownika (UI) (53)
  • Scenopis (57)
  • Historie użytkownika (57)
  • Plan wydań (i iteracji) (60)
  • Słownik (61)
  • Architektura tablicowa (62)
• Uwaga na temat oprogramowania Wiki (63)
  
• Podsumowanie (63)
  
• Rekomendowane źródła (64)

Część II Tworzymy przykładową aplikację (65)

Rozdział 3. Metodologie XP i AMDD (67)

• Co jest omawiane w tym rozdziale? (68)
  
• Projektowanie i wybór artefaktów (69)
  
• Diagram architektury (70)
  
• Od historii użytkownika do projektu (71)
  
• Analizujemy klasy przy pomocy kart CRC (71)
  
• Mapa przepływu aplikacji (artefakt domowej roboty) (73)
  
  • Technika uzupełniająca (74)
  • Rozszerzamy mapę przepływu aplikacji o kolumny CRUD (74)
• UML - diagram klas (74)
  
• Diagramy pakietów UML (76)
  
• Struktura katalogów (77)
  
• Przykładowe nazwy plików (77)
  
• Wytwarzanie oprogramowania od początku do końca (78)
  
• Testy akceptacyjne (78)
  
  • Logowanie (79)
  • Lista kart pracy (79)
  • Wprowadź godziny (79)
• Inne rozważania (79)
  
• Podsumowanie (80)
  
• Rekomendowane źródła (82)

Rozdział 4. Konfiguracja środowiska: JDK, Ant i JUnit (83)

• Co jest omawiane w tym rozdziale? (84)
  
• Java Platform Standard Edition Development Kit (JDK) (84)
  
• Struktura katalogów (85)
  
• Ant (86)
  
  • Prosty plik budujący (86)
  • Złożony plik budujący (87)
• JUnit (90)
  
  • Samodzielnie uruchomiony JUnit (91)
  • JUnit z poziomu Eclipse (92)
• SimpleTest: sprawiamy, że wszystkie narzędzia współpracują razem (92)
  
  • SimpleTest.java (93)
  • Rodzaje metod assert w JUnit (93)
  • Uruchamiamy SimpleTest (pojedynczy test JUnit) (94)
  • Uruchamiamy testy JUnit jako zadanie Anta (95)
• Wstępne testy i refaktoryzacja (96)
  
• Podsumowanie (97)
  
• Rekomendowane źródła (98)

Rozdział 5. Hibernate - zapewniamy trwałość obiektów (99)

• Co jest omawiane w tym rozdziale? (100)
  
• Zarys odwzorowania obiektowo-relacyjnego (Object-Relational Mapping - ORM) (101)
  
  • Relacje i liczebność (102)
  • Tożsamość obiektu (103)
  • Kaskada (103)
  • Odwzorowanie (103)
  • Obiekty w pamięci kontra obiekty trwałe (104)
• Projekt naszej przykładowej bazy danych (104)
  
  • Denormalizacja (104)
  • Konwencje nazewnicze (105)
  • Uwagi do projektowania bazy danych (106)
  • Skrypt DDL (106)
• Gdzie w naszej aplikacji znajduje się HSQLDB i Hibernate? (107)
  
• HSQLDB (108)
  
  • Serwer HSQLDB i przydatne zadania Anta (108)
  • HSQLDB Database Manager i SqlTool (109)
  • Tryby persistent i in-memory w HSQLDB (109)
  • Dołączamy HSQLDB do archiwum naszej aplikacji (110)
• Pracujemy z Hibernate (110)
  
  • Nie potrzeba DAO ani DTO (111)
  • Obsługiwane bazy danych (111)
  • Hibernate i EJB 3.x (111)
  • Przykładowy test konfiguracji Hibernate (112)
  • Instalacja Hibernate (115)
  • Podstawy pracy z Hibernate (117)
  • Tworzymy TimesheetManager.java, korzystając z Hibernate (120)
  • Employee.* i DepartmentManager.java (124)
  • Pliki wymagane w ścieżce klas (124)
  • Uruchamiamy zestaw testów przy pomocy Anta (124)
  • Usuwamy rekordy (125)
  • Interfejs Criteria (125)
  • Obsługa wyjątków (126)
• Pozostałe funkcje Hibernate (127)
  
  • Asocjacje (127)
  • Blokowanie obiektów (kontrola współbieżności) (127)
  • Jeszcze więcej Hibernate (129)
• Podsumowanie (129)
  
• Rekomendowane źródła (130)

Rozdział 6. Wprowadzenie do Spring Framework (133)

• Co jest omawiane w tym rozdziale? (135)
  
• Czym jest Spring? (135)
  
• Pakiety Springa służące do rozwijania aplikacji (136)
  
• Pakiety Springa służące do wdrażania aplikacji (137)
  
• Przegląd modułów Springa (138)
  
  • Spring Core (138)
  • Spring Context (138)
  • Spring AOP (138)
  • Spring DAO (138)
  • Spring ORM (140)
• Gdzie w naszej architekturze jest miejsce Spring Framework? (140)
  
• Korzyści płynące z użycia Springa (141)
  
• Główne koncepcje Springa (142)
  
  • Wzorzec wstrzykiwania zależności (i kontenery IoC) (143)
  • Dwa style wstrzykiwana (143)
  • Bean, BeanFactory i ApplicationContext (144)
  • Edytory właściwości (146)
• Podprojekty Springa (146)
  
• Podsumowanie (147)
  
• Rekomendowane źródła (147)

Rozdział 7. Framework Spring Web MVC (149)

• Co jest omawiane w tym rozdziale? (150)
  
• Zalety Spring MVC (150)
  
• Pojęcia związane ze Spring Web MVC (152)
  
  • Spring MVC a Java (152)
  • Konfiguracja Spring MVC (155)
• Konfiguracja Springa dla Time Expression (156)
  
  • Instalowanie kontenera serwletów (Apache Tomcat) (157)
  • Instalowanie Spring Framework (158)
  • Uruchomienie SpringTest (159)
  • Konfiguracja Spring MVC (159)
• Budowanie interfejsu użytkownika z pomocą Springa (160)
  
  • Ekran: Lista kart pracy (160)
  • Ekran: Wprowadź godziny (161)
• Kaskadowe arkusze stylów (Cascading Style Sheets - CSS) (162)
  
• Ekran: Lista kart pracy - przykład kontrolera bez formularza (163)
  
  • Konfiguracja krok po kroku (163)
  • Kodowanie krok po kroku (164)
• Ekran: Wprowadź godziny - przykład kontrolera formularza (168)
  
  • Konfiguracja krok po kroku (168)
  • Kodowanie krok po kroku (170)
  • Wiązanie do niestandardowych (niebiznesowych) obiektów polecenia (174)
  • DateUtil.java (175)
  • Dyrektywy taglib w JSP (175)
• Widok bez kontrolera (175)
  
• Obiekty przechwytujące w Springu (175)
  
  • Uwierzytelnianie w Time Expression (176)
• Nasza przykładowa aplikacja - pierwsze uruchomienie (177)
  
• Nowe biblioteki znaczników w Spring Framework 2.0 (177)
  
• Słowo o Spring Web Flow i Portlet API (180)
  
  • Spring Web Flow (180)
  • Spring Portlet API (180)
• Podsumowanie (181)
  
• Rekomendowane źródła (181)

Rozdział 8. Fenomen środowiska Eclipse (183)

• Co jest omawiane w tym rozdziale? (184)
  
• Fundacja Eclipse (185)
  
• Eclipse - platforma i projekty (186)
  
• Koncepcje związane z Eclipse SDK (188)
  
  • Workspace - przestrzeń projektów (189)
  • Workbench - obszar roboczy, perspektywy, edytory i widoki (189)
  • Projekt (191)
  • Pluginy (192)
  • Kreatory (192)
• Instalacja Eclipse (192)
  
• Konfiguracja Eclipse na potrzeby Time Expression (195)
  
• Java Development Tools (JDT) - narzędzia programistyczne dla Javy (200)
  
• Instalacja pluginów WTP - zestawu narzędzi do rozwoju aplikacji sieciowych (208)
  
• Praca z Eclipse - rozwijamy Time Expression (209)
  
  • Wbudowane pluginy JDT (210)
  • Plugin z kategorii Data (dla HSQLDB) (212)
  • Pluginy do obsługi serwerów (dla Tomcata) (212)
  • Plugin Hibernate (214)
  • Plugin Spring IDE (215)
  • Inne godne uwagi pluginy WTP (217)
• Więcej Eclipse? Tak, jest pełno pluginów (217)
  
  • Projekty Eclipse.org (217)
  • Katalogi pluginów (218)
  • MyEclipseIDE.com (218)
  • Google.com (219)
• Wsparcie dla pracy zespołowej w Eclipse (219)
  
• System pomocy w Eclipse (220)
  
• Wskazówki i porady (220)
  
  • Skróty klawiaturowe (221)
  • Preferencje (224)
  • Zakładki (225)
  • Uruchamianie zewnętrznych narzędzi i przeglądarki WWW (225)
  • Historia lokalna (226)
  • Resetowanie perspektywy (226)
  • Kopiowanie elementów (226)
  • Czyszczenie projektów (226)
  • Konwersja znaków końca linii (227)
  • Parametry startowe Eclipse/JVM (227)
  • Przeglądanie obcego kodu (227)
  • Ukryte pliki Eclipse (227)
• Deinstalowanie Eclipse (227)
  
• Subiektywne porównanie do IntelliJ i NetBeans (228)
  
  • IntelliJ 5.0 (228)
  • NetBeans 5.0 (229)
  • Porównanie czasów uruchomienia (230)
• Podsumowanie (231)
  
• Rekomendowane źródła (232)

Część III Zaawansowane cechy (233)

Rozdział 9. Zapis logów, debugowanie, monitorowanie i profilowanie (235)

• Co jest omawiane w tym rozdziale? (236)
  
• Opis koncepcji zapisu logów (237)
  
• Zapis logów przy użyciu biblioteki Jakarta Commons Logging (z wykorzystaniem Log4j oraz JDK) (238)
  
  • Jak działa JCL? (239)
  • Programowanie z użyciem JCL (239)
  • Priorytety komunikatów (240)
  • Przykład zapisu logów w TimesheetListController (241)
  • Uwaga na temat klas formatujących (242)
  • Wykorzystanie logowania w Spring i Hibernate (242)
• Debugowanie aplikacji w Javie z wykorzystaniem środowiska Eclipse (242)
  
  • Koncepcje i cechy debugera JDT (243)
• Debugowanie aplikacji internetowych z użyciem Firefoksa (247)
  
  • Debuger JavaScript (247)
  • Web Developer (248)
  • Inne rozszerzenia Firefoksa (248)
  • Konsola JavaScript (249)
• Całościowe debugowanie klasy TimesheetManagerTest (od przeglądarki do bazy danych) (249)
  
• Zarządzanie i monitorowanie z wykorzystaniem technologii JMX (251)
  
• Programy profilujące w Javie (252)
  
• Porady przy debugowaniu (252)
  
• Podsumowanie (253)
  
• Rekomendowane źródła (254)

Rozdział 10. Elementy zaawansowane (257)

• Co jest omawiane w tym rozdziale? (258)
  
• Nowości w Javie 1.5 (258)
  
  • Importy statyczne (259)
  • Typy sparametryzowane - generics (259)
  • Ulepszone pętle (259)
  • Automatyczne opakowywanie - autoboxing (260)
  • Typ wyliczeniowy - enum (260)
  • Zmienna liczba argumentów (260)
  • Inne nowości (261)
• Zadania narzędzia Ant (261)
  
  • CVS (262)
  • Exec (262)
  • Get (262)
  • Sleep (262)
  • Ftp (263)
  • Mail (263)
  • Obfitość zadań! (263)
• JUnit (264)
  
  • Niestandardowe zestawy testowe (264)
  • Powtarzający się kod (264)
• Hibernate (265)
  
  • Natywne zapytania SQL (265)
  • Obiekty przechwytujące (266)
• Spring Framework (266)
  
  • Zadania zaplanowane (267)
  • Spring - wsparcie dla poczty elektronicznej (268)
  • Wsparcie dla JMX (269)
  • Więcej Springa (271)
• Integracja Spring i Hibernate (272)
  
  • Konfiguracja zarządzania transakcjami w Spring (272)
  • Mniejszy i czystszy kod (274)
  • Testy jednostkowe naszego zintegrowanego kodu (276)
  • Podejście bazujące na interfejsie (276)
• Biblioteka znaczników JSP (277)
  
  • Displaytag (277)
  • Własna biblioteka znaczników (278)
• Refaktoryzacja (279)
  
  • Przykłady refaktoryzacji w naszej aplikacji (279)
  • Refaktoryzuj bezlitośnie, ale... zachowaj kopię kodu (280)
  • Zasoby internetowe związane z refaktoryzacją (refactoring.com i agiledata.org) (281)
  • Uwaga na temat refaktoryzacji w Eclipse (281)
• Inne rozważania (281)
  
  • Zarządzanie transakcjami (281)
  • Bezpieczeństwo aplikacji (283)
  • Obsługa wyjątków (285)
• Łączenie w klastry (287)
  
• Wielowątkowość (287)
  
• Uwaga na aplikacje Javy z GUI (grubych klientów) (288)
  
• Zarządzanie konfiguracją środowisk (289)
  
• AJAX - Asynchroniczny JavaScript i XML (290)
  
• Javadoc i komentarze (290)
  
• Cały system w jednym pliku WAR (291)
  
• Podsumowanie (291)
  
• Rekomendowane źródła (292)

Rozdział 11. Co dalej? (293)

• Co jest omawiane w tym rozdziale? (294)
  
• Jak ukończyć aplikację Time Expression (294)
  
• Metodologie XP i AMDD (295)
  
• Platforma Java (295)
  
• Ant (295)
  
• JUnit (296)
  
• Hibernate (296)
  
• Spring Framework (297)
  
• Eclipse SDK (297)
  
• Zapis logów, debugowanie, monitorowanie i profilowanie (298)
  
• Gdzie szukać pomocy? (299)
  
  • Fora dyskusyjne (299)
  • Javadoc i kod źródłowy (299)
• Krótka uwaga na temat narzędzi do sprawdzania "jakości" kodu (300)
  
• Podsumowanie (300)
  
• Rekomendowane źródła (301)

Rozdział 12. Końcowe przemyślenia (303)

• Moje plany na najbliższą przyszłość (304)
  
• Przyszłość, metodologia Agile, technologia Java (304)
  
• Wiwat! (305)

Część IV Dodatki (307)

Dodatek A Kod źródłowy (309)

• Współdzielony katalog bibliotek zewnętrznych (309)
  
• Katalog przykładowej aplikacji (310)
  
  • Pliki Ant (311)
  • Pliki bazy danych HSQLDB (311)
  • Konfiguracja (pliki) Javy (311)
• Katalog przykładowej aplikacji - wersja po refaktoryzacji (313)
  
• Integracja Spring i Hibernate - katalog przykładowej aplikacji (313)

Dodatek B Kończymy refaktoryzować kod przykładowej aplikacji (315)

• SignInController.java: monitorowanie JMX (315)
  
• TimesheetListController.java: monitorowanie JMX (316)
  
• Klasy zarządzające: integracja Spring i Hibernate (316)
  
• timesheetlist.jsp: przechodzimy na plik dołączany i bibliotekę Displaytag (317)
  
• enterhours.jsp: przechodzimy na plik dołączany i bibliotekę znaczników Timex Tag (318)
  
• Klasy *Test i TimexTestCase (318)
  
• DateUtil.java: nowa metoda (319)
  
• timex.css: nowe style (319)
  
• timexhsqldb.xml: naprawiamy błąd w danych (319)

Dodatek C Konwencje pisania kodu w Javie (321)

Dodatek D Zabezpieczamy aplikację sieciową (323)

Dodatek E Ściągawka z przykładowego procesu wytwarzania oprogramowania (325)

• Początki projektu (325)
  
• Faza badań (326)
  
• Planowanie (326)
  
• Iteracyjne wytwarzanie oprogramowania (326)

Dodatek F Ściągawka z modelowania Agile (327)

Dodatek G Ściągawka z programowania ekstremalnego (XP) (329)

Dodatek H Ciekawe narzędzia (331)

• Narzędzia wieloplatformowe (331)
  
• Narzędzia dla Windows (332)
  
• Narzędzia dla Mac OS X (333)
  
• Narzędzia dla Linuksa (KDE) (333)

Dodatek I Badania Visual Patterns (335)

• Definicja problemu (335)
  
• Przeszłość: jak oszukiwaliśmy sami siebie (335)
  
• Przyszłość: metody Agile (337)
  
• Mój punkt widzenia (338)
  
  • BRUF i BDUF (339)
  • Terminologia (339)
• Chcesz dołączyć do społeczności? (339)

Skorowidz (341)