okladka

Poznaj możliwości szkieletu Spring
i usprawnij proces tworzenia aplikacji J2EE

Spring to szkielet wytwarzania aplikacji (framework), dzięki któremu proces budowania oprogramowania w języku Java dla platformy J2EE staje się znacznie prostszy i efektywniejszy. Spring oferuje usługi, które można z powodzeniem używać w wielu środowiskach -- od apletów po autonomiczne aplikacje klienckie, od aplikacji internetowych pracujących w prostych kontenerach serwletów po złożone systemy korporacyjne pracujące pod kontrolą rozbudowanych serwerów aplikacji J2EE. Spring pozwala na korzystanie z możliwości programowania aspektowego, znacznie sprawniejszą obsługę relacyjnych baz danych, błyskawiczne budowanie graficznych interfejsów użytkownika oraz integrację z innymi szkieletami takimi, jak Struts czy JSF.

Książka "Spring Framework. Profesjonalne tworzenie oprogramowania w Javie" odkryje przed Tobą wszystkie tajniki stosowania Springa w procesie wytwarzania systemów informatycznych dla platformy J2EE. Dowiesz się, jak efektywnie korzystać z najważniejszych składników szkieletu Spring i poznasz ich rolę w budowaniu aplikacji. Nauczysz się nie tylko tego, co można zrealizować za pomocą poszczególnych usług, ale także tego, w jaki sposób zrobić to najlepiej. W kolejnych ćwiczeniach przeanalizujesz proces tworzenie kompletnej aplikacji w oparciu o Spring.

W książce poruszono m.in. tematy:

  • Struktura szkieletu Spring
  • Tworzenie komponentów i definiowanie zależności pomiędzy nimi
  • Testowanie aplikacji i testy jednostkowe
  • Programowanie aspektowe w Spring
  • Połączenia z relacyjnymi bazami danych za pomocą JDBC
  • Zarządzanie transakcjami
  • Korzystanie z mechanizmu Hibernate
  • Zabezpieczanie aplikacji
  • Stosowanie szkieletu Web MVC

Przekonaj się, jak Spring może zmienić Twoją pracę
nad tworzeniem aplikacji J2EE.


Wstęp (19)
Rozdział 1. Wprowadzenie do Springa (27)
  • Dlaczego Spring? (27)
    • Problemy związane z tradycyjnym podejściem do programowania dla platformy J2EE (27)
    • Lekkie frameworki (31)
    • Podstawowe składniki Springa (32)
  • Zalety Springa (34)
  • Kontekst Springa (37)
    • Technologie (37)
    • Techniki (51)
    • Związki z pozostałymi frameworkami (52)
  • Budowa architektury aplikacji opartej na frameworku Spring (56)
    • Szerszy kontekst (57)
    • Trwałość i integracja (58)
    • Obiekty usług biznesowych (62)
    • Prezentacja (63)
  • Przyszłość (65)
    • Harmonogram wydawania kolejnych wersji (66)
    • Ewolucja Javy i platformy J2EE (66)
    • Współczesny kontekst technologiczny (69)
    • Standardy i otwarty dostęp do kodu źródłowego (69)
  • Projekt Spring i społeczność programistów (70)
    • Historia (71)
    • Krótkie omówienie modułów Springa (73)
    • Obsługiwane środowiska (78)
  • Podsumowanie (78)
Rozdział 2. Fabryka komponentów i kontekst aplikacji (81)
  • Odwracanie kontroli i wstrzykiwanie zależności (82)
    • Różne formy wstrzykiwania zależności (85)
    • Wybór pomiędzy wstrzykiwaniem przez metody ustawiające a wstrzykiwaniem przez konstruktory (89)
  • Kontener (91)
    • Fabryka komponentów (91)
    • Kontekst aplikacji (93)
    • Uruchamianie kontenera (95)
    • Korzystanie komponentów uzyskiwanych z fabryki (97)
    • Konfiguracja komponentów w formacie XML (98)
    • Podstawowa definicja komponentu (99)
    • Definiowanie zależności komponentów (102)
    • Zarządzanie cyklem życia komponentu (113)
    • Abstrakcja dostępu do usług i zasobów (116)
    • Wielokrotne wykorzystywanie tych samych definicji komponentów (122)
    • Stosowanie postprocesorów do obsługi niestandardowych komponentów i kontenerów (126)
  • Podsumowanie (133)
Rozdział 3. Zaawansowane mechanizmy kontenera (135)
  • Abstrakcje dla niskopoziomowych zasobów (136)
    • Kontekst aplikacji jako implementacja interfejsu ResourceLoader (136)
    • Kontekst aplikacji jako źródło komunikatów (139)
  • Zdarzenia aplikacji (142)
  • Zarządzanie kontenerem (145)
    • Ścieżki lokalizacji zasobów przekazywane do konstruktorów implementacji interfejsu ApplicationContext (145)
    • Deklaratywne korzystanie z kontekstów aplikacji (147)
    • Podział definicji kontenera na wiele plików (149)
    • Strategie obsługi modułów (151)
    • Singletony obsługujące dostęp do kontenera (154)
  • Pomocnicze komponenty fabrykujące (155)
    • Komponent PropertyPathFactoryBean (155)
    • Komponent FieldRetrievingFactoryBean (156)
    • Komponent MethodInvokingFactoryBean (157)
  • Edytory właściwości oferowane w ramach Springa (158)
  • Strategie testowania (159)
    • Testy jednostkowe (160)
    • Testy wykorzystujące kontener Springa (163)
  • Rozwiązania alternatywne względem konfiguracji w formacie XML (166)
    • Definicje konfiguracji w plikach właściwości (166)
    • Programowe definicje komponentów (168)
    • Pozostałe formaty (168)
  • Materiały dodatkowe (169)
  • Podsumowanie (169)
Rozdział 4. Spring i AOP (171)
  • Cele (171)
  • Założenia (173)
  • Przykład (173)
  • Framework programowania aspektowego Springa (177)
    • Łańcuch przechwytywania (178)
    • Zalety i wady (178)
    • Rada (180)
    • Przecięcia (186)
    • Doradcy (193)
    • Integracja z kontenerem IoC Springa (195)
    • Analizowanie i zmiana stanu pośrednika w czasie wykonywania programu (212)
    • Programowe tworzenie pośredników (213)
  • Korzystanie z zaawansowanych funkcji Spring AOP (214)
    • Źródła obiektów docelowych (214)
    • Wczesne kończenie łańcucha przechwytywania (221)
    • Stosowanie wprowadzeń (221)
    • Udostępnianie bieżącego pośrednika (224)
    • Udostępnianie bieżącego egzemplarza interfejsu MethodInvocation (225)
    • Zrozumienie typów pośredników (226)
    • Diagnozowanie i testowanie (228)
    • Rozmaitości (231)
  • Integracja z innymi frameworkami programowania aspektowego (234)
    • Cele (235)
    • Integracja z narzędziem AspectJ (235)
    • AspectWerkz (242)
  • Materiały dodatkowe (243)
  • Podsumowanie (243)
Rozdział 5. Obiekty DAO i framework Spring JDBC (245)
  • Wzorzec obiektów dostępu do danych (246)
  • Wprowadzenie do Spring JDBC (248)
    • Motywacja - problemy bezpośredniego korzystania z interfejsu JDBC (248)
    • W czym może pomóc Spring? (251)
    • Prosty przykład (251)
  • Budowa warstwy dostępu do danych dla przykładowej aplikacji (253)
    • Model danych stosowany w przykładowej aplikacji (253)
    • Źródło danych (254)
    • Tłumaczenie wyjątków (256)
  • Operacje klasy JdbcTemplate (259)
    • Stosowanie metod zwrotnych (259)
    • Metody pomocnicze klasy JdbcTemplate (261)
    • Wykonywanie prostych zapytań za pośrednictwem klasy JdbcTemplate (262)
    • Wykonywanie prostych aktualizacji za pośrednictwem klasy JdbcTemplate (263)
    • Zaawansowane zastosowania klasy JdbcTemplate (264)
    • Obsługa interfejsu RowSet (266)
  • Klasy obsługujące operacje na relacyjnych systemach zarządzania bazami danych (267)
    • Klasy SqlQuery i MappingSqlQuery (268)
    • Operacje wstawiania i aktualizacji realizowane za pomocą klasy SqlUpdate (271)
    • Aktualizowanie zbioru wynikowego za pomocą klasy UpdateSqlQuery (272)
    • Generowanie kluczy głównych (273)
    • Uzyskiwanie kluczy wygenerowanych przez bazę danych (274)
    • Wywoływanie procedur składowanych (275)
  • Zagadnienia zaawansowane (278)
    • Uruchamianie Spring JDBC na serwerze aplikacji (278)
    • Stosowanie niestandardowych mechanizmów tłumaczenia wyjątków (280)
    • Odczytywanie i zapisywanie danych obiektów LOB (284)
    • Aktualizacje wsadowe (289)
    • Zaawansowane techniki korzystania z procedur składowanych (290)
  • Zagadnienia dodatkowe (295)
    • Wydajność (295)
    • Kiedy należy używać biblioteki JDBC, a kiedy narzędzi odwzorowań obiektowo-relacyjnych? (296)
    • Wersje biblioteki JDBC i platformy J2EE (296)
  • Podsumowanie (297)
