Page 1


Tytuł oryginału: Spring in Action, 3rd edition Tłumaczenie: Jacek Kowolik (wstęp, rozdz. 1 – 4); Krzysztof Wołowski (rozdz. 5 – 14) Projekt okładki: Anna Mitka Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. ISBN: 978-83-246-4888-7 Original edition copyright © 2011 by Manning Publications Co. All rights reserved. Polish edition copyright © 2013 by HELION SA. 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/sprwa3 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/sprwa3.zip Printed in Poland.

• Kup książkę • Poleć książkę • Oceń książkę

• Księgarnia internetowa • Lubię to! » Nasza społeczność


Spis treci Przedmowa ............................................................................................................................................... 11 Podzikowania .......................................................................................................................................... 13 O ksice ................................................................................................................................................... 15

CZ 1. PODSTAWY FRAMEWORKA SPRING Rozdzia 1. Zrywamy si do dziaania 1.1.

1.2.

1.3.

1.4.

1.5.

Upraszczamy programowanie w Javie ....................................................................................... 22 1.1.1. Uwalniamy moc zawart w POJO ................................................................................ 23 1.1.2. Wstrzykujemy zalenoci .............................................................................................. 25 1.1.3. Stosujemy aspekty ......................................................................................................... 29 1.1.4. Ograniczamy stosowanie kodu szablonowego dziki wzorcom .................................. 33 Kontener dla naszych komponentów ......................................................................................... 36 1.2.1. Pracujemy z kontekstem aplikacji ................................................................................ 37 1.2.2. Cykl ycia komponentu ................................................................................................. 37 Podziwiamy krajobraz Springa ................................................................................................... 39 1.3.1. Moduy Springa ............................................................................................................. 39 1.3.2. Rodzina projektów wokó Springa ............................................................................... 42 Co nowego w Springu .................................................................................................................. 46 1.4.1. Co nowego w Springu 2.5? ........................................................................................... 46 1.4.2. Co nowego w Springu 3.0? ........................................................................................... 47 1.4.3. Co nowego w rodzinie projektów otaczajcych Springa? ........................................... 47 Podsumowanie .............................................................................................................................. 48

Rozdzia 2. Tworzymy powizania midzy komponentami 2.1.

2.2.

2.3.

2.4.

21

49

Deklarujemy komponenty ........................................................................................................... 50 2.1.1. Tworzymy konfiguracj Springa .................................................................................. 51 2.1.2. Deklarujemy prosty komponent ................................................................................... 51 2.1.3. Wstrzykujemy przez konstruktory ............................................................................... 53 2.1.4. Ustalamy zakres komponentów .................................................................................... 58 2.1.5. Inicjalizujemy i likwidujemy komponenty .................................................................. 59 Wstrzykujemy wartoci do waciwoci komponentu .............................................................. 61 2.2.1. Wstrzykujemy proste wartoci ..................................................................................... 62 2.2.2. Wstrzykujemy referencje do innych beanów .............................................................. 63 2.2.3. Wiemy waciwoci w przestrzeni nazw p Springa ................................................. 66 2.2.4. Wiemy kolekcje ......................................................................................................... 67 2.2.5. Wiemy nic (null) ........................................................................................................ 72 Wi emy za pomoc wyra e ..................................................................................................... 72 2.3.1. Podstawy wyrae w SpEL .......................................................................................... 73 2.3.2. Wykonujemy operacje na wartociach w jzyku SpEL .............................................. 76 2.3.3. Przesiewamy kolekcje za pomoc SpEL ...................................................................... 80 Podsumowanie .............................................................................................................................. 83

Kup książkę

Poleć książkę


6

Spis treci

Rozdzia 3. Ograniczamy u ycie jzyka XML w konfiguracji Springa 3.1.

3.2.

3.3.

3.4.

3.5.

Rozdzia 4. Aspektowy Spring 4.1.

4.2.

4.3.

4.4.

4.5. 4.6.

85

Automatycznie wi emy waciwoci komponentów ................................................................ 86 3.1.1. Cztery rodzaje automatycznego wizania .................................................................... 86 3.1.2. Domylny styl automatycznego wizania .................................................................... 90 3.1.3. Mieszamy wizanie automatyczne i jawne .................................................................. 91 Wi emy za pomoc adnotacji ................................................................................................... 92 3.2.1. Korzystamy z adnotacji @Autowired ........................................................................... 92 3.2.2. Stosujemy automatyczne wizanie zgodne ze standardami, korzystajc z adnotacji @Inject .................................................................................... 97 3.2.3. Posugujemy si wyraeniami podczas wstrzykiwania przez adnotacje .................... 99 Automatyczne wykrywanie komponentów .............................................................................. 100 3.3.1. Oznaczamy komponenty adnotacjami dla automatycznego wykrywania ................. 100 3.3.2. Dodajemy filtry do skanera komponentów ................................................................ 102 U ywamy w Springu konfiguracji opartej na Javie ................................................................ 103 3.4.1. Przygotowujemy si do stosowania konfiguracji opartej na Javie ............................ 103 3.4.2. Definiujemy klas konfiguracyjn .............................................................................. 104 3.4.3. Deklarujemy prosty komponent ................................................................................. 104 3.4.4. Wstrzykujemy w Springu za pomoc konfiguracji opartej na Javie ......................... 105 Podsumowanie ............................................................................................................................ 106

107

Czym jest programowanie aspektowe ...................................................................................... 108 4.1.1. Definiujemy terminologi dotyczc AOP ................................................................ 109 4.1.2. Obsuga programowania aspektowego w Springu .................................................... 112 Wybieramy punkty zczenia za pomoc punktów przecicia .............................................. 115 4.2.1. Piszemy definicje punktów przecicia ....................................................................... 116 4.2.2. Korzystamy z desygnatora bean() w Springu ............................................................. 117 Deklarujemy aspekty w jzyku XML ....................................................................................... 117 4.3.1. Deklarujemy porady before i after ............................................................................. 119 4.3.2. Deklarujemy porad around ....................................................................................... 121 4.3.3. Przekazujemy parametry do porady ........................................................................... 123 4.3.4. Wprowadzamy now funkcjonalno przez aspekty ................................................. 125 U ywamy adnotacji dla aspektów ............................................................................................. 127 4.4.1. Tworzymy porad around za pomoc adnotacji ........................................................ 129 4.4.2. Przekazujemy argumenty do porad konfigurowanych przez adnotacje ................... 130 4.4.3. Tworzymy wprowadzenie za pomoc adnotacji ........................................................ 131 Wstrzykujemy aspekty z AspectJ .............................................................................................. 132 Podsumowanie ............................................................................................................................ 135

CZ 2. PODSTAWY APLIKACJI SPRINGA Rozdzia 5. Korzystanie z bazy danych 5.1.

5.2.

139

Filozofia dostpu do danych Springa ....................................................................................... 140 5.1.1. Hierarchia wyjtków zwizanych z dostpem do danych w Springu ...................... 141 5.1.2. Szablony dostpu do danych ...................................................................................... 143 5.1.3. Klasy bazowe DAO ..................................................................................................... 145 Konfiguracja róda danych ...................................................................................................... 147 5.2.1. róda danych JNDI ................................................................................................... 147 5.2.2. róda danych z pul ................................................................................................... 147 5.2.3. ródo danych oparte na sterowniku JDBC .............................................................. 149

Kup książkę

Poleć książkę


Spis treci 5.3.

5.4.

5.5.

5.6.

U ywanie JDBC w Springu ....................................................................................................... 149 5.3.1. Kod JDBC a obsuga wyjtków .................................................................................. 150 5.3.2. Praca z szablonami JDBC ........................................................................................... 153 Integracja Hibernate ze Springiem ......................................................................................... 158 5.4.1. Przegld Hibernate ..................................................................................................... 159 5.4.2. Deklarowanie fabryki sesji Hibernate ....................................................................... 160 5.4.3. Hibernate bez Springa ................................................................................................ 162 Spring i Java Persistence API ................................................................................................... 163 5.5.1. Konfiguracja fabryki menederów encji .................................................................... 164 5.5.2. Klasa DAO na bazie JPA ............................................................................................. 168 Podsumowanie ............................................................................................................................ 169

Rozdzia 6. Zarzdzanie transakcjami 6.1.

6.2.

6.3. 6.4.

6.5.

7.2.

7.3.

7.4.

7.5.

7.6.

171

Zrozumienie transakcji .............................................................................................................. 172 6.1.1. Cztery sowa kluczowe do zrozumienia transakcji .................................................... 173 6.1.2. Zrozumienie obsugi zarzdzania transakcjami w Springu ....................................... 174 Wybór mened era transakcji .................................................................................................... 175 6.2.1. Transakcje JDBC ........................................................................................................ 175 6.2.2. Transakcje Hibernate .................................................................................................. 176 6.2.3. Transakcje Java Persistence API ................................................................................ 177 6.2.4. Transakcje Java Transaction API ................................................................................ 178 Programowanie transakcji w Springu ...................................................................................... 178 Deklarowanie transakcji ........................................................................................................... 180 6.4.1. Definiowanie atrybutów transakcji ............................................................................ 180 6.4.2. Deklarowanie transakcji w XML ................................................................................ 184 6.4.3. Definiowanie transakcji sterowanych adnotacjami ................................................... 186 Podsumowanie ............................................................................................................................ 187

Rozdzia 7. Budowanie aplikacji sieciowych za pomoc Spring MVC 7.1.

7

189

Wprowadzenie do Spring MVC ............................................................................................... 190 7.1.1. Cykl ycia dania w Spring MVC ............................................................................. 190 7.1.2. Konfiguracja Spring MVC .......................................................................................... 192 Budowa podstawowego kontrolera .......................................................................................... 193 7.2.1. Konfiguracja Spring MVC sterowanego adnotacjami ............................................... 194 7.2.2. Definiowanie kontrolera strony gównej ................................................................... 195 7.2.3. Produkowanie widoków .............................................................................................. 198 7.2.4. Definiowanie widoku strony gównej ........................................................................ 202 7.2.5. Dopracowanie kontekstu aplikacji Springa ............................................................... 203 Kontroler obsugujcy dane wprowadzane przez u ytkownika ............................................ 205 7.3.1. Budowa kontrolera przetwarzajcego dane wprowadzane przez uytkownika ....... 205 7.3.2. Wywietlenie widoku .................................................................................................. 207 Przetwarzanie formularzy ......................................................................................................... 208 7.4.1. Wywietlenie formularza rejestracyjnego .................................................................. 209 7.4.2. Przetwarzanie formularza ........................................................................................... 211 7.4.3. Walidacja przesyanych danych ................................................................................. 213 Obsuga plików wysyanych na serwer .................................................................................... 217 7.5.1. Dodanie pola selektora plików do formularza ........................................................... 217 7.5.2. Odbieranie plików wysyanych na serwer ................................................................. 218 7.5.3. Konfiguracja Springa do przesyania plików na serwer ............................................ 221 Podsumowanie ............................................................................................................................ 221

Kup książkę

Poleć książkę


8

Spis treci

Rozdzia 8. Praca ze Spring Web Flow 8.1. 8.2.

8.3.

8.4. 8.5.

Rozdzia 9. Zabezpieczanie Springa 9.1.

9.2.

9.3.

9.4.

9.5.

9.6.

223

Instalacja Spring Web Flow ..................................................................................................... 224 8.1.1. Konfiguracja Spring Web Flow .................................................................................. 224 Skadowe przepywu .................................................................................................................. 227 8.2.1. Stany ............................................................................................................................ 227 8.2.2. Przejcia ....................................................................................................................... 230 8.2.3. Dane przepywu .......................................................................................................... 231

czymy wszystko w cao : zamówienie pizzy ...................................................................... 233 8.3.1. Definiowanie bazowego przepywu ........................................................................... 233 8.3.2. Zbieranie informacji o kliencie ................................................................................... 237 8.3.3. Budowa zamówienia ................................................................................................... 242 8.3.4. Przyjmowanie patnoci .............................................................................................. 245 Zabezpieczanie przepywu ........................................................................................................ 247 Podsumowanie ............................................................................................................................ 247

249

Wprowadzenie do Spring Security .......................................................................................... 250 9.1.1. Rozpoczynamy prac ze Spring Security ................................................................... 250 9.1.2. Konfiguracyjna przestrze nazw Spring Security ..................................................... 251 Zabezpieczanie da sieciowych ............................................................................................ 252 9.2.1. Poredniczenie w dostpie do filtrów serwletów ...................................................... 252 9.2.2. Minimalna konfiguracja bezpieczestwa sieciowego ................................................ 253 9.2.3. Przechwytywanie da .............................................................................................. 257 Zabezpieczanie elementów na poziomie widoku .................................................................... 259 9.3.1. Dostp do informacji uwierzytelniajcych ................................................................ 260 9.3.2. Wywietlanie z uprawnieniami .................................................................................. 261 Uwierzytelnianie u ytkowników ............................................................................................... 263 9.4.1. Konfiguracja repozytorium w pamici operacyjnej .................................................. 263 9.4.2. Uwierzytelnianie za pomoc bazy danych ................................................................. 264 9.4.3. Uwierzytelnianie za pomoc LDAP ........................................................................... 266 9.4.4. Wczenie funkcji „pamitaj mnie” ............................................................................ 269 Zabezpieczanie metod ............................................................................................................... 270 9.5.1. Zabezpieczanie metod z adnotacj @Secured .......................................................... 270 9.5.2. Adnotacja @RolesAllowed ze specyfikacji JSR-250 ................................................. 271 9.5.3. Zabezpieczenia przed wykonaniem metody ze SpEL i po jej wykonaniu .............. 271 9.5.4. Deklaracja przeci bezpieczestwa na poziomie metody ....................................... 276 Podsumowanie ............................................................................................................................ 276

CZ 3. INTEGRACJA W SPRINGU Rozdzia 10. Praca ze zdalnymi usugami

279

10.1. Zdalny dostp w Springu ........................................................................................................... 280 10.2. Praca z RMI ................................................................................................................................ 282 10.2.1. Eksportowanie usugi RMI ........................................................................................ 283 10.2.2. Dowizanie usugi RMI .............................................................................................. 285 10.3. Udostpnianie zdalnych usug za pomoc Hessian i Burlap ................................................. 287 10.3.1. Udostpnianie funkcjonalnoci komponentu za pomoc Hessian/Burlap ............... 288 10.3.2. Dostp do usug Hessian/Burlap ................................................................................ 290

Kup książkę

Poleć książkę


Spis treci

9

10.4. Obiekt HttpInvoker ................................................................................................................... 292 10.4.1. Udostpnianie komponentów jako usug HTTP ....................................................... 292 10.4.2. Dostp do usug przez HTTP ..................................................................................... 293 10.5. Publikacja i konsumpcja usug sieciowych .............................................................................. 294 10.5.1. Tworzenie punktów kocowych JAX-WS w Springu ............................................... 295 10.5.2. Porednik usug JAX-WS po stronie klienta .............................................................. 299 10.6. Podsumowanie ............................................................................................................................ 300

Rozdzia 11. Spring i model REST

301

11.1. Zrozumienie REST .................................................................................................................... 302 11.1.1. Fundamenty REST ..................................................................................................... 302 11.1.2. Obsuga REST w Springu .......................................................................................... 303 11.2. Tworzenie kontrolerów korzystajcych z zasobów ................................................................. 303 11.2.1. Kontroler niezgodny z konwencj REST pod lup ................................................... 304 11.2.2. Obsuga adresów URL typu RESTful ........................................................................ 305 11.2.3. Czasowniki REST ....................................................................................................... 308 11.3. Reprezentacja zasobów ............................................................................................................. 311 11.3.1. Negocjowanie reprezentacji zasobu ........................................................................... 311 11.3.2. Praca z konwerterami komunikatów HTTP .............................................................. 314 11.4. Tworzenie klientów REST ........................................................................................................ 317 11.4.1. Operacje szablonu RestTemplate ............................................................................... 319 11.4.2. Pobieranie zasobów za pomoc GET ......................................................................... 320 11.4.3. Umieszczanie zasobów na serwerze za pomoc PUT ............................................... 322 11.4.4. Usuwanie zasobów za pomoc DELETE .................................................................. 324 11.4.5. Wysyanie danych zasobu za pomoc POST ............................................................. 325 11.4.6. Wymiana zasobów ....................................................................................................... 327 11.5. Wysyanie formularzy typu RESTful ....................................................................................... 329 11.5.1. Umieszczanie ukrytych pól metod w kodzie za pomoc JSP ................................... 330 11.5.2. Demaskowanie rzeczywistego dania ...................................................................... 330 11.6. Podsumowanie ............................................................................................................................ 332

Rozdzia 12. Obsuga komunikatów w Springu

333

12.1. Krótki wstp do JMS .................................................................................................................. 334 12.1.1. Architektura JMS ........................................................................................................ 335 12.1.2. Szacowanie korzyci zwizanych z uyciem JMS ..................................................... 337 12.2. Konfiguracja brokera komunikatów w Springu ..................................................................... 338 12.2.1. Tworzenie fabryki pocze ........................................................................................ 339 12.2.2. Deklaracja miejsca docelowego komunikatów ActiveMQ ........................................ 340 12.3. Szablon JMS Springa ................................................................................................................. 340 12.3.1. Kod JMS a obsuga wyjtków ..................................................................................... 341 12.3.2. Praca z szablonami JMS .............................................................................................. 342 12.4. Tworzenie obiektów POJO sterowanych komunikatami ....................................................... 347 12.4.1. Tworzenie odbiorcy komunikatów ............................................................................. 348 12.4.2. Konfiguracja odbiorców komunikatów ...................................................................... 349 12.5. U ywanie RPC opartego na komunikatach ............................................................................. 350 12.5.1. Praca z RPC opartym na komunikatach w Springu .................................................. 350 12.5.2. Asynchroniczne RPC z Lingo ..................................................................................... 352 12.6. Podsumowanie ............................................................................................................................ 354

Kup książkę

Poleć książkę


10

Spis treci

Rozdzia 13. Zarzdzanie komponentami Springa za pomoc JMX

357

13.1. Eksportowanie komponentów Springa w formie MBean ...................................................... 358 13.1.1. Udostpnianie metod na podstawie nazwy ............................................................... 361 13.1.2. Uycie interfejsów do definicji operacji i atrybutów komponentu zarzdzanego ...... 363 13.1.3. Praca z komponentami MBean sterowanymi adnotacjami ....................................... 364 13.1.4. Postpowanie przy konfliktach nazw komponentów zarzdzanych ......................... 365 13.2. Zdalny dostp do komponentów zarzdzanych ...................................................................... 366 13.2.1. Udostpnianie zdalnych komponentów MBean ........................................................ 367 13.2.2. Dostp do zdalnego komponentu MBean ................................................................. 367 13.2.3. Obiekty poredniczce komponentów zarzdzanych ................................................ 369 13.3. Obsuga powiadomie ............................................................................................................... 370 13.3.1. Odbieranie powiadomie ........................................................................................... 371 13.4. Podsumowanie ............................................................................................................................ 372

Rozdzia 14. Pozostae zagadnienia

373

14.1. Wyodrbnianie konfiguracji ..................................................................................................... 374 14.1.1. Zastpowanie symboli zastpczych we waciwociach ............................................ 374 14.1.2. Nadpisywanie waciwoci ......................................................................................... 377 14.1.3. Szyfrowanie zewntrznych waciwoci .................................................................... 378 14.2. Wizanie obiektów JNDI .......................................................................................................... 380 14.2.1. Praca z tradycyjnym JNDI ......................................................................................... 380 14.2.2. Wstrzykiwanie obiektów JNDI .................................................................................. 382 14.2.3. Wizanie komponentów EJB w Springu ................................................................... 385 14.3. Wysyanie wiadomoci e-mail ................................................................................................... 386 14.3.1. Konfiguracja komponentu wysyajcego poczt ........................................................ 386 14.3.2. Budowa wiadomoci e-mail ........................................................................................ 388 14.4. Planowanie zada wykonywanych w tle .................................................................................. 392 14.4.1. Deklaracja zaplanowanych metod .............................................................................. 393 14.4.2. Deklaracja metod asynchronicznych ......................................................................... 395 14.5. Podsumowanie ............................................................................................................................ 396 14.6. Koniec…? .................................................................................................................................... 396

Skorowidz

Kup książkę

399

Poleć książkę


Aspektowy Spring

W tym rozdziale omówimy: Q

Podstawy programowania aspektowego

Q

Tworzenie aspektów z POJO

Q

Stosowanie adnotacji @AspectJ

Q

Wstrzykiwanie zalenoci do aspektów AspectJ

Gdy pisz ten rozdzia, w Teksasie (gdzie mieszkam) mamy od kilku dni rekordowo wysokie temperatury. Jest strasznie gorco. Podczas takiej pogody klimatyzacja jest koniecznoci. Jednak wad klimatyzacji jest zuycie energii elektrycznej, a za energi elektryczn trzeba zapaci. Niewiele moemy zrobi w celu uniknicia wydatków na to, by mieszka w chodnych i komfortowych warunkach. To dlatego w kadym domu jest zamontowany licznik energii elektrycznej, który rejestruje wszystkie zuyte kilowaty, i raz w miesicu kto przychodzi odczyta ten licznik, aby zakad energetyczny dokadnie wiedzia, jaki wystawi nam rachunek. Teraz wyobra my sobie, co by si stao, gdyby taki licznik znikn i nikt nie przychodzi, by sprawdzi nasze zuycie energii elektrycznej. Zaómy, e do kadego waciciela domu naleaoby skontaktowanie si z zakadem energetycznym i zgoszenie swojego zuycia energii. Cho jest moliwe, e jaki obsesyjny waciciel domu uwanie rejestrowaby kade uycie wiata, telewizji czy klimatyzacji, wikszo by si tym nie przejmowaa. Wikszo podaaby swoje przyblione zuycie, a niektórzy nie zgosiliby zuycia w ogóle. Sprawdzanie zuycia energii byoby kopotliwe, a pokusa, by nie zapaci, mogaby okaza si zbyt silna.

Kup książkę

Poleć książkę


108

ROZDZIA 4. Aspektowy Spring

Ta forma systemu patnoci za energi elektryczn mógaby by wietna dla klientów, lecz byaby daleka od ideau z punktu widzenia zakadów energetycznych. To dlatego wszyscy mamy w domu liczniki energii i dlatego raz w miesicu kto zaglda, by odczyta licznik i poinformowa zakad energetyczny o zuyciu. Niektóre funkcje systemów oprogramowania s podobne do liczników energii elektrycznej w naszych domach. Funkcje te musz by stosowane w wielu miejscach w naszej aplikacji, lecz byoby niewygodne, gdybymy musieli wywoywa je w kadym miejscu. Kontrola zuycia energii elektrycznej jest wan funkcj, lecz nie zajmuje najwyszej pozycji w wiadomoci wikszoci wacicieli domów. Koszenie trawników, odkurzanie dywanów czy sprztanie azienki to czynnoci, w które posiadacz domu jest aktywnie zaangaowany. Natomiast kontrola zuycia elektrycznoci w domu jest z punktu widzenia waciciela domu czynnoci pasywn (cho byoby cudownie, gdyby koszenie trawników te byo czynnoci pasywn — zwaszcza w takie gorce dni). W oprogramowaniu niektóre czynnoci s powszechne w wikszoci aplikacji. Rejestrowanie transakcji, ich bezpieczestwo i zarzdzanie nimi s wane, lecz czy powinny by czynnociami, w których aktywnie uczestnicz obiekty naszej aplikacji? Czy moe lepiej by byo, aby obiekty naszej aplikacji pozostay skoncentrowane na problemach z dziedziny biznesowej, do jakich zostay zaprojektowane, i pozostawiy pewne aspekty do obsugi przez kogo innego? Funkcje, które przenikaj wiele miejsc w aplikacji, nosz w brany programistycznej nazw zagadnie przecinajcych. W typowej sytuacji takie zagadnienia przecinajce s koncepcyjnie rozdzielone od biznesowej logiki aplikacji (cho czsto bezporednio w ni wbudowane). Oddzielenie zagadnie przecinajcych od logiki biznesowej jest miejscem, gdzie do pracy wcza si programowanie aspektowe (AOP). W rozdziale 2. nauczylimy si, jak uywa wstrzykiwania zalenoci do zarzdzania obiektami naszej aplikacji i ich konfigurowania. Podobnie jak DI pozwala rozdzieli od siebie poszczególne obiekty aplikacji, AOP pozwala oddzieli zagadnienia przecinajce od obiektów, których one dotycz. Logowanie jest popularnym przykadem zastosowania aspektów. Jednak nie jest to jedyne zastosowanie, w którym korzystne bdzie uycie aspektów. Podczas lektury tej ksiki zobaczymy kilka praktycznych zastosowa aspektów, w tym transakcje deklaracyjne, bezpieczestwo oraz pami podrczn. W tym rozdziale zostanie omówiona obsuga aspektów w Springu, w tym sposób deklarowania zwykych klas, aby stay si aspektami, oraz moliwo zastosowania adnotacji podczas tworzenia aspektów. Dodatkowo dowiemy si, w jaki sposób przy uyciu AspectJ — innej popularnej implementacji AOP — moemy uzupeni dziaanie rodowiska AOP Springa. Lecz najpierw, zanim si zajmiemy transakcjami, bezpieczestwem i pamici podrczn, dowiedzmy si, w jaki sposób aspekty s implementowane w Springu, zaczynajc od paru zupenych podstaw AOP.

4.1.

Czym jest programowanie aspektowe Jak wczeniej wspomnielimy, aspekty pomagaj zamyka w moduach zagadnienia przecinajce. W skrócie, zagadnienie przecinajce mona opisa jako dowolny mechanizm, którego wpyw jest uywany na wielu miejscach w aplikacji. Bezpieczestwo na

Kup książkę

Poleć książkę


4.1.

109

Czym jest programowanie aspektowe

przykad jest zagadnieniem przecinajcym, w tym sensie, e wiele metod w aplikacji moe podlega stosowaniu regu bezpieczestwa. Na rysunku 4.1 pokazano obrazow ilustracj zagadnie przecinajcych.

Rysunek 4.1. Aspekty zamykaj w moduach zagadnienia przecinajce, które dotycz logiki zawartej w wielu sporód obiektów aplikacji

Na rysunku 4.1 pokazano typow aplikacj, która jest podzielona na moduy. Gównym zadaniem kadego z moduów jest realizowanie usug ze swojej szczególnej dziedziny. Lecz kady modu potrzebuje take podobnych mechanizmów pomocniczych, takich jak bezpieczestwo czy zarzdzanie transakcjami. Popularn obiektow technik ponownego uycia tej samej funkcjonalnoci jest stosowanie dziedziczenia albo delegacji. Ale dziedziczenie moe prowadzi do zburzenia hierarchii obiektów, jeli ta sama klasa bazowa jest stosowana w caej aplikacji. Z kolei stosowanie delegacji bywa uciliwe, poniewa moe by potrzebne skomplikowane wywoanie delegacji. Aspekty stanowi alternatyw dla dziedziczenia i delegacji, która w wielu sytuacjach moe by bardziej eleganckim rozwizaniem. Korzystajc z techniki AOP, nadal definiujemy popularne mechanizmy w jednym miejscu, lecz za pomoc deklaracji definiujemy, gdzie i jak mechanizmy te zostan zastosowane, bez koniecznoci modyfikowania klasy, do której maj zastosowanie nowe mechanizmy. Odtd zagadnienia przekrojowe moemy zamkn w moduach w postaci specjalnych klas zwanych aspektami. Wynikaj z tego dwie korzyci. Po pierwsze, logika dla kadego zagadnienia znajduje si teraz w jednym miejscu, zamiast by rozrzucon po caym kodzie. Po drugie, nasze moduy usugowe bd teraz bardziej uporzdkowane, poniewa zawieraj jedynie kod dotyczcy ich gównego zadania (albo podstawowych funkcji), za zagadnienia drugorzdne zostay przeniesione do aspektów. 4.1.1.

Definiujemy terminologi dotyczc AOP

Podobnie jak w przypadku innych technologii, wraz z rozwojem AOP powsta specyficzny argon opisujcy t technik programistyczn. Aspekty s czsto opisywane za pomoc poj takich jak „porada”, „punkt przecicia” czy „punkt zczenia”. Na rysunku 4.2 pokazano, jak s ze sob powizane te zagadnienia. Niestety, wiele sporód poj uywanych do opisywania AOP jest dalekie od intuicyjnoci. S one jednak obecnie czci pojcia „programowanie aspektowe” i musimy si z nimi zapozna w celu zrozumienia tej nowej techniki programistycznej. Zanim przejdziemy do praktyki, nauczmy si jzyka, w którym bdziemy rozmawia.

Kup książkę

Poleć książkę


110

ROZDZIA 4. Aspektowy Spring

PORADA

Gdy osoba odczytujca licznik pokae si w naszym domu, jej zadaniem jest poinformowanie zakadu energetycznego o wskazywanej liczbie kilowatogodzin. Z pewnoci osoba ta ma list domów, które musi odwiedzi, za informacje, które dostarcza zakadowi energetycznemu, s wane. Lecz gównym zadaniem osoby odczytujcej liczniki jest sama czynno notowania zuycia energii. Podobnie, aspekty maj gówne zada- Rysunek 4.2. Funkcjonalno aspektu jest wplatana do wykonania nie — czynno, której wykonanie jest (porada) programu w jednym lub wicej punktach celem ich istnienia. W terminologii pro- zczenia gramowania aspektowego zadanie aspektu jest nazywane porad. Porada jest dla aspektu definicj zarówno czynnoci, która ma zosta wykonana, jak i waciwego momentu jej wykonania. Czy aspekt powinien by wykonany przed wywoaniem metody? Po jej wykonaniu? Zarówno przed wywoaniem metody, jak i po niej? A moe tylko wtedy, gdy metoda zgosi wyjtek? Aspekty w Springu mog dziaa z picioma rodzajami porad: Q

Q

Q

Q

Q

Before — Funkcjonalno porady jest wykonywana przed wywoaniem metody z porad. After — Funkcjonalno porady jest wykonywana po zakoczeniu dziaania metody z porad, niezalenie od wyniku jej dziaania. After-returning — Funkcjonalno porady jest wykonywana po prawidowym zakoczeniu metody z porad. After-throwing — Funkcjonalno porady jest wykonywana po zgoszeniu wyjtku przez metod z porad. Around — Porada realizuje t sam funkcjonalno zarówno przed wywoaniem, jak i po zakoczeniu metody z porad.

PUNKTY ZCZENIA

Zakad energetyczny obsuguje wiele domów, prawdopodobnie wrcz cae miasto. W kadym domu zamontowany jest licznik energii elektrycznej, zatem kady dom jest potencjalnym celem dla osoby odczytujcej liczniki. Potencjalnie osoba taka mogaby odczytywa wiele rónych przyrzdów pomiarowych, lecz w ramach swoich obowizków subowych powinna przyj za cel wanie liczniki energii zamontowane w domach. W podobny sposób w naszej aplikacji mog by tysice miejsc, w których moglibymy zastosowa porad. Miejsca te s nazywane punktami zczenia. Punkt zczenia jest tak pozycj w przebiegu wykonania programu, w której moe zosta wpity aspekt. Takim punktem moe by wywoanie metody, zgoszenie wyjtku czy nawet modyfikacja zawartoci pola. S to pozycje, w których kod aspektu moe zosta wczony w normalny przebieg dziaania naszej aplikacji, wzbogacajc tym jej dziaanie.

Kup książkę

Poleć książkę


4.1.

Czym jest programowanie aspektowe

111

PUNKTY PRZECI CIA

Nie jest moliwe, by jedna osoba odczytujca liczniki zdoaa odwiedzi wszystkie domy, którym elektryczno dostarcza ten sam zakad energetyczny. Pojedynczej osobie jest przypisany jedynie pewien podzbiór wszystkich domów. Podobnie porada nie musi koniecznie docza aspektu do kadego punktu zczenia w aplikacji. Punkty przecicia pozwalaj zawzi list punktów zczenia, do których zastosowany bdzie aspekt. Jeli porada definiowaa czynno i moment jej wykonania przez aspekt, to punkty przecicia definiuj miejsce, w którym czynno ta zostanie wykonana. Definicja punktu przecicia dopasowuje jeden lub wicej punktów zczenia, w których naley wple porad. Czsto okrelamy takie punkty przecicia za pomoc jawnego wskazania nazw metod i klas albo za pomoc wyrae regularnych, które dopasowuj do wzorców nazwy klas i metod. Niektóre frameworki aspektowe pozwalaj na tworzenie dynamicznych punktów przecicia, w których decyzja, czy zastosowa porad, jest podejmowana w trakcie dziaania, na przykad na podstawie wartoci parametrów metod. ASPEKTY

Gdy osoba odczytujca liczniki rozpoczyna dzie pracy, wie zarówno, co naley do jej obowizków (kontrola zuycia energii elektrycznej), jak równie z których domów powinna zbiera t informacj. Zatem wie ona wszystko, co potrzeba, by wywiza si ze swoich obowizków. Aspekt jest sum porady i punktów przecicia. Wzite razem porada i punkty przecicia definiuj wszystko, co mona powiedzie o aspekcie — jak czynno wykonuje, gdzie i kiedy. WPROWADZENIA

Wprowadzenie pozwala nam dodawa nowe metody lub atrybuty do istniejcych klas. Na przykad moemy skonstruowa klas z porad, o nazwie Auditable. Bdzie ona przechowywaa informacj o momencie ostatniej modyfikacji obiektu. Moe to by klasa tak prosta, e bdzie posiadaa tylko jedn metod, nazwan setLastModified(Date) i zmienn o zasigu instancji, która bdzie przechowywaa stan tej klasy. Tak now metod i zmienn moemy wprowadzi do istniejcych klas bez koniecznoci ich modyfikowania, wzbogacajc je o nowe dziaanie i zmienn stanu. WPLATANIE

Wplatanie jest procesem zastosowania aspektu do obiektu docelowego w celu utworzenia nowego obiektu z porednikiem. Aspekty s wplatane do docelowych obiektów we wskazanych punktach zczenia. Wplatanie moe mie miejsce w rónych momentach cyklu ycia docelowego obiektu: Q

Q

Kup książkę

W czasie kompilacji — Aspekty zostaj wplecione, gdy klasa docelowa jest kompilowana. W tym celu potrzebny jest specjalny kompilator. Wplatajcy kompilator w AspectJ wplata aspekty w ten sposób. W czasie adowania klasy — Aspekty zostaj wplecione, gdy klasa docelowa jest adowana do maszyny wirtualnej Javy (JVM). W tym celu potrzebny jest specjalny ClassLoader, który rozszerza kod bajtowy docelowej klasy, zanim

Poleć książkę


112

ROZDZIA 4. Aspektowy Spring

Q

zostanie ona wprowadzona do aplikacji. Opcja wplatania w czasie adowania (ang. load-time weaving, LTW) wprowadzona w wersji 5 AspectJ realizuje wplatanie aspektów w ten sposób. W czasie dziaania — Aspekty zostaj wplecione w jakim momencie podczas dziaania aplikacji. W typowej sytuacji kontener aspektowy bdzie dynamicznie generowa obiekt poredniczcy, który zostanie poczony z obiektem docelowym za pomoc delegacji podczas wplatania aspektów. Z tego sposobu korzysta Spring AOP podczas wplatania aspektów.

To wiele nowych poj, z którymi trzeba si zapozna. Wracajc do rysunku 4.2, zobaczymy, e porada zawiera zachowanie zagadnienia przecinajcego, które ma by wczone do obiektów aplikacji. Punktami zczenia s wszystkie punkty w przebiegu dziaania aplikacji, które s potencjalnymi miejscami zastosowania porady. Najwaniejszym, co naley tu sobie uwiadomi, jest fakt, e punkty przecicia definiuj, które punkty zczenia bd brane pod uwag. Gdy ju si troszk oswoilimy z najbardziej podstawow czci terminologii dotyczcej programowania aspektowego, przekonajmy si, jak te podstawowe koncepcje AOP zostay zaimplementowane w Springu. 4.1.2.

Obsuga programowania aspektowego w Springu

Nie wszystkie aspektowe frameworki s skonstruowane tak samo. Mog si róni tym, jak bogaty model punktów zcze posiadaj. Niektóre pozwalaj stosowa porady na poziomie modyfikacji pól, podczas gdy inne udostpniaj jedynie punkty zcze zwizane z wywoaniem metod. Mog si take róni sposobem i momentem wplatania aspektów. Niezalenie od konkretnego przypadku, moliwo tworzenia punktów przecicia, definiujcych punkty zczenia, w których powinny zosta wplecione aspekty, jest tym, co stanowi aspektowy framework. Wiele si zmienio w brany frameworków aspektowych przez ostatnie kilka lat. Zostay poczynione porzdki, w wyniku których niektóre sporód frameworków zostay poczone ze sob, z kolei inne zaczynaj zanika. W roku 2005 projekt AspectWerkz zosta poczony z AspectJ, co byo ostatni istotn zmian w wiecie AOP, pozostawiajc nam do wyboru trzy dominujce frameworki aspektowe: Q Q Q

AspectJ (http://eclipse.org/aspectj), JBoss AOP (http://www.jboss.org/jbossaop), Spring AOP (http://www.springframework.org).

Poniewa ksika ta jest powicona frameworkowi Spring, skupimy si na Spring AOP. Mimo to wystpuje wiele podobiestw midzy projektami Spring i AspectJ, za obsuga AOP w Springu zawiera wiele zapoycze z projektu AspectJ. Obsuga AOP w Springu ma cztery odmiany: Q Q Q Q

Kup książkę

Klasyczna obsuga AOP w Springu na bazie obiektów poredniczcych. Aspekty sterowane adnotacj @AspectJ. Aspekty zbudowane z „czystych” POJO. Wstrzykiwane aspekty z AspektJ (dostpne we wszystkich wersjach Springa).

Poleć książkę


4.1.

113

Czym jest programowanie aspektowe

Pierwsze trzy pozycje s waciwie odmianami obsugi AOP przez Springa na bazie obiektów poredniczcych. W efekcie obsuga AOP w Springu jest ograniczona do przechwytywania metod. Jeli potrzebujemy w Springu rozszerzonego przechwytywania prostych metod (na przykad przechwytywania konstruktora albo waciwoci), bdziemy musieli rozway implementacj aspektów w AspectJ, by moe korzystajc ze wstrzykiwania zalenoci w Springu, by wstrzykn komponenty Springa do aspektów w AspectJ. Co takiego? Nie bdzie omówienia klasycznego AOP w Springu? Sowo klasyczne zwykle budzi pozytywne skojarzenia. Klasyczne samochody, klasyczny turniej golfowy czy te klasyczna Coca-Cola — wszystkie s czym dobrym. Lecz klasyczny model programowania aspektowego w Springu wcale nie jest zbyt dobry. Oczywicie, by czym wietnym jak na swoje czasy. Lecz obecnie istniej w Springu znacznie bardziej uporzdkowane i atwiejsze sposoby pracy z aspektami. W porównaniu do prostego deklaracyjnego modelu AOP i AOP opartego na adnotacjach klasyczny model AOP w Springu robi wraenie ociaego i nadmiernie skomplikowanego. Bezporednie wykorzystanie ProxyFactoryBean moe by mczce. Zatem zdecydowaem, e do biecego wydania tej ksiki nie wcz w ogóle omówienia klasycznego AOP w Springu. Jeli naprawd ciekawi ci, Czytelniku, jak dziaa ten model AOP, moesz sprawdzi w pierwszych dwóch wydaniach. Lecz sdz, e przekonasz si, i praca z nowymi modelami AOP w Springu jest znacznie atwiejsza.

W tym rozdziale dowiemy si wicej o powyszych technikach aspektowych w Springu. Jednak zanim rozpoczniemy, wane, bymy zrozumieli kilka kluczowych zagadnie w aspektowym frameworku Spring. PORADA SPRINGA JEST ZAPISANA W JAVIE

Wszystkie porady, jakie utworzymy w Springu, s zapisane w standardowych klasach Javy. W ten sposób czerpiemy korzy z moliwoci konstruowania naszych aspektów w tym samym zintegrowanym rodowisku programistycznym (IDE), którego na co dzie uywamy do pisania programów w Javie. Co wicej, punkty przecicia, które definiuj miejsca, gdzie porady powinny zosta zastosowane, zwykle zapisujemy w jzyku XML, jako cz naszego pliku konfiguracji Springa. To oznacza, e zarówno kod aspektów, jak i skadnia konfiguracji bd naturalne dla programistów Javy. Inaczej jest w AspectJ. Cho obecnie AspectJ obsuguje ju aspekty oparte na adnotacjach, AspectJ pojawi si take jako rozszerzenie jzyka Java. Takie podejcie ma zarówno zalety, jak i wady. Posiadanie specjalizowanego jzyka do obsugi aspektów zwiksza moliwoci takiego jzyka i pozwala na precyzyjniejsz kontrol jego zachowania, a take bogatszy zestaw narzdzi aspektowych. Lecz osigamy to kosztem koniecznoci nauki nowego narzdzia i nowej skadni. SPRING DOCZA PORADY DO OBIEKTÓW W TRAKCIE PRACY

Spring wplata aspekty do zarzdzanych przez niego komponentów w trakcie pracy, opakowujc je w klasy poredniczce. Jak pokazano na rysunku 4.3, klasa poredniczca zawiera docelowy komponent, przechwytuje wywoania metod z porad i przekierowuje wywoania tych metod do komponentu docelowego.

Kup książkę

Poleć książkę


114

ROZDZIA 4. Aspektowy Spring

Rysunek 4.3. Aspekty w Springu zostay zaimplementowane jako obiekty poredniczce, które opakowuj obiekt docelowy. Obiekt poredniczcy przechwytuje wywoania metod, wykonuje dodatkow logik aspektu, a nastpnie wywouje metod docelow

W czasie pomidzy przechwyceniem przez obiekt poredniczcy wywoania metody a momentem wywoania metody komponentu docelowego obiekt poredniczcy realizuje logik aspektu. Spring nie tworzy obiektu z porednikiem, dopóki aplikacja nie bdzie potrzebowaa okrelonego komponentu. Jeli korzystamy z ApplicationContext, obiekt z porednikiem zostanie utworzony, gdy kontekst bdzie adowa wszystkie nalece do niego komponenty z BeanFactory. Poniewa Spring tworzy obiekty poredniczce w czasie dziaania, korzystanie z AOP w Springu nie zmusza nas do stosowania specjalnego kompilatora, który umoliwiaby wplatanie aspektów. SPRING OBSUGUJE JEDYNIE PUNKTY ZCZENIA ZWIZANE Z METODAMI

Jak wspomnielimy wczeniej, w poszczególnych implementacjach AOP stosowane s róne modele punktów zczenia. Poniewa Spring bazuje na dynamicznych obiektach poredniczcych, obsuguje tylko punkty zczenia zwizane z metodami. W tym róni si od niektórych innych frameworków aspektowych, takich jak AspectJ czy JBoss, które poza punktami zczenia zwizanymi z metodami oferuj take obsug punktów zczenia zwizanych z polami oraz z konstruktorami. Nieobecno w Springu punktów przecicia zwizanych z polami uniemoliwia nam tworzenie porad o bardzo duej precyzji, takich jak przejcie aktualizacji pola w obiekcie. Za bez punktów przecicia zwizanych z konstruktorami nie dysponujemy sposobem, by zastosowa porad podczas tworzenia instancji beana. Przechwytywanie wywoa metod powinno zaspokoi wikszo, jeli nie wszystkie, z naszych potrzeb. Jeli okae si, e potrzebujemy czego wicej ni tylko przechwytywanie wywoa metod, bdziemy mogli uzupeni funkcjonalno AOP w Springu za pomoc AspectJ. Teraz mamy ju ogólne pojcie, do czego suy programowanie aspektowe i w jaki sposób jest obsugiwane przez Springa. Nadszed czas, by zakasa rkawy i wzi si za tworzenie aspektów w Springu. Zacznijmy od deklaracyjnego modelu AOP w Springu.

Kup książkę

Poleć książkę


4.2.

4.2.

115

Wybieramy punkty zczenia za pomoc punktów przecicia

Wybieramy punkty zczenia za pomoc punktów przecicia Jak wczeniej wspominalimy, punktów przecicia uywamy do wskazania miejsca, w którym powinna zosta zastosowana porada aspektu. Obok porady, punkty przecicia stanowi najbardziej podstawowe skadniki aspektu. Jest zatem wane, bymy wiedzieli, w jaki sposób wiza punkty przecicia. Programujc aspektowo w Springu, definiujemy punkty przecicia za pomoc pochodzcego z frameworka AspectJ jzyka wyrae punktów przecicia. Jeli jestemy ju zaznajomieni ze rodowiskiem AspectJ, wówczas definiowanie punktów przecicia w Springu wyda si nam naturalne. Lecz w razie gdyby AspectJ by dla nas frameworkiem nowym, ten podrozdzia moe suy jako szybki samouczek pisania punktów przecicia w stylu AspectJ. Poszukujcym bardziej szczegóowego omówienia frameworka AspectJ oraz pochodzcego z tego frameworka jzyka wyrae punktów przecicia z caego serca polecam drugie wydanie ksiki AspectJ in Action, któr napisa Ramnivas Laddad. Najwaniejszym, co powinnimy wiedzie na temat punktów przecicia w stylu AspectJ w zastosowaniu do programowania aspektowego w Springu, jest fakt obsugiwania przez Springa jedynie podzbioru desygnatorów punktów przecicia dostpnych w AspectJ. Przypomnijmy sobie, e Spring AOP bazuje na obiektach poredniczcych i niektóre wyraenia opisujce punkty przecicia niczego nie wnosz dla programowania aspektowego bazujcego na obiektach poredniczcych. W tabeli 4.1 zawarto zestawienie desygnatorów punktów przecicia pochodzcych z AspectJ, które s obsugiwane przez Spring AOP. Tabela 4.1. Spring do definiowania aspektów wykorzystuje jzyk wyrae punktów przecicia pochodzcy z AspectJ Desygnator w stylu AspectJ

Opis

args()

Ogranicza dopasowanie punktów zczenia do wywoa metod, których argumenty s instancjami okrelonych typów.

@args()

Ogranicza dopasowanie punktów zczenia do wywoa metod, których argumenty s opatrzone adnotacjami okrelonych typów.

execution()

Dopasowuje punkty zczenia, które s wywoaniami metod.

this()

Ogranicza dopasowanie punktów zczenia do takich, które posiadaj w obiekcie poredniczcym AOP referencj do beana okrelonego typu.

target()

Ogranicza dopasowanie punktów zczenia do takich, w których obiekt docelowy jest instancj okrelonego typu.

@target()

Ogranicza dopasowanie do punktów zczenia, w których klasa wywoywanego obiektu jest opatrzona adnotacj okrelonego typu.

within()

Ogranicza dopasowanie do punktów zczenia bdcych instancjami okrelonych typów.

@within()

Ogranicza dopasowanie do punktów zczenia bdcych instancjami typów, które s opatrzone okrelon adnotacj (w zastosowaniu dla Spring AOP wywoania metod zadeklarowanych w typach opatrzonych okrelon adnotacj).

@annotation

Ogranicza dopasowanie punktów zczenia do takich, w których obiekt bdcy przedmiotem dziaania punktów zczenia jest opatrzony okrelon adnotacj.

Kup książkę

Poleć książkę


116

ROZDZIA 4. Aspektowy Spring

Próba uycia którego z desygnatorów pochodzcych z AspectJ, niewymienionego w powyszej tabeli, bdzie skutkowaa zgoszeniem wyjtku IllegalArgumentException. Przegldajc list obsugiwanych desygnatorów, zwrómy uwag, e execution jest jedynym desygnatorem, który faktycznie realizuje dopasowanie. Wszystkich pozostaych uywamy do ograniczania takich dopasowa. To znaczy, e podstawowy jest desygnator execution, którego uyjemy w kadej definicji punktu przecicia, jak napiszemy. Pozostaych bdziemy uywa do ograniczania zasigu punktu przecicia. 4.2.1.

Piszemy definicje punktów przecicia

Przykadowo moemy uy wyraenia pokazanego na rysunku 4.4, by zastosowa porad za kadym wywoaniem metody play(), nalecej do klasy Instrument.

Rysunek 4.4. Wybieramy metod play(), zdefiniowan w klasie Instrument, za pomoc wyraenia punktu przecicia w stylu AspectJ

Uylimy desygnatora execution(), by wybra metod play(), nalec do klasy Instru ´ment. Specyfikacja metody rozpoczyna si od gwiazdki, która oznacza, e nie ma dla nas znaczenia, jaki bdzie typ wartoci zwróconej przez metod. Nastpnie podajemy pen, kwalifikowan nazw klasy oraz nazw metody, któr chcemy wybra. Dla listy parametrów metody uylimy podwójnej kropki (..), co oznacza, e punkt przecicia moe wybra dowoln sporód metod play(), niezalenie od tego, jakie parametry przyjmuj poszczególne z nich. Teraz zaómy, e chcemy zawzi zasig tego punktu przecicia jedynie do pakietu com.springinaction.springidol. W takiej sytuacji moemy ograniczy dopasowanie, dodajc do wyraenia desygnator within(), jak pokazano na rysunku 4.5.

Rysunek 4.5. Ograniczamy zasig punktu przecicia za pomoc desygnatora within()

Zauwamy, e uylimy operatora &&, by poczy desygnatory execution() oraz within() za pomoc relacji koniunkcji (w której warunkiem dopasowania punktu przecicia jest dopasowanie obydwu desygnatorów). Podobnie, moglimy uy operatora ||, by utworzy relacj alternatywy. Z kolei operator ! pozwala zanegowa wynik dziaania desygnatora.

Kup książkę

Poleć książkę


4.3.

117

Deklarujemy aspekty w jzyku XML

Poniewa znak & jest symbolem specjalnym w jzyku XML, moemy swobodnie zastpi notacj && operatorem and, gdy zapisujemy specyfikacj punktów przecicia w pliku konfiguracyjnym XML Springa. Podobnie, moemy uy operatorów or oraz not, zastpujc nimi, odpowiednio, notacj || i !. 4.2.2.

Korzystamy z desygnatora bean() w Springu

W wersji 2.5 Springa wprowadzono nowy desygnator bean(), rozszerzajcy list zawart w tabeli 4.1. Pozwala on wskazywa komponenty za pomoc ich nazw w wyraeniu punktu przecicia. Desygnator bean() przyjmuje jako argument nazw komponentu i ogranicza dziaanie punktu przecicia do tego konkretnego komponentu. Przykadowo, rozwamy poniszy punkt przecicia: execution(* com.springinaction.springidol.Instrument.play()) and bean(eddie)

Informujemy tu Springa, e chcemy zastosowa porad aspektu do wykonania metody play() klasy Instrument, lecz ograniczajc si do wywoa z komponentu o nazwie eddie. Moliwo zawenia punktu przecicia do okrelonego komponentu moe by cenna w niektórych sytuacjach, lecz moemy take uy negacji, by zastosowa aspekt do wszystkich komponentów, z wyjtkiem posiadajcego okrelon nazw: execution(* com.springinaction.springidol.Instrument.play()) and !bean(eddie)

W tym wypadku porada aspektu zostanie wpleciona do wszystkich komponentów, które maj nazw rón od eddie. Teraz, gdy omówilimy podstawy pisania punktów przecicia, zmierzmy si z pisaniem porad i deklarowaniem aspektów, które bd z tych punktów przecicia korzystay.

4.3.

Deklarujemy aspekty w jzyku XML Jeli jeste obeznany z klasycznym modelem programowania aspektowego w Springu, wiesz, e praca z ProxyFactoryBean jest bardzo niewygodna. Twórcy Springa zauwayli ten problem i postanowili udostpni lepszy sposób na deklarowanie aspektów w tym frameworku. Rezultat tych stara znalaz si w przestrzeni nazw aop Springa. Zestawienie elementów konfiguracyjnych AOP umieszczono w tabeli 4.2. W rozdziale 2., pokazujc przykad wstrzykiwania zalenoci, zorganizowalimy turniej talentów o nazwie Idol Springa. W przykadzie tym utworzylimy powizania dla kilku wykonawców, jako elementów <bean>, umoliwiajc im zademonstrowanie ich uzdolnie. To wszystko byo wspania rozrywk. Lecz tego rodzaju przedsiwzicie potrzebuje widowni albo bdzie bezcelowe. Zatem, aby zilustrowa dziaanie Spring AOP, utwórzmy klas Audience dla naszego turnieju talentów. Funkcje widowni definiuje klasa z listingu 4.1. Jak widzimy, klasa Audience niczym szczególnym si nie wyrónia. Jest to podstawowa klasa Javy, zawierajca kilka metod. Moemy take zarejestrowa t klas jako beana w kontekcie aplikacji Springa: <bean id="audience" class="com.springinaction.springidol.Audience" />

Kup książkę

Poleć książkę


118

ROZDZIA 4. Aspektowy Spring Tabela 4.2. Elementy konfiguracyjne Spring AOP upraszczaj deklaracj aspektów bazujcych na POJO Element konfiguracji AOP

Zastosowanie

<aop:advisor>

Definiuje doradc aspektowego.

<aop:after>

Definiuje aspektow porad after (niezalen od wyniku dziaania metody zaopatrzonej w porad).

<aop:after-returning>

Definiuje aspektow porad after-returning (po pomylnym zakoczeniu dziaania metody).

<aop:after-throwing>

Definiuje aspektow porad after-throwing (po zgoszeniu wyjtku przez metod).

<aop:around>

Definiuje aspektow porad around (zarówno przed wykonaniem metody, jak i po zakoczeniu jej dziaania).

<aop:aspect>

Definiuje aspekt.

<aop:aspect-autoproxy>

Przecza w tryb aspektów sterowanych adnotacjami z uyciem @AspectJ.

<aop:before>

Definiuje aspektow porad before (przed wykonaniem metody).

<aop:config>

Element nadrzdnego poziomu w konfiguracji aspektowej. Wikszo elementów <aop:*> powinna znajdowa si wewntrz elementu <aop:config>.

<aop:declare-parents>

Wprowadza do obiektów z porad dodatkowe interfejsy, implementowane w przezroczysty sposób.

<aop:pointcut>

Definiuje punkt przecicia.

Listing 4.1. Klasa Audience dla naszego turnieju talentów

package com.springinaction.springidol; public class Audience { Przed wystpem public void takeSeats() { System.out.println("Widzowie zajmuj miejsca."); } Przed wystpem public void turnOffCellPhones() { System.out.println("Widzowie wy czaj telefony komórkowe."); } Po wystpie public void applaud() { System.out.println("Brawooo! Oklaski!"); } Po nieudanym wystpie public void demandRefund() { System.out.println("Buu! Oddajcie pieni dze za bilety!"); }

}

Mimo skromnego wygldu klasy Audience niezwyke w niej jest to, e ma ona wszystko, czego potrzeba do utworzenia aspektu. Potrzebuje ona jedynie odrobiny specjalnych aspektowych czarów Springa.

Kup książkę

Poleć książkę


4.3.

4.3.1.

119

Deklarujemy aspekty w jzyku XML

Deklarujemy porady before i after

Korzystajc z elementów konfiguracyjnych Spring AOP, jak pokazano na listingu 4.2, moemy z komponentu audience utworzy aspekt. Listing 4.2. Definiujemy aspekt audience, korzystajc z elementów konfiguracyjnych Spring AOP

<aop:config> Referencja do komponentu audience <aop:aspect ref="audience"> <aop:before pointcut= "execution(* com.springinaction.springidol.Performer.perform(..))" Przed wystpem method="takeSeats" /> <aop:before pointcut= "execution(* com.springinaction.springidol.Performer.perform(..))" Przed wystpem method="turnOffCellPhones" /> <aop:after-returning pointcut= "execution(* com.springinaction.springidol.Performer.perform(..))" method="applaud" />

Po wystpie

<aop:after-throwing pointcut= "execution(* com.springinaction.springidol.Performer.perform(..))" Po nieudanym wystpie method="demandRefund" /> </aop:aspect> </aop:config>

Pierwszym, co zauwaamy w temacie elementów konfiguracyjnych Spring AOP, jest fakt, e prawie wszystkie z nich powinny by uyte wewntrz kontekstu elementu <aop: ´config>. Jest od tej reguy kilka wyjtków, lecz podczas deklarowania komponentów jako aspektów zawsze zaczynamy od elementu <aop:config>. Wewntrz elementu <aop:config> moemy zadeklarowa jeden albo wicej aspektów, doradców lub punktów przecicia. Na listingu 4.2 za pomoc elementu <aop:aspect> zadeklarowalimy pojedynczy punkt przecicia. Atrybut ref zawiera referencj do komponentu w postaci POJO, który bdzie uyty jako dostawca funkcjonalnoci aspektu — w tym wypadku jest to komponent audience. Komponent, do którego referencj zawiera atrybut ref, bdzie dostarcza metody wywoywane przez kad z porad w aspekcie. Aspekt posiada cztery róne porady. Dwa elementy <aop:before> definiuj porady realizowane przed wykonaniem metody, które wywoaj metody takeSeats() oraz turn ´OffCellPhones() (zadeklarowane z uyciem atrybutu method) komponentu Audience, przed wykonaniem jakiejkolwiek metody dopasowanej do punktu przecicia. Element <aop:after-returning> definiuje porad realizowan po powrocie z metody, która wywoa metod applaud() po punkcie przecicia. Jednoczenie element <aop:after-throwing> definiuje porad realizowan po zgoszeniu wyjtku, która wywoa metod demandRe ´fund(), jeli zostanie zgoszony jaki wyjtek. Na rysunku 4.6 pokazano, jak logika porady jest wplatana midzy logik biznesow. We wszystkich elementach porad atrybut pointcut definiuje punkt przecicia, w którym zostanie zastosowana porada. Warto, jak podamy w atrybucie pointcut, jest punktem przecicia zdefiniowanym w skadni wyrae punktów przecicia w stylu AspectJ.

Kup książkę

Poleć książkę


120

ROZDZIA 4. Aspektowy Spring

Rysunek 4.6. Aspekt Audience zawiera cztery porady, wplatajce swoj logik wokó metod, które zostan dopasowane do punktu przecicia

Zapewne zwróci nasz uwag fakt, e wszystkie elementy porad posiadaj tak sam warto atrybutu pointcut. To dlatego, e wszystkie porady maj zosta zastosowane w tym samym punkcie przecicia. Widzimy tu zamanie reguy „nie powtarzaj si” (ang. don’t repeat yourself, DRY). Jeli pó niej postanowilibymy zmieni punkt przecicia, musielibymy dokona modyfikacji w czterech rónych miejscach. Aby unikn duplikatów w definicji punktów przecicia, moemy si zdecydowa na zdefiniowanie nazwanego punktu przecicia za pomoc elementu <aop:pointcut>. Kod z listingu 4.3 demonstruje sposób uycia elementu <aop:pointcut> wraz z elementem <aop:aspect> do zdefiniowania nazwanego punktu przecicia, którego bdziemy mogli uy we wszystkich elementach porad. Listing 4.3. Definiujemy nazwany punkt przecicia, by wyeliminowa nadmiarowe definicje punktów przecicia

<aop:config> <aop:aspect ref="audience"> <aop:pointcut id="performance" expression= "execution(* com.springinaction.springidol.Performer.perform(..))" /> Definicja punktu przecicia

<aop:before pointcut-ref="performance" method="takeSeats" /> <aop:before pointcut-ref="performance" method="turnOffCellPhones" /> <aop:after-returning pointcut-ref="performance" method="applaud" /> <aop:after-throwing pointcut-ref="performance" method="demandRefund" />

Kup książkę

Referencje do punktu przecicia

Poleć książkę


4.3.

121

Deklarujemy aspekty w jzyku XML </aop:aspect> </aop:config>

Teraz punkt przecicia jest zdefiniowany w jednym miejscu, do którego odwouje si wiele elementów porad. Element <aop:pointcut> definiuje punkt przecicia o nazwie performance. Jednoczenie wszystkie elementy porad zostay zmienione na odwoania do nazwanego punktu przecicia za pomoc atrybutu pointcut-ref. Jak pokazano na listingu 4.3, element <aop:pointcut> definiuje punkt przecicia, do którego mog si odwoywa wszystkie porady wewntrz tego samego elementu <aop:aspect>. Lecz moemy take zdefiniowa punkty przecicia, które bd widoczne z wielu aspektów. W tym celu musielibymy umieci element <aop:pointcut> bezporednio wewntrz elementu <aop:config>. 4.3.2.

Deklarujemy porad around

Obecna implementacja aspektu Audience dziaa rewelacyjnie, lecz podstawowe porady before i after maj pewne ograniczenia. W szczególnoci duym wyzwaniem jest wymiana informacji midzy par porad before i after bez uciekania si do przechowywania tej informacji w zmiennych skadowych. Przykadowo, wyobra my sobie, e poza wyczeniem telefonów komórkowych i oklaskiwaniem wykonawców po zakoczeniu, chcielibymy, by widzowie zerknli na zegarki i poinformowali nas o czasie trwania danego wystpu. Jedynym sposobem osignicia tego za pomoc porad before i after jest zanotowanie momentu rozpoczcia w poradzie before i raportowanie czasu trwania w jakiej poradzie after. Lecz musielibymy przechowa moment rozpoczcia w zmiennej skadowej. Poniewa za komponent Audience jest instancj klasy singletonowej, nie byoby to rozwizaniem bezpiecznym ze wzgldu na prac wielowtkow, gdybymy w taki sposób przechowywali informacj o stanie. Pod tym wzgldem porada around ma przewag nad par porad before i after. Za pomoc porady around moemy osign ten sam efekt, co za pomoc osobnych porad before i after, lecz wykonujc wszystkie czynnoci za pomoc jednej metody. Dziki umieszczeniu w jednej metodzie caego zbioru porad nie ma potrzeby przechowywania informacji o stanie w zmiennej skadowej. Przykadowo rozwamy now metod watchPerformance(), zdefiniowan na listingu 4.4. Listing 4.4. Metoda watchPerformance() realizuje funkcjonalno aspektowej porady around

public void watchPerformance(ProceedingJoinPoint joinpoint) { try { System.out.println("Widzowie zajmuj miejsca."); System.out.println("Widzowie wy czaj telefony komórkowe."); Przed wystpem long start = System.currentTimeMillis(); joinpoint.proceed();

Przejcie do metody opatrzonej porad

long end = System.currentTimeMillis(); Po wystpie System.out.println("Brawooo! Oklaski!"); System.out.println("Wystp trwa " + (end - start) + " miliskund.");

Kup książkę

Poleć książkę


122

ROZDZIA 4. Aspektowy Spring } catch (Throwable t) { System.out.println("Buu! Oddajcie pieni dze za bilety!"); }

Po nieudanym wystpie

}

Pierwszym, co zauwaamy w tej nowej metodzie porady, jest fakt, e otrzymuje ona parametr ProceedingJoinPoint. Obiekt ten jest konieczny, abymy byli w stanie wywoa docelow metod z wntrza naszej porady. Metoda porady wykonuje wszystkie swoje zadania, po czym, gdy jest gotowa do przekazania sterowania do metody docelowej, wywoa metod proceed() obiektu ProceedingJoinPoint. Zwrómy uwag, e spraw krytyczn jest, abymy pamitali o umieszczeniu w poradzie wywoania metody proceed(). Gdybymy o tym szczególe zapomnieli, w efekcie nasza porada blokowaaby dostp do metody docelowej. Moe byby to efekt zgodny z naszymi zamierzeniami, lecz jest znacznie bardziej prawdopodobne, e naprawd chcielibymy, aby metoda docelowa zostaa w jakim momencie wywoana. Jeszcze jedn interesujc informacj jest fakt, e podobnie jak istnieje moliwo zablokowania dostpu do metody docelowej przez pominicie wywoania metody pro ´ceed(), moemy take umieci w poradzie wielokrotne wywoanie tej metody. Jednym z powodów, by tak postpi, moe by implementowanie logiki ponawiania próby wykonania pewnej czynnoci w sytuacji, gdy realizujca j metoda docelowa zakoczya si niepowodzeniem. W przypadku aspektu audience metoda watchPerformance() zawiera ca funkcjonalno wczeniejszych czterech metod realizujcych porady, lecz tym razem zawartych w jednej, wcznie z tym, e jest odpowiedzialna za obsug zgoszonych przez ni sam wyjtków. Zauwamy te, e tu przed wywoaniem nalecej do punktu zczenia metody proceed() w lokalnej zmiennej zostaje zapisany biecy czas. Tu po odzyskaniu sterowania od wywoanej metody wywietlany jest komunikat o czasie jej trwania. Deklaracja porady around nie róni si znaczco od deklaracji innych rodzajów porad. Musimy jedynie posuy si elementem <aop:around>, jak na listingu 4.5. Listing 4.5. Definiujemy aspekt audience z uyciem porady around

<aop:config> <aop:aspect ref="audience"> <aop:pointcut id="performance2" expression= "execution(* com.springinaction.springidol.Performer.perform(..))" /> <aop:around pointcut-ref="performance2" method="watchPerformance()" /> </aop:aspect> </aop:config>

Deklaracja porady around

Podobnie jak w przypadku elementów XML dotyczcych innych porad, element <aop: ´around> otrzymuje punkt przecicia oraz nazw metody realizujcej porad. Uylimy tu tego samego punktu przecicia co wczeniej, lecz atrybutowi method nadalimy warto wskazujc na now metod watchPerformance().

Kup książkę

Poleć książkę


4.3.

4.3.3.

123

Deklarujemy aspekty w jzyku XML

Przekazujemy parametry do porady

Jak dotd nasze aspekty miay prost budow i nie przyjmoway adnych parametrów. Jedynym wyjtkiem bya metoda watchPerformance(), któr napisalimy w celu realizowania przykadowej porady around. Otrzymywaa ona parametr ProceedingJoinPoint. Poza tym jednym przypadkiem nie zajmowalimy naszym poradom uwagi kontrol wartoci parametrów przekazywanych do metody docelowej. Byo to jednak jak najbardziej poprawne, poniewa metoda perform(), dla której pisalimy porady, nie przyjmowaa parametrów. Zdarzaj si jednak sytuacje, gdy moe si okaza poyteczne, by porada nie tylko opakowywaa metod, lecz take kontrolowaa wartoci parametrów przekazywanych do tej metody. By si przekona, jak to dziaa, wyobra my sobie nowy typ zawodnika w turnieju talentów Idol Springa. Ten nowy zawodnik bdzie wystpowa z pokazami czytania w mylach i zostanie zdefiniowany za pomoc interfejsu MindReader: package com.springinaction.springidol; public interface MindReader{ void interceptThoughts(String thoughts); String getThoughts(); }

Interfejs MindReader zawiera definicje dwu podstawowych czynnoci: przechwytywania myli ochotnika i informowania o ich treci. Prost implementacj interfejsu MindReader jest klasa Magician: package com.springinaction.springidol; public class Magician implements MindReader{ private String thoughts; public void interceptThoughts(String thoughts){ System.out.println("Przechwytuj my li ochotnika: "); this.thoughts=thoughts; } public StringgetThoughts(){ return thoughts; } }

Musimy dostarczy czytajcemu w mylach kogo, kogo myli mógby odczyta. W tym celu zdefiniujemy interfejs Thinker: package com.springinaction.springidol; public interface Thinker{ void thinkOfSomething(String thoughts); }

Klasa Volunteer stanowi podstawow implementacj interfejsu Thinker:

Kup książkę

Poleć książkę


124

ROZDZIA 4. Aspektowy Spring package com.springinaction.springidol; public class Volunteer implements Thinker{ private String thoughts; public void thinkOfSomething(String thoughts){ this.thoughts = thoughts; } public String getThoughts(){ return thoughts; } }

Szczegóy klasy Volunteer nie s jako strasznie interesujce ani wane. Interesujcy jest sposób, w jaki klasa Magician bdzie przechwytywa myli klasy Volunteer za pomoc Spring AOP. Aby osign taki stopie telepatii, bdziemy musieli skorzysta z tych samych elementów <aop:aspect> oraz <aop:before>, których uywalimy ju wczeniej. Lecz tym razem skonfigurujemy je w taki sposób, by przekazyway do porady parametry metody docelowej. <aop:config> <aop:aspectref="magician"> <aop:pointcutid="thinking" expression="execution(* com.springinaction.springidol.Thinker.thinkOfSomething(String)) and args(thoughts)"/> <aop:before pointcut-ref="thinking" method="interceptThoughts" arg-names="thoughts" /> </aop:aspect> </aop:config>

Klucz do umiejtnoci pozazmysowych klasy Magician znajduje si w definicji punktu przecicia oraz atrybucie arg-names elementu <aop:before>. Punkt przecicia identyfikuje metod thinkOfSomething() klasy Thinker, oczekujc argumentu typu String. Nastpnie za parametr args pozwala zarejestrowa argument jako warto thoughts. Jednoczenie deklaracja porady <aop:before> odwouje si do argumentu thoughts, wskazujc, e powinien on zosta przekazany do metody interceptThoughts(). Od tego momentu, kiedykolwiek zostanie wywoana metoda thinkOfSomething() w beanie volunteer, klasa Magician przechwyci te myli. By to udowodni, utworzymy prost klas testow z ponisz metod: @Test public void magicianShouldReadVolunteersMind(){ volunteer.thinkOfSomething("Dama Kier"); assertEquals("Dama Kier", magician.getThoughts()); }

Kup książkę

Poleć książkę


4.3.

Deklarujemy aspekty w jzyku XML

125

Bardziej szczegóowo zagadnienie pisania w Springu testów jednostkowych i testów integracyjnych omówimy w nastpnym rozdziale. Na razie zapamitajmy, e rezultat testu okae si pozytywny, poniewa Magician zawsze bdzie wiedzia wszystko, o czymkolwiek Volunteer pomyli. Teraz dowiedzmy si, w jaki sposób uy techniki Spring AOP, by doda now funkcjonalno do istniejcych obiektów dziki mocy wprowadzenia. 4.3.4.

Wprowadzamy now funkcjonalno przez aspekty

W niektórych jzykach, jak Ruby czy Groovy, istnieje pojcie klas otwartych. Umoliwiaj one dodawanie nowych metod do obiektu albo klasy bez koniecznoci bezporedniego modyfikowania definicji takiego obiektu czy te klasy. Niestety, Java nie jest jzykiem a tak dynamicznym. Gdy klasa zostaa skompilowana, niewiele mona zrobi w celu dodania do niej nowej funkcjonalnoci. Lecz jeli si dobrze zastanowi, czy nie to wanie staralimy si robi w tym rozdziale za pomoc aspektów? Oczywicie, nie dodalimy do obiektów adnej nowej metody, lecz dodawalimy nowe mechanizmy obok metod wczeniej definiowanych przez odpowiednie obiekty. Jeli aspekt moe opakowywa istniejce metody w dodatkowe mechanizmy, czemu nie doda nowych metod do obiektu? Waciwie, korzystajc z aspektowej koncepcji zwanej wprowadzeniem, aspekty mog dodawa zupenie nowe metody do beanów w Springu. Przypomnijmy sobie, e w Springu aspekty s po prostu obiektami poredniczcymi, które implementuj te same interfejsy, co komponent docelowy. Jaki byby skutek, gdyby, poza tymi wspólnymi interfejsami, obiekt poredniczcy implementowa jeszcze jaki inny interfejs? Wówczas kady komponent realizujcy porad aspektu sprawiaby wraenie, jakby take implementowa ten nowy interfejs. Dzieje si tak, mimo e klasa, której instancj jest nasz komponent, nie zawiera implementacji tego dodatkowego interfejsu. Na rysunku 4.7 pokazano, jak to dziaa.

Rysunek 4.7. Spring AOP pozwala na wprowadzanie nowych metod do komponentu. Obiekt poredniczcy przechwytuje wywoania i deleguje do innego obiektu, który implementuje dan metod

Na rysunku 4.7 moemy zauway, e w momencie wywoania wprowadzonego interfejsu obiekt poredniczcy deleguje wywoanie do pewnego innego obiektu, który zawiera implementacj tego nowego interfejsu. W efekcie uzyskujemy pojedynczy komponent, którego implementacja jest rozdzielona pomidzy wicej ni jedn klas.

Kup książkę

Poleć książkę


126

ROZDZIA 4. Aspektowy Spring

By wcieli ten pomys w ycie, powiedzmy, e chcemy wprowadzi do klas wszystkich wykonawców z naszych przykadów poniszy interfejs Contestant: package com.springinaction.springidol; public interfaceContestant{ void receiveAward(); }

Zakadamy, e moemy zajrze do kadej implementacji klasy Performer i zmodyfikowa je wszystkie tak, aby implementoway take interfejs Contestant. Z projektowego punktu widzenia moe to jednak by niezbyt rozwany ruch (poniewa implementacje interfejsów Contestant i Performer niekoniecznie musz w sensie logicznym zawiera si nawzajem w sobie). Co wicej, moe nawet okaza si niemoliwe, by zmieni wszystkie implementacje interfejsu Performer. Szczególnie jeli pracujemy z implementacjami tworzonymi przez osoby trzecie, moemy nie mie dostpu do kodu ródowego. Szczliwie wprowadzenia przez aspekty mog nam pomóc sobie z tym poradzi, nie wymagajc powicania decyzji projektowych lub inwazyjnych dziaa wzgldem istniejcych implementacji. Aby skorzysta z tego mechanizmu, musimy posuy si elementem <aop:declare-parents>: <aop:aspect> <aop:declare-parents types-matching="com.springinaction.springidol.Performer+" implement-interface="com.springinaction.springidol.Contestant" default-impl="com.springinaction.springidol.GraciousContestant" /> </aop:aspect>

Jak sugeruje znaczenie nazwy elementu <aop:declare-parents>, pozwala on na zadeklarowanie, e komponent, którego dotyczy porada, otrzyma nowe obiekty nadrzdne w hierarchii obiektów. W tym konkretnym wypadku deklarujemy za pomoc atrybutu types-matching, e typy pasujce do interfejsu Performer powinny posiada take, jako klas nadrzdn, interfejs Contestant (wskazany przez atrybut implement-interface). Ostatni spraw do rozstrzygnicia jest pooenie implementacji metod interfejsu Contestant. Istniej dwa sposoby, by wskaza implementacj wprowadzonego interfejsu. W tym wypadku korzystamy z atrybutu default-impl, by wprost wskaza implementacj za pomoc jej w peni kwalifikowanej nazwy klasy. Alternatywnie, moglibymy wskaza implementacj za pomoc atrybutu delegate-ref: <aop:declare-parents types-matching="com.springinaction.springidol.Performer+" implement-interface="com.springinaction.springidol.Contestant" delegate-ref="contestantDelegate" />

Atrybut delegate-ref odwouje si do komponentu w Springu jako delegacji wprowadzenia. Zakadamy tu, e komponent o nazwie contestantDelegate istnieje w kontekcie Springa: <bean id="contestantDelegate" class="com.springinaction.springidol.GraciousContestant"/>

Kup książkę

Poleć książkę


4.4.

127

Uywamy adnotacji dla aspektów

Rónica midzy bezporednim wskazaniem delegacji za pomoc atrybutu default-impl oraz porednim przez atrybut delegate-ref polega na tym, e w tym drugim rozwizaniu mamy komponent Springa, który sam moe podlega wstrzykiwaniu, otrzyma porad albo w jaki inny sposób zosta skonfigurowany przez Springa.

4.4.

Uywamy adnotacji dla aspektów Podstawow funkcj wprowadzon w wersji 5 AspectJ bya moliwo uycia adnotacji do tworzenia aspektów. We wczeniejszych wersjach pisanie aspektów w AspectJ wymagao nauki rozszerzenia do jzyka Java. Lecz adnotacyjny model wprowadzony w AspectJ uproci tworzenie aspektu z dowolnej klasy dziki wprowadzeniu kilku nowych adnotacji. Ten nowy mechanizm jest znany pod nazw @AspectJ. Wracajc do klasy Audience, widzielimy, e zawieraa ona wszystkie funkcje, jakie powinni realizowa widzowie, lecz adnego ze szczegóów, które czyniyby z tej klasy aspekt. To zmuszao nas do deklarowania porady i punktów przecicia w pliku XML. Lecz dysponujc adnotacjami w stylu @AspectJ, moemy wróci do naszej klasy Audience i uczyni z niej aspekt, nie potrzebujc do tego celu adnej dodatkowej klasy ani deklaracji komponentu. Na listingu 4.6 pokazano now wersj klasy Audience, dziki adnotacjom przemienion w aspekt. Listing 4.6. Opatrujemy klas Audience adnotacj, by utworzy aspekt

package com.springinaction.springidol; import import import import import

org.aspectj.lang.annotation.AfterReturning; org.aspectj.lang.annotation.AfterThrowing; org.aspectj.lang.annotation.Aspect; org.aspectj.lang.annotation.Before; org.aspectj.lang.annotation.Pointcut;

@Aspect public class Audience{ @Pointcut( "execution(* com.springinaction.springidol.Performer.perform(..))") public void performance() { Definicja } punktu przecicia @Before("performance()") Przed wystpem public void takeSeats() { System.out.println("Widzowie zajmuj miejsca."); } @Before("performance()") Przed wystpem public void turnOffCellPhones() { System.out.println("Widzowie wy czaj telefony komórkowe."); } @AfterReturning("performance()") public void applaud() { System.out.println("Brawooo! Oklaski!"); }

Po wystpie

@AfterThrowing("performance()")

Kup książkę

Poleć książkę


128

ROZDZIA 4. Aspektowy Spring public void demandRefund() { System.out.println("Buu! Oddajcie pieni dze za bilety!"); }

Po nieudanym wystpie

}

Nowa wersja klasy Audience jest opatrzona adnotacj @Aspect. Adnotacja ta wskazuje, e klasa nie jest ju tylko jednym z wielu POJO, lecz jest aspektem. Adnotacji @Pointcut uywamy do zdefiniowania punktu przecicia moliwego do wielokrotnego uycia wewntrz aspektu w stylu @AspectJ. Warto przekazana adnotacji @Pointcut jest wyraeniem punktu przecicia — tu wskazujcym, e punkt przecicia powinien zosta dopasowany do metody perform() klasy Performer. Nazwa punktu przecicia pochodzi od nazwy metody, do której zastosowana jest adnotacja. Zatem ten punkt przecicia bdzie si nazywa performance(). To, co waciwie znajduje si w ciele metody performance(), nie ma specjalnie znaczenia, waciwie mogaby to by metoda pusta. Sama metoda jest tylko znacznikiem, zapewniajcym adnotacji @Pointcut punkt, w którym bdzie moga si zaczepi. Kada sporód metod naszej widowni zostaa opatrzona adnotacj porady. Adnotacja @Before zostaa zastosowana zarówno do metody takeSeats(), jak i do turnOffCellPho ´nes(), wskazujc tym samym, e te dwie metody realizuj porady before. Adnotacja @AfterReturning wskazuje, e metoda applaud() realizuje porad after-returning. Za metoda demandRefound() otrzymaa adnotacj @AfterThrowing, zatem zostanie wywoana w razie zgoszenia jakich wyjtków podczas wystpu. Nazwa punktu przecicia performance() jest przekazana jako warto parametru do wszystkich adnotacji porad. W ten sposób informujemy metody porad, gdzie powinny zosta zastosowane. Zauwamy, e poza adnotacjami oraz metod performance() — niewykonujc adnych operacji — klasa Audience pozostaa funkcjonalnie bez zmian. To oznacza, e nadal jest ona prostym obiektem Javy i moemy jej uywa jako takiego obiektu. Nadal moemy take wiza t klas w Springu w nastpujcy sposób: <bean id="audience" class="com.springinaction.springidol.Audience" />

Poniewa klasa Audience zawiera wszystko, co potrzebne, by zdefiniowa jej wasne punkty przecicia i porady, ju wicej nie potrzebujemy deklaracji punktów przecicia i porad w pliku konfiguracyjnym XML. Pozostaa tylko jedna czynno, jak musimy wykona, aby Spring zacz stosowa klas Audience jako aspekt. Naley zadeklarowa w kontekcie Springa komponent automatycznego poredniczenia, który przeksztaca komponenty opatrzone adnotacjami w stylu @AspectJ w porady obiektów poredniczcych. Do tego celu Spring posiada klas tworzc automatycznych poredników, nazwan AnnotationAwareAspectJAutoProxyCreator. Moemy zarejestrowa obiekt klasy Annota ´tionAwareAspectJAutoProxyCreator jako element <bean> w kontekcie Springa, lecz wymagaoby to bardzo duo pisania (uwierz mi, Czytelniku... ju kilka razy zdarzyo mi si pisa tak deklaracj). Zamiast tego, w celu uproszczenia tej do dugiej nazwy, Spring posiada specjalny element konfiguracyjny w przestrzeni nazw aop, który jest znacznie atwiejszy do zapamitania: <aop:aspectj-autoproxy />

Kup książkę

Poleć książkę


4.4.

Uywamy adnotacji dla aspektów

129

Element <aop:aspectj-autoproxy/> utworzy w kontekcie Springa komponent klasy AnnotationAwareAspectJAutoProxyCreator i bdzie automatycznie poredniczy w wywoaniach z komponentów, których metody zostaj dopasowane do punktów przecicia zdefiniowanych za pomoc adnotacji @Pointcut w beanach opatrzonych adnotacj @Aspect. By móc uy elementu konfiguracyjnego <aop:aspectj-autoproxy>, musimy pamita o umieszczeniu przestrzeni nazw aop w naszym pliku konfiguracyjnym Springa: <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

Powinnimy by wiadomi, e element <aop:aspectj-autoproxy> korzysta jedynie z adnotacji w stylu @AspectJ jako przewodnika podczas tworzenia aspektów opartych na obiektach poredniczcych. Gdybymy zajrzeli „pod mask”, przekonalibymy si, e nadal s to aspekty w stylu Springa. To jest istotne, poniewa oznacza, e cho uywamy adnotacji w stylu @AspectJ, nadal zachowuje wano ograniczenie do poredniczenia jedynie w wywoaniach metod. Jeli potrzebowalibymy wykorzysta pene moliwoci frameworka AspectJ, bdziemy musieli posuy si bibliotekami uruchomieniowymi AspectJ, zamiast polega na Springu, pozwalajcym jedynie na tworzenie aspektów na bazie obiektów poredniczcych. Warto take wspomnie w tym miejscu, e zarówno element <aop:aspect>, jak i adnotacje w stylu @AspectJ s efektywnymi sposobami na przeksztacenie POJO w aspekt. Element <aop:aspect> posiada jednak jedn szczególn zalet w porównaniu do @AspectJ. Polega ona na tym, e nie potrzebujemy kodu ródowego klasy, która realizuje funkcjonalno aspektu. Korzystajc z @AspectJ, musimy opatrzy adnotacjami klas i metody, a to wymaga posiadania dostpu do kodu ródowego. Element <aop:aspect> moe za odwoywa si do dowolnego komponentu. Teraz dowiemy si, jak za pomoc adnotacji w stylu AspectJ utworzy porad around. 4.4.1.

Tworzymy porad around za pomoc adnotacji

Podobnie jak w przypadku konfigurowania Spring AOP z uyciem plików XML, korzystajc z adnotacji w stylu @AspectJ, nie jestemy ograniczeni do porad before i after. Moemy take zdecydowa si na zastosowanie porady around. W tym celu powinnimy uy adnotacji @Around, jak w poniszym przykadzie: @Around("performance()") public voidwatchPerformance(ProceedingJoinPointjoinpoint){ try { System.out.println("Widzowie zajmuj miejsca."); System.out.println("Widzowie wy czaj telefony komórkowe."); longstart=System.currentTimeMillis(); joinpoint.proceed(); longend=System.currentTimeMillis(); System.out.println("Brawooo! Oklaski!");

Kup książkę

Poleć książkę


130

ROZDZIA 4. Aspektowy Spring System.out.println("Wystp trwa " + (end - start) + " miliskund."); } catch(Throwable t){ System.out.println("Buu! Oddajcie pieni dze za bilety!"); } }

Adnotacja @Around wskazuje, e metoda watchPerformance() ma by zastosowana jako porada around w punkcie przecicia performance. Powinno to wyglda w dziwnie znajomy sposób, poniewa jest to dokadnie ta sama metoda watchPerformance(), któr widzielimy wczeniej. Jedyna rónica polega na tym, e teraz zostaa ona opatrzona adnotacj @Around. Jak by moe pamitamy z wczeniejszych przykadów, nie wolno zapomnie o jawnym wywoaniu w poradzie around metody proceed(), co zapewnia wywoanie metody docelowej. Lecz samo opatrzenie metody adnotacj @Around nie wystarczy do umoliwienia wywoania metody proceed(). Wiemy, e metoda, która bdzie realizowaa porad around, musi otrzyma jako argument obiekt ProceedingJoinPoint, a nastpnie wywoa metod proceed() tego obiektu. 4.4.2.

Przekazujemy argumenty do porad konfigurowanych przez adnotacje

Dostarczanie parametrów do porad za porednictwem adnotacji w stylu @AspectJ nie róni si istotnie od sposobu, w jaki osigalimy to za pomoc deklaracji aspektów w plikach konfiguracyjnych XML Springa. Waciwie, w sporej wikszoci elementy jzyka XML, których uylimy wczeniej, przekadaj si prawie bezporednio na odpowiedniki w postaci adnotacji w stylu @AspectJ, jak moemy si przekona na przykadzie nowej wersji klasy Magician z listingu 4.7. Listing 4.7. Tworzymy aspekt z klasy Magician za pomoc adnotacji w stylu @AspectJ

package com.springinaction.springidol; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; @Aspect public class Magician implements MindReader { private String thoughts; @Pointcut("execution(* com.springinaction.springidol." Deklaracja + "Thinker.thinkOfSomething(String)) && args(thoughts)") parametryzowanego public void thinking(String thoughts) { punktu przecicia } Przekazujemy parametry do porady @Before("thinking(thoughts)") public void interceptThoughts(String thoughts) { System.out.println("Przechwytuj my li ochotnika: " + thoughts); this.thoughts = thoughts; }

public String getThoughts() {

Kup książkę

Poleć książkę


4.4.

131

Uywamy adnotacji dla aspektów return thoughts; } }

Element <aop:pointcut> zosta zastpiony adnotacj @Pointcut, za element <aop:before> zastpia adnotacja @Before. Jedyna znaczca zmiana polega na tym, e adnotacje @AspectJ mog, bazujc na skadni Javy, wyznacza szczegóowo parametry przekazywane do porady. Zatem w konfiguracji opartej na adnotacjach nie potrzebujemy odpowiednika atrybutu arg-names z elementu <aop:before>. 4.4.3.

Tworzymy wprowadzenie za pomoc adnotacji

Wczeniej zademonstrowalimy sposób na wprowadzenie nowego interfejsu do istniejcego komponentu bez zmian w kodzie ródowym tego komponentu, za pomoc elementu <aop:declare-parents>. Wrómy teraz raz jeszcze do tamtego przykadu, lecz tym razem korzystajc z konfiguracji aspektów za pomoc adnotacji. Odpowiednikiem elementu <aop:declare-parents> w @AspectJ jest adnotacja @Decla ´re-Parents. Adnotacja ta, uyta wewntrz klasy opatrzonej adnotacj @Aspect, dziaa niemal identycznie jak element w XML, który zastpia. Uycie adnotacji @DeclareParents demonstruje listing 4.8. Listing 4.8. Wprowadzamy interfejs Contestant za pomoc adnotacji w stylu @AspectJ

package com.springinaction.springidol; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.DeclareParents; @Aspect public class ContestantIntroducer { Dodajemy interfejs Contestant @DeclareParents( value = "com.springinaction.springidol.Performer+", defaultImpl = GraciousContestant.class) public static Contestant contestant;

}

Jak widzimy, klasa ContestantIntroducer jest aspektem. Jednak w odrónieniu od aspektów, jakie do tej pory utworzylimy, nie realizuje ona porad before, after czy te around. Zamiast tego wprowadza do beanów klasy Performer interfejs Contestant. Podobnie jak element <aop:declare-parents>, adnotacja @DeclareParents skada si z trzech czci: Q

Q

Q

Kup książkę

Atrybut value jest odpowiednikiem atrybutu types-matching w elemencie <aop:declare-parents>. Identyfikuje on rodzaje komponentów, do których wprowadzony bdzie interfejs. Atrybut defaultImpl jest odpowiednikiem atrybutu default-impl w elemencie <aop:declare-parents>. Identyfikuje on klas, która bdzie zawieraa implementacj wprowadzonego interfejsu. Statyczna waciwo, która jest opatrzona adnotacj @DeclareParents, identyfikuje wprowadzany interfejs.

Poleć książkę


132

ROZDZIA 4. Aspektowy Spring

Podobnie jak w przypadku kadego aspektu, musimy zadeklarowa klas Contestant ´Introducer jako komponent w kontekcie aplikacji Springa: <bean class="com.springinaction.springidol.ContestantIntroducer" />

Element <aop:aspect-autoproxy> bdzie tam siga po ten komponent. Gdy odkryje komponent opatrzony adnotacj @Aspect, automatycznie utworzy obiekt poredniczcy, który bdzie delegowa wywoania albo do docelowego komponentu, albo do obiektu implementujcego wprowadzony interfejs, zalenie od tego, do którego z nich wywoywana metoda naley. Spraw, która zwróci nasz uwag, jest fakt, e adnotacja @DeclareParents nie posiada odpowiednika atrybutu delegate-ref z elementu <aop:declare-parents>. Dzieje si tak, poniewa @DeclareParents jest adnotacj w stylu @AspectJ. @AspectJ jest projektem niezalenym od Springa i z tego powodu jego adnotacje nie s wiadome istnienia komponentów Springa. Wskutek tego, jeli potrzebujemy delegata do komponentu, który zosta skonfigurowany w Springu, wówczas adnotacja @DeclareParents moe okaza si nieodpowiednia i bdziemy musieli uciec si do zastosowania w konfiguracji elementu <aop:declare-parents>. Spring AOP umoliwia oddzielenie zagadnie przecinajcych od biznesowej logiki aplikacji. Lecz, jak widzielimy, aspekty w Springu cigle jeszcze s oparte na obiektach poredniczcych i obowizuje je ograniczenie wycznie do porad zwizanych z wywoaniami metod. Jeli potrzebujemy czego wicej ni tylko obsugi poredniczenia w wywoaniach metod, moe warto, bymy rozwayli uycie aspektów AspectJ. W nastpnym punkcie zobaczymy, jak mona uy tradycyjnych aspektów z AspectJ w aplikacji Springa.

4.5.

Wstrzykujemy aspekty z AspectJ Cho Spring AOP jest wystarczajcym rozwizaniem dla wielu zastosowa aspektów, wypada sabo w porównaniu z rozwizaniem AOP, jakim jest AspectJ. AspectJ obsuguje wiele typów punktów przecicia, które nie s moliwe w Spring AOP. Punkty przecicia w konstruktorach, na przykad, s przydatne, gdy potrzebujemy zastosowa porad podczas tworzenia obiektów. W odrónieniu od konstruktorów w niektórych innych jzykach obiektowych, konstruktory w Javie róni si od zwykych metod. Z tego powodu bazujca na obiektach poredniczcych obsuga programowania aspektowego w Springu okazuje si zdecydowanie niewystarczajca, gdy chcemy zastosowa porad podczas tworzenia obiektu. W znacznej wikszoci aspekty w AspectJ s niezalene od Springa. Cho mog by wplatane do aplikacji opartych na Javie, w tym aplikacji w Springu, zastosowanie aspektów z AspectJ wprowadza odrobin zamieszania po stronie Springa. Jednak kady dobrze zaprojektowany i znaczcy aspekt prawdopodobnie bdzie zalea od innych klas, które bd go wspomagay podczas dziaania. Jeli aspekt jest zaleny od jednej lub wicej klas w trakcie realizacji porady, moemy z poziomu tego aspektu tworzy instancje takich wspópracujcych obiektów. Albo, jeszcze lepiej, moemy posuy si wstrzykiwaniem zalenoci w Springu, by wstrzykiwa komponenty do aspektów w AspectJ.

Kup książkę

Poleć książkę


4.5.

Wstrzykujemy aspekty z AspectJ

133

By to zobrazowa, utwórzmy kolejny aspekt dla turnieju talentów Idol Springa. Turniej talentów potrzebuje jurora. Zatem utworzymy aspekt jurora w rodowisku AspectJ. Aspekt ten, zdefiniowany na listingu 4.9, nazwiemy JudgeAspect. Listing 4.9. Implementacja w AspectJ jurora dla turnieju talentów

package com.springinaction.springidol; public aspect JudgeAspect { public JudgeAspect() {} pointcut performance() : execution(* perform(..)); after() returning() : performance() { System.out.println(criticismEngine.getCriticism()); } // wstrzyknity obiekt private CriticismEngine criticismEngine; public void setCriticismEngine(CriticismEngine criticismEngine) { this.criticismEngine = criticismEngine; } }

Gównym zadaniem aspektu JudgeAspect jest komentowanie wystpu po jego zakoczeniu. Punkt przecicia performance() z listingu 4.9 zostanie dopasowany do metody perform(). W poczeniu z porad after()returning() otrzymujemy aspekt, który reaguje na zakoczenie wystpu. Tym, co okazuje si interesujce w listingu 4.9, jest fakt, e juror nie komentuje wystpu sam we wasnym zakresie. Zamiast tego aspekt JudgeAspect wspópracuje z obiektem CriticismEngine, wywoujc jego metod getCriticism(), aby uzyska krytyczny komentarz po wystpie. By unikn niepotrzebnego wizania midzy aspektem JudgeAspect i obiektem CriticismEngine, aspekt JudgeAspect otrzymuje referencj do obiektu CriticismEngine za pomoc wstrzykiwania przez metod dostpow. Relacja ta zostaa zobrazowana na rysunku 4.8.

Rysunek 4.8. Aspekty te potrzebuj wstrzykiwania. Spring moe wstrzykiwa zalenoci do aspektów w AspectJ, zupenie jakby to byy zwyke komponenty

CriticismEngine sam jest tylko interfejsem, który deklaruje prost metod getCriticism(). Oto implementacja tego interfejsu (listing 4.10).

Kup książkę

Poleć książkę


134

ROZDZIA 4. Aspektowy Spring

Listing 4.10. Implementacja interfejsu CriticismEngine, z którego korzysta aspekt JudgeAspect

package com.springinaction.springidol; public class CriticismEngineImpl implements CriticismEngine { public CriticismEngineImpl() {} public String getCriticism() { int i = (int) (Math.random() * criticismPool.length); return criticismPool[i]; } // wstrzyknity obiekt private String[] criticismPool; public void setCriticismPool(String[] criticismPool) { this.criticismPool = criticismPool; } }

Klasa CriticismEngineImpl implementuje interfejs CriticismEngine, losowo wybierajc krytyczny komentarz z listy wstrzyknitej krytyki. Klasa ta moe zosta zadeklarowana jako bean w Springu za pomoc poniszego kodu w jzyku XML: <bean id="criticismEngine" class="com.springinaction.springidol.CriticismEngineImpl"> <property name="criticisms"> <list> <value>I'm not being rude, but that was appalling.</value> <value>You may be the least talented person in this show.</value> <value>Do everyone a favor and keep your day job.</value> </list> </property> </bean>

Jak dotd nie le. Mamy ju implementacj interfejsu CriticismEngine, z którego bdzie korzysta aspekt JudgeAspect. Wszystko, co pozostao, to powizanie klasy Criticism ´EngineImpl z aspektem JudgeAspect. Zanim zademonstrujemy, jak zrealizowa wstrzykiwanie, powinnimy wiedzie, e aspekty w AspectJ mog by wplatane do naszej aplikacji zupenie bez angaowania Springa. Jednak jeli chcemy uy wstrzykiwania zalenoci w Springu, by wstrzykiwa klasy wspópracujce do aspektu w AspectJ, musimy zadeklarowa aspekt jako element <bean> w konfiguracji Springa. Ponisza deklaracja elementu <bean> realizuje wstrzykiwanie beana criticismEngine do aspektu JudgeAspect: <bean class="com.springinaction.springidol.JudgeAspect" factory-method="aspectOf"> <propertyname="criticismEngine" ref="criticismEngine"/> </bean>

W duej czci ta deklaracja elementu <bean> nie róni si w istotny sposób od wszystkich innych deklaracji komponentów, jakie wystpuj w Springu. Jedyna powana rónica polega na uyciu atrybutu factory-method. Normalnie instancje komponentów w Springu tworzy kontener Springa, lecz aspekty w AspectJ s tworzone przez bibliotek

Kup książkę

Poleć książkę


4.6.

Podsumowanie

135

uruchomieniow AspectJ. Do momentu, gdy Spring uzyska moliwo wstrzyknicia komponentu typu CriticismEngine do aspektu JudgeAspect, istnieje ju instancja klasy JudgeAspect. Poniewa Spring nie odpowiada za tworzenie instancji aspektu JudgeAspect, nie moemy po prostu zadeklarowa klasy JudgeAspect jako komponentu w Springu. Zamiast tego potrzebujemy sposobu, by Spring uzyska uchwyt do instancji klasy JudgeAspect, która zostaa wanie utworzona przez AspectJ, tak abymy mogli wstrzykn do niej obiekt CriticismEngine. Zgodnie z konwencj, wszystkie aspekty w AspectJ posiadaj statyczn metod aspectOf(), która zwraca singleton bdcy instancj aspektu. Zatem, by uzyska instancj aspektu, musimy uy atrybutu factory-method, by wywoa metod aspectOf(), zamiast próbowa wywoywa konstruktor klasy JudgeAspect. W skrócie, Spring nie korzysta z deklaracji <bean>, jakiej uywalimy wczeniej, do tworzenia instancji klasy JudgeAspect — instancja ta zostaa ju utworzona przez bibliotek uruchomieniow AspectJ. Zamiast tego Spring otrzymuje referencj do aspektu przez metod aspectOf() fabryki, a nastpnie realizuje wstrzykiwanie do niego zalenoci zgodnie z przepisem w elemencie <bean>.

4.6.

Podsumowanie Programowanie aspektowe jest potnym uzupenieniem programowania obiektowego. Dziki aspektom moemy rozpocz grupowanie zachowa aplikacji, dotychczas rozproszonych po caej aplikacji, w moduach wielokrotnego uytku. Moemy wówczas zadeklarowa, gdzie i w jaki sposób dane zachowanie bdzie zastosowane. Pozwala to na ograniczenie niepotrzebnego powielania kodu i pozwala, aby podczas konstruowania klas skupi si na ich gównych funkcjach. Spring zapewnia aspektowe rodowisko uruchomieniowe, które pozwala nam na dodawanie aspektów wokó wywoa metod. Nauczylimy si, jak moemy wplata porady przed wywoaniem metody, po jej wywoaniu oraz wokó niego, a take doda dostosowane zachowanie do obsugi wyjtków. Mamy moliwo podjcia kilku decyzji co do sposobu uycia aspektów przez nasz aplikacj w Springu. Wizanie porad i punktów przecicia w Springu jest znacznie prostsze dziki dodaniu obsugi adnotacji @AspectJ i uproszczonemu schematowi konfiguracji. Na koniec, zdarzaj si sytuacje, gdy Spring AOP jest mechanizmem niewystarczajcym i musimy przej na AspectJ, aby korzysta z aspektów o wikszych moliwociach. Na wypadek takich sytuacji zerknlimy na sposób uycia Springa, by wstrzykiwa zalenoci do aspektów w AspectJ. Do tego momentu omówilimy podstawy frameworka Spring. Dowiedzielimy si, jak skonfigurowa kontener Springa i jak zastosowa aspekty do obiektów zarzdzanych przez Springa. Jak widzielimy, te podstawowe techniki daj wietn moliwo tworzenia aplikacji zoonych z lu no powizanych obiektów. W nastpnym rozdziale dowiemy si, w jaki sposób lu ne wizanie przez techniki DI i AOP pozwala na testowanie przez programist i jak zapewni pokrycie testami kodu w Springu.

Kup książkę

Poleć książkę


136

Kup książkę

ROZDZIA 4. Aspektowy Spring

Poleć książkę


Cz 2 Podstawy aplikacji Springa

W

czci 1. omówilimy podstawowy kontener Springa i oferowane przez niego moliwoci w zakresie wstrzykiwania zalenoci (DI) i programowania aspektowego (AOP). Majc t podstawow wiedz, w czci 2. dowiemy si, w jaki sposób tworzy aplikacje biznesowe w rodowisku Springa. Wikszo aplikacji utrwala informacje biznesowe w relacyjnej bazie danych. Rozdzia 5., „Korzystanie z bazy danych”, dostarczy informacji na temat wsparcia Springa dla utrwalania danych. Jednym z omawianych w tym rozdziale zagadnie bdzie wsparcie Springa dla JDBC, dziki któremu mona wydatnie zredukowa kod potrzebny przy pracy z JDBC. Omówiona zostanie te integracja Springa z rozwizaniami trwaoci opartymi na mechanizmach odwzorowa obiektowo-relacyjnych, takich jak Hibernate czy JPA. Utrwalone dane musz pozosta spójne. W rozdziale 6., „Zarzdzanie transakcjami”, nauczysz si deklaratywnego stosowania strategii transakcyjnych w obiektach aplikacji przy pomocy programowania aspektowego. W rozdziale 7., „Budowanie aplikacji sieciowych za pomoc Spring MVC”, poznasz podstawy Spring MVC, frameworka sieciowego zbudowanego na bazie Springa. Odkryjesz szeroki wybór kontrolerów Spring MVC do obsugi da sieciowych i zobaczysz, jak w przezroczysty sposób podpina parametry dania pod obiekty biznesowe, dbajc jednoczenie o poprawno danych i obsug bdów. Z rozdziau 8., „Praca ze Spring Web Flow”, dowiesz si, jak budowa oparte na przepywach, konwersacyjne aplikacje sieciowe, uywajc frameworka Spring Web Flow. Jako e bezpieczestwo jest istotnym aspektem kadej aplikacji, w rozdziale 9., „Zabezpieczanie Springa”, omówimy wreszcie uycie frameworka Spring Security w celu ochrony informacji aplikacji.

Kup książkę

Poleć książkę


Kup książkę

Poleć książkę


Skorowidz A Acegi Security, 250 ACID, 173 ActiveMQ, 338 adnotacja @Around, 129 @Aspect, 129 @AspectJ, 127 @Async, 395 @Autowired, 92–96, 391 @Bean, 104 @Configuration, 104 @Controller, 206 @DeclareParents, 131 @Entity, 161 @Inject, 97 @ManagedResource, 364 @PathVariable, 307 @Pointcut, 128 @PreAuthorize, 272 @Qualifier, 95, 98 @Repository, 163 @RequestMapping, 307, 331 @RequestParam, 207 @ResponseBody, 314 @RolesAllowed, 271 @Scheduled, 393 @Secured, 270 @SkipIt, 102 @StringedInstrument, 96 @Transactional, 180 @Value, 99 adnotacje standardowe, 92, 100 adres URL, 262 przepywu, 236 typu RESTful, 305 typu RESTless, 305 zdalnej usugi, 294 agent MBean, 359 algorytm MD5, 269 szyfrowania, 379

Kup książkę

AOP, aspect-oriented programming, 22, 30, 108 aplikacja Spitter, 255 aplikacje klienckie JMS, 338 aplikacje sieciowe, 189 architektura JMS, 335 asembler InterfaceBasedMBeanInfoAssembler, 363 MetadataMBeanInfoAssembler, 364 MethodExclusionMBeanInfo, 362 MethodNameBasedMBeanInfoAssembler, 361 asemblery informacji MBean, 361 AspectJ, 113, 115 aspekt, 29, 109, 114 Audience, 120 w XML, 117 asynchroniczna obsuga komunikatów, 354 asynchroniczne RPC, 352 wywoania, 353 atrybut default-init-method, 60 delegate-ref, 126 destroy-method, 59 factory-method, 57 hash, 267 init-method, 59 p:song, 66 scope, 58 system-properties-mode, 376 value, 62 atrybuty transakcji, 180 dania, 203 automatyczne rejestrowanie, 103 wizanie, 85–90, 99, Patrz take wizanie wykrywanie, 85, 100 autoryzacja @PostAuthorize, 273 AWS, Amazon Web Service, 220

Poleć książkę


400

Skorowidz

B bezpieczestwo aplikacji sieciowych, 259 na poziomie widoku, 260 sieciowe, 253 biblioteka JAXB, 324 znaczników, 330 blok catch, 142 bdy walidacji, 214, 216 brokery komunikatów, message brokers, 335, 338 brudne odczyty, dirty reads, 182 Burlap, 287

C Caucho Burlap, 280 Caucho Hessian, 280 chciwe pobieranie, eager fetching, 158 ciasteczko, 269 CMT, container managed transactions, 174 CRUD, create read update delete, 309 cykl ycia komponentu, 37 czas wykonania, runtime, 155

D dane przepywu, 231 DAO, Data Access Objects, 41, 140 definiowanie aspektu audience, 122 atrybutów transakcji, 180 bazowego przepywu, 233 kafelków, 201 kontrolera, 195 punktów przecicia, 120 transakcji, 186 widoku, 202 deklarowanie aspektów, 117 dostawcy uwierzytelnienia LDAP, 266 fabryki, 160 komponentu, 104 porad, 119 transakcji, 180, 184 desygnator, 116 bean(), 117 execution(), 116 within(), 116 DI, dependency injection, 19, 29, 50, 64, 132, 250 dodawanie funkcjonalnoci, 125

Kup książkę

domylne waciwoci, 376 dostawca uwierzytelnienia, 264, 266 dostp do adresu URL, 262 atrybutów komponentu, 368 danych, 41, 139, 154 filtrów serwletów, 252 informacji uwierzytelniajcych, 260 komponentów, 367 komponentów EJB, 385 metody, 272 S3, 220 skadników kolekcji, 81 szablonu JdbcTemplate, 146 usug, 290, 293 usug JMS, 352 usug RMI, 282 zdalnego komponentu, 367 zdalnych usug, 281 dostp tylko do odczytu, 183 dowizanie szablonu JMS, 343

E egzekutor przepywu, 225 EJB, Enterprise JavaBeans, 22 EJB 2, 24 eksport asynchronicznej usugi, 353 komponentu, 359 eksporter HttpInvokerServiceExporter, 292 JmsInvokerServiceExporter, 350 RmiServiceExporter, 284, 350 eksportowanie komponentów, 358 usugi Burlap, 290 usugi Hessian, 288 element <amq:connectionFactory>, 339 <aop:around>, 122 <aop:aspect-autoproxy>, 132 <aop:aspectj-autoproxy/>, 129 <aop:config>, 119 <aop:declare-parents>, 126 <aop:pointcut>, 120 <authentication-manager>, 264 <beans>, 51 <constructor-arg>, 54, 340 <context:annotation-config>, 92 <context:component-scan>, 100

Poleć książkę


401

Skorowidz <context:mbean-export>, 364 <decision-state>, 239 <div>, 202 <end-state>, 229 <entry>, 70, 359 <evaluate>, 232 <filter>, 252 <flow:flow-executor>, 225 <flow:flow-location>, 226 <flow:flow-location-pattern>, 225 <form>, 330 <global-method-security>, 270, 276 <http>, 253 <http-basic>, 256 <if>, 241 <input>, 244 <intercept-url>, 257 <jdbc-user-service>, 264 <jee:jndi-lookup>, 382 <jee:local-slsb>, 385 <jms:listener>, 350 <ldap-server>, 268 <list>, 67 <map>, 67, 70 <mvc:resources>, 193 <null/>, 72 <on-entry>, 246 <property>, 62 <props>, 67 <secured>, 247 <security:authentication>, 260 <security:authorize>, 261 <set>, 67, 69, 232 <sf:errors>, 214 <sf:form>, 330 <subflow-state>, 229 <task:annotation-driven/>, 393 <tx:advice>, 185 <tx:annotation-driven>, 186 <tx:method>, 185 <util:list>, 81 elementy konfiguracyjne, 67, 118 e-mail, 386

F fabryka komponentów, 36 menederów encji, 165 pocze JMS, 339 sesji Hibernate, 160 fantomy, phantom read, 182

Kup książkę

filtr, 102 annotation, 102 aspectj, 102 assignable, 102 custom, 102 HiddenHttpMethodFilter, 331 regex, 102 filtry serwletów, 250, 253 Spring Security, 253 format JSON, 329 formularz, 208 logowania, 254 rejestracyjny, 209 formularze typu RESTful, 329 funkcja hasRole(), 272 funkcjonalno porady, 110

H haso, 267 haso szyfrowania, 379 Hessian, 287 Hibernate, 158, 162 hierarchia wyjtków, 142

I iBATIS, 139 IDE, 113 identyfikatory, 105 implementacja SpitterDao, 163 SplitterController, 205 informacja o lokalizacji, 326 inicjalizacja na danie posiadacza, 57 instalacja ActiveMQ, 339 Spring Web Flow, 224 interfejs AlertService, 351 Contestant, 126 CriticismEngine, 134 DisposableBean, 60 InitializingBean, 60 Instrument, 61 javax.management.NotificationListener, 371 MailSender, 386 MindReader, 123 Performer, 50 Session, 160

Poleć książkę


402

Skorowidz

interfejs SpitterService, 283 Thinker, 123 izolacja, isolation, 173, 183

J JAX-RPC, 295 JAX-WS, 295 JDBC, 35, 139, 149–152, 158 JDO, Java Data Objects, 159, 164 jednostka organizacyjna, organization unit, 267 utrwalania, persistence unit, 165 jzyk AspectJ, 113, 115 SpEL, 72, 80, 257 JMS, Java Message Service, 41, 334 JMX, Java Management Extensions, 357, 372 JNDI, Java Naming and Directory Interface, 147, 380–384, 396 JPA, Java Persistence API, 149, 164 zarzdzane przez aplikacj, 165 zarzdzane przez kontener, 166 JSP, 330 JSR-330, 97 JTA, Java Transaction API, 174

K kaskadowo, cascading, 159 katalog LDAP, 263 META-INF, 165 klasa Audience, 118, 127 Auditorium, 59 BraveKnight, 27, 31 CriticismEngineImpl, 134 DamselRescuingKnight, 25 HomeController, 196 HttpInvokerServiceExporter, 292 Instrumentalist, 61, 62 java.util.Properties, 81 JdbcDaoSupport, 146 JmsTemplate102, 343 Juggler, 51, 53 Magician, 130 MimeMessageHelper, 389 Minstrel, 33 Piano, 64

Kup książkę

PoeticJuggler, 54, 56 Properties, 71 Saxophone, 63 SimpleJdbcDaoSupport, 157 Sonnet29, 55 SpitterEmailServiceImpl, 387 SpitterServiceEndpoint, 296 SpringBeanAutowiringSupport, 296 Stage, 57 StandardPBEStringEncryptor, 379 Volunteer, 123 klasy bazowe DAO, 145, 156 otwarte, 125 singletonowe, 57 statyczne, 57 szablonowe, 144 klient REST, 317 SpitterService, 285 usugi RMI Spitter, 285 klucz prywatny, 269 kod szablonowy, 34 kolejka spittle.alert.queue, 353 kolejki, queues, 335 kolekcje typu map, 69 komponent, 50, 59 MBeanServerConnectionFactoryBean, 368 BasicDataSource, 148 dataSource, 377 HessianServiceExporter, 288 JaxWsPortProxyFactoryBean, 299 Minstrel, 32 RmiServiceExporter, 288 SpitterEmailServiceImpl, 387 spitterService, 284 TransactionProxyFactoryBean, 180 komponenty EJB, 385 encyjne, entity beans, 163 encyjne BMP, 163 encyjne CMP, 163 jako usugi, 292 MBean, 364 MDB, 348 sterowane komunikatami, 347 w kontenerze, 38 wysyajce poczt, 387 zagniedone, 65 zarzdzane, managed beans, 357, 361, 367 dynamic MBeans, 358 model MBeans, 358

Poleć książkę


403

Skorowidz open MBeans, 358 standard MBeans, 357 komunikacja asynchroniczna, 335 RPC, 338 synchroniczna, 334, 337 konfiguracja Acegi, 251 beanów, 51 bezpieczestwa sieciowego, 253 brokera komunikatów, 338 danych szyfrowania, 379 fabryki menederów encji, 164 JPA, 165 konteneru, 52 kontrolera Hessian, 289 odbiorców komunikatów, 349 puli, 148 rejestru przepywów, 225 repozytorium, 263 serwera LDAP, 268 Spring MVC, 192, 194 Spring Web Flow, 224 Springa, 103, 105 usugi RMI, 283

róda danych, 147 konflikt nazw komponentów, 366 koniec przepywu, 242 konsumowanie komunikatów, 346 konteksty aplikacji, 28, 36, 203 kontener, 36, 50, 60 odbiorcy komunikatów, 349 podstawowy, 39 kontrola nad atrybutami, 360 kontroler, 193 DisplaySpittleController, 304 HomeController, 195 spittle, 205 konwertery komunikatów HTTP, 314

L LDAP, 266, 268 LDIF, LDAP Data Interchange Format, 268 leniwe adowanie, lazy loading, 158 leniwe adowanie obiektów JNDI, 383 limit czasowy, timeout, 184 Lingo, 352, 354 localhost, 268 logowanie, 254 logowanie przez formularz, 254 lu ne wizanie, 27, 64

Kup książkę

M MBean, 357 MDB, message-driven bean, 334, 347 MDP, message-driven POJO, 348 mechanizm utrwalania danych, 169 meneder encji, 164 transakcji, 175 metadane, 321 metoda addAttribute(), 207 addCustomer(), 242 addInline(), 390 addSpitter(), 154, 211 addSpitterFromForm(), 218 aspectOf(), 135 createMessage(), 345 createMimeMessage(), 388 createSpittle(), 310 delete(), 324 displaySpittle(), 305 embark(), 25, 27 exchange(), 327 getBean(), 58 getCriticism(), 133 getEmployeeById(), 35 getFirst(), 322 getForEntity(), 320 getForObject(), 320 getHeaders(), 321 getLastModified(), 322 getObject(), 346 getRecentSpittles(), 196 getSimpleJdbcTemplate(), 157 getSpitter(), 315 getSpittle(), 307 getStatusCode(), 322 hasPermission(), 274 hasProfanity(), 275 invoke(), 368 listSpittlesForSpitter(), 207 main(), 28 Math.random(), 76 perform(), 91 postForEntity(), 326 postForLocation(), 327 postForObject(), 325 postSpitterForObject(), 326 proceed(), 130 put(), 323

Poleć książkę


404

Skorowidz

metoda putSpittle(), 309 queryNames(), 368 receive(), 346 retrieveSpittlesForSpitter(), 318, 321 saveImage(), 220 saveSpittle(), 179, 395 selectSong(), 75 send(), 345 sendSimpleSpittleEmail(), 388 sendSpittleEmailWithAttachment(), 389 setNotificationPublisher(), 371 setSong(), 62 setSpittlesPerPage(), 368 showHomePage(), 196, 360, 362 singBeforeQuest(), 33 toList(), 246 toUpperCase, 75 toUpperCase(), 75 updateSpitter(), 317 updateSpittle(), 323 watchPerformance(), 121–123 metody asynchroniczne, 395 do przetwarzania zasobów, 308 dostpowe, 361 eksportowane, 363 fabryki, 56 HTTP, 308 idempotentne, 308 RestTemplate, 319 zaplanowane, 393 miejsca docelowe, destinations, 335 domylne, 345 komunikatów, 340, 345 MIME, Multipurpose Internet Mail Extensions, 388 model, 191 model-widok-kontroler, 42 modu AOP, 41 moduy, 39 moduy Spring Security, 251 MVC, Model-View-Controller, 42, 189

N nadpisywanie waciwoci, 377 nagówek Accept, 315 negocjacja zawartoci, 311, 314 niepodzielno, atomicity, 173 niepowtarzalne odczyty, nonrepeatable reads, 182

Kup książkę

O obiekt EntityManagerFactory, 167 HttpInvoker, 292 MDP, 349 ResponseEntity, 322 obiekty dostpu do danych, 41 nadpisujce waciwoci, 374, 377 poredniczce, 299, 369 porednika zdalnego, 369 poredników, 291 wywoujce HTTP, 294 zastpujce waciwoci, 374, 378 obraz wewntrzny, inline image, 390 obsuga AOP, 113 filtrów, 253 komunikatów, 335 publikacja-subskrypcja, 336 punkt-punkt, 336 komunikatów asynchroniczna, 354 komunikatów JMS, 351 plików, 218 powiadomie, 370 REST, 303 RPC, 281 wyjtków, 150, 341 da, 212 da przepywu, 226 odbieranie komunikatów, 341, 346, 349 powiadomie, 371 odwzorowania obiektowo-relacyjne, 41, 159 odwzorowanie SimpleUrlHandlerMapping, 290 ograniczenia bezpieczestwa, 276 okresowe uruchamianie zada, 394 operacje matematyczne, 76 operator !, 116 &&, 116 ?, 75 [], 82 and, 117 Elvis, 79 not, 117 or, 117 T(), 75, 246 wyboru, 82 operatory w SpEL, 76 ORM, object-relational mapping, 41, 139, 159

Poleć książkę


405

Skorowidz osadzanie parametrów w adresach, 306 OSGi Blueprint Container, 44

P pakiet org.springframework.beans.factory. annotation, 98 parametry nazwane, 156 plik coupon.png, 389 db.properties, 375 deliveryWarning.jspx, 241 emailTemplate.vm, 392 foo.xml, 37 home.jsp, 203 knights.xml, 28 konfiguracyjny, 66 list.jsp, 208 persistence.xml, 165 spitter-security.xml, 252 spring-idol.xml, 52 users.ldif, 268 pliki JAR, 40 LDIF, 268 pobieranie danych, 152 zasobów, 320 podprzepyw order, 243 patnoci, 245 zamówienia, 245 POJO, Plain Old Java Obiects, 22 pole _hidden, 331 _method, 330 poczenie z baz danych, 374 porada, 110, 119 after, 33, 119 around, 121, 129 before, 33, 119 porównywanie hase, 267 postautoryzacja metod, 273 postfiltrowanie metod, 273 porednik RMI, 286 powiadomienia JMX, 370 powizania midzy obiektami, 50 poziomy izolacji, 182 preautoryzacja metod, 272 producent widoków, 198, 200, 312 program Cron, 395

Kup książkę

programowanie aspektowe, 22, 30, 108 funkcyjne, 302 transakcji, 178 propagacja, 181 protokó JMXMP, 367 przechwytywanie da, 257 przecianie operacji, 319 przejcia, transitions, 227, 230 przejcia globalne, 231 przejcie cancel, 231 przekazywanie argumentów do porad, 130 przeksztacanie w komponent, 364 w aspekt, 33 przepyw, 231 _flowExecutionKey, 239 bazowy, 233 customer, 242 identyfikujcy klienta, 237 nadrzdny, 234 przestrze nazw, 52 amq, 339 Spring Security, 251 przesyanie plików, 221 przetwarzanie formularza, 208, 211 warunkowe, 78 publikacje komponentu zarzdzanego, 365 publikator NotifcationPublisher, 370 pula komponentu BasicDataSource, 148 punkty kocowe, 295–298 przecicia, 111, 132 zczenia, 110, 114

R regua DRY, 120 reguy walidacji, 213 rejestr przepywów, 225 relacja alternatywy, 116 repozytoria, 140 resolver danych wieloczciowych, 221 REST, Representational State Transfer, 190, 221, 301, 318 RESTful, 304 RESTless, 303 RMI, Remote Method Invocation, 42, 280, 282 rodzaje adnotacji, 92 menederów encji, 164 stanów, 227

Poleć książkę


406

Skorowidz

rozszerzenia Springa, 46 RPC, remote procedure call, 280, 350 rzutowanie kolekcji, 82

S schematy dziaania, workflow, 189 serializacja obiektów, 291 serwer JMXConnectorServer, 367 LDAP, 268 MBean, 359 pocztowy, 387 serwlet dyspozytora, 191 nasuchujcy, 204 sesja pocztowa JNDI, 387 sesje kontekstowe, 162 skanowanie komponentów, 102 skadowe przepywu, 227 SOA, service-oriented architecture, 294 specyfikacja LDIF, 268 SpEL, Spring Expression Language, 72, 80, 257 spójno, consistency, 173 Spring 3.0, 47 AOP, 117 Batch, 43 Dynamic Modules, 44 Faces, 48 Integration, 43 JavaScript, 48 LDAP, 44 Mobile, 44 MVC, 190, 255 Rich Client, 45 Roo, 45 Security, 43, 250 Security 2.0, 48 Security 3.0, 271 Social, 44 Web Flow, 43, 48, 224, 247 Web Services, 43 .NET, 45 -Flex, 45 stae propagacji, 181 stan addCustomer, 242 buildOrder, 236 checkDeliveryArea, 238 createPizza, 242, 244 identifyCustomer, 235, 236

Kup książkę

registrationForm, 240 showOrder, 242 takePayment, 236 thankCustomer, 236 welcome, 239, 241 stany, states, 227 akcji, 228 decyzyjne, 228 kocowe, 229, 236 obiektów, 317 pocztkowe, 235 podprzepywów, 229 widoków, 227, 243 zasobów, 315 sterownik JDBC, 149 stopnie izolacji, 183 szablon, template, 144 JdbcTemplate, 153, 155 JMS Springa, 340 JmsTemplate, 342 NamedParameterJdbcTemplate, 153 RestTemplate, 318 SimpleJdbcTemplate, 153, 155 TransactionTemplate, 179 Velocity, 391, 393 szablony dostpu do danych, 143 JDBC, 153 wiadomoci, 391 szyfrator acuchów, string encryptor, 379 szyfrowanie, 267 szyfrowanie waciwoci, 378

T technologie zdalnego dostpu, 281 tematy, topics, 335 testowanie, 42 testowanie kontrolera, 197 transakcje, 171 Hibernate, 176 Java Persistence API, 177 Java Transaction API, 178 JDBC, 175 programowe, 180 transformacja da, 331 trwao, durability, 173 tworzenie aspektów, 127 beanów, 59 fabryki pocze, 339 klientów REST, 317

Poleć książkę


407

Skorowidz tworzenie komponentów, 56 kwalifikatorów, 95 obiektów POJO, 347 odbiorcy komunikatów, 348 porady around, 129 punktów kocowych, 295 spittle’ów, 310 szablonów wiadomoci, 391 usugi RMI, 283 wprowadzenia, 131 typy MIME, 312

U uaktualnianie na gorco, 383 udostpnianie metod, 361 zdalnych komponentów, 367 uprawnienie ROLE_ADMIN, 247 ROLE_SPITTER, 266 URI, uniform resorce identifier, 305 URL, uniform resource locator, 305 usuga Burlap, 290 Simple Storage Service, 219 Spitter, 187, 286, 290 usugi asynchroniczne, 353 Hessian, 288 RMI, 282, 283 sieciowe, 42, 294 systemowe, 30 uytkownika, 264 zdalne, 280, 282, 300 usuwanie komponentu, 60 spittle, 274 zasobów, 324 uwierzytelnianie HTTP, 256 uytkowników, 263–269 za pomoc bazy danych, 264 za pomoc LDAP, 266

W walidacja, 189, 213 warstwa sieciowa aplikacji, 190, 194 wiadomo MIME, 388

Kup książkę

wizanie, 27 automatyczne, 85–90, 99 autodetect, 87, 90 byName, 86 byType, 86, 88 constructor, 87, 89 jawne, 91 kolekcji, 67 kolekcji typu map, 69 kolekcji waciwoci, 71 list, 68 komponentów EJB, 385 midzy obiektami, 25 null, 72 obiektów JNDI, 380 opcjonalne, 94 punktów kocowych, 296 za pomoc adnotacji, 92 za pomoc wyrae, 72 widok, 191 formularza, 210 strony gównej, 202 widoki Tiles, 200 wewntrzne, 198 waciwoci komponentów, 62 systemowe, 376 waciwo connectionFactory, 354 database, 167 destination, 354 managedInterfaces, 363 notificationListenerMappings, 372 registrationBehaviorName, 366 serviceInterface, 354 spittlesPerPage, 358 wplatanie, 111 wprowadzenie, 111, 125 WSDL, 300 wspóbieno, 182 wstrzykiwanie obiektów JNDI, 382 przez adnotacje, 99 przez konstruktor, 26, 56 przez wywoanie metod, 62 referencji, 54, 63 zalenoci, 29, 50, 64, 132, 250 wycofanie transakcji, 184 wydajno postrzegana, 395 rzeczywista, 395

Poleć książkę


408

Skorowidz

wyjtek CustomerNotFoundException, 240 DataAccessExeption, 143 java.rmi.RemoteException, 281 NullPointerException, 75 SQLException, 141, 151 wyjtki dostpu do danych, 143 JDBC, 143 kontrolowane, checked, 184 wykrywanie komponentĂłw, 100 wyliczenie PaymentType, 246 wylogowywanie, 256 wymiana zasobĂłw, 327 wymuszanie HTTPS, 259 wyodrbnianie konfiguracji, 374 wyraenia bezpieczestwa, 258 logiczne, 78 programu Cron, 395 regularne, 79 w SpEL, 73â&#x20AC;&#x201C;76 wyraenie hasRole(), 258 wysyanie danych zasobu, 325 formularzy, 329 komunikatĂłw, 341, 344 plikĂłw, 217 spittleâ&#x20AC;&#x2122;a, 344 wiadomoci, 386â&#x20AC;&#x201C;390 zasobĂłw, 323 wyszukiwanie obiektĂłw, 380 wywietlenie widoku, 207 wywoania zwrotne, callbacks, 144 wzorzec, 33, 192

Z zabezpieczanie metod, 270, 272 przepywu, 247 da sieciowych, 252 zabezpieczenia na poziomie kanau, 258 zagadnienia przecinajce, 108 przekrojowe, 29 zakres komponentĂłw, 58 propagacji, 181

Kup ksiÄ&#x2026;ĹźkÄ&#x2122;

zaczniki wiadomoci, 388 zapis pliku, 219 zapis w pamici podrcznej, 383 zapytania SQL, 152 zarzdzanie stanem, 189 transakcjami, 174 zarzdzany atrybut, managed attribute, 359 zasig danych przepywu, 232 kontekstu, 59 zasoby REST, 303 zastpowanie waciwoci, 375 zmiennych, 376 zdalne usugi, 280, 282, 300 wywoanie procedury, 280 wywoywanie metod, 42, 280 zdalny dostp, remoting, 280 zdalny dostp JMX, 367 zintegrowane rodowisko programistyczne, 113 zmienne rodowiskowe, 379 znacznik, Patrz take element <security:authentication>, 260 <security:authorize>, 261 <sf:errors>, 214 <sf:form>, 330 znak &, 117 znak kontynuacji wiersza, 17 znaki kropek (..), 116



rĂłdo danych JDBC, 149 JNDI, 147 z pul, 147

 dania przepywu, 226 danie DELETE, 310, 324 GET, 309, 320 HttpServletRequest, 252 POST, 310, 325 PUT, 322

PoleÄ&#x2021; ksiÄ&#x2026;ĹźkÄ&#x2122;


Spring w Akcji. Wydanie III  
Read more
Read more
Similar to
Popular now
Just for you