Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00276 005745 13252271 na godz. na dobę w sumie
Wprowadzenie do Spring Framework dla programistów Java - ebook/pdf
Wprowadzenie do Spring Framework dla programistów Java - ebook/pdf
Autor: Liczba stron: 304
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-0442-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).
Pojawienie się Springa na zawsze zmieniło świat Javy. Ten przemyślany, dobrze zaprojektowany, dający programistom mnóstwo możliwości framework został przez nich wyjątkowo ciepło przyjęty. Obecnie jest on prawdopodobnie najczęściej wybieranym narzędziem do tworzenia aplikacji — niezależnie od stopnia ich skomplikowania. Za Springiem stoi ogromna społeczność oraz przepastne zasoby dokumentacji, przykładów czy instrukcji. Już teraz dowiedz się, dlaczego Spring jest numerem 1!

Książka ta wprowadzi Cię w świat Springa oraz zagadnień z nim związanych. Sięgnij po nią, by skonfigurować swój pierwszy projekt i przetestować aplikację. W kolejnych rozdziałach odkryjesz sposoby wykorzystania programowania aspektowego i wzorca MVC oraz integrowania aplikacji Spring z systemami zewnętrznymi. Ponadto przygotujesz swoje pierwsze API typu REST oraz zapiszesz dane w bazie MongoDB. Książka ta jest doskonałą lekturą dla osób znających język Java, chcących poznać legendarne możliwości Spring Framework.

