Spring w akcji. Wydanie IV - ebook

Kompendium wiedzy na temat Spring Framework!

• poznasz komponenty składające się na Spring Framework
• zabezpieczysz aplikację z pomocą Spring Security
• błyskawicznie uruchomisz projekt ze Spring Boot
• z łatwością skorzystasz z baz danych SQL i NoSQL
• wykorzystasz potencjał najnowszej wersji Springa

Niemal 100 tysięcy programistów sięgnęło po tę książkę, by nauczyć się Springa! Jej lektura wymaga praktycznej znajomości języka Java. Poznaj potencjał Springa! 

• Przedmowa (13)
• Podziękowania (15)
• O książce (17)

CZĘŚĆ I. PODSTAWY FRAMEWORKA SPRING (21)

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

• 1.1. Upraszczamy programowanie w Javie (24)
  • 1.1.1. Uwalniamy moc zawartą w POJO (25)
  • 1.1.2. Wstrzykujemy zależności (25)
  • 1.1.3. Stosujemy aspekty (31)
  • 1.1.4. Ograniczamy powtórzenia kodu dzięki szablonom (36)
• 1.2. Kontener dla naszych komponentów (38)
  • 1.2.1. Pracujemy z kontekstem aplikacji (39)
  • 1.2.2. Cykl życia komponentu (40)
• 1.3. Podziwiamy krajobraz Springa (42)
  • 1.3.1. Moduły Springa (42)
  • 1.3.2. Rodzina projektów wokół Springa (45)
• 1.4. Co nowego w Springu (48)
  • 1.4.1. Co nowego w Springu 3.1? (49)
  • 1.4.2. Co nowego w Springu 3.2? (50)
  • 1.4.3. Co nowego w Springu 4.0? (51)
• 1.5. Podsumowanie (52)

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

• 2.1. Poznajemy opcje konfiguracji Springa (54)
• 2.2. Wykorzystujemy automatyczne wiązanie komponentów (55)
  • 2.2.1. Tworzymy wyszukiwalne komponenty (56)
  • 2.2.2. Nadajemy nazwy skanowanemu komponentowi (59)
  • 2.2.3. Ustawiamy pakiet bazowy dla skanowania komponentów (60)
  • 2.2.4. Oznaczamy adnotacją komponenty przeznaczone do autowiązania (61)
  • 2.2.5. Weryfikujemy automatyczną konfigurację (63)
• 2.3. Wiążemy kod za pomocą Javy (64)
  • 2.3.1. Tworzymy klasy konfiguracji (64)
  • 2.3.2. Deklarujemy prosty komponent (65)
  • 2.3.3. Wstrzykujemy zależności za pomocą konfiguracji JavaConfig (66)
• 2.4. Wiążemy komponenty za pomocą plików XML (68)
  • 2.4.1. Tworzymy specyfikację konfiguracji XML (68)
  • 2.4.2. Deklarujemy prosty komponent (69)
  • 2.4.3. Wstrzykujemy komponent przez konstruktor (70)
  • 2.4.4. Ustawiamy właściwości (76)
• 2.5. Importujemy i łączymy konfiguracje (81)
  • 2.5.1. Odwołujemy się do konfiguracji XML z poziomu konfiguracji JavaConfig (82)
  • 2.5.2. Odwołujemy się do konfiguracji JavaConfig z poziomu konfiguracji XML (83)
• 2.6. Podsumowanie (85)

Rozdział 3. Zaawansowane opcje wiązania (87)

• 3.1. Środowiska i profile (87)
  • 3.1.1. Konfigurujemy komponenty profilu (89)
  • 3.1.2. Aktywujemy profil (93)
• 3.2. Warunkowe komponenty (95)
• 3.3. Radzimy sobie z niejednoznacznościami w autowiązaniach (98)
  • 3.3.1. Wybieramy główny komponent (99)
  • 3.3.2. Kwalifikujemy autowiązane komponenty (100)
