Spring Framework odmienił sposób konstruowania aplikacji w języku Java. Prawdopodobnie jest on najczęściej wybieranym narzędziem do tworzenia aplikacji, niezależnie od tego, czy są one internetowe, czy biurkowe. Czym zasłużył sobie na taką popularność? Niezwykle wygodna konfiguracja, ogromna ilość różnego rodzaju bibliotek, przemyślana architektura to tylko niektóre z jego atutów. Jeżeli do tego dodać ogromną społeczność, chętną do udzielania wszelkich porad, otrzymujemy wyjątkowe narzędzie do zadań specjalnych.

Kolejne wydanie książki uwzględnia wszystkie zmiany wprowadzone w trzeciej wersji Spring Framework. A jest ich sporo. Dzięki nim praca z tym narzędziem stała się jeszcze prostsza. W trakcie lektury dowiesz się, jak zminimalizować użycie XML do konfiguracji, wstrzykiwać zależności oraz korzystać z potencjału programowania aspektowego. Ponadto znajdziesz tu komplet informacji na temat współpracy z bazami danych, a pojęcia takie, jak transakcje, JPA, JDBC przestaną być Ci obce. Twoją ciekawość powinien wzbudzić rozdział poświęcony bezpieczeństwu - dzięki Spring Security implementacja tego kluczowego elementu aplikacji staje się o niebo przyjaźniejsza. Książka ta jest skarbnicą informacji o Spring Framework, którą powinien zainteresować się każdy programista języka Java!

Dzięki Spring Framework:

• zbudujesz lepszą architekturę Twojej aplikacji
• wykorzystasz potencjał aspektów i wstrzykiwania zależności
• zagwarantujesz bezpieczeństwo Twoim rozwiązaniom
• stworzysz zaawansowaną aplikację!

Osoby które kupowały "Spring w Akcji. Wydanie III", wybierały także:

• Spring Web MVC. Kurs video. Programowanie aplikacji webowych 69,00 zł, (31,05 zł -55%)
• Java EE 6. Tworzenie aplikacji w NetBeans 7 58,98 zł, (29,49 zł -50%)
• Java EE 6. Programowanie aplikacji WWW 37,00 zł, (18,50 zł -50%)
• Java EE 6. Programowanie aplikacji WWW. Wydanie II 49,00 zł, (29,40 zł -40%)
• Spring. Receptury 119,00 zł, (71,40 zł -40%)

Spis treści

Spring w Akcji. Wydanie III eBook -- spis treści

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)