Po przeczytaniu tej książki będziesz wiedzieć wszystko, czego potrzebujesz, aby efektywnie rozpocząć pracę z systemem szkieletowym Spring. Nauczysz się:
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Introducing Spring Framework: A Primer Tłumaczenie: Łukasz Piwko ISBN: 978-83-283-0439-0 Original edition copyright © 2014 by Felipe Gutierrez. All rights reserved. Polish edition copyright © 2015 by HELION SA. 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 bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi 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) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/wprsfj.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/wprsfj Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:258)ci O autorze ...............................................................................................................11 O korektorze merytorycznym .................................................................................12 Wprowadzenie ......................................................................................................13 Cz(cid:246)(cid:264)(cid:232) I Podstawy systemu szkieletowego Spring ............................15 Rozdzia(cid:239) 1. Pierwsza aplikacja Spring ......................................................................................17 Wymagania wstępne ........................................................................................................................... 18 Witaj, świecie ................................................................................................................................. 18 Podsumowanie ..................................................................................................................................... 25 Rozdzia(cid:239) 2. Klasy i zale(cid:285)no(cid:258)ci ...................................................................................................27 Aplikacja Spring: Moje dokumenty .................................................................................................. 27 Wymagania do programu Moje dokumenty ............................................................................ 27 Definiowanie klas i zależności .................................................................................................... 28 Praca z systemem Spring .................................................................................................................... 32 System szkieletowy Spring a wstrzykiwanie zależności ................................................................. 34 Podsumowanie ..................................................................................................................................... 36 Stosowanie ró(cid:285)nych konfiguracji ...........................................................................37 Konfiguracja XML programu Moje dokumenty ............................................................................. 37 Używanie adnotacji Spring ................................................................................................................. 44 Stereotypy Spring ................................................................................................................................. 47 Konfiguracja w postaci klasy ziarna Java ......................................................................................... 48 Użycie klasy GroovyBeanDefinitionReader .................................................................................... 51 Który rodzaj konfiguracji wybrać ...................................................................................................... 53 Podsumowanie ..................................................................................................................................... 54 Zakresy ziaren ........................................................................................................55 Zakresy .................................................................................................................................................. 55 Adnotacja @Scope ........................................................................................................................ 58 Zakresy ziaren w klasie GroovyBeanDefinitionReader .................................................................. 60 Podsumowanie ..................................................................................................................................... 61 Rozdzia(cid:239) 4. Rozdzia(cid:239) 3. Kup książkęPoleć książkę SPIS TRE(cid:165)CI Rozdzia(cid:239) 5. Kolekcje i typy w(cid:239)asne ...........................................................................................63 Listy, słowniki i własności .................................................................................................................. 63 Kolekcje w konfiguracji XML ............................................................................................................ 65 Scalanie kolekcji ................................................................................................................................... 67 Podsumowanie ..................................................................................................................................... 69 Rozdzia(cid:239) 6. Pliki zasobów ........................................................................................................71 Pliki własności ...................................................................................................................................... 76 Używanie innego języka — czy mówisz po hiszpańsku? ............................................................... 79 Podsumowanie ..................................................................................................................................... 82 Testowanie aplikacji Spring ...................................................................................83 Testowanie przy użyciu adnotacji ..................................................................................................... 83 Profile .................................................................................................................................................... 85 Inne adnotacje testowe ........................................................................................................................ 90 Podsumowanie ..................................................................................................................................... 92 Rozdzia(cid:239) 7. Cz(cid:246)(cid:264)(cid:232) II System szkieletowy Spring .................................................93 Rozdzia(cid:239) 8. Rady dla aplikacji Spring .......................................................................................95 Rady dla aplikacji Moje dokumenty ................................................................................................. 95 Na ratunek programowanie aspektowe ............................................................................................ 96 Podstawowe pojęcia programowania aspektowego ................................................................. 97 Rada before .................................................................................................................................. 101 Rada after ..................................................................................................................................... 103 Rada around ................................................................................................................................ 105 Rada AfterThrowing .................................................................................................................. 107 Zastosowanie technik AOP z adnotacjami .................................................................................... 111 Podsumowanie ................................................................................................................................... 113 Rozdzia(cid:239) 9. Przechowywanie danych aplikacji Spring ............................................................115 Dodawanie mechanizmu przechowywania danych ..................................................................... 115 Osadzanie bazy danych ..................................................................................................................... 128 Nowa metoda gromadzenia danych — JdbcTemplate i RowMapper ....................................... 130 Podsumowanie ................................................................................................................................... 134 Rozdzia(cid:239) 10. Publikowanie aplikacji Spring w internecie .........................................................135 Warstwa przechowywania danych .................................................................................................. 135 Wzorzec MVC w systemie Spring ................................................................................................... 137 Internacjonalizacja ............................................................................................................................. 142 Podsumowanie ................................................................................................................................... 145 Rozdzia(cid:239) 11. Integracja aplikacji Spring z systemami zewn(cid:218)trznymi ........................................147 Java Message Service ......................................................................................................................... 148 Spring JMS .......................................................................................................................................... 148 RabbitMQ i Spring Rabbit ................................................................................................................ 158 Podsumowanie ................................................................................................................................... 165 Rozdzia(cid:239) 12. Udost(cid:218)pnianie API typu REST ..............................................................................167 Interfejs API typu RESTful ............................................................................................................... 167 HTTP GET ................................................................................................................................... 174 HTTP POST ................................................................................................................................ 175 6 Kup książkęPoleć książkę SPIS TRE(cid:165)CI HTTP PUT ................................................................................................................................... 176 HTTP DELETE ........................................................................................................................... 177 Podsumowanie ................................................................................................................................... 178 Rozdzia(cid:239) 13. Zadania e-mail i planowanie zada(cid:241) .....................................................................179 Wysyłanie wiadomości e-mail ......................................................................................................... 179 Zadania asynchroniczne ................................................................................................................... 182 Planowanie zadań .............................................................................................................................. 185 Podsumowanie ................................................................................................................................... 187 Cz(cid:246)(cid:264)(cid:232) III Zaawansowane techniki programowania przy u(cid:276)yciu systemu szkieletowego Spring ........................189 Rozdzia(cid:239) 14. U(cid:285)ywanie dynamicznych j(cid:218)zyków programowania .............................................191 Bądź dynamiczny ............................................................................................................................... 191 Zastosowanie języka Groovy ............................................................................................................ 192 Zastosowanie języków JRuby i BeanShell ...................................................................................... 196 Podsumowanie ................................................................................................................................... 198 Rozdzia(cid:239) 15. Dane Spring w aplikacjach Spring .......................................................................199 Bazy danych NoSQL .......................................................................................................................... 199 Implementacja klasy DocumentDAO ............................................................................................ 202 Testowanie MongoDB ...................................................................................................................... 205 Kompletny test DocumentDAO ...................................................................................................... 207 Podsumowanie ................................................................................................................................... 210 Rozdzia(cid:239) 16. Przesy(cid:239)anie wiadomo(cid:258)ci w aplikacji Spring .........................................................211 Zastosowanie programu RabbitMQ ............................................................................................... 211 RabbitMQ — wymiany, powiązania i kolejki ......................................................................... 212 Zastosowanie marshallera XML do przekształcania wiadomości ....................................... 214 rabbit:connection-factory/ .................................................................................................... 218 rabbit:template/ ...................................................................................................................... 219 rabbit:direct-exchange/ i rabbit:binding/ ...................................................................... 219 rabbit:queue/ ........................................................................................................................... 219 rabbit:listener-container/ i rabbit:listener/ .................................................................... 219 Testowanie .......................................................................................................................................... 219 Podsumowanie ................................................................................................................................... 221 Rozdzia(cid:239) 17. Media spo(cid:239)eczno(cid:258)ciowe i mobilne .......................................................................223 Moduł Spring Social .......................................................................................................................... 223 Spring Social Twitter ......................................................................................................................... 223 Rejestrowanie aplikacji w Twitterze ......................................................................................... 224 Zaćwierkajmy .............................................................................................................................. 231 Wysyłanie tweetów z aplikacji Spring ............................................................................................. 234 Podsumowanie ................................................................................................................................... 236 7 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Cz(cid:246)(cid:264)(cid:232) IV Nowy system wej(cid:264)cia-wyj(cid:264)cia Spring ................................237 Rozdzia(cid:239) 18. Spring i Groovy ....................................................................................................239 Napiszmy coś w języku Groovy ....................................................................................................... 239 Testowanie kodu w języku Groovy ................................................................................................. 243 Składnia języka DSL .......................................................................................................................... 244 Podsumowanie ................................................................................................................................... 247 Rozdzia(cid:239) 19. Upraszczanie wszystkiego przy u(cid:285)yciu Spring Boot .............................................249 Spring Boot ......................................................................................................................................... 249 Wdrażanie aplikacji ........................................................................................................................... 253 Tworzenie wykonywalnego pliku JAR .................................................................................... 253 Tworzenie pliku WAR ............................................................................................................... 254 Spring Boot i Groovy ......................................................................................................................... 256 Podsumowanie ................................................................................................................................... 260 Rozdzia(cid:239) 20. Pierwsza aplikacja Spring XD ..............................................................................261 Instalowanie modułu Spring XD ..................................................................................................... 261 Archiwum ZIP z modułem Spring XD .................................................................................... 261 Instalacja w OSX przy użyciu menedżera Homebrew .......................................................... 261 Spring XD ........................................................................................................................................... 262 Moduły ......................................................................................................................................... 262 Podsłuchy ..................................................................................................................................... 262 Zastosowanie Spring XD w aplikacji Moje dokumenty ............................................................... 263 Analiza .......................................................................................................................................... 266 Podsumowanie ................................................................................................................................... 269 ........................................................................................271 Instalacja narz(cid:218)dzi ...............................................................................................273 Instalacja Javy ..................................................................................................................................... 273 Instalacja Javy w systemie Windows ........................................................................................ 274 Ustawianie zmiennych środowiskowych ................................................................................ 276 Instalowanie Javy w systemie OS X .......................................................................................... 279 Narzędzia dla systemu Mac OS X .................................................................................................... 281 Instalacja programu Homebrew ............................................................................................... 281 Instalacja GVM ........................................................................................................................... 282 Instalacja Gradle ................................................................................................................................ 282 Instalacja programu Gradle w systemie Windows ................................................................ 283 Instalacja Gradle w systemach Mac OS X i Linux .................................................................. 284 Instalacja interpretera języka Groovy ............................................................................................. 285 Instalacja Groovy w systemie Windows .................................................................................. 285 Instalacja Groovy w systemach Mac OS X i Linux ................................................................ 287 Instalacja MongoDB .......................................................................................................................... 287 Instalacja MongoDB w systemie Windows ............................................................................ 287 Uruchamianie serwera MongoDB ........................................................................................... 288 Zatrzymywanie serwera MongoDB ......................................................................................... 289 Instalacja MongoDB w systemie Mac OS X ............................................................................ 289 Uruchamianie serwera MongoDB ........................................................................................... 289 Zatrzymywanie serwera MongoDB ......................................................................................... 289 Uruchamianie serwera MongoDB przy logowaniu ............................................................... 289 Dodatki Dodatek A 8 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Instalacja brokera Apache Active MQ ............................................................................................ 290 Instalacja programu Apache Active MQ w systemie Windows .......................................... 290 Uruchamianie programu ActiveMQ ....................................................................................... 290 Zatrzymywanie programu ActiveMQ ..................................................................................... 290 Otwieranie konsoli sieciowej hawtio programu ActiveMQ ................................................. 291 Instalacja programu ActiveMQ w systemie Mac OS X ......................................................... 291 Uruchamianie programu ActiveMQ ....................................................................................... 291 Zatrzymywanie brokera ActiveMQ ......................................................................................... 291 Instalacja programu RabbitMQ ....................................................................................................... 292 Instalacja programu RabbitMQ w systemie Windows ......................................................... 292 Instalacja programu RabbitMQ w systemie Mac OS X ......................................................... 293 Przydatne polecenia do obsługi programu RabbitMQ ......................................................... 293 Instalacja systemu Spring Boot ........................................................................................................ 294 Instalacja Spring Boot w systemie Windows .......................................................................... 294 Instalacja Spring Boot w systemach Mac OS X i Linux ........................................................ 295 Instalacja Spring XD .......................................................................................................................... 295 Instalacja Spring XD w systemie Windows ............................................................................ 295 Instalacja Spring XD w systemie Mac OS X ........................................................................... 296 Podsumowanie ................................................................................................................................... 296 Skorowidz ............................................................................................................297 9 Kup książkęPoleć książkę SPIS TRE(cid:165)CI 10 Kup książkęPoleć książkę R O Z D Z I A (cid:146) 3 (cid:132) (cid:132) (cid:132) Stosowanie ró(cid:285)nych konfiguracji System szkieletowy Spring umożliwia stosowanie różnych technik konfiguracji kontenera. W tym rozdziale znajduje się opis metody opartej na formacie XML, z której skorzystaliśmy w poprzednim rozdziale. Ponadto czytając ten rozdział, poznasz inne techniki obsługi konfiguracji, takie jak adnotacje Spring, klasy konfiguracyjne ziaren Java oraz nowa klasa GroovyBeanDefinitionReader. W poprzednim rozdziale zdefiniowaliśmy aplikację Spring o nazwie Moje dokumenty, a także za pomocą pliku konfiguracyjnego XML wstrzyknęliśmy naszą implementację interfejsu SearchEngine. W tym rozdziale będziemy używać tej samej konfiguracji XML, dowiesz się również, jak używać pozostałych technik konfiguracji. Konfiguracja XML programu Moje dokumenty Na początek przypomnimy sobie aktualnie posiadaną konfigurację XML aplikacji Moje dokumenty i dokładnie ją przeanalizujemy (listing 3.1). Listing 3.1. Zawartość pliku mydocuments-context.xml ?xml version= 1.0 encoding= UTF-8 ? beans xmlns= http://www.springframework.org/schema/beans xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation= http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd bean id= engine class= com.apress.isf.java.service.MySearchEngine / bean id= documentType class= com.apress.isf.java.model.Type property name= name value= WEB / property name= desc value= (cid:146)(cid:200)cze sieciowe / property name= extension value= .url / /bean /beans Na listingu 3.1 pokazano treść pliku konfiguracyjnego w formacie XML zawierającego potrzebne kontenerowi Spring informacje na temat klas i ich zależności. W pliku tym informujemy kontener, że nasza implementacja interfejsu SearchEngine będzie ziarnem MySearchEngine o identyfikatorze engine. Innymi słowy, przypisaliśmy identyfikator zdefiniowanemu przez nas ziarnu. Ponadto tworzymy egzemplarz klasy Type w postaci ziarna o identyfikatorze documentType. Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA Ale chwileczkę! Ziarno? A co to jest ziarno? W Javie pojęcie ziarna (ang. bean) występuje od początku istnienia tego języka programowania i dlatego w systemie Spring przyjęto podobną nazwę. Ziarna Javy mają pewne standardowe cechy, np. znormalizowane nazwy metod (z przedrostkami set, get i is), odpowiednie konstruktory, zachowania itd., dzięki którym mogą współpracować z innymi ziarnami oraz klasami. Później w społeczności programistów Javy pojęcie ziarna przekształciło się w obiekt POJO (ang. plain old java object). Dzięki tym konwencjom system szkieletowy Spring rozpoznaje, tworzy, wstrzykuje, obsługuje, a nawet niszczy wszystkie klasy zadeklarowane na kontenerze. Ziarna deklaruje się przy użyciu elementu bean/ w pliku XML. Mogą one mieć kilka atrybutów, opisanych w tabeli 3.1. Tabela 3.1. Atrybuty elementu bean Atrybut id class scope init-method factory-method destroy-method lazy-init Opis Identyfikator ziarna. Każdy identyfikator może być zdefiniowany tylko raz. Wskazuje pełną nazwę wraz z nazwą pakietu konkretnej klasy. Informuje kontener Spring o sposobie tworzenia ziarna. Jeśli atrybut ten jest niezdefiniowany, ziarno jest domyślnie egzemplarzem singletonowym. Poza tym można ustawić zakres prototype (dla każdego żądania ziarna tworzony jest egzemplarz), request (dla każdego żądania sieciowego HTTP tworzony jest pojedynczy egzemplarz) oraz session (ziarno jest tworzone i istnieje przez czas trwania sesji HTTP). Nazwa metody wywoływanej po utworzeniu ziarna. Metoda ta jest przydatna, gdy trzeba ustawić stan po utworzeniu obiektu. Nazwa metody służącej do tworzenia ziarna. Innymi słowy, programista powinien dostarczyć metodę tworzącą egzemplarz obiektu. Metoda ta powinna mieć parametry. Nazwa metody wywoływanej po usunięciu ziarna. Parametr ten należy ustawić na wartość true, jeśli chcemy, aby kontener tworzył ziarno przy jego wywołaniu lub użyciu przez programistę (poprzez wywołanie metody getBean) bądź później w innej klasie wymagającej tego obiektu. W systemie Spring informacje na temat klas i ich zależności oraz sposobów interakcji między nimi można dodawać na różne sposoby. O tym wszystkim opowiem w tej książce przy okazji omawiania dodawania różnych funkcji do aplikacji Moje dokumenty. Na listingu 3.2 pokazano implementację interfejsu SearchEngine o nazwie MySearchEngine z poprzedniego rozdziału. Wydaje się, że to dużo kodu, ale zawiera on sporo danych wpisanych na stałe. Jak w takim razie sobie poradzić, gdy trzeba będzie dodać więcej typów lub metod? W takim przypadku konieczne jest zmodyfikowanie i ponowne skompilowanie kodu. To za dużo pracy! Listing 3.2. Zawartość pliku MySearchEngine.java package com.apress.isf.java.service; import java.util.ArrayList; import java.util.List; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; public class MySearchEngine implements SearchEngine { @Override public List Document findByType(Type documentType) { 38 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI List Document result = new ArrayList Document (); for(Document document : storage()){ if(document.getType().getName().equals(documentType.getName())) result.add(document); } return result; } @Override public List Document listAll() { return storage(); } private List Document storage(){ List Document result = new ArrayList Document (); Type type = new Type(); type.setName( PDF ); type.setDesc( Portable Document Format ); type.setExtension( .pdf ); Document document = new Document(); document.setName( Szablon ksi(cid:200)(cid:285)ki ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Book Template.pdf ); result.add(document); document = new Document(); document.setName( Przyk(cid:239)adowa umowa ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Contracts/Sample Contract.pdf ); result.add(document); type = new Type(); type.setName( NOTE ); type.setDesc( Notatki tekstowe ); type.setExtension( .txt ); document = new Document(); document.setName( Clustering with RabbitMQ ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Clustering with RabbitMQ.txt ); result.add(document); type = new Type(); type.setName( WEB ); type.setDesc( (cid:146)(cid:200)cze sieciowe ); type.setExtension( .url ); document = new Document(); document.setName( Pro Spring Security Book ); document.setType(type); document.setLocation( http://www.apress.com/9781430248187 ); result.add(document); 39 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA return result; } } Aby wyeliminować opisane niedogodności, zaimplementujemy interfejs SearchEngine od nowa. Do tej implementacji wstrzykniemy typy za pomocą metody ustawiającej. Na listingu 3.3 znajduje się nowa klasa, SearchEngineService. Listing 3.3. Zawartość pliku SearchEngineService.java package com.apress.isf.spring.service; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; import com.apress.isf.spring.data.DocumentDAO; public class SearchEngineService implements SearchEngine { private DocumentDAO documentDAO; public DocumentDAO getDocumentDAO() { return documentDAO; } public void setDocumentDAO(DocumentDAO documentDAO) { this.documentDAO = documentDAO; } public List Document findByType(Type documentType) { List Document result = new ArrayList Document (); for(Document doc : listAll()){ if(doc.getType().getName().equals(documentType.getName())) result.add(doc); } return result; } public List Document listAll() { return Arrays.asList(documentDAO.getAll()); } } Porównamy kod znajdujący się na listingu 3.2 z kodem z listingu 3.3. Na tym ostatnim brak sztywnych fragmentów kodu i metody storage, natomiast dodano nowy atrybut o nazwie documentDAO, który będzie wstrzykiwany przez metodę ustawiającą, tylko trzeba poinformować kontener Spring o tym nowym atrybucie i klasie zawierającej dane. Teraz zdefiniujemy nowe klasy: DocumentDAO i DocumentRepository (listingi 3.4 i 3.5). Pokazana na listingu 3.4 klasa DocumentDAO przechowuje wszystkie informacje na temat dokumentów, które na razie będą zapisywane w pamięci. Natomiast widoczna na listingu 3.5 klasa DocumentRepository to jej implementacja. 40 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI Listing 3.4. Zawartość pliku DocumentDAO.java package com.apress.isf.spring.data; import com.apress.isf.java.model.Document; public interface DocumentDAO { public Document[] getAll(); } Na listingu 3.5 przedstawiono klasę DocumentRepository zawierającą cztery własności typu Document z własnymi metodami ustawiającymi i pobierającymi. Tak, będziemy wstrzykiwać cztery dokumenty za pomocą ich metod ustawiających. Listing 3.5. Zawartość pliku DocumentRepository.java package com.apress.isf.spring.data; import com.apress.isf.java.model.Document; public class DocumentRepository implements DocumentDAO { private Document doc1; private Document doc2; private Document doc3; private Document doc4; public Document getDoc1() { return doc1; } public void setDoc1(Document doc1) { this.doc1 = doc1; } public Document getDoc2() { return doc2; } public void setDoc2(Document doc2) { this.doc2 = doc2; } public Document getDoc3() { return doc3; } public void setDoc3(Document doc3) { this.doc3 = doc3; } public Document getDoc4() { return doc4; } public void setDoc4(Document doc4) { this.doc4 = doc4; 41 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA } public Document[] getAll() { return new Document[] { doc1, doc2, doc3, doc4 }; } } To wygląda już trochę lepiej. Oddzieliliśmy metodę wydobywania danych, ale jak to robimy? Przypomnę, że wcześniej do pobierania informacji używaliśmy metody storage (listing 3.2). Później postanowiliśmy od nowa zaimplementować interfejs SearchEngine. W tej nowej implementacji zmieniliśmy sposób pobierania danych i utworzyliśmy interfejs, który będzie wstrzykiwany niezależnie od swojej implementacji, dzięki czemu klasa stanie się solidniejsza i łatwiejsza w obsłudze. Ale zobaczmy teraz, co trzeba zmienić w pliku XML, aby poinformować kontener Spring o tych wszystkich nowych modyfikacjach. Nowa wersja pliku mydocuments-context.xml jest przedstawiona na listingu 3.6. Znajdują się w nim wszystkie informacje dotyczące implementacji klasy DocumenDAO (DocumentRepository) oraz sposobu jej wstrzykiwania do implementacji SearchEngine. Listing 3.6. Zawartość pliku mydocuments-context.xml ?xml version= 1.0 encoding= UTF-8 ? beans xmlns= http://www.springframework.org/schema/beans xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation= http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd bean id= engine class= com.apress.isf.spring.service.ServiceSearchEngine property name= documentDAO ref= documentDAO / /bean bean id= documentDAO class= com.apress.isf.spring.data.DocumentRepository property name= doc1 ref= doc1 / property name= doc2 ref= doc2 / property name= doc3 ref= doc3 / property name= doc4 ref= doc4 / /bean bean id= doc1 class= com.apress.isf.java.model.Document property name= name value= Szablon ksi(cid:200)(cid:285)ki / property name= type ref= pdfType / property name= location value= /Users/felipeg/Documents/Random/Book Template.pdf / /bean bean id= doc2 class= com.apress.isf.java.model.Document property name= name value= Przyk(cid:239)adowa umowa / property name= type bean id= pdfType class= com.apress.isf.java.model.Type property name= name value= PDF / property name= desc value= Portable Document Format / property name= extension value= .pdf / /bean /property property name= location value= /Users/felipeg/Documents/Contracts/Sample Contract.pdf / /bean bean id= doc3 class= com.apress.isf.java.model.Document property name= name value= Clustering with RabbitMQ / property name= type ref= noteType / property name= location value= /Users/felipeg/Documents/Random/Clustering with RabbitMQ.txt / /bean bean id= doc4 class= com.apress.isf.java.model.Document property name= name value= Pro Spring Security Book / property name= type ref= webType / 42 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI property name= location value= http://www.apress.com/9781430248187 / /bean bean id= webType class= com.apress.isf.java.model.Type property name= name value= WEB / property name= desc value= (cid:146)(cid:200)cze sieciowe / property name= extension value= .url / /bean bean id= pdfType class= com.apress.isf.java.model.Type property name= name value= PDF / property name= desc value= Portable Document Format / property name= extension value= .pdf / /bean bean id= noteType class= com.apress.isf.java.model.Type property name= name value= NOTE / property name= desc value= Notatki tekstowe / property name= extension value= .txt / /bean /beans Analizując kod przedstawiony na listingu 3.6, można zauważyć, że do przypisywania wartości użyto referencji, takich jak atrybut ref. Ponadto w kodzie znajduje się nowa deklaracja klasy ServiceSearchEngine, ustawiono także własność documentDao i odniesiono jego wartość do innego ziarna o identyfikatorze documentDAO. Spójrz też na ziarno o identyfikatorze doc2. Osadzamy nowe ziarno jako wartość, co jest zgodne z zasadami konfiguracji Spring. Jak widać, wszystkie dane dotyczące typów i dokumentów zostały umieszczone w pliku XML. Może istnieje jeszcze lepszy sposób, ale na razie zajmiemy się utworzeniem testu jednostkowego. Na listingu 3.7 pokazano zmodyfikowaną wersję naszego testu. Listing 3.7. Zawartość pliku MyDocumentsTest.java package com.apress.isf.spring.test; import static org.junit.Assert.*; import java.util.List; import org.junit.Before; import org.junit.Test; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; public class MyDocumentsTest { private ClassPathXmlApplicationContext context; private SearchEngine engine; private Type webType; @Before public void setup(){ context = new ClassPathXmlApplicationContext( META-INF/spring/mydocuments-context.xml ); engine = context.getBean(SearchEngine.class); webType = context.getBean( webType ,Type.class); } 43 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA @Test public void testWithSpringFindByType() { List Document documents = engine.findByType(webType); assertNotNull(documents); assertTrue(documents.size() == 1); assertEquals(webType.getName(),documents.get(0).getType().getName()); assertEquals(webType.getDesc(),documents.get(0).getType().getDesc()); assertEquals(webType.getExtension(),documents.get(0).getType().getExtension()); } @Test public void testWithSpringListAll() { List Document documents = engine.listAll(); assertNotNull(documents); assertTrue(documents.size() == 4); } } W metodzie setup() (metoda ta jest uruchamiana przed wykonaniem każdej metody w klasie) używamy klasy ClassPathXmlApplicationContext, która uruchamia kontener Spring przez utworzenie i powiązanie wszystkich egzemplarzy oraz przygotowanie ich do użytku w momencie, gdy będą potrzebne. Teraz uruchom ten test za pomocą poniższego polecenia: gradle test W katalogu głównym projektu można użyć polecenia: gradle :r03:test (cid:132) Uwaga Ka(cid:285)dy rozdzia(cid:239) zawiera kilka plików z testami jednostkowymi, wi(cid:218)c poni(cid:285)ej przedstawiam polecenie wykonuj(cid:200)ce jeden konkretny test: gradle -Dtest.single=MyDocumentsTest test Na razie pokazałem Ci, jak skonfigurować kontener Spring poprzez dodanie ziaren i utworzenie do nich odwołań, aby kontener wiedział, jak je tworzyć i jakie łączą je relacje, oraz by mógł je przygotować, gdy będą potrzebne. Ale przypomnę, że w systemie Spring konfigurację można tworzyć także innymi sposobami, i dlatego w następnym podrozdziale pokazuję, jak utworzyć taką samą konfigurację jak wcześniej przy użyciu adnotacji. U(cid:285)ywanie adnotacji Spring Adnotacje do języka Java wprowadzono w jego wersji 5. Było to znakomite posunięcie ze strony twórców Javy, ponieważ za pomocą adnotacji do klas można dodawać metadane stosowane zarówno podczas kompilacji, jak i działania programu, co stwarza nowe możliwości dla programistów. Programiści systemu Spring postanowili wykorzystać tę okazję do budowy mechanizmu konfiguracyjnego opartego na adnotacjach. Mechanizm ten pojawił się w wersji 2.5 systemu. Ale wystarczy tego gadania. Czas się wziąć za kod źródłowy i sprawdzić, co trzeba zmienić, aby zastosować konfigurację opartą na adnotacjach. Spójrz na listing 3.8. Listing 3.8. Zawartość pliku AnnotatedSearchEngine.java package com.apress.isf.spring.annotated.service; import java.util.ArrayList; 44 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI import java.util.Arrays; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; import com.apress.isf.spring.data.DocumentDAO; @Service( engine ) public class AnnotatedSearchEngine implements SearchEngine { @Autowired private DocumentDAO documentDAO; public List Document findByType(Type documentType) { List Document result = new ArrayList Document (); for(Document doc : listAll()){ if(doc.getType().getName().equals(documentType.getName())) result.add(doc); } return result; } public List Document listAll() { return Arrays.asList(documentDAO.getAll()); } } Na powyższym listingu przedstawiono nową implementację interfejsu SearchEngine w postaci klasy AnnotatedSearchEngine. Jak widać, zostały w niej użyte adnotacje @Service( engine ) i @Autowired. System Spring obsługuje kilka adnotacji, które zostały wymienione w tabeli 3.2. Są one jedynie markerami albo stereotypami, podobnie jak adnotacja @Service. Adnotacja ta może mieć wartość. W tym przypadku jest to wartość engine, która oznacza, że kontener utworzy ziarno o identyfikatorze engine. W tym przykładzie wskazywana jest klasa AnnotatedSearchEngine. To tak samo, jakbyśmy w pliku XML wpisali poniższy element: bean id= engine class= com.apress.isf.spring.annotated.service AnnotatedSearchEngine / Tabela 3.2. Stereotypy Stereotyp/marker @Component @Repository @Service @Controller Opis Jest to marker, ogólny stereotyp, który przez system Spring jest rozpoznawany jako zarządzany przez niego składnik. Jest to specjalizacja adnotacji @Component dotycząca obiektu obsługującego dostęp do danych. Klasy oznaczone tą adnotacją mogą być przetwarzane przez inne narzędzia, a nawet aspekty w kontenerze Spring. Jest to specjalizacja adnotacji @Component dotycząca warstwy usługowej. To również jest specjalizacja adnotacji @Component, której zazwyczaj używa się w kontekście sieciowym. Zastosowaliśmy też adnotację @Autowired. Nakazuje ona systemowi Spring utworzenie egzemplarza i przypisanie go do zadeklarowanej zmiennej. Ma takie samo znaczenie jak poniższy element XML: property name= documentDAO ref= documentDAO / 45 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA Podsumowując, konfiguracja klasy AnnotatedSearchEngine będzie wyglądała następująco: bean id= engine class= com.apress.isf.spring.annotated.service AnnotatedSearchEngine property name= documentDAO ref= documentDAO / /bean Na listingu 3.9 znajduje się kod źródłowy klasy AnnotatedDocumentRepository. Zawiera ona marker @Repository i będzie wstrzykiwana do implementacji SearchEngine dzięki adnotacji @Autowired (listing 3.8). Listing 3.9. AnnotatedDocumentRespository.java package com.apress.isf.spring.annotated.data; import java.util.ArrayList; import java.util.List; import org.springframework.stereotype.Repository; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.spring.data.DocumentDAO; @Repository( documentDAO ) public class AnnotatedDocumentRepository implements DocumentDAO { public Document[] getAll() { return storage(); } private Document[] storage(){ List Document result = new ArrayList Document (); Type type = new Type(); type.setName( PDF ); type.setDesc( Portable Document Format ); type.setExtension( .pdf ); Document document = new Document(); document.setName( Szablon ksi(cid:200)(cid:285)ki ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Book Template.pdf ); result.add(document); document = new Document(); document.setName( Przyk(cid:239)adowa umowa ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Contracts/Sample Contract.pdf ); result.add(document); type = new Type(); type.setName( NOTE ); type.setDesc( Notatki tekstowe ); type.setExtension( .txt ); document = new Document(); document.setName( Clustering with RabbitMQ ); 46 Kup książkęPoleć książkę document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Clustering with RabbitMQ.txt ); Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI result.add(document); type = new Type(); type.setName( WEB ); type.setDesc( (cid:146)(cid:200)cze sieciowe ); type.setExtension( .url ); document = new Document(); document.setName( Pro Spring Security Book ); document.setType(type); document.setLocation( http://www.apress.com/9781430248187 ); result.add(document); return result.toArray(new Document[result.size()]); } } Teraz skierujemy uwagę na listing 3.10. Znajduje się na nim treść pliku konfiguracyjnego XML zawierającego elementy nakazujące kontenerowi Spring poszukać klas z adnotacjami i ich adnotacji. W pliku tym użyty został też specjalny element context:component-scan-base-package/ . Należy on do tej samej przestrzeni nazw XML co nasza konfiguracja. W przestrzeni tej będzie dodanych jeszcze więcej znaczników, o których przeczytasz w dalszych rozdziałach tej książki. Na razie wystarczy wiedzieć, że opisywany element nakazuje kontenerowi Spring wyszukiwanie klas z adnotacjami z podanego pakietu, tu com.apress.isf.spring.annotated, i wszystkich podpakietów. Listing 3.10. Zawartość pliku Mydocuments-annotations-context.xml ?xml version= 1.0 encoding= UTF-8 ? beans xmlns= http://www.springframework.org/schema/beans xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance xmlns:context= http://www.springframework.org/schema/context xsi:schemaLocation= http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring- context-4.0.xsd context:component-scan base-package= com.apress.isf.spring.annotated / bean id= webType class= com.apress.isf.java.model.Type property name= name value= WEB / property name= desc value= (cid:146)(cid:200)cze sieciowe / property name= extension value= .url / /bean /beans Stereotypy Spring Stereotypy są markerami pomagającymi kontenerowi Spring w zidentyfikowaniu składników zarządzanych przez system Spring. Markerów tych można używać do oznaczania zewnętrznych narzędzi przetwarzających albo jako referencji dla punktów przecięcia (ang. pointcat) w programowaniu aspektowym. Obecnie stereotypy 47 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA znajdujące się w kodzie źródłowym pomagają programistom zrozumieć ten kod, ponieważ sprawiają, że jest on bardziej czytelny oraz że są w nim zaznaczone warstwy strukturalne i architektoniczne. Do najczęściej wykorzystywanych stereotypów (w społeczności skupionej wokół systemu Spring i oczywiście w naszej aplikacji) zaliczają się te, których opis znajduje się w tabeli 3.2. Konfiguracja w postaci klasy ziarna Java W wersji 3.0 systemu Spring wprowadzono nową technikę konfigurowania kontenera Spring polegającą na użyciu nowej klasy konfiguracyjnej w postaci ziarna Java. Początkowo był to osobny projekt, ale postanowiono wcielić go do rdzenia systemu w wersji 3.0. Aktualnie jest to jedna z zalecanych metod konfigurowania kontenera, ponieważ daje wyraźny obraz relacji występujących między klasami i pokazuje interakcje pomiędzy nimi. A w niektórych przypadkach pomaga nawet uniknąć całego tego bałaganu związanego z plikami XML. Na listingu 3.11 znajduje się kod źródłowy klasy konfiguracyjnej w Javie. Klasa ta jest równoważna z pokazanym na listingu 3.6 kodem konfiguracyjnym w formacie XML. Każda definicja ziarna z tego pliku ma odpowiednik w postaci adnotacji @Bean w metodzie. Listing 3.11. Zawartość pliku MyDocumentsContext.java package com.apress.isf.spring.config; import java.util.HashMap; import java.util.Map; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; import com.apress.isf.spring.data.DocumentDAO; import com.apress.isf.spring.data.DocumentRepository; import com.apress.isf.spring.service.ServiceSearchEngine; @Configuration public class MyDocumentsContext { private Map String,Document documents = new HashMap String,Document (); private Map String,Type types = new HashMap String,Type (); @Bean public Type webType(){ return getTypeFromMap( web ); } @Bean public SearchEngine engine(){ ServiceSearchEngine engine = new ServiceSearchEngine(); engine.setDocumentDAO(documentDAO()); return engine; } public MyDocumentsContext(){ Type type = new Type(); type.setName( PDF ); type.setDesc( Portable Document Format ); type.setExtension( .pdf ); 48 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI Document document = new Document(); document.setName( Szablon ksi(cid:200)(cid:285)ki ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Book Template.pdf ); documents.put( doc1 , document); types.put( pdf ,type); document = new Document(); document.setName( Przyk(cid:239)adowa umowa ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Contracts/Sample Contract.pdf ); documents.put( doc2 ,document); type = new Type(); type.setName( NOTE ); type.setDesc( Notatki tekstowe ); type.setExtension( .txt ); document = new Document(); document.setName( Clustering with RabbitMQ ); document.setType(type); document.setLocation( /Users/felipeg/Documents/Random/Clustering with RabbitMQ.txt ); documents.put( doc3 ,document); types.put( note ,type); type = new Type(); type.setName( WEB ); type.setDesc( (cid:146)(cid:200)cze sieciowe ); type.setExtension( .url ); document = new Document(); document.setName( Pro Spring Security Book ); document.setType(type); document.setLocation( http://www.apress.com/9781430248187 ); documents.put( doc4 ,document); types.put( web ,type); } private DocumentDAO documentDAO(){ DocumentRepository documentDAO = new DocumentRepository(); documentDAO.setDoc1(getDocumentFromMap( doc1 )); documentDAO.setDoc2(getDocumentFromMap( doc2 )); documentDAO.setDoc3(getDocumentFromMap( doc3 )); documentDAO.setDoc4(getDocumentFromMap( doc4 )); return documentDAO; } private Document getDocumentFromMap(String documentKey){ return documents.get(documentKey); } private Type getTypeFromMap(String typeKey){ return types.get(typeKey); } } 49 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA Na początku kodu tej klasy dodaliśmy adnotację @Configuration, a metodom przypisaliśmy adnotację @Bean. Użycie adnotacji @Configuration jest jak przekazanie kontenerowi Spring następującej informacji: „Tutaj znajdują się definicje moich ziaren”. Natomiast adnotacja @Bean przed metodą jest równoznaczna z utworzeniem elementu bean/ i ustawieniem jego własności. A zatem powyższa klasa poinformuje kontener Spring o tym, jakie są ziarna i jak będą powiązane. Teraz wykorzystamy tę nową konfigurację w teście jednostkowym (listing 3.12). Listing 3.12. Zawartość pliku MyDocumentsBeanConfigurationTest.java package com.apress.isf.spring.test; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertEquals; import java.util.List; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; import com.apress.isf.spring.config.MyDocumentsContext; public class MyDocumentsBeanConfigurationTest { private ApplicationContext context; private SearchEngine engine; private Type webType; @Before public void setup(){ context = new AnnotationConfigApplicationContext(MyDocumentsContext.class); engine = context.getBean(SearchEngine.class); webType = context.getBean(Type.class); } @Test public void testWithBeanConfigurationFindByType() { List Document documents = engine.findByType(webType); assertNotNull(documents); assertTrue(documents.size() == 1); assertEquals(webType.getName(),documents.get(0).getType().getName()); assertEquals(webType.getDesc(),documents.get(0).getType().getDesc()); assertEquals(webType.getExtension(),documents.get(0).getType().getExtension()); } @Test public void testWithBeanConfigurationListAll() { List Document documents = engine.listAll(); assertNotNull(documents); assertTrue(documents.size() == 4); } } 50 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI W tym kodzie do załadowania konfiguracji użyliśmy klasy Java AnnotationConfigApplicationContext. W ten sposób informujemy kontener Spring, że stosowana jest konfiguracja klasowa, a nie w postaci pliku XML. Aby przeprowadzić ten test jednostkowy, należy wykonać polecenie gradle: gradle test U(cid:285)ycie klasy GroovyBeanDefinitionReader W wersji 4. systemu Spring wprowadzono nowy sposób konfigurowania ziaren przy użyciu języka programowania Groovy. Nowość tę ściągnięto z systemu Grails, w którym do tworzenia ziaren zaczęto używać języka specjalistycznego (ang. domain-specific language — DSL). Spójrz na przykładowy kod przedstawiony na listingu 3.13. Listing 3.13. Zawartość pliku mydocuments.groovy import com.apress.isf.spring.service.ServiceSearchEngine import com.apress.isf.spring.data.DocumentRepository import com.apress.isf.java.model.Document beans { engine(ServiceSearchEngine){ documentDAO = ref( documentDAO ) } documentDAO(DocumentRepository){ doc1 = ref( doc1 ) doc2 = ref( doc2 ) doc3 = ref( doc3 ) doc4 = ref( doc4 ) } doc1(Document){ name = Szablon ksi(cid:200)(cid:285)ki type = ref( pdfType ) location = /Users/felipeg/Documents/Random/Book Template.pdf } doc2(Document){ name = Przyk(cid:239)adowa umowa type = ref( pdfType ) location = /Users/felipeg/Documents/Contracts/Sample Contract.pdf } doc3(Document){ name = Clustering with RabbitMQ type = ref( noteType ) location = /Users/felipeg/Documents/Random/Clustering with RabbitMQ.txt } doc4(Document){ name = Pro Spring Security Book type = ref( webType ) location = http://www.apress.com/9781430248187 } 51 Kup książkęPoleć książkę WPROWADZENIE DO SPRING FRAMEWORK DLA PROGRAMISTÓW JAVA webType(com.apress.isf.java.model.Type){ name = WEB desc = (cid:146)(cid:200)cze sieciowe extension = .url } pdfType(com.apress.isf.java.model.Type){ name = PDF desc = Portable Document Format extension = .url } noteType(com.apress.isf.java.model.Type){ name = NOTE desc = Notatki tekstowe extension = .txt } } Na listingu tym przedstawiono nowy sposób definiowania konfiguracji za pomocą języka Groovy zamiast XML (listing 3.6), adnotacji (listing 3.9) lub klasy Java (listing 3.10). Na razie nie przejmuj się składnią, bo jej opis znajduje się w rozdziale 18. Teraz utworzymy test jednostkowy (listing 3.14), w którym użyjemy nowej klasy GroovyBeanDefinitionReader do załadowania definicji ziaren. Klasa ta będzie ładowała plik mydocuments.groovy, którego zawartość pokazano na listingu 3.13. Listing 3.14. Zawartość pliku MyDocumentsBeanDefinitionReaderTest.java package com.apress.isf.spring.test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import java.util.List; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.GenericGroovyApplicationContext; import com.apress.isf.java.model.Document; import com.apress.isf.java.model.Type; import com.apress.isf.java.service.SearchEngine; public class MyDocumentsBeanDefinitionReaderTest { private ApplicationContext context; private SearchEngine engine; private Type webType; @Before public void setup(){ context = new GenericGroovyApplicationContext( META-INF/spring/mydocuments.groovy ); engine = context.getBean(SearchEngine.class); webType = context.getBean( webType ,Type.class); } 52 Kup książkęPoleć książkę Rozdzia(cid:239) 3. (cid:132) STOSOWANIE RÓ(cid:191)NYCH KONFIGURACJI @Test public void testWithGroovyFindByType() { List Document documents = engine.findByType(webType); assertNotNull(documents); assertTrue(documents.size() == 1); assertEquals(webType.getName(),documen
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Wprowadzenie do Spring Framework dla programistów Java
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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