Rozdział 6. Zarządzanie transakcjami i źródłami danych (299)
  • Pojęcia podstawowe (299)
    • Czym jest transakcja? (300)
    • Właściwości ACID (300)
    • Sterowanie współbieżnością (303)
  • Transakcje i platforma J2EE (303)
    • Transakcje lokalne (304)
    • Transakcje globalne (rozproszone) (304)
    • Propagowanie transakcji (305)
    • Wyznaczanie granic pomiędzy transakcjami (305)
  • Przykład obsługi transakcji w Springu (306)
  • Wprowadzenie do oferowanej przez Spring warstwy abstrakcji ponad transakcjami (308)
    • Przegląd możliwych opcji sterowania transakcjami (310)
    • Definicja transakcji (312)
    • Status transakcji (314)
    • Strategie wyznaczania granic transakcji (314)
    • Strategie zarządzania transakcjami (328)
  • Deklaracje źródeł danych (338)
    • Źródła lokalne bez puli (338)
    • Źródła lokalne z pulą (339)
    • JNDI (340)
    • Wybór pomiędzy lokalnym źródłem danych a źródłem danych JNDI (341)
  • Podsumowanie (341)
Rozdział 7. Odwzorowania obiektowo-relacyjne (343)
  • Pojęcia podstawowe (344)
    • Podstawy odwzorowań obiektowo-relacyjnych (345)
    • Obiektowe języki zapytań (346)
    • Przezroczyste utrwalanie (347)
    • Kiedy należy korzystać z narzędzi odwzorowań obiektowo-relacyjnych? (348)
  • Obsługa odwzorowań obiektowo-relacyjnych w Springu (349)
    • Obiekty dostępu do danych (DAO) (349)
    • Zarządzanie transakcjami (350)
  • iBATIS SQL Maps (351)
    • Plik odwzorowania (352)
    • Implementacja interfejsu DAO (354)
    • Konfiguracja w kontekście Springa (356)
    • Zarządzanie transakcjami (357)
    • Podsumowanie analizy narzędzia iBATIS (359)
  • Hibernate (360)
    • Plik odwzorowań (362)
    • Implementacja interfejsu DAO (363)
    • Konfiguracja w kontekście Springa (366)
    • Zarządzanie transakcjami (370)
    • Otwarta sesja w widoku (377)
    • Obsługa obiektów BLOB i CLOB (381)
    • Hibernate: podsumowanie (383)
  • JDO (385)
    • Cykl życia trwałego obiektu (386)
    • Implementacje interfejsów DAO (387)
    • Konfiguracja kontekstu aplikacji Springa (389)
    • Zarządzanie transakcjami (391)
    • Cykl życia egzemplarza PersistenceManager (392)
    • Otwarty egzemplarz PersistenceManager w widoku (393)
    • Dialekt JDO (396)
    • Podsumowanie analizy technologii JDO (397)
  • Pozostałe narzędzia odwzorowań obiektowo-relacyjnych (399)
    • Apache OJB (399)
    • TopLink (401)
    • Cayenne (403)
    • Specyfikacja JSR-220 (403)
  • Podsumowanie (404)
