Spring w akcji

Spis treści
Przedmowa
Podziękowania
O książce
Część I. Podstawy frameworka Spring
	Rozdział 1. Zrywamy się do działania
		1.1. Upraszczamy programowanie w Javie
			1.1.1. Uwalniamy moc zawartą w POJO
			1.1.2. Wstrzykujemy zależności
			1.1.3. Stosujemy aspekty
			1.1.4. Ograniczamy powtórzenia kodu dzięki szablonom
		1.2. Kontener dla naszych komponentów
			1.2.1. Pracujemy z kontekstem aplikacji
			1.2.2. Cykl życia komponentu
		1.3. Podziwiamy krajobraz Springa
			1.3.1. Moduły Springa
			1.3.2. Rodzina projektów wokół Springa
		1.4. Co nowego w Springu
			1.4.1. Co nowego w Springu 3.1?
			1.4.2. Co nowego w Springu 3.2?
			1.4.3. Co nowego w Springu 4.0?
		1.5. Podsumowanie
	Rozdział 2. Tworzymy powiązania między komponentami
		2.1. Poznajemy opcje konfiguracji Springa
		2.2. Wykorzystujemy automatyczne wiązanie komponentów
			2.2.1. Tworzymy wyszukiwalne komponenty
			2.2.2. Nadajemy nazwy skanowanemu komponentowi
			2.2.3. Ustawiamy pakiet bazowy dla skanowania komponentów
			2.2.4. Oznaczamy adnotacją komponenty przeznaczone do autowiązania
			2.2.5. Weryfikujemy automatyczną konfigurację
		2.3. Wiążemy kod za pomocą Javy
			2.3.1. Tworzymy klasy konfiguracji
			2.3.2. Deklarujemy prosty komponent
			2.3.3. Wstrzykujemy zależności za pomocą konfiguracji JavaConfig
		2.4. Wiążemy komponenty za pomocą plików XML
			2.4.1. Tworzymy specyfikację konfiguracji XML
			2.4.2. Deklarujemy prosty komponent
			2.4.3. Wstrzykujemy komponent przez konstruktor
			2.4.4. Ustawiamy właściwości
		2.5. Importujemy i łączymy konfiguracje
			2.5.1. Odwołujemy się do konfiguracji XML z poziomu konfiguracji JavaConfig
			2.5.2. Odwołujemy się do konfiguracji JavaConfig z poziomu konfiguracji XML
		2.6. Podsumowanie
	Rozdział 3. Zaawansowane opcje wiązania
		3.1. Środowiska i profile
			3.1.1. Konfigurujemy komponenty profilu
			3.1.2. Aktywujemy profil
		3.2. Warunkowe komponenty
		3.3. Radzimy sobie z niejednoznacznościami w autowiązaniach
			3.3.1. Wybieramy główny komponent
			3.3.2. Kwalifikujemy autowiązane komponenty
		3.4. Ustalamy zasięg komponentów
			3.4.1. Zasięg żądania oraz sesji
			3.4.2. Deklarujemy obiekty pośredniczące o określonym zasięgu za pomocą XML
		3.5. Wstrzykujemy wartości w czasie wykonywania
			3.5.1. Wstrzykujemy zewnętrzne wartości
			3.5.2. Tworzymy powiązania z użyciem języka wyrażeń Springa (SpEL)
		3.6. Podsumowanie
	Rozdział 4. Aspektowy Spring
		4.1. Czym jest programowanie aspektowe
			4.1.1. Definiujemy terminologię dotyczącą AOP
			4.1.2. Obsługa programowania aspektowego w Springu
		4.2. Wybieramy punkty złączenia za pomocą punktów przecięcia
			4.2.1. Piszemy definicje punktów przecięcia
			4.2.2. Wybieramy komponenty w punktach przecięcia
		4.3. Tworzenie aspektów z użyciem adnotacji
			4.3.1. Definiujemy aspekt
			4.3.2. Tworzymy porady around
			4.3.3. Przekazujemy parametry do porady
			4.3.4. Wprowadzenia z użyciem adnotacji
		4.4. Deklarujemy aspekty w języku XML
			4.4.1. Deklarujemy porady before i after
			4.4.2. Deklarujemy poradę around
			4.4.3. Przekazujemy parametry do porady
			4.4.4. Wprowadzamy nową funkcjonalność przez aspekty
		4.5. Wstrzykujemy aspekty z AspectJ
		4.6. Podsumowanie
Część II. Spring w sieci
	Rozdział 5. Budowanie aplikacji internetowych za pomocą Springa
		5.1. Wprowadzenie do Spring MVC
			5.1.1. Cykl życia żądania
			5.1.2. Konfiguracja Spring MVC
			5.1.3. Wprowadzenie do aplikacji Spittr
		5.2. Tworzymy prosty kontroler
			5.2.1. Testujemy kontroler
			5.2.2. Definiujemy obsługę żądań na poziomie klasy
			5.2.3. Przekazujemy dane modelu do widoku
		5.3. Obsługujemy dane wejściowe
			5.3.1. Pobieramy parametry zapytania
			5.3.2. Pobieramy dane wejściowe za pośrednictwem parametrów ścieżki
		5.4. Przetwarzamy formularze
			5.4.1. Tworzymy kontroler do obsługi formularza
			5.4.2. Walidujemy formularze
		5.5. Podsumowanie
	Rozdział 6. Generowanie widoków
		6.1. Poznajemy sposób produkowania widoków
		6.2. Tworzymy widoki JSP
			6.2.1. Konfigurujemy producenta widoków gotowego do pracy z JSP
			6.2.2. Korzystamy z bibliotek JSP Springa
		6.3. Definiujemy układ stron za pomocą widoków Apache Tiles
			6.3.1. Konfigurujemy producenta widoków Tiles
		6.4. Pracujemy z Thymeleaf
			6.4.1. Konfigurujemy producenta widoków Thymeleaf
			6.4.2. Definiujemy szablony Thymeleaf
		6.5. Podsumowanie
	Rozdział 7. Zaawansowane możliwości Spring MVC
		7.1. Alternatywna konfiguracja Spring MVC
			7.1.1. Dostosowujemy konfigurację serwletu dystrybutora
			7.1.2. Dodajemy kolejne serwlety i filtry
			7.1.3. Deklarujemy serwlet dystrybutora za pomocą pliku web.xml
		7.2. Przetwarzamy dane formularza wieloczęściowego
			7.2.1. Konfigurujemy rezolwer danych wieloczęściowych
			7.2.2. Obsługujemy żądania wieloczęściowe
		7.3. Obsługujemy wyjątki
			7.3.1. Mapujemy wyjątki na kody odpowiedzi HTTP
			7.3.2. Tworzymy metody obsługi wyjątków
		7.4. Doradzamy kontrolerom
		7.5. Przenosimy dane między przekierowaniami
			7.5.1. Wykonujemy przekierowanie z użyciem szablonów URL
			7.5.2. Pracujemy z atrybutami jednorazowymi
		7.6. Podsumowanie
	Rozdział 8. Praca ze Spring Web Flow
		8.1. Konfiguracja Spring Web Flow
			8.1.1. Dowiązanie egzekutora przepływu
			8.1.2. Konfiguracja rejestru przepływów
			8.1.3. Obsługa żądań przepływu
		8.2. Składowe przepływu
			8.2.1. Stany
			8.2.2. Przejścia
			8.2.3. Dane przepływu
		8.3. Łączymy wszystko w całość: zamówienie pizzy
			8.3.1. Definiowanie bazowego przepływu
			8.3.2. Zbieranie informacji o kliencie
			8.3.3. Budowa zamówienia
			8.3.4. Przyjmowanie płatności
		8.4. Zabezpieczanie przepływu
		8.5. Podsumowanie
	Rozdział 9. Zabezpieczanie Springa
		9.1. Rozpoczynamy pracę ze Spring Security
			9.1.1. Poznajemy moduły Spring Security
			9.1.2. Filtrujemy żądania internetowe
			9.1.3. Tworzymy prostą konfigurację bezpieczeństwa
		9.2. Wybieramy usługi szczegółów użytkownika
			9.2.1. Pracujemy z bazą użytkowników zapisaną w pamięci
			9.2.2. Uwierzytelnianie w oparciu o tabele danych
			9.2.3. Uwierzytelniamy użytkownika w oparciu o usługę LDAP
			9.2.4. Tworzymy własną usługę użytkowników
		9.3. Przechwytywanie żądań
			9.3.1. Zabezpieczanie za pomocą wyrażeń Springa
			9.3.2. Wymuszamy bezpieczeństwo kanału komunikacji
			9.3.3. Ochrona przed atakami CSRF
		9.4. Uwierzytelnianie użytkowników
			9.4.1. Dodajemy własną stronę logowania
			9.4.2. Włączamy uwierzytelnianie HTTP Basic
			9.4.3. Włączenie funkcji „pamiętaj mnie”
			9.4.4. Wylogowujemy się
		9.5. Zabezpieczanie elementów na poziomie widoku
			9.5.1. Korzystamy z biblioteki znaczników JSP w Spring Security
			9.5.2. Pracujemy z dialektem Spring Security w Thymeleaf
		9.6. Podsumowanie