• 3.4. Ustalamy zasięg komponentów (104)
  • 3.4.1. Zasięg żądania oraz sesji (105)
  • 3.4.2. Deklarujemy obiekty pośredniczące o określonym zasięgu za pomocą XML (107)
• 3.5. Wstrzykujemy wartości w czasie wykonywania (108)
  • 3.5.1. Wstrzykujemy zewnętrzne wartości (109)
  • 3.5.2. Tworzymy powiązania z użyciem języka wyrażeń Springa (SpEL) (113)
• 3.6. Podsumowanie (119)

Rozdział 4. Aspektowy Spring (121)

• 4.1. Czym jest programowanie aspektowe (122)
  • 4.1.1. Definiujemy terminologię dotyczącą AOP (123)
  • 4.1.2. Obsługa programowania aspektowego w Springu (126)
• 4.2. Wybieramy punkty złączenia za pomocą punktów przecięcia (128)
  • 4.2.1. Piszemy definicje punktów przecięcia (130)
  • 4.2.2. Wybieramy komponenty w punktach przecięcia (131)
• 4.3. Tworzenie aspektów z użyciem adnotacji (131)
  • 4.3.1. Definiujemy aspekt (131)
  • 4.3.2. Tworzymy porady around (136)
  • 4.3.3. Przekazujemy parametry do porady (137)
  • 4.3.4. Wprowadzenia z użyciem adnotacji (140)
• 4.4. Deklarujemy aspekty w języku XML (143)
  • 4.4.1. Deklarujemy porady before i after (144)
  • 4.4.2. Deklarujemy poradę around (146)
  • 4.4.3. Przekazujemy parametry do porady (148)
  • 4.4.4. Wprowadzamy nową funkcjonalność przez aspekty (150)
• 4.5. Wstrzykujemy aspekty z AspectJ (151)
• 4.6. Podsumowanie (153)

CZĘŚĆ II. SPRING W SIECI (155)

Rozdział 5. Budowanie aplikacji internetowych za pomocą Springa (157)

• 5.1. Wprowadzenie do Spring MVC (158)
  • 5.1.1. Cykl życia żądania (158)
  • 5.1.2. Konfiguracja Spring MVC (160)
  • 5.1.3. Wprowadzenie do aplikacji Spittr (165)
• 5.2. Tworzymy prosty kontroler (165)
  • 5.2.1. Testujemy kontroler (167)
  • 5.2.2. Definiujemy obsługę żądań na poziomie klasy (169)
  • 5.2.3. Przekazujemy dane modelu do widoku (170)
• 5.3. Obsługujemy dane wejściowe (175)
  • 5.3.1. Pobieramy parametry zapytania (176)
  • 5.3.2. Pobieramy dane wejściowe za pośrednictwem parametrów ścieżki (178)
• 5.4. Przetwarzamy formularze (180)
  • 5.4.1. Tworzymy kontroler do obsługi formularza (182)
  • 5.4.2. Walidujemy formularze (186)
• 5.5. Podsumowanie (189)

Rozdział 6. Generowanie widoków (191)

• 6.1. Poznajemy sposób produkowania widoków (191)
• 6.2. Tworzymy widoki JSP (194)
  • 6.2.1. Konfigurujemy producenta widoków gotowego do pracy z JSP (194)
  • 6.2.2. Korzystamy z bibliotek JSP Springa (196)
• 6.3. Definiujemy układ stron za pomocą widoków Apache Tiles (209)
  • 6.3.1. Konfigurujemy producenta widoków Tiles (209)
• 6.4. Pracujemy z Thymeleaf (214)
  • 6.4.1. Konfigurujemy producenta widoków Thymeleaf (215)
  • 6.4.2. Definiujemy szablony Thymeleaf (216)
• 6.5. Podsumowanie (220)

Rozdział 7. Zaawansowane możliwości Spring MVC (221)

• 7.1. Alternatywna konfiguracja Spring MVC (222)
  • 7.1.1. Dostosowujemy konfigurację serwletu dystrybutora (222)
  • 7.1.2. Dodajemy kolejne serwlety i filtry (223)
  • 7.1.3. Deklarujemy serwlet dystrybutora za pomocą pliku web.xml (225)