Rozdział 8. Lekki framework zdalnego dostępu (407)
  • Pojęcia podstawowe i zakres tematyczny rozdziału (408)
  • Jednolity styl konfiguracji (410)
  • Hessian i Burlap (412)
    • Uzyskiwanie dostępu do usługi (414)
    • Eksportowanie usługi (416)
  • Obiekt wywołujący HTTP (417)
    • Uzyskiwanie dostępu do usługi (419)
    • Eksportowanie usługi (420)
    • Opcje konfiguracyjne (421)
  • RMI (422)
    • Uzyskiwanie dostępu do usługi (424)
    • Strategie wyszukiwania pieńków (426)
    • Eksportowanie usługi (428)
    • Opcje konfiguracyjne (429)
    • RMI-IIOP (429)
  • Usługi sieciowe przez JAX-RPC (430)
    • Uzyskiwanie dostępu do usługi (432)
    • Eksportowanie usługi (435)
    • Niestandardowe odwzorowania typów (437)
  • Podsumowanie (439)
Rozdział 9. Usługi wspomagające (443)
  • JMS (443)
    • Wprowadzenie (444)
    • Cele obsługi JMS w Springu (445)
    • Dostęp do JMS za pomocą szablonu (446)
    • Obsługa wyjątków (449)
    • Zarządzanie obiektem ConnectionFactory (449)
    • Konwertery komunikatów (450)
    • Zarządzanie miejscami docelowymi (451)
    • Zarządzanie transakcjami (453)
    • Klasa JmsGatewaySupport (453)
    • W przyszłości (455)
  • Planowanie w Springu (455)
    • Czasomierze a Quartz (456)
    • Czasomierze (457)
    • Framework Quartz (459)
  • Wysyłanie poczty elektronicznej w Springu (466)
    • Od czego zacząć? (466)
    • Wielokrotne stosowanie tej samej sesji pocztowej (467)
    • Wysyłanie wiadomości przy użyciu COS (468)
    • Menedżer poczty elektronicznej ogólnego zastosowania (468)
  • Zastosowanie języków skryptowych (473)
    • Spójny model (474)
    • Inne języki skryptowe (479)
  • Podsumowanie (479)
Rozdział 10. System bezpieczeństwa Acegi dla Springa (481)
  • Sposoby zabezpieczania aplikacji korporacyjnych (481)
    • Typowe wymagania (481)
    • System bezpieczeństwa Acegi w zarysie (483)
    • Usługa uwierzytelniania i autoryzacji Javy (488)
    • Specyfikacja serwletów (491)
  • Podstawy systemu bezpieczeństwa Acegi (493)
    • Uwierzytelnianie (493)
    • Przechowywanie obiektów Authentication (498)
    • Autoryzacja (500)
    • Bezpieczeństwo obiektów dziedziny (503)
  • Przykład (505)
    • Wprowadzenie do przykładowej aplikacji (505)
    • Implementacja pozbawiona mechanizmów bezpieczeństwa (507)
    • Rozwiązanie wykorzystujące zabezpieczenia (509)
    • Uwierzytelnianie (509)
    • Autoryzacja (510)
  • Podsumowanie (514)
Rozdział 11. Spring i EJB (517)
  • Określanie, czy stosowanie komponentów EJB jest potrzebne (518)
  • Dostęp do komponentów EJB (519)
    • Typowe rozwiązanie (520)
    • Rozwiązanie z wykorzystaniem Springa (521)
  • Tworzenie komponentów EJB w Springu (529)
    • Bezstanowe komponenty sesyjne (529)
    • Stanowe komponenty sesyjne (532)
    • Komponenty sterowane komunikatami (534)
    • Kilka słów o XDoclet (535)
  • Dostęp na zasadzie singletonu - rozwiązanie dobre czy złe? (536)
    • ContextSingletonBeanFactoryLocator i SingletonBeanFactoryLocator (537)
    • Wspólny kontekst jako "rodzic" kontekstu aplikacji sieciowej (540)
    • Stosowanie wspólnego kontekstu w komponentach EJB (543)
  • Zagadnienia związane z testowaniem (543)
    • Implementacja funkcjonalności biznesowej w zwyczajnych obiektach Javy (544)
    • Zastosowanie imitacji kontenera EJB (544)
    • Testy integracyjne w środowisku serwera aplikacji (545)
  • Podsumowanie (546)
Rozdział 12. Framework Web MVC (547)
  • Prosty przykład (548)
  • Ogólna architektura (550)
    • Pojęcia związane z Web MVC (550)
    • Ogólne działanie Web MVC wykorzystujące serwlet dyspozytora oraz kontrolery (551)
    • Wymagania dobrego sieciowego frameworku MVC (552)
    • Elementy Spring Web MVC (554)
  • Komponenty infrastruktury (556)
    • DispatcherServlet (557)
    • WebApplicationContext (560)
  • Przepływ sterowania związanego z przetwarzaniem żądań (563)
  • Typowy układ aplikacji Spring MVC (566)
  • Odwzorowania HandlerMapping (568)
    • BeanNameUrlHandlerMapping (568)
    • SimpleUrlHandlerMapping (569)
    • CommonsPathMapUrlHandlerMapping (571)
    • Więcej niż jedno odwzorowanie HandlerMapping (572)
  • HandlerExecutionChain oraz obiekty przechwytujące (573)
    • WebContentInterceptor (575)
    • UserRoleAuthorizationInterceptor (576)
    • Inne obiekty przechwytujące udostępniane przez Spring MVC (577)
  • Obiekty obsługi oraz ich adaptery (577)
  • ModelAndView oraz ViewResolver (577)
    • UrlBasedViewResolver (578)
    • BeanNameViewResolver oraz XmlViewResolver (579)
    • ResourceBundleViewResolver (579)
    • Tworzenie łańcucha obiektów ViewResolver (580)
  • Zmiana i wybór ustawień lokalnych (582)
  • Obiekty HandlerExceptionResolver (584)
  • Kontrolery (587)
    • WebContentGenerator (587)
    • AbstractController (587)
    • UrlFilenameViewController (588)
    • ParametrizableViewController (589)
    • MulitActionController (590)
  • Wiązanie danych (591)
    • Przydatne możliwości używane podczas wiązania danych (592)
  • Praktyczne przykłady zastosowania kontrolerów (593)
    • Przeglądanie listy przedstawień przy użyciu kontrolera AbstractController (594)
    • Rezerwacja miejsc (596)
  • Kreatory (606)
    • Podstawowa konfiguracja (606)
    • Metody szablonowe (607)
    • Przepływ sterowania kreatora (608)
    • Zmiany stron, numeracja oraz inne akcje (609)
  • Rozszerzanie infrastruktury obiektów obsługi (610)
  • Przesyłanie plików na serwer (611)
    • Konfiguracja resolvera (611)
    • Tworzenie formularza do przesyłania plików na serwer (612)
    • Obsługa przesłanych danych (612)
  • Testowanie kontrolerów (614)
    • Testowanie bez kontekstu aplikacji (614)
    • Bardziej szczegółowe testowanie przy użyciu obiektów pozornych (615)
    • Testowanie przy wykorzystaniu pełnego kontekstu aplikacji (616)
    • Inne sposoby testowania aplikacji (618)
  • Podsumowanie (618)
Rozdział 13. Technologie widoków (621)
  • Przykład (622)
    • Ogólna konfiguracja (623)
    • JavaServer Pages (623)
    • FreeMarker (624)
    • Generacja dokumentów PDF przy użyciu biblioteki iText (624)
  • Czynniki mające wpływ na wybór technologii generacji widoków (625)
  • Obiekty widoków i modeli (626)
  • Możliwości klasy AbstractView (628)
    • Zgłaszanie nowych żądań przy użyciu widoków RedirectView (629)
    • Użycie prefiksu widoku do generacji przekazań i przekierowań (631)
  • JavaServer Pages (631)
    • Konfiguracja aplikacji korzystającej z JSP (632)
    • Tworzenie formularzy przy użyciu znaczników niestandardowych (633)
    • Wykorzystanie plików znaczników do tworzenia elementów nadających się do wielokrotnego zastosowania (640)
  • Velocity oraz FreeMarker (642)
    • Konfiguracja resolvera widoków (642)
    • Stosowanie makr ułatwiających tworzenie formularzy (645)
  • Tiles (648)
  • Widoki bazujące na dokumentach XML i XSLT (652)
  • Widoki generujące arkusze Excela lub inne dokumenty (654)
    • Generacja arkusza kalkulacyjnego na podstawie listy przedstawień (654)
    • Wykorzystanie szablonów jako podstawy do generacji arkuszy kalkulacyjnych (656)
    • Inne widoki generujące dokumenty (656)
    • Zastosowanie obiektów przechwytujących HandlerInterceptor w celu rozróżniania wybranego typu odpowiedzi (657)
  • Implementacja widoków niestandardowych (659)
    • Interfejs View i klasa AbstractView (659)
    • Implementacja widoku generującego dane XML na podstawie obiektu danych (660)
    • Czynniki, jakie należy uwzględniać podczas tworzenia widoków niestandardowych (662)
  • Podsumowanie (662)
