Przedmowa (11)

Podziękowania (13)

O książce (15)

Część 1. Podstawy frameworka Spring

Rozdział 1. Zrywamy się do działania (21)

• 1.1. Upraszczamy programowanie w Javie (22)
  • 1.1.1. Uwalniamy moc zawartą w POJO (23)
  • 1.1.2. Wstrzykujemy zależności (25)
  • 1.1.3. Stosujemy aspekty (29)
  • 1.1.4. Ograniczamy stosowanie kodu szablonowego dzięki wzorcom (33)
• 1.2. Kontener dla naszych komponentów (36)
  • 1.2.1. Pracujemy z kontekstem aplikacji (37)
  • 1.2.2. Cykl życia komponentu (37)
• 1.3. Podziwiamy krajobraz Springa (39)
  • 1.3.1. Moduły Springa (39)
  • 1.3.2. Rodzina projektów wokół Springa (42)
• 1.4. Co nowego w Springu (46)
  • 1.4.1. Co nowego w Springu 2.5? (46)
  • 1.4.2. Co nowego w Springu 3.0? (47)
  • 1.4.3. Co nowego w rodzinie projektów otaczających Springa? (47)
• 1.5. Podsumowanie (48)

Rozdział 2. Tworzymy powiązania między komponentami (49)

• 2.1. Deklarujemy komponenty (50)
  • 2.1.1. Tworzymy konfigurację Springa (51)
  • 2.1.2. Deklarujemy prosty komponent (51)
  • 2.1.3. Wstrzykujemy przez konstruktory (53)
  • 2.1.4. Ustalamy zakres komponentów (58)
  • 2.1.5. Inicjalizujemy i likwidujemy komponenty (59)
• 2.2. Wstrzykujemy wartości do właściwości komponentu (61)
  • 2.2.1. Wstrzykujemy proste wartości (62)
  • 2.2.2. Wstrzykujemy referencje do innych beanów (63)
  • 2.2.3. Wiążemy właściwości w przestrzeni nazw p Springa (66)
  • 2.2.4. Wiążemy kolekcje (67)
  • 2.2.5. Wiążemy nic (null) (72)
• 2.3. Wiążemy za pomocą wyrażeń (72)
  • 2.3.1. Podstawy wyrażeń w SpEL (73)
  • 2.3.2. Wykonujemy operacje na wartościach w języku SpEL (76)
  • 2.3.3. Przesiewamy kolekcje za pomocą SpEL (80)
• 2.4. Podsumowanie (83)

Rozdział 3. Ograniczamy użycie języka XML w konfiguracji Springa (85)

• 3.1. Automatycznie wiążemy właściwości komponentów (86)
  • 3.1.1. Cztery rodzaje automatycznego wiązania (86)
  • 3.1.2. Domyślny styl automatycznego wiązania (90)
  • 3.1.3. Mieszamy wiązanie automatyczne i jawne (91)
• 3.2. Wiążemy za pomocą adnotacji (92)
  • 3.2.1. Korzystamy z adnotacji @Autowired (92)
  • 3.2.2. Stosujemy automatyczne wiązanie zgodne ze standardami, korzystając z adnotacji @Inject (97)
  • 3.2.3. Posługujemy się wyrażeniami podczas wstrzykiwania przez adnotacje (99)
• 3.3. Automatyczne wykrywanie komponentów (100)
  • 3.3.1. Oznaczamy komponenty adnotacjami dla automatycznego wykrywania (100)
  • 3.3.2. Dodajemy filtry do skanera komponentów (102)
• 3.4. Używamy w Springu konfiguracji opartej na Javie (103)
  • 3.4.1. Przygotowujemy się do stosowania konfiguracji opartej na Javie (103)
  • 3.4.2. Definiujemy klasę konfiguracyjną (104)
  • 3.4.3. Deklarujemy prosty komponent (104)
  • 3.4.4. Wstrzykujemy w Springu za pomocą konfiguracji opartej na Javie (105)
• 3.5. Podsumowanie (106)

Rozdział 4. Aspektowy Spring (107)

• 4.1. Czym jest programowanie aspektowe (108)
  • 4.1.1. Definiujemy terminologię dotyczącą AOP (109)
  • 4.1.2. Obsługa programowania aspektowego w Springu (112)
• 4.2. Wybieramy punkty złączenia za pomocą punktów przecięcia (115)
  • 4.2.1. Piszemy definicje punktów przecięcia (116)
  • 4.2.2. Korzystamy z desygnatora bean() w Springu (117)
