Spring. Receptury - ebook

Najlepsze receptury na wykorzystanie Springa!

Spring zadebiutował na rynku w 2004 roku, osiem lat po opublikowaniu pierwszej wersji języka Java i od tego czasu jest dynamicznie rozwijany. Dzięki licznym modułom pozwala on błyskawicznie tworzyć skomplikowane aplikacje i wyręcza programistów w trudzie ustawiania typowych konfiguracji. Jeżeli do tego dołożyć ogromną społecznoć i świetną dokumentację, to nie ma się co dziwić, że jest tak popularny!

Jeżeli wykorzystujesz Springa w swojej codziennej pracy lub chcesz wypróbować jego możliwoci, to trafiłe na doskonałą książkę. Należy ona do cenionej wśród programistów serii Receptury. Znajdziesz w niej omówienie zarówno podstawowych zagadnień związanych ze Springiem, jak i tych zaawansowanych. Na samym początku poznasz kontener IoC (ang. Inversion of Control), nauczysz się tworzyć ziarna oraz wstrzykiwać je na różne sposoby. W kolejnych rozdziałach odkryjesz, jak korzystać z AspectJ, Spring WebFlow oraz Spring-WS. Ponadto zobaczysz, jak używać REST, testów jednostkowych i integracyjnych oraz ORM. Spring wspiera te i wiele innych obszarów codziennej pracy programisty. Książka ta jest doskonałym omówieniem Springa na podstawie przykładów jego zastosowań.

Dzięki tej książce:

• stworzysz kontener IoC
• skonstruujesz ziarna i wstrzykniesz je
• poznasz dostępne moduły
• przygotujesz usługi sieciowe i skorzystasz z tych usług

Wykorzystaj potencjał Springa i zoptymalizuj swoją pracę!

O autorach (13)

O recenzentach technicznych (15)

Podziękowania (17)

Wprowadzenie (19)

• Dla kogo przeznaczona jest ta książka? (19)
• Struktura książki (20)
• Konwencje (21)
• Wymagania wstępne (21)
• Pobieranie kodu (21)
• Kontakt z autorami (21)

Rozdział 1. Wprowadzenie do platformy Spring (23)

• 1.1. Tworzenie egzemplarza kontenera IoC w Springu (23)
• 1.2. Konfigurowanie ziaren w kontenerze IoC (26)
• 1.3. Tworzenie ziaren za pomocą konstruktora (34)
• 1.4. Wybieranie konstruktora w przypadku wieloznaczności (37)
• 1.5. Podawanie referencji do ziaren (39)
• 1.6. Określanie typu danych elementów kolekcji (43)
• 1.7. Tworzenie ziaren za pomocą interfejsu FactoryBean Springa (45)
• 1.8. Definiowanie kolekcji za pomocą ziaren fabrycznych i schematu util (47)
• 1.9. Sprawdzanie właściwości na podstawie zależności (49)
• 1.10. Sprawdzanie właściwości z adnotacją @Required (51)
• 1.11. Automatyczne łączenie ziaren za pomocą konfiguracji w pliku XML (53)
• 1.12. Automatyczne łączenie ziaren z adnotacjami @Autowired i @Resource (57)
• 1.13. Dziedziczenie konfiguracji ziarna (62)
• 1.14. Skanowanie komponentów z parametru classpath (65)
• Podsumowanie (70)

Rozdział 2. Zaawansowany kontener IoC w Springu (71)

• 2.1. Tworzenie ziaren za pomocą statycznych metod fabrycznych (71)
• 2.2. Tworzenie ziaren za pomocą fabrycznej metody egzemplarza (72)
• 2.3. Deklarowanie ziaren na podstawie pól statycznych (74)
• 2.4. Deklarowanie ziaren na podstawie właściwości obiektów (75)
• 2.5. Używanie języka wyrażeń dostępnego w Springu (77)
• 2.6. Ustawianie zasięgu ziarna (82)
• 2.7. Modyfikowanie procesu inicjowania i usuwania ziaren (84)
• 2.8. Skracanie konfiguracji w XML-u za pomocą projektu Java Config (88)
• 2.9. Ziarna znające zasoby kontenera (92)
• 2.10. Wczytywanie zasobów zewnętrznych (93)
• 2.11. Tworzenie postprocesorów ziaren (96)
• 2.12. Zewnętrzne przechowywanie konfiguracji ziarna (99)
• 2.13. Określanie komunikatów tekstowych (100)
• 2.14. Komunikowanie się ze zdarzeniami aplikacji (102)
• 2.15. Rejestrowanie edytorów właściwości w Springu (105)
• 2.16. Tworzenie niestandardowych edytorów właściwości (108)
• 2.17. Obsługa współbieżności za pomocą interfejsu TaskExecutor (109)
• Podsumowanie (117)

Rozdział 3. Programowanie aspektowe i obsługa języka AspectJ w Springu (119)

• 3.1. Włączanie obsługi adnotacji języka AspectJ w Springu (120)
• 3.2. Deklarowanie aspektów za pomocą adnotacji języka AspectJ (122)
• 3.3. Dostęp do informacji o punkcie złączenia (127)
• 3.4. Określanie pierwszeństwa aspektów (128)
• 3.5. Ponowne wykorzystanie definicji punktu przecięcia (130)
• 3.6. Pisanie wyrażeń z punktami przecięcia w języku AspectJ (132)
• 3.7. Dodawanie operacji do ziaren (136)
• 3.8. Dodawanie stanu do ziarna (138)
• 3.9. Deklarowanie aspektów za pomocą konfiguracji w XML-u (140)
• 3.10. Wplatanie aspektów języka AspectJ w Springu w czasie ładowania (143)
• 3.11. Konfigurowanie w Springu aspektów języka AspectJ (148)
• 3.12. Wstrzykiwanie ziaren Springa do obiektów domenowych (149)
• Podsumowanie (152)

Rozdział 4. Skrypty w Springu (153)

• 4.1. Implementowanie ziaren za pomocą języków skryptowych (153)
• 4.2. Wstrzykiwanie ziaren Springa do skryptów (157)
• 4.3. Aktualizowanie ziaren ze skryptów (160)
• 4.4. Wewnątrzwierszowe definiowanie kodu źródłowego skryptów (161)
• Podsumowanie (162)

Rozdział 5. Bezpieczeństwo w Springu (163)

• 5.1. Zabezpieczanie dostępu do adresów URL (163)
• 5.2. Logowanie się do aplikacji sieciowych (172)
• 5.3. Uwierzytelnianie użytkowników (176)
• 5.4. Podejmowanie decyzji z zakresu kontroli dostępu (185)
• 5.5. Zabezpieczanie wywołań metod (188)
• 5.6. Obsługa zabezpieczeń w widokach (190)
• 5.7. Zabezpieczanie obiektów domenowych (192)
• Podsumowanie (200)

Rozdział 6. Integrowanie Springa z innymi platformami do tworzenia aplikacji sieciowych (203)

• 6.1. Dostęp do Springa w dowolnych aplikacjach sieciowych (204)
• 6.2. Używanie Springa w serwletach i filtrach (208)
• 6.3. Integrowanie Springa z platformą Struts 1.x (212)
• 6.4. Integrowanie Springa z platformą JSF (218)
• 6.5. Integrowanie Springa z platformą DWR (223)
• Podsumowanie (227)

Rozdział 7. Platforma Spring Web Flow (229)

• 7.1. Zarządzanie prostym przepływem sterowania za pomocą platformy Spring Web Flow (229)
• 7.2. Modelowanie przepływów sterowania za pomocą różnych rodzajów stanów (236)
• 7.3. Zabezpieczanie przepływów sterowania w aplikacjach sieciowych (247)
• 7.4. Utrwalanie obiektów w przepływach sterowania w aplikacjach sieciowych (249)
• 7.5. Integrowanie platformy Spring Web Flow z technologią JSF (255)
• 7.6. Korzystanie z platformy RichFaces w platformie Spring Web Flow (262)
• Podsumowanie (266)

Rozdział 8. Platforma Spring MVC (267)

• 8.1. Tworzenie prostej aplikacji sieciowej za pomocą platformy Spring MVC (267)
• 8.2. Wiązanie żądań za pomocą adnotacji @RequestMapping (278)
• 8.3. Przechwytywanie żądań przy użyciu interceptorów przetwarzania (282)
• 8.4. Określanie ustawień regionalnych użytkowników (285)
• 8.5. Pliki zewnętrzne z tekstem dostosowanym do ustawień regionalnych (287)
• 8.6. Określanie widoków na podstawie nazw (289)
• 8.7. Widoki i negocjowanie treści (291)
• 8.8. Wiązanie wyjątków z widokami (294)
• 8.9. Przypisywanie wartości w kontrolerze za pomocą adnotacji @Value (296)
• 8.10. Obsługiwanie formularzy za pomocą kontrolerów (297)
• 8.11. Obsługa wielu formularzy za pomocą kontrolerów formularzy kreatora (310)
• 8.12. Sprawdzanie poprawności ziaren za pomocą adnotacji (na podstawie standardu JSR-303) (319)
• 8.13. Tworzenie widoków w formatach XLS i PDF (321)
• Podsumowanie (327)

Rozdział 9. Usługi REST w Springu (329)

• 9.1. Publikowanie usług typu REST w Springu (329)
• 9.2. Dostęp do usług typu REST w Springu (333)
• 9.3. Publikowanie danych z kanałów informacyjnych RSS i Atom (338)
• 9.4. Publikowanie danych w formacie JSON w usługach typu REST (345)
• 9.5. Dostęp do usług typu REST zwracających skomplikowane odpowiedzi w formacie XML (348)
• Podsumowanie (356)

Rozdział 10. Spring i Flex (357)

• 10.1. Wprowadzenie do środowiska Flex (359)
• 10.2. Poza piaskownicę (364)
• 10.3. Dodawanie obsługi narzędzia Spring BlazeDS Integration do aplikacji (374)
• 10.4. Udostępnianie usług za pomocą technologii BlazeDS i Springa (378)
• 10.5. Używanie obiektów działających po stronie serwera (384)
• 10.6. Korzystanie z usług opartych na komunikatach w narzędziach BlazeDS i Spring (387)
• 10.7. Wstrzykiwanie zależności w kliencie w ActionScripcie (398)
• Podsumowanie (402)

Rozdział 11. Grails (403)

• 11.1. Pobieranie i instalowanie platformy Grails (403)
• 11.2. Tworzenie aplikacji za pomocą platformy Grails (404)
• 11.3. Wtyczki platformy Grails (408)
• 11.4. Środowisko rozwojowe, produkcyjne i testowe w platformie Grails (410)
• 11.5. Tworzenie klas domenowych aplikacji (412)
• 11.6. Generowanie kontrolerów CRUD i widoków na potrzeby klas domenowych aplikacji (414)
• 11.7. Właściwości związane z umiędzynarodawianiem komunikatów (417)
• 11.8. Zmienianie systemu pamięci trwałej (420)
• 11.9. Rejestrowanie danych wyjściowych (423)
• 11.10. Przeprowadzanie testów jednostkowych i integracyjnych (425)
• 11.11. Stosowanie niestandardowych układów i szablonów (430)
• 11.12. Zapytania GORM (432)
• 11.13. Tworzenie niestandardowych znaczników (434)
• Podsumowanie (436)

Rozdział 12. Spring Roo (437)

• 12.1. Konfigurowanie środowiska programistycznego pod kątem narzędzia Spring Roo (439)
• 12.2. Tworzenie pierwszego projektu opartego na narzędziu Roo (441)
• 12.3. Importowanie istniejących projektów do środowiska STS (446)
• 12.4. Szybsze budowanie lepszych aplikacji (448)
• 12.5. Usuwanie Roo z projektu (454)
• Podsumowanie (456)

Rozdział 13. Testy w Springu (457)

• 13.1. Tworzenie testów za pomocą platform JUnit i TestNG (458)
• 13.2. Tworzenie testów jednostkowych i testów integracyjnych (463)
• 13.3. Testy jednostkowe kontrolerów platformy Spring MVC (471)
• 13.4. Zarządzanie kontekstem aplikacji w testach integracyjnych (472)
• 13.5. Wstrzykiwanie konfiguracji testów w testach integracyjnych (478)
• 13.6. Zarządzanie transakcjami w testach integracyjnych (482)
• 13.7. Dostęp do bazy danych w testach integracyjnych (487)
• 13.8. Stosowanie w Springu standardowych adnotacji związanych z testami (491)
• Podsumowanie (493)

Rozdział 14. Platforma Spring Portlet MVC (495)

• 14.1. Tworzenie prostego portletu za pomocą platformy Spring Portlet MVC (495)
• 14.2. Wiązanie żądań kierowanych do portletów z metodami obsługi (503)
• 14.3. Obsługa formularzy z portletów za pomocą prostych kontrolerów formularzy (510)
• Podsumowanie (517)

Rozdział 15. Dostęp do danych (519)

• Problemy z bezpośrednim korzystaniem z JDBC (520)
• 15.1. Używanie szablonu JDBC do aktualizowania bazy danych (526)
• 15.2. Używanie szablonów JDBC do pobierania danych z bazy (530)
• 15.3. Upraszczanie tworzenia szablonów JDBC (535)
• 15.4. Używanie prostego szablonu JDBC w Javie 1.5 (537)
• 15.5. Stosowanie nazwanych parametrów w szablonach JDBC (540)
• 15.6. Obsługa wyjątków w platformie Spring JDBC (542)
• 15.7. Problemy z bezpośrednim używaniem platform do tworzenia odwzorowań ORM (547)
• 15.8. Konfigurowanie fabryk zasobów ORM w Springu (556)
• 15.9. Utrwalanie obiektów za pomocą szablonów ORM Springa (562)
• 15.10. Utrwalanie obiektów za pomocą sesji kontekstowych platformy Hibernate (567)
• 15.11. Utrwalanie obiektów za pomocą wstrzykiwania kontekstu w JPA (570)
• Podsumowanie (573)

Rozdział 16. Zarządzanie transakcjami w Springu (575)

• 16.1. Problemy z zarządzaniem transakcjami (576)
• 16.2. Jak wybrać implementację menedżera transakcji? (581)
• 16.3. Programowe zarządzanie transakcjami za pomocą interfejsu menedżera transakcji (583)
• 16.4. Programowe zarządzanie transakcjami za pomocą szablonu transakcji (585)
• 16.5. Deklaratywne zarządzanie transakcjami za pomocą rad transakcji (588)
• 16.6. Deklaratywne zarządzanie transakcjami za pomocą adnotacji @Transactional (590)
• 16.7. Ustawianie atrybutu propagation transakcji (591)
• 16.8. Ustawianie atrybutu określającego poziom izolacji transakcji (596)
• 16.9. Ustawianie atrybutu dotyczącego wycofywania transakcji (602)
• 16.10. Ustawianie atrybutów związanych z limitem czasu i trybem tylko do odczytu (604)
• 16.11. Zarządzanie transakcjami za pomocą wplatania w czasie ładowania (605)
• Podsumowanie (608)

Rozdział 17. Ziarna EJB, zdalne wywołania i usługi sieciowe (609)

• 17.1. Udostępnianie i wywoływanie usług za pomocą technologii RMI (609)
• 17.2. Tworzenie komponentów EJB 2.x za pomocą Springa (613)
• 17.3. Dostęp do dawnych komponentów EJB 2.x w Springu (618)
• 17.4. Tworzenie komponentów EJB 3.0 w Springu (621)
• 17.5. Dostęp do komponentów EJB 3.0 w Springu (623)
• 17.6. Udostępnianie i wywoływanie usług za pomocą protokołu HTTP (625)
• 17.7. Wybieranie sposobu tworzenia usług sieciowych SOAP (628)
• 17.8. Udostępnianie i wywoływanie usług sieciowych SOAP z kontraktem pisanym na końcu za pomocą JAX-WS (630)
• 17.9. Definiowanie kontraktu usługi sieciowej (636)
• 17.10. Implementowanie usług sieciowych za pomocą platformy Spring-WS (640)
• 17.11. Wywoływanie usług sieciowych za pomocą platformy Spring-WS (645)
• 17.12. Tworzenie usług sieciowych za pomocą serializowania dokumentów XML (648)
• 17.13. Tworzenie punktów końcowych usług za pomocą adnotacji (653)
• Podsumowanie (655)

Rozdział 18. Spring w Javie EE (657)

• 18.1. Eksportowanie ziaren Springa jako ziaren MBeans technologii JMX (657)
• 18.2. Publikowanie i odbieranie powiadomień JMX (667)
• 18.3. Dostęp do zdalnych ziaren MBeans technologii JMX w Springu (669)
• 18.4. Wysyłanie e-maili za pomocą dostępnej w Springu obsługi poczty elektronicznej (672)
• 18.5. Planowanie zadań za pomocą dostępnej w Springu obsługi Quartza (679)
• 18.6. Planowanie zadań za pomocą przestrzeni nazw Scheduling ze Springa 3.0 (683)
• Podsumowanie (686)

Rozdział 19. Komunikaty (687)

• 19.1. Wysyłanie i pobieranie komunikatów JMS w Springu (688)
• 19.2. Przekształcanie komunikatów JMS (698)
• 19.3. Zarządzanie transakcjami JMS (700)
• 19.4. Tworzenie w Springu obiektów POJO sterowanych komunikatami (701)
• 19.5. Nawiązywanie połączeń (706)
• Podsumowanie (708)

Rozdział 20. Platforma Spring Integration (709)

• 20.1. Integrowanie jednego systemu z innym za pomocą EAI (710)
• 20.2. Integrowanie dwóch systemów za pomocą technologii JMS (712)
• 20.3. Wyszukiwanie informacji o kontekście w komunikatach platformy Spring Integration (716)
• 20.4. Integrowanie dwóch systemów za pomocą systemu plików (718)
• 20.5. Przekształcanie komunikatów z jednego typu na inny (720)
• 20.6. Obsługa błędów za pomocą platformy Spring Integration (723)
• 20.7. Rozdzielanie operacji w integrowanych mechanizmach - rozdzielacze i agregatory (726)
• 20.8. Warunkowe przekazywanie za pomocą komponentu router (729)
• 20.9. Dostosowywanie zewnętrznych systemów do magistrali (730)
• 20.10. Podział zdarzeń na etapy za pomocą projektu Spring Batch (739)
• 20.11. Używanie bram (740)
• Podsumowanie (745)

Rozdział 21. Platforma Spring Batch (747)

• 21.1. Konfigurowanie infrastruktury platformy Spring Batch (749)
• 21.2. Odczyt i zapis (751)
• 21.3. Tworzenie niestandardowych implementacji interfejsów ItemWriter i ItemReader (756)
• 21.4. Przetwarzanie danych wejściowych przed ich zapisaniem (758)
• 21.5. Łatwiejsza praca dzięki transakcjom (761)
• 21.6. Ponawianie prób (762)
• 21.7. Kontrolowanie wykonywania kroków (765)
• 21.8. Uruchamianie zadania (769)
• 21.9. Parametry w zadaniach (772)
• Podsumowanie (774)

Rozdział 22. Przetwarzanie rozproszone w Springu (775)

• 22.1. Przechowywanie stanu obiektów w klastrach za pomocą narzędzia Terracotta (777)
• 22.2. Przetwarzanie w gridzie (785)
• 22.3. Równoważenie obciążenia przy wykonywaniu metody (787)
• 22.4. Przetwarzanie równoległe (790)
• 22.5. Instalowanie aplikacji korzystających z narzędzia GridGain (792)
• Podsumowanie (796)

Rozdział 23. Spring i jBPM (797)

• Procesy w oprogramowaniu (798)
• 23.1. Modele przepływu pracy (800)
• 23.2. Instalowanie systemu jBPM (802)
• 23.3. Integrowanie systemu jBPM 4 ze Springiem (804)
• 23.4. Tworzenie usług za pomocą Springa (809)
• 23.5. Tworzenie procesu biznesowego (812)
• Podsumowanie (814)

Rozdział 24. Spring i OSGi (815)

• 24.1. Początki pracy z OSGi (816)
• 24.2. Wprowadzenie do korzystania z platformy Spring Dynamic Modules (821)
• 24.3. Eksportowanie usług za pomocą platformy Spring Dynamic Modules (825)
• 24.4. Wyszukiwanie konkretnych usług w rejestrze OSGi (828)
• 24.5. Publikowanie usług zgodnych z wieloma interfejsami (830)
• 24.6. Dostosowywanie działania platformy Spring Dynamic Modules (831)
• 24.7. Używanie serwera dm Server firmy SpringSource (832)
• 24.8. Narzędzia firmy SpringSource (834)
• Podsumowanie (835)

Skorowidz (837)