Część III. Spring po stronie serwera
	Rozdział 10. Korzystanie z bazy danych z użyciem Springa i JDBC
		10.1. Filozofia dostępu do danych Springa
			10.1.1. Hierarchia wyjątków związanych z dostępem do danych w Springu
			10.1.2. Szablony dostępu do danych
		10.2. Konfiguracja źródła danych
			10.2.1. Źródła danych JNDI
			10.2.2. Źródła danych z pulą
			10.2.3. Źródła danych oparte na sterowniku JDBC
			10.2.4. Korzystamy z wbudowanego źródła danych
			10.2.5. Korzystamy z profili do wyboru źródła danych
		10.3. Używanie JDBC w Springu
			10.3.1. Kod JDBC a obsługa wyjątków
			10.3.2. Praca z szablonami JDBC
		10.4. Podsumowanie
	Rozdział 11. Zapisywanie danych z użyciem mechanizmów ORM
		11.1. Integrujemy Hibernate ze Springiem
			11.1.1. Deklarowanie fabryki sesji Hibernate
			11.1.2. Hibernate bez Springa
		11.2. Spring i Java Persistence API
			11.2.1. Konfiguracja fabryki menedżerów encji
			11.2.2. Klasa repozytorium na bazie JPA
		11.3. Automatyczne repozytoria z wykorzystaniem Spring Data
			11.3.1. Definiujemy metody zapytań
			11.3.2. Deklarujemy własne zapytania
			11.3.3. Dodajemy własne funkcjonalności
		11.4. Podsumowanie
	Rozdział 12. Pracujemy z bazami NoSQL
		12.1. Zapisujemy dane w MongoDB
			12.1.1. Włączamy MongoDB
			12.1.2. Dodajemy adnotacje umożliwiające zapis w MongoDB
			12.1.3. Dostęp do bazy MongoDB za pomocą szablonów MongoTemplate
			12.1.4. Tworzymy repozytorium MongoDB
		12.2. Pracujemy z danymi w postaci grafów w Neo4j
			12.2.1. Konfigurujemy Spring Data Neo4j
			12.2.2. Dodajemy adnotacje do encji grafów
			12.2.3. Pracujemy z Neo4jTemplate
			12.2.4. Tworzymy automatyczne repozytoria Neo4j
		12.3. Pracujemy z danymi typu klucz-wartość z użyciem bazy Redis
			12.3.1. Łączymy się z Redisem
			12.3.2. Pracujemy z klasą RedisTemplate
			12.3.3. Ustawiamy serializatory kluczy i wartości
		12.4. Podsumowanie
	Rozdział 13. Cachowanie danych
		13.1. Włączamy obsługę cachowania
			13.1.1. Konfigurujemy menedżera pamięci podręcznej
		13.2. Stosowanie adnotacji cachowania na poziomie metod
			13.2.1. Zapisujemy dane w pamięci podręcznej
			13.2.2. Usuwamy wpisy z pamięci podręcznej
		13.3. Deklarujemy cachowanie w pliku XML
		13.4. Podsumowanie
	Rozdział 14. Zabezpieczanie metod
		14.1. Zabezpieczamy metody za pomocą adnotacji
			14.1.1. Zabezpieczamy metody za pomocą adnotacji @Secured
			14.1.2. Adnotacja @RolesAllowed ze specyfikacji JSR-250 w Spring Security
		14.2. Korzystamy z wyrażeń do zabezpieczania metod
			14.2.1. Wyrażenia reguł dostępu do metod
			14.2.2. Filtrowanie danych wejściowych i wyjściowych metody
		14.3. Podsumowanie
Część IV. Integracja w Springu
	Rozdział 15. Praca ze zdalnymi usługami
		15.1. Zdalny dostęp w Springu
		15.2. Praca z RMI
			15.2.1. Eksportowanie usługi RMI
			15.2.2. Dowiązanie usługi RMI
		15.3. Udostępnianie zdalnych usług za pomocą Hessian i Burlap
			15.3.1. Udostępnianie funkcjonalności komponentu za pomocą Hessian/Burlap
			15.3.2. Dostęp do usług Hessian/Burlap
		15.4. Obiekt HttpInvoker
			15.4.1. Udostępnianie komponentów jako usług HTTP
			15.4.2. Dostęp do usług przez HTTP
		15.5. Publikacja i konsumpcja usług sieciowych
			15.5.1. Tworzenie punktów końcowych JAX-WS w Springu
			15.5.2. Pośrednik usług JAX-WS po stronie klienta
		15.6. Podsumowanie
	Rozdział 16. Tworzenie API modelu REST przy użyciu Spring MVC
		16.1. Zrozumienie REST
			16.1.1. Fundamenty REST
			16.1.2. Obsługa REST w Springu
		16.2. Tworzenie pierwszego punktu końcowego REST
			16.2.1. Negocjowanie reprezentacji zasobu
			16.2.2. Stosowanie konwerterów komunikatów HTTP
		16.3. Zwracanie zasobów to nie wszystko
			16.3.1. Przekazywanie błędów
			16.3.2. Ustawianie nagłówków odpowiedzi
		16.4. Konsumowanie zasobów REST
			16.4.1. Operacje szablonu RestTemplate
			16.4.2. Pobieranie zasobów za pomocą GET
			16.4.3. Pobieranie zasobów
			16.4.4. Odczyt metadanych z odpowiedzi
			16.4.5. Umieszczanie zasobów na serwerze za pomocą PUT
			16.4.6. Usuwanie zasobów za pomocą DELETE
			16.4.7. Wysyłanie danych zasobu za pomocą POST
			16.4.8. Odbieranie obiektów odpowiedzi z żądań POST
			16.4.9. Pobranie informacji o lokalizacji po żądaniu POST
			16.4.10. Wymiana zasobów
		16.5. Podsumowanie
	Rozdział 17. Obsługa komunikatów w Springu
		17.1. Krótkie wprowadzenie do asynchronicznej wymiany komunikatów
			17.1.1. Wysyłanie komunikatów
			17.1.2. Szacowanie korzyści związanych ze stosowaniem asynchronicznej wymiany komunikatów
		17.2. Wysyłanie komunikatów przy użyciu JMS
			17.2.1. Konfiguracja brokera komunikatów w Springu
			17.2.2. Szablon JMS Springa
			17.2.3. Tworzenie obiektów POJO sterowanych komunikatami
			17.2.4. Używanie RPC opartego na komunikatach
		17.3. Obsługa komunikatów przy użyciu AMQP
			17.3.1. Krótkie wprowadzenie do AMQP
			17.3.2. Konfigurowanie Springa do wymiany komunikatów przy użyciu AMQP
			17.3.3. Wysyłanie komunikatów przy użyciu RabbitTemplate
			17.3.4. Odbieranie komunikatów AMQP
		17.4. Podsumowanie
	Rozdział 18. Obsługa komunikatów przy użyciu WebSocket i STOMP
		18.1. Korzystanie z API WebSocket niskiego poziomu
		18.2. Rozwiązanie problemu braku obsługi WebSocket
		18.3. Wymiana komunikatów z użyciem STOMP
			18.3.1. Włączanie obsługi komunikatów STOMP
			18.3.2. Obsługa komunikatów STOMP nadsyłanych przez klienty
			18.3.3. Wysyłanie komunikatów do klienta
		18.4. Komunikaty skierowane do konkretnego klienta
			18.4.1. Obsługa komunikatów skojarzonych z użytkownikiem w kontrolerze
			18.4.2. Wysyłanie komunikatów do konkretnego użytkownika
		18.5. Obsługa wyjątków komunikatów
		18.6. Podsumowanie
	Rozdział 19. Wysyłanie poczty elektronicznej w Springu
		19.1. Konfigurowanie Springa do wysyłania wiadomości e-mail
			19.1.1. Konfigurowanie komponentu wysyłającego
			19.1.2. Dowiązanie komponentu wysyłającego pocztę do komponentu usługi
		19.2. Tworzenie e-maili z załącznikami
			19.2.1. Dodawanie załączników
			19.2.2. Wysyłanie wiadomości e-mail z bogatą zawartością
		19.3. Tworzenie wiadomości e-mail przy użyciu szablonów
			19.3.1. Tworzenie wiadomości e-mail przy użyciu Velocity
			19.3.2. Stosowanie Thymeleaf do tworzenia wiadomości e-mail
		19.4. Podsumowanie
	Rozdział 20. Zarządzanie komponentami Springa za pomocą JMX
		20.1. Eksportowanie komponentów Springa w formie MBean
			20.1.1. Udostępnianie metod na podstawie nazwy
			20.1.2. Użycie interfejsów do definicji operacji i atrybutów komponentu zarządzanego
			20.1.3. Praca z komponentami MBean sterowanymi adnotacjami
			20.1.4. Postępowanie przy konfliktach nazw komponentów zarządzanych
		20.2. Zdalny dostęp do komponentów zarządzanych
			20.2.1. Udostępnianie zdalnych komponentów MBean
			20.2.2. Dostęp do zdalnego komponentu MBean
			20.2.3. Obiekty pośredniczące komponentów zarządzanych
		20.3. Obsługa powiadomień
			20.3.1. Odbieranie powiadomień
		20.4. Podsumowanie
	Rozdział 21. Upraszczanie tworzenia aplikacji przy użyciu Spring Boot
		21.1. Prezentacja Spring Boot
			21.1.1. Dodawanie zależności początkowych
			21.1.2. Automatyczna konfiguracja
			21.1.3. Spring Boot CLI
			21.1.4. Aktuator
		21.2. Pisanie aplikacji korzystającej ze Spring Boot
			21.2.1. Obsługa żądań
			21.2.2. Tworzenie widoku
			21.2.3. Dodawanie statycznych artefaktów
			21.2.4. Trwałe zapisywanie danych
			21.2.5. Próba aplikacji
		21.3. Stosowanie Groovy i Spring Boot CLI
			21.3.1. Pisanie kontrolera w języku Groovy
			21.3.2. Zapewnianie trwałości danych przy użyciu repozytorium Groovy
			21.3.3. Uruchamianie Spring Boot CLI
		21.4. Pozyskiwanie informacji o aplikacji z użyciem aktuatora
		21.5. Podsumowanie
Skorowidz