• 4.3. Deklarujemy aspekty w języku XML (117)
  • 4.3.1. Deklarujemy porady before i after (119)
  • 4.3.2. Deklarujemy poradę around (121)
  • 4.3.3. Przekazujemy parametry do porady (123)
  • 4.3.4. Wprowadzamy nową funkcjonalność przez aspekty (125)
• 4.4. Używamy adnotacji dla aspektów (127)
  • 4.4.1. Tworzymy poradę around za pomocą adnotacji (129)
  • 4.4.2. Przekazujemy argumenty do porad konfigurowanych przez adnotacje (130)
  • 4.4.3. Tworzymy wprowadzenie za pomocą adnotacji (131)
• 4.5. Wstrzykujemy aspekty z AspectJ (132)
• 4.6. Podsumowanie (135)

Część 2. Podstawy aplikacji Springa

Rozdział 5. Korzystanie z bazy danych (139)

• 5.1. Filozofia dostępu do danych Springa (140)
  • 5.1.1. Hierarchia wyjątków związanych z dostępem do danych w Springu (141)
  • 5.1.2. Szablony dostępu do danych (143)
  • 5.1.3. Klasy bazowe DAO (145)
• 5.2. Konfiguracja źródła danych (147)
  • 5.2.1. Źródła danych JNDI (147)
  • 5.2.2. Źródła danych z pulą (147)
  • 5.2.3. Źródło danych oparte na sterowniku JDBC (149)
• 5.3. Używanie JDBC w Springu (149)
  • 5.3.1. Kod JDBC a obsługa wyjątków (150)
  • 5.3.2. Praca z szablonami JDBC (153)
• 5.4. Integracja Hibernate ze Springiem (158)
  • 5.4.1. Przegląd Hibernate (159)
  • 5.4.2. Deklarowanie fabryki sesji Hibernate (160)
  • 5.4.3. Hibernate bez Springa (162)
• 5.5. Spring i Java Persistence API (163)
  • 5.5.1. Konfiguracja fabryki menedżerów encji (164)
  • 5.5.2. Klasa DAO na bazie JPA (168)
• 5.6. Podsumowanie (169)

Rozdział 6. Zarządzanie transakcjami (171)

• 6.1. Zrozumienie transakcji (172)
  • 6.1.1. Cztery słowa kluczowe do zrozumienia transakcji (173)
  • 6.1.2. Zrozumienie obsługi zarządzania transakcjami w Springu (174)
• 6.2. Wybór menedżera transakcji (175)
  • 6.2.1. Transakcje JDBC (175)
  • 6.2.2. Transakcje Hibernate (176)
  • 6.2.3. Transakcje Java Persistence API (177)
  • 6.2.4. Transakcje Java Transaction API (178)
• 6.3. Programowanie transakcji w Springu (178)
• 6.4. Deklarowanie transakcji (180)
  • 6.4.1. Definiowanie atrybutów transakcji (180)
  • 6.4.2. Deklarowanie transakcji w XML (184)
  • 6.4.3. Definiowanie transakcji sterowanych adnotacjami (186)
• 6.5. Podsumowanie (187)

Rozdział 7. Budowanie aplikacji sieciowych za pomocą Spring MVC (189)

• 7.1. Wprowadzenie do Spring MVC (190)
  • 7.1.1. Cykl życia żądania w Spring MVC (190)
  • 7.1.2. Konfiguracja Spring MVC (192)
• 7.2. Budowa podstawowego kontrolera (193)
  • 7.2.1. Konfiguracja Spring MVC sterowanego adnotacjami (194)
  • 7.2.2. Definiowanie kontrolera strony głównej (195)
  • 7.2.3. Produkowanie widoków (198)
  • 7.2.4. Definiowanie widoku strony głównej (202)
  • 7.2.5. Dopracowanie kontekstu aplikacji Springa (203)
• 7.3. Kontroler obsługujący dane wprowadzane przez użytkownika (205)
  • 7.3.1. Budowa kontrolera przetwarzającego dane wprowadzane przez użytkownika (205)
  • 7.3.2. Wyświetlenie widoku (207)
• 7.4. Przetwarzanie formularzy (208)
  • 7.4.1. Wyświetlenie formularza rejestracyjnego (209)
  • 7.4.2. Przetwarzanie formularza (211)
  • 7.4.3. Walidacja przesyłanych danych (213)
• 7.5. Obsługa plików wysyłanych na serwer (217)
  • 7.5.1. Dodanie pola selektora plików do formularza (217)
  • 7.5.2. Odbieranie plików wysyłanych na serwer (218)
  • 7.5.3. Konfiguracja Springa do przesyłania plików na serwer (221)