Rozdział 14. Integracja z innymi frameworkami sieciowymi (665)
  • Czynniki wpływające na wybór używanego frameworka MVC (666)
    • Porównanie tradycyjnych frameworków Web MVC (666)
  • Integracja z frameworkiem Spring. Pojęcia podstawowe (682)
  • Integracja z frameworkiem WebWork (684)
    • Przygotowanie obiektu ObjectFactory (684)
  • Integracja z frameworkiem Struts (685)
    • Stosowanie obiektów ActionSupport (686)
    • Stosowanie klas DelegatingRequestProcessor oraz DelegatingActionProxy (687)
    • Stosowanie bazowej akcji dysponującej możliwością automatycznego wiązania (691)
  • Integracja z frameworkiem Tapestry (692)
    • Pobieranie komponentów na potrzeby Tapestry (692)
    • Klasa strony (693)
    • Definicja strony (693)
    • Szablon strony (695)
    • Ostatnie informacje o integracji z frameworkiem Tapestry (696)
  • Integracja z JavaServer Faces (697)
  • Podsumowanie (698)
Rozdział 15. Aplikacja przykładowa (701)
  • Wybór technologii serwera (702)
  • Warstwy aplikacji (702)
  • Warstwa trwałości (704)
    • Model danych (704)
    • Model obiektów dziedziny (705)
    • Odwzorowania obiektowo-relacyjne (707)
    • Implementacja DAO (712)
    • Konfiguracja dostępu do danych (714)
  • Warstwa usług biznesowych (715)
    • Usługi (715)
    • Kontekst aplikacji (716)
  • Warstwa sieciowa (718)
    • Przepływ sterowania w aplikacji (718)
    • Konfiguracja aplikacji przy użyciu pliku web.xml (720)
    • Kontrolery sieciowe (721)
    • Technologia widoków (723)
  • Porównanie z implementacją przedstawioną w książce J2EE Design and Development (725)
    • Prostsza technologia (725)
    • Zmiany związane z bazą danych (725)
  • Konfiguracja serwera (726)
    • MySQL (726)
    • Tomcat (727)
  • Kompilacja aplikacji i jej wdrożenie (727)
    • Utworzenie tabel bazy danych i zapisanie w nich informacji (727)
    • Kompilacja aplikacji i wdrożenie jej na serwerze Tomcat (728)
  • Podsumowanie (728)
Rozdział 16. Wnioski (729)
  • Problemy, jakie rozwiązuje Spring (729)
  • Rozwiązania przyjęte w Springu (730)
  • Porady związane ze stosowaniem Springa (733)
    • Wybór technologii (733)
    • Warstwy aplikacji (736)
    • Struktura aplikacji (744)
    • Testowanie aplikacji (749)
  • Projekty związane z frameworkiem Spring (752)
    • System bezpieczeństwa Acegi Security (752)
    • Inne projekty (753)
  • Spring poza środowiskiem J2EE (754)
  • Poszukiwanie informacji dodatkowych (755)
    • Książki i artykuły (755)
    • Zasoby dostępne na stronach WWW (756)
    • Przykładowe aplikacje (757)
  • Przyszłość (758)
A Wymagania dla przykładowej aplikacji (761)
  • Przegląd (761)
  • Grupy użytkowników (762)
    • Publiczni użytkownicy internetowi (762)
    • Kasjerzy (763)
    • Administratorzy (763)
  • Założenia (764)
  • Ograniczenia zakresu aplikacji (765)
  • Terminarz prac (765)
  • Interfejs użytkowników internetowych (766)
    • Podstawowy schemat działania (766)
    • Obsługa błędów (767)
    • Ekrany aplikacji (767)
  • Wymagania niefunkcjonalne (780)
  • Środowisko sprzętowe i programowe (782)
Skorowidz (785)