• 7.2. Przetwarzamy dane formularza wieloczęściowego (227)
  • 7.2.1. Konfigurujemy rezolwer danych wieloczęściowych (228)
  • 7.2.2. Obsługujemy żądania wieloczęściowe (232)
• 7.3. Obsługujemy wyjątki (236)
  • 7.3.1. Mapujemy wyjątki na kody odpowiedzi HTTP (236)
  • 7.3.2. Tworzymy metody obsługi wyjątków (238)
• 7.4. Doradzamy kontrolerom (239)
• 7.5. Przenosimy dane między przekierowaniami (240)
  • 7.5.1. Wykonujemy przekierowanie z użyciem szablonów URL (241)
  • 7.5.2. Pracujemy z atrybutami jednorazowymi (242)
• 7.6. Podsumowanie (244)

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

• 8.1. Konfiguracja Spring Web Flow (248)
  • 8.1.1. Dowiązanie egzekutora przepływu (248)
  • 8.1.2. Konfiguracja rejestru przepływów (249)
  • 8.1.3. Obsługa żądań przepływu (250)
• 8.2. Składowe przepływu (250)
  • 8.2.1. Stany (251)
  • 8.2.2. Przejścia (254)
  • 8.2.3. Dane przepływu (255)
• 8.3. Łączymy wszystko w całość: zamówienie pizzy (257)
  • 8.3.1. Definiowanie bazowego przepływu (257)
  • 8.3.2. Zbieranie informacji o kliencie (261)
  • 8.3.3. Budowa zamówienia (266)
  • 8.3.4. Przyjmowanie płatności (269)
• 8.4. Zabezpieczanie przepływu (271)
• 8.5. Podsumowanie (271)

Rozdział 9. Zabezpieczanie Springa (273)

• 9.1. Rozpoczynamy pracę ze Spring Security (274)
  • 9.1.1. Poznajemy moduły Spring Security (274)
  • 9.1.2. Filtrujemy żądania internetowe (275)
  • 9.1.3. Tworzymy prostą konfigurację bezpieczeństwa (276)
• 9.2. Wybieramy usługi szczegółów użytkownika (279)
  • 9.2.1. Pracujemy z bazą użytkowników zapisaną w pamięci (279)
  • 9.2.2. Uwierzytelnianie w oparciu o tabele danych (281)
  • 9.2.3. Uwierzytelniamy użytkownika w oparciu o usługę LDAP (283)
  • 9.2.4. Tworzymy własną usługę użytkowników (287)
• 9.3. Przechwytywanie żądań (289)
  • 9.3.1. Zabezpieczanie za pomocą wyrażeń Springa (291)
  • 9.3.2. Wymuszamy bezpieczeństwo kanału komunikacji (292)
  • 9.3.3. Ochrona przed atakami CSRF (294)
• 9.4. Uwierzytelnianie użytkowników (295)
  • 9.4.1. Dodajemy własną stronę logowania (296)
  • 9.4.2. Włączamy uwierzytelnianie HTTP Basic (297)
  • 9.4.3. Włączenie funkcji "pamiętaj mnie" (298)
  • 9.4.4. Wylogowujemy się (299)
• 9.5. Zabezpieczanie elementów na poziomie widoku (300)
  • 9.5.1. Korzystamy z biblioteki znaczników JSP w Spring Security (300)
  • 9.5.2. Pracujemy z dialektem Spring Security w Thymeleaf (304)
• 9.6. Podsumowanie (305)

CZĘŚĆ III. SPRING PO STRONIE SERWERA (307)

Rozdział 10. Korzystanie z bazy danych z użyciem Springa i JDBC (309)

• 10.1. Filozofia dostępu do danych Springa (310)
  • 10.1.1. Hierarchia wyjątków związanych z dostępem do danych w Springu (311)
  • 10.1.2. Szablony dostępu do danych (314)
• 10.2. Konfiguracja źródła danych (316)
  • 10.2.1. Źródła danych JNDI (316)
  • 10.2.2. Źródła danych z pulą (317)
  • 10.2.3. Źródła danych oparte na sterowniku JDBC (318)
  • 10.2.4. Korzystamy z wbudowanego źródła danych (320)
  • 10.2.5. Korzystamy z profili do wyboru źródła danych (321)
• 10.3. Używanie JDBC w Springu (323)
  • 10.3.1. Kod JDBC a obsługa wyjątków (323)
  • 10.3.2. Praca z szablonami JDBC (327)
• 10.4. Podsumowanie (332)

Rozdział 11. Zapisywanie danych z użyciem mechanizmów ORM (333)

• 11.1. Integrujemy Hibernate ze Springiem (335)
  • 11.1.1. Deklarowanie fabryki sesji Hibernate (335)
  • 11.1.2. Hibernate bez Springa (337)
• 11.2. Spring i Java Persistence API (339)
  • 11.2.1. Konfiguracja fabryki menedżerów encji (339)
  • 11.2.2. Klasa repozytorium na bazie JPA (344)
• 11.3. Automatyczne repozytoria z wykorzystaniem Spring Data (346)
  • 11.3.1. Definiujemy metody zapytań (348)
  • 11.3.2. Deklarujemy własne zapytania (351)
  • 11.3.3. Dodajemy własne funkcjonalności (352)
• 11.4. Podsumowanie (354)

Rozdział 12. Pracujemy z bazami NoSQL (357)

• 12.1. Zapisujemy dane w MongoDB (358)
  • 12.1.1. Włączamy MongoDB (359)
  • 12.1.2. Dodajemy adnotacje umożliwiające zapis w MongoDB (362)
  • 12.1.3. Dostęp do bazy MongoDB za pomocą szablonów MongoTemplate (365)
  • 12.1.4. Tworzymy repozytorium MongoDB (366)
• 12.2. Pracujemy z danymi w postaci grafów w Neo4j (371)
  • 12.2.1. Konfigurujemy Spring Data Neo4j (371)
  • 12.2.2. Dodajemy adnotacje do encji grafów (374)
  • 12.2.3. Pracujemy z Neo4jTemplate (377)
  • 12.2.4. Tworzymy automatyczne repozytoria Neo4j (379)
• 12.3. Pracujemy z danymi typu klucz-wartość z użyciem bazy Redis (383)
  • 12.3.1. Łączymy się z Redisem (383)
  • 12.3.2. Pracujemy z klasą RedisTemplate (385)
  • 12.3.3. Ustawiamy serializatory kluczy i wartości (388)
• 12.4. Podsumowanie (389)

Rozdział 13. Cachowanie danych (391)

• 13.1. Włączamy obsługę cachowania (392)
  • 13.1.1. Konfigurujemy menedżera pamięci podręcznej (393)
• 13.2. Stosowanie adnotacji cachowania na poziomie metod (397)
  • 13.2.1. Zapisujemy dane w pamięci podręcznej (398)
  • 13.2.2. Usuwamy wpisy z pamięci podręcznej (402)
• 13.3. Deklarujemy cachowanie w pliku XML (403)
• 13.4. Podsumowanie (407)

Rozdział 14. Zabezpieczanie metod (409)

• 14.1. Zabezpieczamy metody za pomocą adnotacji (410)
  • 14.1.1. Zabezpieczamy metody za pomocą adnotacji @Secured (410)
  • 14.1.2. Adnotacja @RolesAllowed ze specyfikacji JSR-250 w Spring Security (412)
• 14.2. Korzystamy z wyrażeń do zabezpieczania metod (412)
  • 14.2.1. Wyrażenia reguł dostępu do metod (413)
  • 14.2.2. Filtrowanie danych wejściowych i wyjściowych metody (415)
• 14.3. Podsumowanie (420)

CZĘŚĆ IV. INTEGRACJA W SPRINGU (421)