• 7.6. Podsumowanie (221)

Rozdział 8. Praca ze Spring Web Flow (223)

• 8.1. Instalacja Spring Web Flow (224)
  • 8.1.1. Konfiguracja Spring Web Flow (224)
• 8.2. Składowe przepływu (227)
  • 8.2.1. Stany (227)
  • 8.2.2. Przejścia (230)
  • 8.2.3. Dane przepływu (231)
• 8.3. Łączymy wszystko w całość: zamówienie pizzy (233)
  • 8.3.1. Definiowanie bazowego przepływu (233)
  • 8.3.2. Zbieranie informacji o kliencie (237)
  • 8.3.3. Budowa zamówienia (242)
  • 8.3.4. Przyjmowanie płatności (245)
• 8.4. Zabezpieczanie przepływu (247)
• 8.5. Podsumowanie (247)

Rozdział 9. Zabezpieczanie Springa (249)

• 9.1. Wprowadzenie do Spring Security (250)
  • 9.1.1. Rozpoczynamy pracę ze Spring Security (250)
  • 9.1.2. Konfiguracyjna przestrzeń nazw Spring Security (251)
• 9.2. Zabezpieczanie żądań sieciowych (252)
  • 9.2.1. Pośredniczenie w dostępie do filtrów serwletów (252)
  • 9.2.2. Minimalna konfiguracja bezpieczeństwa sieciowego (253)
  • 9.2.3. Przechwytywanie żądań (257)
• 9.3. Zabezpieczanie elementów na poziomie widoku (259)
  • 9.3.1. Dostęp do informacji uwierzytelniających (260)
  • 9.3.2. Wyświetlanie z uprawnieniami (261)
• 9.4. Uwierzytelnianie użytkowników (263)
  • 9.4.1. Konfiguracja repozytorium w pamięci operacyjnej (263)
  • 9.4.2. Uwierzytelnianie za pomocą bazy danych (264)
  • 9.4.3. Uwierzytelnianie za pomocą LDAP (266)
  • 9.4.4. Włączenie funkcji "pamiętaj mnie" (269)
• 9.5. Zabezpieczanie metod (270)
  • 9.5.1. Zabezpieczanie metod z adnotacją @Secured (270)
  • 9.5.2. Adnotacja @RolesAllowed ze specyfikacji JSR-250 (271)
  • 9.5.3. Zabezpieczenia przed wykonaniem metody ze SpEL i po jej wykonaniu (271)
  • 9.5.4. Deklaracja przecięć bezpieczeństwa na poziomie metody (276)
• 9.6. Podsumowanie (276)

Część 3. Integracja w Springu

Rozdział 10. Praca ze zdalnymi usługami (279)

• 10.1. Zdalny dostęp w Springu (280)
• 10.2. Praca z RMI (282)
  • 10.2.1. Eksportowanie usługi RMI (283)
  • 10.2.2. Dowiązanie usługi RMI (285)
• 10.3. Udostępnianie zdalnych usług za pomocą Hessian i Burlap (287)
  • 10.3.1. Udostępnianie funkcjonalności komponentu za pomocą Hessian/Burlap (288)
  • 10.3.2. Dostęp do usług Hessian/Burlap (290)
• 10.4. Obiekt HttpInvoker (292)
  • 10.4.1. Udostępnianie komponentów jako usług HTTP (292)
  • 10.4.2. Dostęp do usług przez HTTP (293)
• 10.5. Publikacja i konsumpcja usług sieciowych (294)
  • 10.5.1. Tworzenie punktów końcowych JAX-WS w Springu (295)
  • 10.5.2. Pośrednik usług JAX-WS po stronie klienta (299)
• 10.6. Podsumowanie (300)

Rozdział 11. Spring i model REST (301)

• 11.1. Zrozumienie REST (302)
  • 11.1.1. Fundamenty REST (302)
  • 11.1.2. Obsługa REST w Springu (303)
• 11.2. Tworzenie kontrolerów korzystających z zasobów (303)
  • 11.2.1. Kontroler niezgodny z konwencją REST pod lupą (304)
  • 11.2.2. Obsługa adresów URL typu RESTful (305)
  • 11.2.3. Czasowniki REST (308)
• 11.3. Reprezentacja zasobów (311)
  • 11.3.1. Negocjowanie reprezentacji zasobu (311)
  • 11.3.2. Praca z konwerterami komunikatów HTTP (314)
• 11.4. Tworzenie klientów REST (317)
  • 11.4.1. Operacje szablonu RestTemplate (319)
  • 11.4.2. Pobieranie zasobów za pomocą GET (320)
  • 11.4.3. Umieszczanie zasobów na serwerze za pomocą PUT (322)
  • 11.4.4. Usuwanie zasobów za pomocą DELETE (324)
  • 11.4.5. Wysyłanie danych zasobu za pomocą POST (325)
  • 11.4.6. Wymiana zasobów (327)
• 11.5. Wysyłanie formularzy typu RESTful (329)
  • 11.5.1. Umieszczanie ukrytych pól metod w kodzie za pomocą JSP (330)
  • 11.5.2. Demaskowanie rzeczywistego żądania (330)
• 11.6. Podsumowanie (332)

Rozdział 12. Obsługa komunikatów w Springu (333)

• 12.1. Krótki wstęp do JMS (334)
  • 12.1.1. Architektura JMS (335)
  • 12.1.2. Szacowanie korzyści związanych z użyciem JMS (337)
• 12.2. Konfiguracja brokera komunikatów w Springu (338)
  • 12.2.1. Tworzenie fabryki połączeń (339)
  • 12.2.2. Deklaracja miejsca docelowego komunikatów ActiveMQ (340)
• 12.3. Szablon JMS Springa (340)
  • 12.3.1. Kod JMS a obsługa wyjątków (341)
  • 12.3.2. Praca z szablonami JMS (342)
• 12.4. Tworzenie obiektów POJO sterowanych komunikatami (347)
  • 12.4.1. Tworzenie odbiorcy komunikatów (348)
  • 12.4.2. Konfiguracja odbiorców komunikatów (349)
• 12.5. Używanie RPC opartego na komunikatach (350)
  • 12.5.1. Praca z RPC opartym na komunikatach w Springu (350)
  • 12.5.2. Asynchroniczne RPC z Lingo (352)
• 12.6. Podsumowanie (354)

Rozdział 13. Zarządzanie komponentami Springa za pomocą JMX (357)

• 13.1. Eksportowanie komponentów Springa w formie MBean (358)
  • 13.1.1. Udostępnianie metod na podstawie nazwy (361)
  • 13.1.2. Użycie interfejsów do definicji operacji i atrybutów komponentu zarządzanego (363)
  • 13.1.3. Praca z komponentami MBean sterowanymi adnotacjami (364)
  • 13.1.4. Postępowanie przy konfliktach nazw komponentów zarządzanych (365)
• 13.2. Zdalny dostęp do komponentów zarządzanych (366)
  • 13.2.1. Udostępnianie zdalnych komponentów MBean (367)
  • 13.2.2. Dostęp do zdalnego komponentu MBean (367)
  • 13.2.3. Obiekty pośredniczące komponentów zarządzanych (369)
• 13.3. Obsługa powiadomień (370)
  • 13.3.1. Odbieranie powiadomień (371)
• 13.4. Podsumowanie (372)

Rozdział 14. Pozostałe zagadnienia (373)

• 14.1. Wyodrębnianie konfiguracji (374)
  • 14.1.1. Zastępowanie symboli zastępczych we właściwościach (374)
  • 14.1.2. Nadpisywanie właściwości (377)
  • 14.1.3. Szyfrowanie zewnętrznych właściwości (378)
• 14.2. Wiązanie obiektów JNDI (380)
  • 14.2.1. Praca z tradycyjnym JNDI (380)
  • 14.2.2. Wstrzykiwanie obiektów JNDI (382)
  • 14.2.3. Wiązanie komponentów EJB w Springu (385)
• 14.3. Wysyłanie wiadomości e-mail (386)
  • 14.3.1. Konfiguracja komponentu wysyłającego pocztę (386)
  • 14.3.2. Budowa wiadomości e-mail (388)
• 14.4. Planowanie zadań wykonywanych w tle (392)
  • 14.4.1. Deklaracja zaplanowanych metod (393)
  • 14.4.2. Deklaracja metod asynchronicznych (395)
• 14.5. Podsumowanie (396)
• 14.6. Koniec...? (396)

Skorowidz (399)

• Tytuł: Spring w Akcji. Wydanie III
• Autor: Craig Walls
• Tytuł oryginału: Spring in Action, 3rd edition
• Tłumaczenie: Jacek Kowolik (wstęp, rozdz. 1 - 4); Krzysztof Wołowski (rozdz. 5 - 14)
• ISBN: 978-83-246-7030-7, 9788324670307
• Data wydania: 2013-03-29
• Format: Ebook
• Identyfikator pozycji: sprwa3
• Wydawca: Helion