Long J. - Spring. Receptury

Spis treści

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

SPIS TREŚCI

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

SPIS TREŚCI

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

7

SPIS TREŚCI

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 8

SPIS TREŚCI

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

9

SPIS TREŚCI

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

10

SPIS TREŚCI

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

11

SPIS TREŚCI

12



O autorach

Gary Mak jest założycielem firmy Meta-Archit Software Technology, gdzie zajmuje stanowisko głównego konsultanta. Przez ponad siedem lat był architektem technicznym i programistą aplikacji opartych na platformie Java EE. Jest autorem wydanych przez wydawnictwo Apress książek Spring Recipes: A Problem-Solution Approach i Pro SpringSource dm Server. W trakcie swojej kariery opracował wiele projektów oprogramowania bazujących na Javie. Większość z nich to: platformy do tworzenia aplikacji, projekty infrastruktury systemów i narzędzia do tworzenia oprogramowania. Gary uwielbia projektować i implementować skomplikowane aspekty oprogramowania. Posiada dyplom magistra nauk komputerowych, a jego zainteresowania obejmują: technologie obiektowe, technologie aspektowe, wzorce projektowe, ponowne wykorzystanie oprogramowania i programowanie domenowe. Gary specjalizuje się w tworzeniu aplikacji korporacyjnych za pomocą takich technologii jak: Spring, Hibernate, JPA, JSF, Portlet, AJAX i OSGi. Platformy Spring używa w projektach od pięciu lat, od czasu pojawienia się wersji Spring 1.0. Gary prowadził szkolenia z zakresu technologii: Jave EE, Spring, Hibernate, Web Services i programowania zwinnego. Na potrzeby tych kursów napisał serię samouczków na temat platform Spring i Hibernate. Niektóre z tych materiałów zostały udostępnione publicznie i zyskują coraz większą popularność w społeczności związanej z Javą. W wolnym czasie Gary lubi grać w tenisa i oglądać rozgrywki tenisowe. Josh Long pracuje na stanowisku Spring Developer Advocate w firmie SpringSource. Jest inżynierem (najczęściej pełni rolę architekta) o ponaddziesięcioletnim doświadczeniu, a także aktywnie uczestniczy w życiu społeczności związanej z Javą. Współtworzy projekty o otwartym dostępie do kodu źródłowego, w tym projekt Spring Integration. Uczestniczy w programie JCP i jest redaktorem popularnego serwisu poświęconego technologiom, http://InfoQ.com. Josh często występuje na krajowych i międzynarodowych konferencjach, gdzie prowadzi wykłady na temat rozmaitych zagadnień: od zarządzania procesami biznesowymi, przez platformy do tworzenia aplikacji sieciowych, po integrację aplikacji korporacyjnych i wzorce architektoniczne. Do jego zainteresowań należą: skalowalność, zarządzanie procesami biznesowymi, przetwarzanie siatkowe, praca na urządzeniach przenośnych i systemy inteligentne. Na stanowisku Spring Developer Advocate w firmie SpringSource Josh koncentruje się na powiększaniu i rozwijaniu społeczności skupionej wokół platformy Spring. Mieszka w słonecznej południowej części Kalifornii razem ze swoją żoną Richelle. Prowadzi blog http://www.joshlong.com. Skontaktować się z Joshem można pod adresem [email protected].

O AUTORACH

Daniel Rubio jest konsultantem i ma ponaddziesięcioletnie doświadczenie z zakresu technologii korporacyjnych i sieciowych. W czasie swojej kariery korzystał z Javy i Pythona oraz z technologii CORBA i .NET do tworzenia niedrogich rozwiązań w branżach finansowej i produkcyjnej. Od niedawna Daniel koncentruje się na platformach do tworzenia aplikacji sieciowych działających w modelu Convention Over Configuration (Spring, Grails, Roo i Django), przy czym najbardziej interesują go wydajność i skalowalność takich narzędzi w środowisku korporacyjnym. Daniel ponadto pisze artykuły na temat nowych technologii dla różnych sieci informacyjnych (takich jak Oracle Technology Network i Dzone), a także prowadzi blog http://www.WebForefront.com.

14



O recenzentach technicznych

Manuel Jordan Elera jest programistą Javy pracującym jako wolny strzelec. Dla swoich klientów projektował i tworzył spersonalizowane systemy, używając do tego między innymi rozbudowanych platform Javy, takich jak Spring i Hibernate. Manuel jest obecnie programistą samoukiem i lubi poznawać nowe platformy, które ułatwiają mu pracę. Manuel posiada dyplom inżyniera systemów (studia ukończył z wyróżnieniem) oraz jest profesorem na uczelniach Universidad Católica de Santa María i Universidad Alas Peruanas w Peru. W wolnym czasie, którego ma niewiele, lubi czytać Biblię i komponować muzykę gitarową. Manuel jest zasłużonym członkiem forum Spring Community, gdzie posługuje się ksywką dr_pompeii. Z Manuelem możesz się skontaktować przez jego blog: http://manueljordan.wordpress.com/. Mario Gray jest inżynierem i ma ponaddziesięcioletnie doświadczenie w nast.ępujących dziedzinach: integracji systemów, zarządzaniu systemami, programowaniu gier i wysoce dostępnych architektur korporacyjnych. Nieustannie śledzi nowe technologie usprawniające pracę, które mogą ułatwiać funkcjonowanie firm. Opracował niezliczone systemy, w tym: systemy CRM, fabryki komunikatów i wysoce dostępne aplikacje sieciowe. Stosował przy tym popularne systemy o otwartym dostępie do kodu źródłowego, a także platformy i narzędzia związane z Javą EE. Mario ma doświadczenie w udanym wykorzystywaniu platform o otwartym dostępie do kodu źródłowego do usprawniania pracy firm. Mario mieszka w Chandler w stanie Arizona razem ze swoją żoną Fumiko i córką Makani. Poza pracą lubi rekreację na świeżym powietrzu oraz spędzanie czasu z rodziną. Mario prowadzi blog http://www.sudoinit5.com i jest dostępny pod adresem [email protected].

O RECENZENTACH TECHNICZNYCH

Greg Turnquist jest wielkim fanem testów i skryptów, który do wykonania każdego zadania szuka odpowiedniego narzędzia. Zawodowo zajmuje się programowaniem od 1997 roku. Pracował nad wieloma różnymi systemami, w tym nad krytycznymi, które muszą pracować 24 godziny na dobę, 7 dni w tygodniu przez 365 dni w roku. W 2006 roku Greg opracował projekt Spring Python. W jego ramach przeniósł rozwiązania z platformy Spring do Pythona. W 2010 roku Greg dołączył do firmy SpringSource. Napisał książkę Spring Python 1.1 i wygłaszał wykłady na konferencji SpringOne. Otrzymał dyplom magistra uczelni Auburn University i mieszka w Stanach Zjednoczonych razem ze swoją rodziną.

16



Podziękowania Nie zamierzam kłamać — konieczność napisania podziękowań jest dla mnie przerażająca. Ocena (przeze mnie lub kogokolwiek innego) bezpośredniego lub pośredniego wkładu poszczególnych osób w powstanie tej książki wydaje mi się niemożliwa. Postaram się zrobić to, co w mojej mocy, ale niewykluczone, że kogoś pominę. Za to z góry gorąco przepraszam. Dziękuję mojej żonie Richelle za nieustającą cierpliwość, wyrozumiałość, mądrość, wsparcie i miłość. Jestem wdzięczny moim rodzicom (mamie i tacie oraz ich partnerom) i teściom za ich wpływ na mnie, wyrozumiałość, wsparcie i miłość. Dziękuję współautorom tej pozycji, Gary’emu Makowi i Danielowi Rubio, którzy przyczynili się do tego, że jest to najciekawsza książka, jaką kiedykolwiek przeczytałem (a tym bardziej napisałem)! Jestem wdzięczny fantastycznym redaktorom. Oto oni: Steve Anglin, Laurin Becker, Tom Welsh, Manuel Jordan, Mario Gray i Greg Turnquist. Dbali oni o najwyższą jakość książki na każdym etapie procesu jej powstawania i robili to z wielkim profesjonalizmem. Dziękuję zwłaszcza Gregowi Turnquistowi, który przez cały czas trwania prac nad tą książką przekazywał nam bardzo cenne wskazówki. Greg jest inżynierem w firmie SpringSource i kierownikiem projektu Spring Python, w ramach którego powstaje pythonowa wersja platformy Spring, przeznaczona do użytku w Pythonie. Greg pisze też wydawaną przez wydawnictwo Manning książkę Spring Python in Action, która powinna być niezwykle ciekawą lekturą. Dziękuję także Markowi Fisherowi, kierownikowi projektu Spring Integration. Cenię ten projekt, ponieważ pozwala (podobnie jak podstawowa platforma) w elegancki sposób rozwiązywać bardzo skomplikowane problemy. Dzięki niemu niemożliwe do wykonania zadania stają się trudne, a skomplikowane problemy — łatwe. Jestem wdzięczny Markowi za jego projekt, a także wyrozumiałość, entuzjazm i wsparcie w związku z moim wkładem w prace nad tym projektem. Dziękuję mu także za jego dobroć. Jestem redaktorem serwisu InfoQ.com. Ta książka powstała w wyniku roku ciężkiej pracy w obliczu zupełnie nieprzewidywalnych harmonogramów i bardzo wymagających terminów. Choć w tym czasie pracowałem w chaotyczny sposób, zespół odpowiedzialny za wspomniany serwis był dla mnie niezwykle wyrozumiały. Dziękuję Floydowi Marinescu, Charlesowi Humble’owi i Ryanowi Slobojanowi, a także całemu zespołowi z serwisu InfoQ.com za podnoszenie poprzeczki w dziedzinie dziennikarstwa technicznego oraz za nieustające wsparcie i inspiracje. Na zakończenie wyrażam wdzięczność wszystkim moim współpracownikom z firmy Shopzilla. W czasie gdy powstawała ta książka, przenosiłem się z Shopzilli do SpringSource. Shopzilla to zdecydowanie najlepsza firma, w jakiej miałem przyjemność pracować. Jest pełna fantastycznych ludzi. Każdego dnia uczyłem się tam czegoś nowego i cieszyłem się przyjacielską atmosferą, jakiej nie widziałem wcześniej w żadnej innej firmie. Kultura pracy była tam bardzo wysoka — nie da się znaleźć lepszego miejsca zatrudnienia dla zmotywowanego inżyniera. Efekty naszej pracy były rewelacyjne. W czasie gdy byłem tam zatrudniony, miałem szczęście pracować z wieloma świetnymi ludźmi, dlatego opracowanie krótkiej listy, którą dalej przytaczam, było bardzo trudne. Oto osoby, którym dziękuję za ich wskazówki, przyjaźń i wsparcie: Tim Morrow, Rodney Barlow, Andy Chan, Rob Roland, Paul Snively, Phil Dixon i Jody Mulkey. — Josh Long

PODZIĘKOWANIA

Przede wszystkim dziękuję współautorom tej książki. Gary Mak napisał jej pierwsze wydanie i zadbał o jego wysoki poziom, dzięki czemu stało się ono jednym z bestsellerów w dziedzinie Springa i Javy. Z kolei Josh Long napisał książkę Spring Enterprise Recipes. Obie te pozycje zostały ściśle zintegrowane i zaktualizowane, a w efekcie powstało niniejsze nowe, drugie wydanie książki Spring. Receptury. Dziękuję też wszystkim osobom z wydawnictwa Apress. Steve Anglin, Matt Moodie i Tom Welsh brali udział we wszystkich etapach procesu powstawania tej książki — od określania struktury spisu treści po lekturę każdej strony. Laurin Becker pełniła rolę menedżera projektu i dbała o połączenie wszystkich elementów, a także o to, aby wszyscy na czas wykonywali swoją pracę. Ponadto jestem oczywiście wdzięczny wszystkim osobom z wydawnictwa Apress, które przyczyniły się do powstania tej książki i z którymi nie miałem okazji kontaktować się bezpośrednio. Są to między innymi: adiustator, korektor i projektant okładki. Jeśli chodzi o kwestie techniczne i pomoc w zapewnieniu poprawności treści tej książki, specjalne podziękowania należą się Manuelowi Jordanowi, który pełnił rolę recenzenta technicznego tej pozycji. Dziękuję też Mario Grayowi, który również brał udział w procesie recenzji technicznej. Powstanie tej książki nie byłoby możliwe, gdyby nie liczne artykuły, wpisy na blogach i fragmenty dokumentacji przygotowane przez wiele osób pracujących nad narzędziami Spring i Grails. Byli to między innymi: Arjen Poutsma, Juergen Hoeller, Alef Arendsen i Graeme Rocher. Oczywiście dziękuję też wielu innym aktywnym w tym obszarze osobom, które z pewnością wpłynęły na mój sposób myślenia. Niestety z powodu ograniczonej ilości miejsca nie mogę wymienić ich wszystkich z imienia i nazwiska. Na zakończenie dziękuję mojej rodzinie i przyjaciołom. Dużym zaskoczeniem dla nich było już to, że wziąłem się za pisanie. Dowodem na ich cierpliwość były puste spojrzenia w momencie, gdy próbowałem w przystępny sposób przedstawić im treść tej książki. Jednak nawet mimo tych spojrzeń moim bliskim udawało się zadawać poważne pytania, które pomogły mi zachować entuzjazm. Dlatego dziękuję wszystkim, którzy zwyczajnie zadawali mi pytania. Dzięki udzielonemu mi bezpośredniemu wsparciu przyczyniliście się do powstania tej książki. — Daniel Rubio

18



Wprowadzenie Platforma Spring wciąż jest rozwijana. Od zawsze jest budowana po to, aby zapewnić programistom większy wybór. W Javie EE skoncentrowano się na kilku technologiach, a zrezygnowano z innych, czasem lepszych rozwiązań. Gdy pojawiła się platforma Spring, mało kto uważał, że Java EE była najlepszą architekturą w swojej klasie. Wprowadzenie Springa spotkało się z dużym zainteresowaniem, ponieważ platforma ta pozwalała uprościć Javę EE. W każdej kolejnej wersji pojawiały się nowe funkcje, które ułatwiały lub umożliwiały tworzenie określonych rozwiązań. Od wersji 2.0 platforma Spring współdziała z różnymi systemami. Platforma, podobnie jak wcześniej, udostępnia usługi oparte na istniejących systemach, ale tam, gdzie to możliwe, jest od nich niezależna. Spring wciąż jest przeznaczony głównie dla Javy EE, jednak teraz nie jest to już jedyna docelowa architektura. Ważnym aspektem strategii wybranej przez firmę SpringSource jest wykorzystanie OSGi — obiecującej technologii do tworzenia architektury modułowej. Ponadto Spring współdziała z platformą Google App Engine. Po wprowadzeniu platform opartych na adnotacjach i schematów XML firma SpringSource zaczęła budować rozwiązania, które odzwierciedlają dziedziny konkretnych problemów. W efekcie powstają języki specyficzne dla domeny (ang. Domain-Specific Language — DSL). Pojawiły się też platformy budowane na podstawie Springa, które umożliwiają integrowanie aplikacji, przetwarzanie wsadowe, integrację z technologiami Flex i Flash, obsługę pakietu GWT, obsługę technologii OSGi itd. Kiedy nadeszła pora na zaktualizowanie ważnej książki Spring. Receptury, szybko dostrzegliśmy, że minęło dużo czasu od momentu, gdy istniała tylko jedna wersja platformy Spring. Firma SpringSource udostępnia obecnie kilka platform, z których każda zapewnia znacznie większe możliwości niż konkurencyjne produkty. Dzięki tej książce dobrze poznasz różne z tych platform. Jeśli nie potrzebujesz niektórych z omawianych rozwiązań, nie musisz ich stosować ani dodawać do projektu. Może jednak okazać się, że poszczególne platformy będą dla Ciebie przydatne, więc warto wiedzieć o ich istnieniu.

Dla kogo przeznaczona jest ta książka? Książka ta jest przeznaczona dla programistów Javy chcących uprościć stosowaną architekturę i rozwiązywać problemy, z którymi trudno poradzić sobie za pomocą samej Javy EE. Jeśli już korzystasz ze Springa w swoich projektach, w rozdziałach przeznaczonych dla zaawansowanych użytkowników znajdziesz omówienie nowych technologii, których być może jeszcze nie znasz. Jeżeli dopiero poznajesz Spring, dzięki tej książce szybko nauczysz się używać tej platformy. Zakładamy, że znasz już Javę i potrafisz korzystać z wybranego środowiska IDE. Choć możliwe (i przydatne) jest stosowanie Javy wyłącznie w aplikacjach klienckich, język ten najczęściej używany jest w środowisku korporacyjnym. To właśnie tam większość z omawianych tu technologii przynosi największe korzyści. Dlatego zakładamy też, że znasz podstawowe zagadnienia z zakresu programowania aplikacji korporacyjnych (na przykład interfejs Servlet API).

WPROWADZENIE

Struktura książki Rozdział 1., „Wprowadzenie do platformy Spring”, zawiera ogólne omówienie platformy Spring. Dowiesz się tu, jak skonfigurować platformę Spring, czym jest ta platforma i jak się jej używa. Rozdział 2., „Zaawansowany kontener IoC w Springu”, zawiera opis zagadnień, które wprawdzie nie są tak powszechnie spotykane jak kwestie z rozdziału 1., ale są ważne, jeśli chcesz wykorzystać wszystkie możliwości Springa. Rozdział 3., „Programowanie aspektowe i obsługa języka AspectJ w Springu”, to omówienie dostępnej w Springu obsługi programowania aspektowego w języku AspectJ. Rozdział 4., „Skrypty w Springu”, przedstawia stosowanie w Springu języków skryptowych, takich jak: Groovy, BeanShell i JRuby. Rozdział 5., „Bezpieczeństwo w Springu”, zawiera opis projektu Spring Security (jego wcześniejsza nazwa to Acegi), który ułatwia zabezpieczanie aplikacji. Rozdział 6., „Integrowanie Springa z innymi platformami do tworzenia aplikacji sieciowych”, zawiera wprowadzenie do dostępnej w Springu obsługi warstwy sieciowej. Opisane tu mechanizmy stanowią podstawę wszystkich technologii udostępnianych przez Spring w warstwie sieciowej. Rozdział 7., „Platforma Spring Web Flow”, to wprowadzenie do platformy Spring Web Flow. Umożliwia ona projektowanie przepływu sterowania w warstwie sieciowej. Rozdział 8., „Platforma Spring MVC”, przedstawia tworzenie aplikacji sieciowych za pomocą platformy Spring Web MVC. Rozdział 9., „Usługi REST w Springu”, zawiera wprowadzenie do dostępnej w Springu obsługi usług sieciowych typu REST. Rozdział 10., „Spring i Flex”, to omówienie stosowania technologii BlazeDS do integrowania bogatych aplikacji internetowych z ziarnami Springa. Ponadto znajdziesz tu wprowadzenie do platformy Spring ActionScript. Zapewnia ona użytkownikom tworzącym aplikacje flashowe w języku ActionScript te same usługi kontenerowe i udogodnienia, z których mogą korzystać programiści Javy. Rozdział 11., „Grails”, zawiera omówienie platformy Grails. Pozwala ona zwiększyć produktywność w wyniku zastosowania optymalnych elementów i połączenia ich kodem w języku Groovy. Rozdział 12., „Spring Roo”, przedstawia nową, przełomową platformę Spring Roo. Została ona opracowana w firmie SpringSource i ma przyspieszać pracę programistów używających Javy. Rozdział 13., „Testy w Springu”, to opis przeprowadzania testów jednostkowych w platformie Spring. Rozdział 14., „Platforma Spring Portlet MVC”, jest poświęcony używaniu platformy Spring Portlet MVC do budowania aplikacji i wykorzystywaniu zalet kontenera Portlet. Rozdział 15., „Dostęp do danych”, dotyczy stosowania Springa do komunikowania się z magazynami danych za pomocą takich interfejsów API jak JDBC, Hibernate i JPA. Rozdział 16., „Zarządzanie transakcjami w Springu”, to wprowadzenie do dostępnych w Springu mechanizmów zarządzania transakcjami. Rozdział 17., „Ziarna EJB, zdalne wywołania i usługi sieciowe”, zawiera wprowadzenie do różnych mechanizmów obsługi zdalnych wywołań, w tym do projektu Spring Web Services. Rozdział 18., „Spring w Javie EE”, to omówienie licznych dostępnych w platformie Spring narzędzi służących na przykład do obsługi technologii JMX, planowania zadań i obsługi poczty elektronicznej. Rozdział 19., „Komunikaty”, dotyczy stosowania Springa w warstwie pośredniej opartej na komunikatach. Wykorzystuje się przy tym usługi JMS i ułatwiające pracę abstrakcje Springa. Rozdział 20., „Platforma Spring Integration”, zawiera opis używania platformy Spring Integration do integrowania różnych usług i danych. Rozdział 21., „Platforma Spring Batch”, jest poświęcony platformie Spring Batch. Umożliwia ona modelowanie rozwiązań tradycyjnie stosowanych w komputerach typu mainframe. Rozdział 22., „Przetwarzanie rozproszone w Springu”, zawiera omówienie różnych sposobów skalowania Springa za pomocą rozproszonego stanu i przetwarzania siatkowego. Rozdział 23., „Spring i jBPM”, to wprowadzenie do zagadnień z zakresu zarządzania procesami biznesowymi i integrowania ze Springiem popularnej platformy jBPM JBoss. Rozdział 24., „Spring i OSGi”, to omówienie dostępnej w Springu rozbudowanej obsługi technologii OSGi.

20

KONWENCJE

Konwencje Czasem gdy chcemy zwrócić szczególną uwagę na fragment przykładowego kodu, stosujemy pogrubioną czcionkę. Zauważ, że takie wyróżnienie nie zawsze oznacza zmianę kodu w porównaniu z jego wcześniejszą wersją. Jeśli wiersz kodu jest zbyt długi, aby zmieścił się na stronie, używamy znaku kontynuacji wiersza. Gdy będziesz próbował wpisać taki kod, wpisz wiersz w całości, bez stosowania dodatkowych spacji.

Wymagania wstępne Ponieważ język Java jest niezależny od systemu, możesz korzystać z dowolnego systemu operacyjnego. Jednak w niektórych przykładach z tej książki stosujemy ścieżki dostosowane do konkretnych systemów. W razie potrzeby przy wpisywaniu kodu przekształć takie ścieżki na format odpowiedni dla używanego systemu. Aby jak najwięcej skorzystać na lekturze tej książki, zainstaluj pakiet JDK w wersji 1.5 lub nowszej. Powinieneś też mieć zainstalowane środowisko IDE Javy, co ułatwia programowanie. Przykładowy kod tej książki jest oparty na Mavenie. Jeśli używasz środowiska Eclipse i zainstalowałeś wtyczkę m2Eclipse, możesz otworzyć kod w tym środowisku, a parametr classpath i zależności zostaną ustawione na podstawie metadanych Mavena. Jeżeli korzystasz ze środowiska Eclipse, możesz użyć pakietu SpringSource Tool Suite (STS), ponieważ zawiera on wtyczki potrzebne do wydajnego stosowania platformy Spring w tym środowisku. Jeśli posługujesz się środowiskiem NetBeans lub IDEA IntelliJ, nie musisz ustawiać specjalnej konfiguracji — te narzędzia mają wbudowaną obsługę Mavena. W tej książce zastosowaliśmy Mavena, ponieważ platforma Spring od wersji 3.0.3 nie jest już udostępniana ze wszystkimi potrzebnymi zależnościami. Zalecane podejście to wykorzystanie Mavena (lub podobnych narzędzi, takich jak Ant lub Ivy) do zarządzania zależnościami. Jeśli nie używałeś wcześniej Mavena, zajrzyj do rozdziału 12., „Spring Roo”, gdzie opisane jest konfigurowanie środowiska — w tym narzędzia Apache Maven — na potrzeby platformy Spring Roo.

Pobieranie kodu Kod źródłowy do tej książki jest dostępny pod adresem ftp://ftp.helion.pl/przyklady/sprire.zip. Kod jest uporządkowany na podstawie rozdziałów; do każdego z nich dołączone są niezależne przykłady.

Kontakt z autorami Zawsze czekamy na Wasze pytania i informacje zwrotne dotyczące treści książki. Z Joshem Longiem możesz się skontaktować pod adresem [email protected] (lub przez stronę internetową http://www.joshlong.com). Gary Mak jest dostępny pod adresem [email protected] (lub przez stronę internetową http://www.metaarchit.com). Z Danielem Rubio skontaktujesz się przez jego stronę internetową, http://www.webforefront.com.

21

WPROWADZENIE

22

ROZDZIAŁ 1

Wprowadzenie do platformy Spring � � � ��

. . . 'k'1e wprawadzeme ' . . . .mformaCJl W tym rozdZlale znaJ'dZlesz krot p ngu, podstawowym lub odsw1ezeme kontenerze, a tak:l.e wybranych globalnie dostępnych mechanizmach u . ni nian h przez ten kontener. Poznasz również format, w jakim konfiguruje się Spring w XML-u, oraz �jc. Dzięki temu rozdziałowi zdobędziesz wiedzę potrzebną do zrozum �� adnień omawianych w dalszych tcncrzc IoC Springa. Najważniejszy częściach książki. Poznasz podstawową konfigurację komponent element platformy Spring, kontener IoC, jest zaprojektowa y t' � można go by o w dużym zakresie ' dostosowywać i konfigurować. Dostępny jest zestaw mechaniz atwiających konfigurowanie komponentów. Dzięki temu możesz w prosty sposób ustawić komponent� amiane w kontenerze ToC. W Springu komponenty są czasem nazywane ziar · uważ, że różnią się one od specyfikacji ziaren JavaReans opracowanej przez firmę Sun. Ziarna dekl o ne w kontenerze ToC nie muszą być ziarnami JavaBeans. Mogą też być zwykłymi obiektami . lain Old ]ava Objects- POJO). Pojęcie POJO oznacza zwyczajny obiekt Javy, który nie mu ać żadnych specjalnych warunków (na przykład iczyć po danej klasie bazowej). Pojęcie to stosuje się w celu implementować określonego interfejsu lub d odróżnienia prostych komponentów a od �omplikowanych komponentów w innych złożonych modelach (na przykład komponentów EJB prze wadzeniem wersji 3.1 specyfikacji EJB). Gdy zakończysz lekturę tego oz zia , będziesz potrafił zbudować w Javie kompletną aplikację za pomocą kontenera IoC Springa. Ponadt e ajrzysz do swoich starszych aplikacji w Javie, może się okazać, że dzięki temu kontenerowi zdołas cz ie uprościć i usprawnić. · ·

� l(oE }�

$ vj �

� � �

J� n� �

�

�

·

1.1. Tworzenie egzemplarza kontenera loC w Springu Problem

Aby tworzyć egzemplarze ziaren na podstawie ich konfiguracji, trzeba najpierw utworzyć egzemplarz kontenera IoC. Następnie można pobierać egzemplarze ziaren z tego kontenera i korzystać z nich.

Rozwiązanie

Spring udostępnia dwa typy implementacji kontenera IoC. Podstawową wersją jest fabryka ziaren. Bardziej zaawansowana odmiana to kontekst aplikacji, który jest rozszerzeniem fabryki ziaren. Zauważ, że w obu wersjach kontcnerów IoC pliki z konfiguracją ziaren są identyczne.

ROZDZIAŁ 1. • WPROWADZENIE DO PLATFORMY SPRING

Kontekst aplikacji udostępnia bardziej zaawansowane funkcje niż fabryka ziaren, a jednocześnie jest zgodny z podstawowymi funkcjami. Dlatego gorąco zachęcamy do stosowania w każdym programie kontekstu aplikacji, chyba że dostępne zasoby są ograniczone (może tak się zdarzyć na przykład przy uruchamianiu kodu w apletach lub na urządzeniach przenośnych) . Interfejsy odpowiadające fabryce ziaren i kontekstowi aplikacji to BeanFactory i Appl icationContext. Interfejs Appl icationContext jest pochodny od interfejsu BeanFactory, co pozwala zachować zgodność między nimi.

•

Uwaga Aby skompilować i uruchomić oparty na Springu kod przedstawiony w tym i w dalszych rozdziałach, trzeba zapisać w parametrze cl asspath zależności potrzebne w platformie Spring. Zalecaną metodą jest tu zastosowanie narzędzia do zarządzania kompilacją, takiego jak Apache Maven, Apache Ant lub lvy. Jeśli korzystasz z Mavena, dodaj do projektu Mavena wymienione poniżej zależności. Tu (podobnie jak dalej) człon ${spring. versionl określa wersję Springa. Zastąp ten człon nazwą używanej wersji. Tę książkę napisano i skompilowano za pomocą wersji 3. 0.2. RELEASE.

org. springframework spri ng-aop $ {spring. version l

�

�
org. springframework spri ng-web $ {spring. version l

'>s-�

'-L O''Y

org. springframework spring-context-support$ {spring. version l

O

�

O1 �

org. springframeworkspring-beans$ {spring. version l< ·

A...\. �

org. spri wark spri ng-context $ {spring. version l org. springframework spri ng-core $ {spring. version l

24

1.1. TWORZENIE EGZEMPLARZA KONTENERA IOC W SPRINGU

Jak to działa? Tworzenie egzemplarza kontekstu aplikacji Appl icati onContext to tylko interfejs. Musisz utworzyć obiekt z jego implementacją. Implementacja Cl assPathXml Appl icationContext jest oparta na kontekście aplikacji i wczytuje z katalogu z parametru cl asspath plik z konfiguracją w XML-u. W tej implementacji można też zastosować kilka plików konfiguracyjnych. Appl icationContext context

new Cl assPathXml Appl icationContext("beans.xml ");

=

Spring udostępnia także inne (obok Cl assPathXml Appl icationContext) implementacje interfejsu Appl icationContext. Implementacja Fil eSystemXml Appl icationContext służy do wczytywania plików z konfiguracją w XML-u z systemu plików lub na podstawie adresów URL, a implementacje Xml Web 4Appl icationContext i Xml Portl etAppl icationContext są przeznaczone do użytku tylko w aplikacjach sieciowych i portalowych.

�';-yw �� '

Pobieranie ziaren z kontenera loC

ołać metodę Aby pobrać zadeklarowane ziarno z fabryki ziaren lub kontekstu aplikacji, wyst � przez metodę getBean O a getBean O i przekazać do niej niepowtarzalną nazwę ziarna. Typ obiektu �ła ciwy typ. to java. l ang. Object, dlatego przed użyciem ziarna obiekt trzeba zrzut

��

SequenceGenerator generator (SequenceGenerator) context.getBean("sequenceGenerator") =

()...7 . ��V

�� �onego za pomocą konstruktora. L ziesz w przedstawionej poniżej klasie Main. �'V

Teraz można używać ziarna tak jak każdego innego ob Kompletny kod źródłowy aplikacji generatora kolejnych lic package com. apress. springrecipes. sequence;

O

��; � athXml Appl icationContext; V

import org. springframework. context. Appl ica import org. springframework. context. support

0

publ ic cl ass Main {

f-\, { ��� � SequenceGenerator ge � or (SequenceGenerato �text. getBean ("sequenceGenerator");

publ ic static void main(String[' Appl icationContext contex new Cl assPathXml Appl ic ontext("beans. xml "); =

System. out. printl n (generator. getSequence O); System. out. printl n (generator. getSequence O);

Jeśli wszystko przebiegło poprawnie, powinieneś zobaczyć w danych wyjściowych kolejne liczby (a także komunikaty dziennika, które zapewne nie będą Cię interesować). 30100000A 30100001A

25

ROZDZIAŁ 1. • WPROWADZENIE DO PLATFORMY SPRING

1.2. Konfigurowanie ziaren w kontenerze loC Problem

Spring udostępnia rozbudowany kontener ToC:, który pozwala zarządzać ziarnami używanymi w aplikacji. Aby wykorzystać usługi kontenera, trzeba skonfigurować ziarna pod kątem uruchamiania ich w tym kontenerze.

Rozwiązanie

Ziarna w kontenerze I o C można skonfigurować za pomocą plików XML, plików właściwości, adnotacji, a nawet interfejsów API. W Springu ziarna można skonfigurować w jednym lub w kilku plikach konfiguracyjnych. W prostych aplikacjach wystarczy ustawić ziarna w jednym takim pliku. Jednak w dużych programach, zawierających wiele ziaren, należy rozdzielić je na podstawie funkcji (na przykład na kontrolery, ziarna DAO i ziarna JMS) pomiędzy kilka plików konf1guracyjnych. Przydatnym sposobem podziału jest wyko stanie warstw architektury obsługiwanych przez dany kontekst.

�

"''-�

Jak to działa?

�� )'r
� lkaCJa ta ma generować rózne ;cUi'st ma określony przedrostek,

Załózmy, ze chcesz opracować aphkac)ę do generowama koleJny h listy kolejnych liczb przeznaczone do odmiennych celów. Każd t p z rostek i wartość początkową. W aplikacji trzeba więc u o y\ł � � mml.

�f ,-v

a egzemplarzy generatora i zarządzać

{"'\O

Tworzenie klasy ziarna

�� � � d�

equenceGenerator o trzech właściwościach: prefix, Na podstawie podanych wymagań należy utwo suffi xiinit ial . Wartości tych właściwości moż wić za pomocą settera lub konstruktora. Pole prywatne � counter przechowuje numer generatora. Prz dym wywołaniu metody getSequence() danego egzemplarza generatora zwracana jest następna li zb· z onym odpowiednim przedrostkiem i przyrostkiem. Ws pomniana metoda jest zadeklarow mtdyfikatorem synchronized, dzięki czemu jest bezpieczna ze wzgl<;du na wątki.

�

package com. apress. springrec publ ic cl ass SequenceGe private private private private

A...\ quence; �

�

{

String prefix; String suffix; int initial ; int counter;

publ ic SequenceGenerator() {} publ ic SequenceGenerator(String prefix, String suffix, int initial ) { this. prefix prefix; this.suffix suffix; this. initial initial ; =

=

=

publ ic void setPrefix(String prefix) { this. prefix prefix; =

26

1.2. KONFIGU ROWANIE ZIAREN W KONTENERZE IOC

publ ic void setSuffi x(String suf fix) { this.suffix = suffix;

publ ic void setlnitial (int initial ) { this. initial = initial ;

publ ic synchronized String getSequence() { StringBuffer buffer = new StringBuffer(); buffer.append(prefix); buffer. append(initial + counter++); buffer.append(suffix); return buffer. toString();

�

Jak widać, klasę SequenceGenerator można skonfigurować za pomocą getterów i setterów lub konstruktora (przy konfigurowaniu ziaren z poziomu kontenera operacje te są nazywane wst kiwaniem za pomocą konstruktora i wstrzykiwaniem za pomocą settera) .

�"""' ....'._ .'
A.,;;

schematów (t�, jndi, jee itd.). Dzięki temu konfiguracja zia

�

�V

możliwa konfiguracja w pliku XML:

�

ostsza i bardziej przejrzysta. Oto najprostsza


b��ns>

� ��m r

Deklarowanie ziare

�p � •

konfiguracyjnym

Ahy kontener To C: mógł ut . ć egze pla z ziarna, powinno ono mieć niepowtarzalne właściwości name i id oraz pełną nazwę klasy. Kaz rzypisaną do ziarna właściwość typu prostego (na przykład typu String) można określić w elemencie . Spring próbuje przekształcić podaną wartość na zadeklarowany typ właściwości. Aby skonfigurować właściwość w wyniku wstrzykiwania za pomocą settera, można wykorzystać element i podać nazwę właściwości w atrybucie name. Przy stosowaniu elementu ziarno musi zawierać odpowiedni setter.
cl ass= 11com. apress. springrecipes. sequence. SequenceGenerator 11 >

30

A lOOOOO

27

ROZDZIAŁ 1. • WPROWADZENIE DO PLATFORMY SPRING

Właściwości ziarna można też skonfigurować w wyniku wstrzykiwania za pomocą konstruktora. Wtedy właściwości należy zadeklarować jako elementy . Takie elementy nie mają atrybutu name, ponieważ argumenty konstruktora są określane na podstawie pozycji. 30

/

A< val ue> < constructor-arg> lOOOOO< val ue> < constructor-arg> < bean>

/

/

/

/

�

W kontenerze IoC każda nazwa ziarna powinna być niepowtarzalna, przy czym dozwolone są powtarzające się nazwy (pozwalają one zastąpić deklarację ziarna, jeśli wczytywanych jest kilka ntekstów). Nazwę ziarna definiuje się w atrybucie name elementu . Zalecanym sposobem identyfikowa ·. ziaren jest używanie standardowego atrybutu id XML-a. Atryhut ten słu7.y do identyfikowania ele dokumentach XML Jeśli edytor tekstu obsługuje język XML, może w czasie pisania kodu po eniu, czy poszczególne wu ziarna się nie powtarzają.

�


�

� N •

< bean> W XML-u występują ograniczenia dotyczące znaków, j ki ożna stosować w atrybucie id. Zwykle jednak nie używa się znaków specjalnych w nazwach ziaren. Sf1 wala ustawić w atrybucie name kilka rozdzielonych · st to możliwe, ponieważ stosowanie przecinków przecinkami nazw ziarna. W przypadku atrybu jest w nim niedozwolone.

� �V

�

Ziarno nic musi mieć ani nazwy, ani idcn tora. Ziarno bez nazwy to ziarno anonimowe. Takie ziarna tworzy się zwykle tylko na potrzeby int cjiez kontenerem Springa, gdy wiadomo, że właściwości będą wstrzykiwane na podstawie typu lub zagnieżdżone wewnątrzwierszowo w ziarnie zewnętrznym.

z_�

�

·aren za pomocą skrótów Spring udost<;pnia skróty d w elemencie , za

cślania wartości właściwości typu prostego. Atrybut val ue można ustawić st umieszczać wartość w zagnieżdżonym elemencie .

< bean>

/

/

/

/

Skrót ten działa też przy podawaniu argumentów dla konstruktora. < bean>

/

28

/

/

/

1.2. KONFIGU ROWANIE ZIAREN W KONTENERZE IOC

W wersji Spring 2.0 pojawił się inny wygodny skrót służący do definiowania właściwości. Wymaga on zastosowania schematu p do zdefiniowania właściwości ziarna jako atrybutów elementu . Pozwala to skrócić kod konfiguracji w formacie XML.



Konfigurowanie kolekcji na potrzeby ziaren List, Set i Map to podstawowe interfejsy reprezentujące trzy główne typy kolekcji w pakiecie Java SDK. Są one częścią platformy Java Collections. Dla każdego rodzaju kolekcji w Javie dostępn jest kilka implementacji o różnych funkcjach i cechach. W Springu kolekcje można łatwo skonfigurować ocą zestawu wbudowanych znaczników XML-a, takich jak , i