Rozdział 15. Praca ze zdalnymi usługami (423)

• 15.1. Zdalny dostęp w Springu (424)
• 15.2. Praca z RMI (426)
  • 15.2.1. Eksportowanie usługi RMI (427)
  • 15.2.2. Dowiązanie usługi RMI (429)
• 15.3. Udostępnianie zdalnych usług za pomocą Hessian i Burlap (431)
  • 15.3.1. Udostępnianie funkcjonalności komponentu za pomocą Hessian/Burlap (432)
  • 15.3.2. Dostęp do usług Hessian/Burlap (435)
• 15.4. Obiekt HttpInvoker (436)
  • 15.4.1. Udostępnianie komponentów jako usług HTTP (437)
  • 15.4.2. Dostęp do usług przez HTTP (438)
• 15.5. Publikacja i konsumpcja usług sieciowych (439)
  • 15.5.1. Tworzenie punktów końcowych JAX-WS w Springu (440)
  • 15.5.2. Pośrednik usług JAX-WS po stronie klienta (443)
• 15.6. Podsumowanie (445)

Rozdział 16. Tworzenie API modelu REST przy użyciu Spring MVC (447)

• 16.1. Zrozumienie REST (448)
  • 16.1.1. Fundamenty REST (448)
  • 16.1.2. Obsługa REST w Springu (449)
• 16.2. Tworzenie pierwszego punktu końcowego REST (450)
  • 16.2.1. Negocjowanie reprezentacji zasobu (452)
  • 16.2.2. Stosowanie konwerterów komunikatów HTTP (458)
• 16.3. Zwracanie zasobów to nie wszystko (464)
  • 16.3.1. Przekazywanie błędów (464)
  • 16.3.2. Ustawianie nagłówków odpowiedzi (469)
• 16.4. Konsumowanie zasobów REST (471)
  • 16.4.1. Operacje szablonu RestTemplate (472)
  • 16.4.2. Pobieranie zasobów za pomocą GET (473)
  • 16.4.3. Pobieranie zasobów (474)
  • 16.4.4. Odczyt metadanych z odpowiedzi (475)
  • 16.4.5. Umieszczanie zasobów na serwerze za pomocą PUT (476)
  • 16.4.6. Usuwanie zasobów za pomocą DELETE (478)
  • 16.4.7. Wysyłanie danych zasobu za pomocą POST (478)
  • 16.4.8. Odbieranie obiektów odpowiedzi z żądań POST (478)
  • 16.4.9. Pobranie informacji o lokalizacji po żądaniu POST (480)
  • 16.4.10. Wymiana zasobów (481)
• 16.5. Podsumowanie (483)

Rozdział 17. Obsługa komunikatów w Springu (485)

• 17.1. Krótkie wprowadzenie do asynchronicznej wymiany komunikatów (486)
  • 17.1.1. Wysyłanie komunikatów (487)
  • 17.1.2. Szacowanie korzyści związanych ze stosowaniem asynchronicznej wymiany komunikatów (489)
• 17.2. Wysyłanie komunikatów przy użyciu JMS (491)
  • 17.2.1. Konfiguracja brokera komunikatów w Springu (491)
  • 17.2.2. Szablon JMS Springa (494)
  • 17.2.3. Tworzenie obiektów POJO sterowanych komunikatami (502)
  • 17.2.4. Używanie RPC opartego na komunikatach (505)
• 17.3. Obsługa komunikatów przy użyciu AMQP (508)
  • 17.3.1. Krótkie wprowadzenie do AMQP (509)
  • 17.3.2. Konfigurowanie Springa do wymiany komunikatów przy użyciu AMQP (510)
  • 17.3.3. Wysyłanie komunikatów przy użyciu RabbitTemplate (513)
  • 17.3.4. Odbieranie komunikatów AMQP (515)
• 17.4. Podsumowanie (518)

Rozdział 18. Obsługa komunikatów przy użyciu WebSocket i STOMP (519)

• 18.1. Korzystanie z API WebSocket niskiego poziomu (520)
• 18.2. Rozwiązanie problemu braku obsługi WebSocket (525)
• 18.3. Wymiana komunikatów z użyciem STOMP (528)
  • 18.3.1. Włączanie obsługi komunikatów STOMP (530)
  • 18.3.2. Obsługa komunikatów STOMP nadsyłanych przez klienty (533)
  • 18.3.3. Wysyłanie komunikatów do klienta (537)
• 18.4. Komunikaty skierowane do konkretnego klienta (541)
  • 18.4.1. Obsługa komunikatów skojarzonych z użytkownikiem w kontrolerze (541)
  • 18.4.2. Wysyłanie komunikatów do konkretnego użytkownika (544)
• 18.5. Obsługa wyjątków komunikatów (545)
• 18.6. Podsumowanie (546)

Rozdział 19. Wysyłanie poczty elektronicznej w Springu (547)

• 19.1. Konfigurowanie Springa do wysyłania wiadomości e-mail (548)
  • 19.1.1. Konfigurowanie komponentu wysyłającego (548)
  • 19.1.2. Dowiązanie komponentu wysyłającego pocztę do komponentu usługi (550)
• 19.2. Tworzenie e-maili z załącznikami (551)
  • 19.2.1. Dodawanie załączników (551)
  • 19.2.2. Wysyłanie wiadomości e-mail z bogatą zawartością (552)
• 19.3. Tworzenie wiadomości e-mail przy użyciu szablonów (554)
  • 19.3.1. Tworzenie wiadomości e-mail przy użyciu Velocity (554)
  • 19.3.2. Stosowanie Thymeleaf do tworzenia wiadomości e-mail (556)
• 19.4. Podsumowanie (558)

Rozdział 20. Zarządzanie komponentami Springa za pomocą JMX (561)

• 20.1. Eksportowanie komponentów Springa w formie MBean (562)
  • 20.1.1. Udostępnianie metod na podstawie nazwy (565)
  • 20.1.2. Użycie interfejsów do definicji operacji i atrybutów komponentu zarządzanego (567)
  • 20.1.3. Praca z komponentami MBean sterowanymi adnotacjami (568)
  • 20.1.4. Postępowanie przy konfliktach nazw komponentów zarządzanych (570)
• 20.2. Zdalny dostęp do komponentów zarządzanych (571)
  • 20.2.1. Udostępnianie zdalnych komponentów MBean (571)
  • 20.2.2. Dostęp do zdalnego komponentu MBean (572)
  • 20.2.3. Obiekty pośredniczące komponentów zarządzanych (573)
• 20.3. Obsługa powiadomień (575)
  • 20.3.1. Odbieranie powiadomień (576)
• 20.4. Podsumowanie (577)

Rozdział 21. Upraszczanie tworzenia aplikacji przy użyciu Spring Boot (579)

• 21.1. Prezentacja Spring Boot (580)
  • 21.1.1. Dodawanie zależności początkowych (581)
  • 21.1.2. Automatyczna konfiguracja (584)
  • 21.1.3. Spring Boot CLI (585)
  • 21.1.4. Aktuator (586)
• 21.2. Pisanie aplikacji korzystającej ze Spring Boot (586)
  • 21.2.1. Obsługa żądań (589)
  • 21.2.2. Tworzenie widoku (591)
  • 21.2.3. Dodawanie statycznych artefaktów (593)
  • 21.2.4. Trwałe zapisywanie danych (594)
  • 21.2.5. Próba aplikacji (596)
• 21.3. Stosowanie Groovy i Spring Boot CLI (599)
  • 21.3.1. Pisanie kontrolera w języku Groovy (600)
  • 21.3.2. Zapewnianie trwałości danych przy użyciu repozytorium Groovy (603)
  • 21.3.3. Uruchamianie Spring Boot CLI (604)
• 21.4. Pozyskiwanie informacji o aplikacji z użyciem aktuatora (605)
• 21.5. Podsumowanie (609)

Skorowidz (611)