Szczegóły ebooka

Spring w akcji. Wydanie IV

Spring w akcji. Wydanie IV

Craig Walls

Ebook

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! 

  • 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)

  • Tytuł: Spring w akcji. Wydanie IV
  • Autor: Craig Walls
  • Tytuł oryginału: Spring in Action, Fourth Edition
  • Tłumaczenie: Mirosław Gołda, Piotr Rajca
  • ISBN: 978-83-283-0850-3, 9788328308503
  • Data wydania: 2015-08-13
  • Format: Ebook
  • Identyfikator pozycji: sprwa4
  • Wydawca: Helion