Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse

Autor: Anil Hemrajani

Szczegóły książki w Helionie
Tytuł oryginału: Agile Java Development with Spring, Hibernate and Eclipse
ISBN: 978-83-246-0682-5
Cena: 47 zł
Oprawa: miękka
Format: B5
Data wydania: 2007.06.11
Liczba stron: 352
Przykładowy rozdział: ftp://ftp.helion.pl/online/javatw/javatw-3.pdf
Kategoria: Java

Tworzenie zaawansowanych projektów korporacyjnych w Javie

  • 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.

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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań