Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00096 005704 12603208 na godz. na dobę w sumie
Spring Framework. Wprowadzenie do tworzenia aplikacji. Wydanie II - ebook/pdf
Spring Framework. Wprowadzenie do tworzenia aplikacji. Wydanie II - ebook/pdf
Autor: , Liczba stron: 480
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-0932-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).

Twoja przepustka do świata Spring Framework!

Pojawienie się na rynku Spring Framework było jednym z istotnych punktów zwrotnych w historii języka Java. Dzięki tej bibliotece tworzenie aplikacji w Javie stało się przyjemnością, a zadania, które do tej pory spędzały programistom sen z powiek, okazały się trywialne. Spring wciąż jest rozwijany, a każda kolejna wersja wprowadza powiew świeżości do świata Javy!

Jeżeli chcesz poznać możliwości tego frameworka oraz wykorzystać drzemiący w nim potencjał w Twoim kolejnym projekcie, to trafiłeś na doskonałą książkę. Wprowadzi Cię ona bezboleśnie w świat odwróconej kontroli (Inversion of Control, w skrócie IoC), wstrzykiwania zależności oraz łatwego dostępu do danych i tworzenia aplikacji internetowych. Każda kolejna strona to bezcenna wiedza na temat tworzenia REST-owych interfejsów API, bezpieczeństwa aplikacji (Spring Security) oraz korzystania z usług JMS. Książka ta będzie świetnym wyborem, jeżeli chcesz poznać ten wyjątkowy szkielet!

Dzięki tej książce:

Najlepsze wprowadzenie do Spring Framework!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Getting started with Spring Framework Tłumaczenie: Robert Górczyński ISBN: 978-83-283-0929-6 Projekt okładki: Studio Gravite / Olsztyn; Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. © Jyotsna Sharma, Ashish Sarin 2015. Polish edition copyright © 2015 by Helion S.A. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/spfrwp Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/spfrwp.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:319)ci Wprowadzenie ..................................................................................................... 15 Rozdzia(cid:295) 1. Wprowadzenie do frameworku Spring ............................................ 17 1.1. Wprowadzenie ..........................................................................................................................17 1.2. Moduły frameworku Spring ....................................................................................................17 1.3. Kontener IoC .............................................................................................................................18 1.4. Zalety stosowania frameworku Spring ..................................................................................21 Spójne podejście w zakresie zarządzania transakcjami lokalnymi i globalnymi .................. 21 Deklaracyjne zarządzanie transakcjami ....................................................................................... 23 Zapewnienie bezpieczeństwa ......................................................................................................... 24 JMX (Java Management Extensions) ........................................................................................... 24 JMS (Java Message Service) ............................................................................................................ 26 Buforowanie ...................................................................................................................................... 27 1.5. Prosta aplikacja Springa ...........................................................................................................28 Identyfikacja obiektów aplikacji i ich zależności ....................................................................... 28 Utworzenie klas POJO odpowiadających zidentyfikowanym obiektom aplikacji .............. 29 Utworzenie metadanych konfiguracyjnych ................................................................................ 30 Utworzenie egzemplarza kontenera Springa .............................................................................. 35 Uzyskanie dostępu do obiektów aplikacji z poziomu egzemplarza kontenera Springa .........36 1.6. Frameworki zbudowane na bazie Springa ............................................................................37 1.7. Podsumowanie ..........................................................................................................................38 Rozdzia(cid:295) 2. Podstawy frameworku Spring .......................................................... 39 2.1. Wprowadzenie ..........................................................................................................................39 2.2. Reguła projektowa o nazwie „podejście oparte na programowaniu interfejsów” ...........39 Scenariusz: klasa zależna zawiera odwołanie do konkretnej klasy zależności ...................... 39 Scenariusz: klasa zależna zawiera odwołanie do interfejsu implementowanego przez zależność ................................................................... 40 Oferowana przez Spring obsługa podejścia opartego na programowaniu interfejsu ......... 42 2.3. Różne podejścia podczas tworzenia komponentów Springa ..............................................44 Utworzenie komponentu za pomocą statycznej metody fabryki ........................................... 44 Tworzenie komponentu za pomocą metody fabryki egzemplarza ........................................ 46 Poleć książkęKup książkę 6 Spring Framework 2.4. Techniki wstrzykiwania zależności ........................................................................................ 47 Wstrzykiwanie zależności za pomocą metody typu setter ....................................................... 47 Wstrzykiwanie zależności za pomocą argumentów konstruktora ......................................... 51 2.5. Zasięg komponentu .................................................................................................................. 54 Singleton ............................................................................................................................................ 55 Prototyp ............................................................................................................................................. 63 Wybór właściwego zasięgu dla komponentu ............................................................................. 64 2.6. Podsumowanie .......................................................................................................................... 64 Rozdzia(cid:295) 3. Konfiguracja komponentów .............................................................65 3.1. Wprowadzenie .......................................................................................................................... 65 3.2. Dziedziczenie definicji komponentu ..................................................................................... 65 Przykład dziedziczenia definicji komponentu w aplikacji MyBank ...................................... 65 Co jest dziedziczone? ....................................................................................................................... 68 3.3. Dopasowanie argumentu konstruktora ................................................................................. 73 Przekazywanie wartości i odwołań do komponentów za pomocą elementu constructor-arg ............................................................................................................................ 73 Dopasowanie argumentu konstruktora na podstawie typu .................................................... 74 Dopasowanie argumentu konstruktora na podstawie nazwy argumentu ............................ 79 3.4. Konfiguracja różnego typu właściwości komponentu i argumentów konstruktora .......... 82 Wbudowane edytory właściwości ................................................................................................. 83 Określanie wartości dla różnych typów kolekcji ........................................................................ 86 Definiowanie wartości dla tablic ................................................................................................... 92 Domyślne implementacje kolekcji dla elementów list , set i map ............................ 92 3.5. Wbudowane edytory właściwości .......................................................................................... 93 Edytor CustomCollectionEditor ................................................................................................... 93 Edytor CustomMapEditor ............................................................................................................. 96 Edytor CustomDateEditor ............................................................................................................. 96 3.6. Rejestracja edytorów właściwości w kontenerze Springa .................................................... 97 Utworzenie implementacji PropertyEditorRegistrar ................................................................ 97 Konfiguracja klasy CustomEditorConfigurer ............................................................................ 98 3.7. Zwięzłe definicje komponentów dzięki użyciu przestrzeni nazw p oraz c ....................... 99 Przestrzeń nazw p ............................................................................................................................ 99 Przestrzeń nazw c ........................................................................................................................... 100 Poleć książkęKup książkę Spis tre(cid:318)ci 7 3.8. Schemat util .............................................................................................................................103 Element list ................................................................................................................................. 104 Element map .............................................................................................................................. 105 Element set ................................................................................................................................. 107 Element properties ................................................................................................................... 109 Element constant ...................................................................................................................... 110 Element property-path ............................................................................................................ 111 Interfejs FactoryBean .............................................................................................................113 Aplikacja MyBank — przechowywanie zdarzeń w bazie danych ......................................... 113 Aplikacja MyBank — przykład użycia interfejsu FactoryBean ............................................. 115 Uzyskanie dostępu do egzemplarza FactoryBean .................................................................... 118 3.10. Podsumowanie ........................................................................................................................120 3.9. Rozdzia(cid:295) 4. Wstrzykiwanie zale(cid:351)no(cid:319)ci ................................................................121 4.1. Wprowadzenie ........................................................................................................................121 4.2. Komponenty wewnętrzne ......................................................................................................121 4.3. Wyraźna kontrola kolejności inicjalizacji procesu za pomocą atrybutu depends-on .........123 Aplikacja MyBank — zasugerowane zależności między komponentami ........................... 123 Problem niejawnej zależności ...................................................................................................... 124 4.4. Zależności w postaci komponentów o zasięgu singleton i prototypu .............................129 Zależności komponentu o zasięgu singleton ............................................................................ 129 Zależności komponentu o zasięgu prototypu .......................................................................... 132 4.5. Pobieranie w komponencie singleton nowego egzemplarza komponentu o zasięgu prototypu ........................................................................................135 Interfejs ApplicationContextAware ........................................................................................... 136 Element lookup-method ......................................................................................................... 138 Element replaced-method ....................................................................................................... 142 4.6. Automatyczne wiązanie zależności ......................................................................................145 Wartość byType ............................................................................................................................. 146 Wartość constructor ...................................................................................................................... 147 Wartość byName ........................................................................................................................... 148 Wartości default i no ..................................................................................................................... 150 Uniedostępnienie komponentu dla funkcji automatycznego wiązania .............................. 150 Ograniczenia automatycznego wiązania ................................................................................... 152 4.7. Podsumowanie ........................................................................................................................153 Poleć książkęKup książkę 8 Spring Framework Rozdzia(cid:295) 5. Dostosowanie komponentów i ich definicji ................................... 155 5.1. Wprowadzenie ........................................................................................................................155 5.2. Dostosowanie logiki inicjalizacji i usuwania komponentu ...............................................155 Wywołanie przez Spring metody czyszczącej wskazanej przez atrybut destroy-method ..................................................................................................... 158 Metoda czyszcząca i komponent o zasięgu prototypu ............................................................ 160 Określenie domyślnych metod inicjalizacji i usuwania obiektu dla wszystkich komponentów ..................................................................................................... 160 Interfejsy cyklu życiowego InitializingBean i DisposableBean ............................................. 161 Adnotacje @PostConstruct i @PreDestroy wprowadzone w specyfikacji JSR 250 ........... 161 5.3. Użycie interfejsu BeanPostProcessor do pracy z nowo utworzonym egzemplarzem komponentu ..................................................................................................163 Przykład użycia interfejsu BeanPostProcessor — weryfikacja egzemplarzy komponentu ................................................................................. 165 Przykład BeanPostProcessor — rozwiązywanie zależności komponentu .......................... 168 Zachowanie BeanPostProcessor w przypadku komponentów implementujących FactoryBeans .................................................................... 172 RequiredAnnotationBeanPostProcessor ................................................................................... 174 DestructionAwareBeanPostProcessor ....................................................................................... 175 5.4. Modyfikacja definicji komponentu za pomocą BeanFactoryPostProcessor ..................176 Przykład użycia BeanFactoryPostProcessor ............................................................................. 177 Komponent PropertySourcesPlaceholderConfigurer ............................................................. 182 Komponent PropertyOverrideConfigurer ................................................................................ 187 5.5. Podsumowanie ........................................................................................................................190 Rozdzia(cid:295) 6. Programowanie oparte na adnotacjach ....................................... 191 6.1. Wprowadzenie ........................................................................................................................191 6.2. Identyfikacja komponentów Springa za pomocą adnotacji @Component ....................191 6.3. Adnotacja @Autowired, czyli automatyczne wiązanie zależności według ich typu ......194 6.4. Adnotacja @Qualifier pozwalająca na automatyczne wiązanie zależności według ich nazwy ................................................................................198 6.5. Adnotacje @Inject i @Named zdefiniowane przez specyfikację JSR 330 .......................199 6.6. Zdefiniowana przez JSR 250 adnotacja @Resource ...........................................................201 6.7. Adnotacje @Scope, @Lazy, @DependsOn i @Primary .....................................................202 Poleć książkęKup książkę Spis tre(cid:318)ci 9 6.8. Ułatwienie konfiguracji komponentu za pomocą adnotacji @Value ..............................203 6.9. Weryfikacja obiektów za pomocą interfejsu Validator .....................................................207 6.10. Określanie ograniczeń za pomocą adnotacji JSR 303 ........................................................211 Obsługa specyfikacji JSR 303 w Springu .................................................................................... 212 6.11. Programowa konfiguracja komponentów Springa za pomocą adnotacji @Configuration i @Bean ..................................................................216 6.12. Podsumowanie ........................................................................................................................219 Rozdzia(cid:295) 7. Wspó(cid:296)praca z baz(cid:236) danych ............................................................221 7.1. Wprowadzenie ........................................................................................................................221 7.2. Wymagania aplikacji MyBank ..............................................................................................221 7.3. Utworzenie aplikacji MyBank opartej na module JDBC ..................................................222 Konfiguracja źródła danych ......................................................................................................... 223 Tworzenie obiektów DAO używających klas modułu JDBC ................................................ 224 7.4. Utworzenie aplikacji MyBank z użyciem Hibernate .........................................................231 Konfiguracja SessionFactory ....................................................................................................... 231 Utworzenie klas DAO używających do pracy z bazą danych API Hibernate .................... 232 7.5. Zarządzanie transakcjami za pomocą Springa ...................................................................233 Wymagania aplikacji MyBank w zakresie zarządzania transakcjami .................................. 233 Programowe zarządzanie transakcjami ..................................................................................... 234 Deklaracyjne zarządzanie transakcjami ..................................................................................... 238 Oferowana przez Spring obsługa JTA ........................................................................................ 241 7.6. Podsumowanie ........................................................................................................................243 Rozdzia(cid:295) 8. Komunikaty, wiadomo(cid:319)ci e-mail, asynchroniczne wykonywanie metod i buforowanie w Springu .............................245 8.1. Wprowadzenie ........................................................................................................................245 8.2. Wymagania aplikacji MyBank ..............................................................................................245 8.3. Wysyłanie komunikatów JMS ...............................................................................................246 Konfiguracja brokera ActiveMQ do działania w trybie osadzonym .................................... 247 Konfiguracja JMS ConnectionFactory ....................................................................................... 247 Wysyłanie komunikatów JMS za pomocą klasy JmsTemplate ............................................. 248 Wysyłanie komunikatów JMS w transakcji .............................................................................. 249 Poleć książkęKup książkę 10 Spring Framework Dynamiczni odbiorcy komunikatów JMS i konfiguracja klasy JmsTemplate ................... 253 Klasa JmsTemplate i konwersja komunikatu ........................................................................... 254 8.4. Odbieranie komunikatów JMS .............................................................................................255 Synchroniczne odbieranie komunikatów JMS za pomocą klasy JmsTemplate ................. 255 Asynchroniczne odbieranie komunikatów JMS za pomocą kontenerów odbiorców komunikatów .................................................................. 255 8.5. Wysyłanie wiadomości e-mail ..............................................................................................258 8.6. Harmonogram zadań i wykonywanie asynchroniczne .....................................................263 Interfejs TaskExecutor .................................................................................................................. 263 Interfejs TaskScheduler ................................................................................................................ 265 Adnotacje @Async i @Scheduled ............................................................................................... 267 8.7. Buforowanie ............................................................................................................................269 Konfiguracja interfejsu CacheManager ..................................................................................... 271 Adnotacje buforowania @Cacheable, @CacheEvict i @CachePut ....................................... 271 8.8. Aplikacja MyBank ..................................................................................................................275 8.9. Podsumowanie ........................................................................................................................277 Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo .................................... 279 9.1. Wprowadzenie ........................................................................................................................279 9.2. Prosty przykład AOP .............................................................................................................279 9.3. Oferowany przez Spring framework AOP ..........................................................................282 Tworzenie proxy ............................................................................................................................ 283 Atrybut expose-proxy ................................................................................................................... 284 9.4. Wyrażenia punktu przecięcia ................................................................................................286 Adnotacja @Pointcut .................................................................................................................... 286 Desygnatory execution i args ....................................................................................................... 287 Desygnator bean ............................................................................................................................ 291 Desygnatory oparte na adnotacjach ........................................................................................... 292 9.5. Typy rad ...................................................................................................................................293 Rada before ..................................................................................................................................... 293 Rada after returning ...................................................................................................................... 294 Rada after throwing ....................................................................................................................... 295 Rada after ......................................................................................................................................... 296 Rada around .................................................................................................................................... 297 Poleć książkęKup książkę Spis tre(cid:318)ci 11 9.6. Spring AOP, czyli styl schematu XML .................................................................................298 Konfiguracja aspektu AOP .......................................................................................................... 299 Konfiguracja rady .......................................................................................................................... 300 Powiązanie wyrażenia punktu przecięcia z radą ...................................................................... 301 9.7. Podsumowanie ........................................................................................................................302 Rozdzia(cid:295) 10. Podstawy modu(cid:296)u Spring Web MVC ............................................303 10.1. Wprowadzenie ........................................................................................................................303 10.2. Struktura katalogów przykładowych projektów .................................................................303 10.3. Poznajemy przykładową aplikację ........................................................................................304 Plik HelloWorldController.java, czyli klasa kontrolera aplikacji sieciowej Hello World .............................................................................................................................305 Plik helloworld.js, czyli strona JSP wyświetlająca komunikat ..........................................306 Plik myapp-config.xml, czyli plik XML kontekstu aplikacji sieciowej ............................307 Plik web.xml, czyli deskryptor wdrożenia aplikacji sieciowej ..........................................308 10.4. Serwlet DispatcherServlet ......................................................................................................311 Uzyskanie dostępu do obiektów ServletContext i ServletConfig .......................................... 313 10.5. Opracowanie kontrolerów za pomocą adnotacji @Controller i @RequestMapping ........ 314 Opracowanie aplikacji sieciowej za pomocą kontrolera oznaczonego adnotacją ............. 314 10.6. Wymagania aplikacji sieciowej MyBank .............................................................................317 10.7. Adnotacje Spring Web MVC: @RequestMapping i @RequestParam .............................318 Mapowanie żądań na kontrolery lub metody kontrolerów za pomocą adnotacji @RequestMapping .................................................................................. 318 Argumenty metod oznaczonych adnotacją @RequestMapping ........................................... 324 Typy wartości zwrotnych metod oznaczonych adnotacją @RequestMapping .................. 325 Przekazanie parametrów żądania do metod kontrolera z użyciem adnotacji @RequestParam ............................................................................................................................. 326 10.8. Weryfikacja ..............................................................................................................................330 10.9. Obsługa wyjątków za pomocą adnotacji @ExceptionHandler .........................................333 10.10. Wczytanie głównego pliku XML kontekstu aplikacji sieciowej .......................................335 10.11. Podsumowanie ........................................................................................................................335 Poleć książkęKup książkę 12 Spring Framework Rozdzia(cid:295) 11. Weryfikacja i do(cid:296)(cid:236)czanie danych w Spring Web MVC ................ 337 11.1. Wprowadzenie ........................................................................................................................337 11.2. Dodawanie i pobieranie atrybutów modelu za pomocą adnotacji @ModelAttribute ....................................................................................................................337 Dodanie atrybutów modelu za pomocą adnotacji @ModelAttribute stosowane na poziomie metody ...................................................................................................................... 338 Pobieranie atrybutów modelu za pomocą adnotacji @ModelAttribute .............................. 342 Przetwarzanie żądania i metody oznaczone adnotacją @ModelAttribute .......................... 343 Zachowanie argumentów metody oznaczonych adnotacją @ModelAttribute .................. 345 Obiekt RequestToViewNameTranslator ................................................................................... 346 11.3. Buforowanie atrybutów modelu za pomocą adnotacji @SessionAttributes ..................347 11.4. Dołączanie danych .................................................................................................................350 WebDataBinder, czyli dołączanie danych dla parametrów żądania sieciowego ............... 352 Konfiguracja egzemplarza WebDataBinder ............................................................................. 353 Włączenie lub wyłączenie poszczególnych właściwości w procesie dołączania danych ........................................................................................... 358 Analiza błędów dołączania danych i weryfikacji przechowywanych przez obiekt BindingResult .......................................................................................................... 361 11.5. Weryfikacja w Springu ...........................................................................................................362 Weryfikacja atrybutów modelu za pomocą oferowanego przez Spring interfejsu Validator ................................................................................................ 363 Zdefiniowanie ograniczeń za pomocą adnotacji JSR 303 ...................................................... 366 Weryfikacja obiektu używającego adnotacji JSR 303 .............................................................. 367 11.6. Biblioteka znaczników form ..................................................................................................371 Obsługa HTML5 przez bibliotekę form .................................................................................... 372 11.7. Podsumowanie ........................................................................................................................374 Rozdzia(cid:295) 12. Tworzenie us(cid:296)ug sieciowych typu RESTful za pomoc(cid:236) Spring Web MVC ....................................................... 375 12.1. Wprowadzenie ........................................................................................................................375 12.2. Usługa sieciowa do obsługi lokat ..........................................................................................376 12.3. Implementacja usługi sieciowej w stylu RESTful za pomocą Spring Web MVC ..........376 Format JSON .................................................................................................................................. 377 Implementacja usługi sieciowej FixedDepositWS ................................................................... 379 Poleć książkęKup książkę Spis tre(cid:318)ci 13 12.4. Uzyskanie dostępu do usługi sieciowej w stylu RESTful za pomocą klasy RestTemplate .............................................................................................386 12.5. Użycie HttpMessageConverter do konwersji obiektów Javy na żądania lub odpowiedzi HTTP i na odwrót ...................................................................394 12.6. Adnotacje @PathVariable i @MatrixVariable ....................................................................395 12.7. Podsumowanie ........................................................................................................................399 Rozdzia(cid:295) 13. Wi(cid:256)cej o Spring Web MVC: internacjonalizacja, przesy(cid:296)anie plików i przetwarzanie (cid:351)(cid:236)da(cid:298) asynchronicznych ......401 13.1. Wprowadzenie ........................................................................................................................401 13.3. 13.2. Przetwarzanie żądań za pomocą procedur obsługi interceptorów ..................................401 Implementacja i konfiguracja procedury obsługi interceptorów ......................................... 401 Internacjonalizacja za pomocą paczek zasobów .................................................................404 Wymagania aplikacji sieciowej MyBank ................................................................................... 404 Internacjonalizacja i lokalizacja aplikacji sieciowej MyBank ................................................ 404 13.4. Asynchroniczne przetwarzanie żądań .................................................................................407 Konfiguracja asynchronicznego przetwarzania żądań ........................................................... 407 Zwrot obiektu Callable przez metodę oznaczoną adnotacją @RequestMapping ..................408 Zwrot obiektu DeferredResult przez metodę oznaczoną adnotacją @RequestMapping .....409 Ustawienie domyślnego limitu czasu ......................................................................................... 416 Przechwytywanie żądań asynchronicznych .............................................................................. 417 13.5. Obsługa konwersji typu i formatowania .............................................................................417 Utworzenie własnej implementacji interfejsu Converter ....................................................... 418 Konfiguracja i użycie własnej implementacji interfejsu Converter ...................................... 418 Tworzenie własnej implementacji Formatter ........................................................................... 420 Konfiguracja własnej implementacji Formatter ...................................................................... 422 Utworzenie implementacji AnnotationFormatterFactory do formatowania jedynie właściwości oznaczonych adnotacją @AmountFormat ........................................... 422 Konfiguracja implementacji AnnotationFormatterFactory .................................................. 423 13.6. Obsługa przekazywania plików w Spring Web MVC ........................................................425 Przekazywanie plików za pomocą implementacji CommonsMultipartResolver .............. 425 Przekazywanie plików za pomocą StandardServletMultipartResolver ............................... 427 13.7. Podsumowanie ........................................................................................................................428 Poleć książkęKup książkę 14 Spring Framework Rozdzia(cid:295) 14. Zabezpieczanie aplikacji za pomoc(cid:236) Spring Security ................. 429 14.1. Wprowadzenie ........................................................................................................................429 14.2. Wymagania aplikacji sieciowej MyBank w zakresie bezpieczeństwa ..............................429 14.3. Zabezpieczanie aplikacji MyBank za pomocą frameworku Spring Security ..................431 Konfiguracja zabezpieczeń dla żądań sieciowych .................................................................... 431 Konfiguracja uwierzytelniania .................................................................................................... 434 Zabezpieczenie zawartości strony JSP przez użycie oferowanej przez Spring Security biblioteki znaczników ............................................................................ 435 Zabezpieczanie metod ................................................................................................................... 436 14.4. Zabezpieczanie egzemplarzy FixedDepositDetails za pomocą modułu ACL ................440 Wdrożenie i użycie projektu ch14-bankapp-db-security ....................................................... 440 Tabele bazy danych przeznaczone do przechowywania informacji o listach ACL i użytkownikach .................................................................................................... 442 Uwierzytelnianie użytkownika .................................................................................................... 446 Zabezpieczenie żądań sieciowych ............................................................................................... 447 Konfiguracja JdbcMutableAclService ........................................................................................ 449 Konfiguracja zabezpieczeń na poziomie metody .................................................................... 452 Bezpieczeństwo egzemplarza obiektu domeny ........................................................................ 453 Programowe zarządzanie informacjami ACL .......................................................................... 455 Egzemplarz MutableAcl i bezpieczeństwo ................................................................................ 458 14.5. Podsumowanie ........................................................................................................................459 Dodatek A Import i wdro(cid:351)enie przyk(cid:296)adowych projektów w Eclipse IDE (lub IntelliJ IDEA) ............................................................................ 461 A.1. Przygotowanie środowiska pracy .........................................................................................461 A.2. Import przykładowego projektu do Eclipse IDE (lub IntelliJ IDEA) ..............................461 Import przykładowego projektu ................................................................................................. 462 Konfiguracja zmiennej M2_REPO w Eclipse IDE .................................................................. 463 A.3. Konfiguracja Eclipse IDE do pracy z serwerem Tomcat 7 ................................................463 A.4. Wdrożenie projektu sieciowego w serwerze Tomcat 7 .....................................................465 Uruchomienie serwera Tomcat 7 w trybie osadzonym .......................................................... 465 Skorowidz .......................................................................................................... 467 Poleć książkęKup książkę Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo 9.1. Wprowadzenie Programowanie zorientowane aspektowo (ang. aspect-oriented programming, AOP) to rodzaj podejścia programistycznego, w którym obowiązki rozproszone między wieloma klasami są her- metyzowane w oddzielnej klasie określanej mianem aspektu. Natomiast obowiązki rozproszone między wieloma klasami są nazywane zagadnieniami przekrojowymi (ang. cross-cutting concern). Rejestrowanie danych, zarządzanie transakcjami, buforowanie, zapewnienie bezpieczeństwa itd. to przykłady zadań przekrojowych. Spring oferuje framework AOP używany wewnętrznie przez Spring do implementacji usług deklara- cyjnych, na przykład zarządzania transakcjami (patrz: rozdział 7.) i buforowania (patrz: rozdział 8.). Zamiast stosować oferowany przez Spring framework AOP rozważ użycie AspectJ (http://www.eclipse. org/aspectj/) jako frameworku AOP dla tworzonej aplikacji. Ponieważ możliwości frameworku Spring AOP są wystarczające w większości sytuacji, a ponadto zapewnia on integrację z kontene- rem Springa, w tym rozdziale skoncentrujemy się właśnie na użyciu frameworku AOP dostar- czanego przez Spring. Rozpoczynamy od przykładu użycia AOP. 9.2. Prosty przyk(cid:295)ad AOP Przyjmujemy założenie, że na potrzeby audytu konieczne jest przechwytywanie argumentów prze- kazywanych w klasach, które zostały zdefiniowane w warstwie usługi w aplikacji MyBank. Proste podejście w zakresie rejestracji danych o argumentach metody polega na umieszczeniu w każdej metodzie logiki odpowiedzialnej za rejestrację danych. Takie rozwiązanie oznacza jednak, że każda metoda otrzymuje dodatkowe zadanie, jakim jest rejestracja szczegółów dotyczących argu- mentów metody. Ponieważ zadanie rejestracji danych o argumentach metody pojawia się w wielu klasach i metodach, przedstawia zagadnienie przekrojowe. Przygotowanie obsługi zagadnienia przekrojowego za pomocą AOP wymaga wykonania nastę- pujących kroków: (cid:121) utworzenie klasy Javy (określanej mianem aspektu); (cid:121) dodanie do nowo utworzonej klasy implementacji zagadnienia przekrojowego; (cid:121) użycie wyrażenia regularnego w celu określenia metod, do których ma zastosowanie przygo- towane zagadnienie przekrojowe. W terminologii programowania zorientowanego aspektowego metody aspektu implementującego zagadnienia przekrojowe są określane mianem rady (ang. advice). Każda rada jest powiązana z punktem przecięcia (ang. pointcut) identyfikującym metody, do których ma zastosowanie rada. Metody, do których stosowana będzie rada, są nazywane punktami złączenia (ang. join points). Poleć książkęKup książkę 280 Spring Framework W oferowanym przez Spring frameworku AOP masz możliwość opracowania aspektu za pomocą stylu adnotacji (AspectJ) lub stylu schematu (XML). W przypadku stylu adnotacji udostępniane przez AspectJ adnotacje takie jak @Aspect, @Pointcut i @Before są używane do przygotowania aspektu. Natomiast w stylu schematu elementy schematu aop służą do konfiguracji komponentu Springa jako aspektu. IMPORT Rozdzial09/ch09-simple-aop. (Ten projekt pokazuje aplikację MyBank, w której frame- work Spring AOP został wykorzystany do rejestracji informacji o argumentach metod przekazanych metodom zdefiniowanym przez klasy w warstwie usługi aplikacji MyBank. Aby uruchomić tę aplikację, wystarczy wywołać metodę main() w klasie BankApp projektu). W listingu 9.1 przedstawiamy przykład aspektu rejestrowania danych, który zapisuje informacje o argumentach przekazanych metodom usług w aplikacji MyBank. Listing 9.1. Klasa LoggingAspect Projekt: ch09-simple-aop Położenie pliku: src/main/java/sample/spring/chapter09/bankapp/aspects package sample.spring.chapter09.bankapp.aspects; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; @Aspect @Component public class LoggingAspect { private Logger logger = Logger.getLogger(LoggingAspect.class); @Before(value = execution(* sample.spring.chapter09.bankapp.service.*Service.*(..)) ) public void log(JoinPoint joinPoint) { logger.info( Wej(cid:258)cie do metody + joinPoint.getSignature().getName()) + klasy + joinPoint.getTarget().getClass().getSimpleName(); Object[] args = joinPoint.getArgs(); for (int i = 0; i args.length; i++) { logger.info( args[ + i + ] -- + args[i]); } } } W listingu 9.1: (cid:121) Adnotacja @Aspect na poziomie typu oznacza, że klasa LoggingAspect jest aspektem AOP. (cid:121) Adnotacja @Before na poziomie metody oznacza, że metoda log() przedstawia radę stosowaną, zanim nastąpi wykonanie metod dopasowanych przez atrybut value. W podrozdziale 9.5 znaj- dziesz więcej informacji o różnych typach rad, które możesz zdefiniować. (cid:121) Atrybut value adnotacji @Before określa wyrażenie punktu przecięcia, które jest przez frame- work Spring AOP używane w celu identyfikacji metod (nazywanych metodami docelowymi) stosujących zdefiniowane rady. W podrozdziale 9.4 znajdziesz dokładne omówienie wyrażeń Poleć książkęKup książkę Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo 281 punktu przecięcia. W tym miejscu możesz przyjąć następujące założenie: wyrażenie punktu przecięcia execution(* sample.spring.chapter09.bankapp.service.*Service.*(..)) określa, że metoda log() klasy LoggingAspect ma zastosowanie dla wszystkich metod publicznych zdefiniowanych przez klasy (lub interfejsy) w pakiecie sample.spring.chapter09.bankapp. (cid:180)service i których nazwa kończy się na Service. (cid:121) Argument JoinPoint metody log() przedstawia metodę docelową, w której zostanie zastoso- wana rada. Metoda log() używa egzemplarza JoinPoint w celu pobrania informacji o argu- mentach przekazanych metodzie docelowej. W listingu 9.1 metoda getArgs() egzemplarza JoinPoint jest wywoływana i pobiera argumenty przekazane metodzie docelowej. Aspekt trzeba zarejestrować w kontenerze Springa, aby udostępniany przez Spring framework AOP wiedział o istnieniu aspektu. W listingu 9.1 klasa LoggingAspect została oznaczona adnotacją @Component, a więc jest automatycznie rejestrowana w kontenerze Springa. W listingu 9.2 została przedstawiona klasa BankApp wywołująca metody klas BankAccountServi (cid:180)ceImpl (implementuje interfejs BankAccountService) i FixedDepositServiceImpl (implementuje interfejs FixedDepositService) aplikacji MyBank. Listing 9.2. Klasa BankApp Projekt: ch09-simple-aop Położenie pliku: src/main/java/sample/spring/chapter09/bankapp package sample.spring.chapter09.bankapp; ..... public class BankApp { public static void main(String args[]) throws Exception { ApplicationContext context = new ClassPathXmlApplicationContext( classpath:META-INF/spring/applicationContext.xml ); BankAccountService bankAccountService = context.getBean(BankAccountService.class); BankAccountDetails bankAccountDetails = new BankAccountDetails(); bankAccountDetails.setBalanceAmount(1000); bankAccountDetails.setLastTransactionTimestamp(new Date()); bankAccountService.createBankAccount(bankAccountDetails); FixedDepositService FixedDepositService = context.getBean(FixedDepositService.class); FixedDepositService.createFixedDeposit(new FixedDepositDetails(1, 1000, 12, nazwa-u(cid:285)ytkownika@nazwa-domeny.pl )); } } W powyższym listingu przez metodę main() klasy BankApp wywoływane są metoda createBank (cid:180)Account() klasy BankAccountService i metoda createFixedDeposit() klasy FixedDepositService. Jeżeli więc wywołasz metodę main() klasy BankApp, w konsoli zostaną wyświetlone następujące dane wyjściowe: INFO LoggingAspect - Wej(cid:258)cie do metody createBankAccount klasy BankAccountServiceImpl INFO LoggingAspect - args[0] -- BankAccountDetails [accountId=0, balanceAmount=1000, (cid:180)lastTransactionTimestamp=Sat Oct 27 16:48:11 IST 2012] INFO BankAccountServiceImpl - Wywo(cid:239)anie metody createBankAccount Poleć książkęKup książkę 282 Spring Framework INFO LoggingAspect - Wej(cid:258)cie do metody createFixedDeposit klasy FixedDepositServiceImpl INFO LoggingAspect - args[0] -- id :1, wysoko(cid:258)(cid:202) lokaty : 1000.0, czas trwania : 12, e-mail : (cid:180)nazwa-u(cid:285)ytkownika@nazwa-domeny.pl INFO FixedDepositServiceImpl - Wywo(cid:239)anie metody createFixedDeposit Powyższe dane wyjściowe pokazują, że metoda log() klasy LoggingAspect jest wykonywana przed metodą createBankAccount() klasy BankAccountService oraz metodą createFixedDeposit() klasy FixedDepositService. W kontekście LoggingAspect zobaczmy teraz, jak działa oferowany przez Spring framework AOP. (cid:206) W projekcie ch09-simple-aop zdefiniowano w celu użycia stylu adnotacji AspectJ zależność od plików JAR o nazwach spring-aop, aopalliance, aspectjrt i aspectjweaver. Więcej informacji na ten temat znajdziesz w pliku pom.xml znajdującym się w projekcie ch09-simple-aop. 9.3. Oferowany przez Spring framework AOP Framework AOP w Springu jest oparty na proxy, a więc obiekt proxy jest tworzony dla obiektów będących celem rady. Proxy to obiekt pośredniczący, wprowadzony przez framework AOP i znajdujący się między obiektem wywołującym i obiektem docelowym. W trakcie działania apli- kacji wywołania do obiektu docelowego są przechwytywane przez proxy, a rady zdefiniowane dla metod docelowych są wykonywane przez proxy. We frameworku AOP obiekt docelowy jest egzem- plarzem komponentu zarejestrowanym w kontenerze Springa. Diagram na rysunku 9.1 pokazuje metodę log() klasy LoggingAspect (patrz: listing 9.1) zastoso- waną do metod klas BankAccountService i FixedDepositService (patrz: listing 9.2). Rysunek 9.1. Obiekt proxy jest odpowiedzialny za przechwytywanie wywołań metod w obiekcie docelowym oraz wykonywanie rad mających zastosowanie dla metody docelowej Na rysunku 9.1 widać, że proxy jest tworzone dla obiektów BankAccountService i FixedDeposit (cid:180)Service. Proxy dla obiektu BankAccountService przechwytuje wywołania metody createBank (cid:180)Account(), natomiast proxy dla obiektu FixedDepositService przechwytuje wywołania metody createFixedDeposit(). Proxy dla obiektu BankAccountService najpierw wykonuje metodę log() klasy LoggingAspect, a następnie metodę createBankAccount() klasy BankAccountService. Podobnie proxy dla obiektu FixedDepositService najpierw wykonuje metodę log() klasy LoggingAspect, a następnie metodę createFixedDeposit() klasy FixedDepositService. Poleć książkęKup książkę Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo 283 Czas wykonania rady (takiej jak metoda log() aspektu LoggingAspect) zależy od typu rady. W stylu adnotacji AspectJ typ rady jest określany za pomocą adnotacji AspectJ. Na przykład adnotacja @Before oznacza wykonanie rady przed wywołaniem metody docelowej, natomiast adnotacja @After oznacza wykonanie rady po wywołaniu metody docelowej. Adnotacja @Around oznacza wykonanie rady zarówno przed, jak i po wykonaniu metody docelowej. Ponieważ metoda log() klasy LoggingAspect została oznaczona adnotacją @Before, metoda log() będzie wykonywana przed wykonaniem metody obiektu docelowego. Zobaczmy teraz, jak framework AOP w Springu tworzy obiekt proxy. Tworzenie proxy Podczas użycia frameworku Spring AOP masz możliwość jawnego tworzenia proxy za pomocą ProxyFactoryBean (patrz: pakiet org.springframework.aop.framework) lub pozostawienia Sprin- gowi zadania automatycznego tworzenia proxy AOP, co jest określane mianem autoproxying. Jeżeli do tworzenia aspektów chcesz zastosować adnotacje w stylu AspectJ, musisz włączyć obsługę tego rodzaju adnotacji, co wymaga użycia elementu aspectj-autoproxy schematu aop ofero- wanego przez Spring. Element aspectj-autoproxy nakazuje także frameworkowi Spring AOP automatyczne tworzenie proxy AOP dla obiektów docelowych. Listing 9.3 przedstawia przykład użycia elementu aspectj- autoproxy w projekcie ch09-simple-aop. Listing 9.3. Plik applicationContext.xml przedstawiający użycie elementu aspectj-autoproxy Projekt: ch09-simple-aop Położenie pliku: src/main/resources/META-INF/spring beans ..... xmlns:context= http://www.springframework.org/schema/context xmlns:aop= http://www.springframework.org/schema/aop xsi:schemaLocation= .....http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd context:component-scan base-package= sample.spring / aop:aspectj-autoproxy proxy-target-class= false expose-proxy= true / /beans Atrybut proxy-target-class elementu aspectj-autoproxy określa rodzaj proxy (oparte na Javie SE lub na CGLIB) tworzonych dla obiektów docelowych. Z kolei atrybut expose-proxy określa, czy proxy AOP będzie dostępne dla obiektu docelowego. Jeżeli wartością atrybutu expose-proxy jest true, wówczas metoda obiektu docelowego może uzyskać dostęp do proxy AOP przez wywoła- nie metody statycznej currentProxy() klasy AopContext. Framework Spring AOP tworzy proxy oparte na CGLIB lub Javie SE. Jeżeli obiekt docelowy nie implementuje żadnego interfejsu, wówczas Spring AOP tworzy proxy oparte na CGLIB. Nato- miast w przypadku, gdy obiekt docelowy implementuje jeden lub więcej interfejsów, Spring AOP tworzy proxy oparte na Javie SE. Jeżeli wartością atrybutu proxy-target-class elementu aspectj-autoproxy będzie false, wówczas Spring AOP tworzy proxy oparte na Javie SE, gdy Poleć książkęKup książkę 284 Spring Framework obiekt docelowy implementuje jeden bądź więcej interfejsów. W przypadku przypisania atrybutowi proxy-target-class wartości true Spring AOP tworzy proxy oparte na CGLIB, nawet jeśli obiekt implementuje jeden lub więcej interfejsów. (cid:206) Począwszy od wersji Spring 3.2, klasy CGLIB znajdują się w pliku JAR o nazwie spring-core. Dlatego nie trzeba w aplikacji wyraźnie wskazywać pliku JAR CGLIB, aby umożliwić fra- meworkowi Spring AOP tworzenie dla obiektów docelowych proxy opartych na CGLIB. Przechodzimy teraz do przypadku, w którym preferowane będzie przypisanie wartości true atry- butowi expose-proxy elementu aspectj-autoproxy . IMPORT Rozdzial09/ch09-aop-proxy. (Ten projekt pokazuje aplikację MyBank, w której metoda currentProxy() klasy AopProxy została użyta przez metodę docelową do pobrania obiektu proxy AOP utworzonego przez framework AOP w Springu. Aby uruchomić tę aplikację, wystarczy wywołać metodę main() w klasie BankApp projektu). Atrybut expose-proxy W listingu 9.4 została przedstawiona zmodyfikowana wersja klasy BankAccountServiceImpl, w której metoda createBankAccount() wywołuje metodę isDuplicateAccount() w celu sprawdzenia, czy w systemie istnieje już konto bankowe charakteryzujące się podanymi cechami. Listing 9.4. Klasa BankAccountServiceImpl @Service(value = bankAccountService ) public class BankAccountServiceImpl implements BankAccountService { @Autowired private BankAccountDao bankAccountDao; @Override public int createBankAccount(BankAccountDetails bankAccountDetails) { if(!isDuplicateAccount(bankAccountDetails)) { return bankAccountDao.createBankAccount(bankAccountDetails); } else { throw new BankAccountAlreadyExistsException( Konto ju(cid:285) istnieje. ); } } @Override public boolean isDuplicateAccount(BankAccountDetails bankAccountDetails) { ..... } } W powyższym listingu widać, że metoda createBankAccount() wywołuje metodę isDuplicateAc (cid:180)count() w celu sprawdzenia, czy konto bankowe o podanych parametrach istnieje już w systemie. W tym momencie może pojawić się pytanie, czy metoda log() klasy LoggingAspect (patrz: listing 9.1) zostanie wykonana, gdy nastąpi wywołanie metody isDuplicateAccount() przez metodę create (cid:180)BankAccount(). Nawet pomimo dopasowania przez metodę isDuplicateAccount() wyrażenia punktu przecięcia określonego za pomocą adnotacji @Before metody log() klasy LoggingAspect (patrz: listing 9.1) metoda log() nie zostanie wywołana. Wynika to z faktu, że względem metod Poleć książkęKup książkę Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo 285 wywoływanych przez obiekt docelowy nie jest stosowane proxy przez AOP. Ponieważ wywołanie metody nie przechodzi przez obiekt proxy AOP, jakakolwiek rada powiązana z metodą docelową nie zostanie wykonana. Aby zagwarantować, że wywołanie metody isDuplicateAccount() będzie do obiektu docelowego przeprowadzone poprzez proxy AOP, w metodzie createBankAccount() należy pobrać obiekt proxy AOP, a następnie wywołać metodę isDuplicateAccount() w tym obiekcie. Listing 9.5 przedstawia przykład pobrania obiektu proxy AOP w metodzie createBankAccount(). Listing 9.5. Klasa BankAccountServiceImpl Projekt: ch09-aop-proxy Położenie pliku: src/main/java/sample/spring/chapter09/bankapp/service package sample.spring.chapter09.bankapp.service; import org.springframework.aop.framework.AopContext; ..... @Service(value = bankAccountService ) public class BankAccountServiceImpl implements BankAccountService { ..... @Override public int createBankAccount(BankAccountDetails bankAccountDetails) { // Pobranie proxy i wywołanie za jego pomocą metody isDuplicateAccount(). boolean isDuplicateAccount = ((BankAccountService)AopContext.currentProxy()). isDuplicateAccount(bankAccountDetails); if(!isDuplicateAccount) { ..... } ..... } @Override public boolean isDuplicateAccount(BankAccountDetails bankAccountDetails) { ..... } } W powyższym listingu wywołanie metody currentProxy() klasy AopContext zwraca proxy AOP, które wykonuje wywołanie metody createBankAccount(). Jeżeli metoda createBankAccount() nie zostanie wykonana za pomocą frameworku Spring AOP lub wartością atrybutu expose-proxy elementu aspectj-autoproxy jest false, wówczas wywołanie metody currentProxy() zakończy się zgłoszeniem wyjątku java.lang.IllegalStateException. Ponieważ proxy AOP implementuje ten sam interfejs co obiekt docelowy, w omawianym listingu zwrócone przez metodę currentProxy() proxy AOP jest rzutowane na typ BankAccountService i następuje wywołanie metody isDuplicate (cid:180)Account() klasy BankAccountService. Jeżeli przejdziesz do projektu ch09-aop-proxy i wykonasz metodę main() klasy BankApp, zauwa- żysz, że metoda log() klasy LoggingAspect jest wykonywana, gdy nastąpi wywołanie metody isDuplicateAccount() przez metodę createBankAccount(). Teraz przechodzimy do dokładnego omówienia wyrażeń punktu przecięcia. Poleć książkęKup książkę 286 Spring Framework 9.4. Wyra(cid:350)enia punktu przeci(cid:255)cia Podczas użycia frameworku Spring AOP wyrażenie punktu przecięcia identyfikuje punkty złączeń, do których zastosowanie mają rady. W przypadku Springa AOP punkt złączenia zawsze jest metodą komponentu. Jeżeli chcesz zastosować rady dla właściwości, konstruktorów, metod niepublicz- nych oraz obiektów niebędących komponentami Springa, powinieneś użyć AspectJ zamiast frame- worku Spring AOP. Jeśli masz zamiar opracować aspekty za pomocą adnotacji stylu AspectJ, wyrażenie punktu przecięcia możesz podać, używając adnotacji AspectJ @Pointcut lub adnotacji AspectJ @Before, @After itd. określających typ rady. Wyrażenia punktów przecięcia używają tak zwanych desygnatorów punktu przecięcia, takich jak execution, args, within, this itd., w celu dopasowania metod, do których ma być zastosowana rada. Na przykład w listingu 9.1 adnotacja @Before zawiera desygnator execution, a tym samym wyszukuje metody, do których zastosowanie będzie miała metoda log() klasy LoggingAspect. Teraz zobaczysz, jak wyrażenia punktów przecięcia są określone za pomocą adnotacji @Pointcut. IMPORT Rozdzial09/ch09-aop-pointcut. (Ten projekt pokazuje aplikację MyBank, w której użyto adnotacji AspectJ @Pointcut w celu określenia wyrażenia punktu przecięcia. Aby uruchomić tę aplikację, wystarczy wywołać metodę main() w klasie BankApp projektu). Adnotacja @Pointcut Atrybut value adnotacji @Pointcut określa wyrażenie punktu przecięcia. Aby użyć adnotacji @Pointcut, utwórz pustą metodę i oznacz ją adnotacją @Pointcut. Pusta metoda musi być zdefiniowana w taki sposób, aby zwracała void. Rada odwołująca się do metody oznaczonej adnotacją @Pointcut będzie zastosowana w metodach dopasowanych przez wyrażenie punktu przecięcia wskazane przez adno- tację @Pointcut. (cid:206) Użycie adnotacji @Pointcut okazuje się szczególnie użyteczne, gdy wyrażenie punktu przecięcia jest współdzielone przez wiele rad w tym samym aspekcie lub w różnych aspektach. W listingu 9.6 została przedstawiona zmodyfikowana wersja klasy LoggingAspect (patrz: listing 9.1) używająca adnotacji @Pointcut. Listing 9.6. Klasa LoggingAspect Projekt: ch09-aop-pointcuts Położenie pliku: src/main/java/sample/spring/chapter09/bankapp/aspects package sample.spring.chapter09.bankapp.aspects; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; @Aspect @Component public class LoggingAspect { Poleć książkęKup książkę Rozdzia(cid:295) 9. Programowanie zorientowane aspektowo 287 @Pointcut(value = execution(* sample.spring.chapter09.bankapp.service.*Service.*(..)) ) private void invokeServiceMethods() { } @Before(value = invokeServiceMethods() ) public void log(JoinPoint joinPoint) { logger.info( Wej(cid:258)cie do metody + joinPoint.getSignature().getName()) + klasy + joinPoint.getTarget().getClass().getSimpleName(); ..... } } W powyższym listingu metoda invokeServiceMethods została oznaczona adnotacją @Pointcut, a atrybut value adnotacji @Before odwołuje się do metody invokeServiceMethods(). Oznacza to, że metoda log() będzie zastosowana względem metod dopasowanych przez wyrażenie punktu przecięcia określone za pomocą adnotacji @Pointcut w metodzie invokeServiceMethods(). Ponieważ execution i args są najczęściej używanymi desygnatorami punktu przecięcia, teraz dokładnie je przeanalizujemy. Desygnatory execution i args Desygnator execution punktu przecięcia ma następujący format: execution( wzorzec-modyfikatora-dost(cid:218)pu wzorzec-zwracanego-typu wzorzec-deklarowanego-typu (cid:180) wzorzec-nazwy-metody ( wzorzec-parametrów-metody ) wzorzec-wyj(cid:200)tku ) Jeżeli porównasz wyrażenie execution z deklaracją metody, zauważysz występujące między nimi podobieństwa. Na rysunku 9.2 pokazujemy, jak poszczególne fragmenty wyrażenia execution można mapować na deklarację metody. Rysunek 9.2. Mapowanie poszczególnych fragmentów wyrażenia execution na różne części deklaracji metody Framework Spring AOP dopasowuje poszczególne fragmenty wyrażenia expression do różnych części deklaracji metody (patrz: rysunek 9.2) w celu znalezienia metod, do których ma zastosowanie dana rada. Na rysunku nie pokazano wzorca-deklarowanego-typu , ponieważ jest on używany tylko wtedy, gdy zachodzi potrzeba odwołania się do metod, które znajdują się w określonym pakiecie lub są określonego typu. Poleć książkęKup książkę 288 Spring Framework W tabeli 9.1 wymieniamy poszczególne fragmenty tworzące wyrażenie execution. Tabela 9.1. Elementy tworzące wyrażenie execution Fragment wyrażenia Opis wzorzec-modyfikatora-dost(cid:218)pu wzorzec-zwracanego-typu wzorzec-deklarowanego-typu wzorzec-nazwy-metody wzorzec-parametrów-metody wzorzec-wyj(cid:200)tku Określa modyfikator dostępu metody docelowej. W Springu AOP jedyna wartość, jaką można określić dla tej części wyrażenia, to public. Ta część wyrażenia execution jest opcjonalna. Określa w pełni kwalifikowaną nazwę typu zwrotnego metody docelowej. Wartość * oznacza, że typ zwrotny metody docelowej nie ma znaczenia. Określa w pełni kwalifikowaną nazwę typu zwrotnego zawierającego metodę docelową. Ta część wyrażenia execution jest opcjonalna. Wartość * oznacza, że wszystkie typy (klasy i interfejsy) w aplikacji są uwzględniane przez wyra
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Spring Framework. Wprowadzenie do tworzenia aplikacji. Wydanie II
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: