| Tytuł: | Spring w akcji. Wydanie IV | | | Autor: | Craig Walls | | | ISBN: | 978-83-283-0849-7 | | | Ilość stron: | 624 | | | Data wydania: | 08/2015 | | | Format: | 168x237 | | | Wydawnictwo: | HELION | |
| | Cena: | 89.00zł | |
Kompendium wiedzy na temat Spring Framework!Spring jest odpowiedzią na problemy trapiące programistów tworzących oprogramowanie przy użyciu EJB 2.x. Dzień, w którym został udostępniony szerokiemu gronu użytkowników, był punktem zwrotnym w historii języka Java. Od tej pory życie deweloperów stało się prostsze, a tworzenie nawet skomplikowanych aplikacji — zdecydowanie przyjemniejsze. Od tamtego czasu Spring jest wciąż rozwijany i oferuje coraz lepsze narzędzia programistom na całym świecie.
Kolejne wydanie tej książki, w całości poświęconej frameworkowi Spring (w wersji 4), zostało poprawione, zaktualizowane i uzupełnione o nowe informacje. W trakcie lektury przekonasz się, jakie nowości zostały wprowadzone w czwartej wersji Springa, oraz zaznajomisz się z zaawansowanymi metodami wiązania komponentów. Ponadto zdobędziesz doświadczenie w stosowaniu aspektów, zobaczysz, jak działają Spring MVC czy Spring WebFlow, oraz nauczysz się uzyskiwać dostęp do baz danych — zarówno SQL, jak i NoSQL. Osobny rozdział został poświęcony bezpieczeństwu aplikacji tworzonych z wykorzystaniem Springa. Spring Security to potężne narzędzie, które pozwoli Ci bezboleśnie wprowadzić zaawansowane mechanizmy bezpieczeństwa w Twoich programach. Na sam koniec poznasz techniki obsługi komunikatów oraz możliwości modułu Spring Boot. Książka ta jest doskonałą lekturą dla programistów chcących w pełni wykorzystać potencjał Springa!
Dzięki tej książce:
- 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!
Rozdziały:
- 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)
|
