Spring w Akcji Wydanie III.pdf

(865 KB) Pobierz
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 tre ci
Przedmowa ............................................................................................................................................... 11
PodziÚkowania .......................................................................................................................................... 13
O ksiÈ ce ................................................................................................................................................... 15
C
Z}¥m
1. P
ODSTAWY FRAMEWORKA
S
PRING
Rozdziaï 1. Zrywamy siÚ do dziaïania
1.1.
21
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 zale no ci .............................................................................................. 25
1.1.3.
Stosujemy aspekty ......................................................................................................... 29
1.1.4.
Ograniczamy stosowanie kodu szablonowego dziÚki 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.
Moduïy 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 otaczajÈcych Springa? ........................................... 47
Podsumowanie .............................................................................................................................. 48
Rozdziaï 2. Tworzymy powiÈzania miÚdzy komponentami
2.1.
49
2.2.
2.3.
2.4.
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 warto ci do wïa ciwo ci komponentu .............................................................. 61
2.2.1.
Wstrzykujemy proste warto ci ..................................................................................... 62
2.2.2.
Wstrzykujemy referencje do innych beanów .............................................................. 63
2.2.3.
WiÈ emy wïa ciwo ci w przestrzeni nazw p Springa ................................................. 66
2.2.4.
WiÈ emy kolekcje ......................................................................................................... 67
2.2.5.
WiÈ emy nic (null) ........................................................................................................ 72
WiÈ emy za pomocÈ wyra eñ ..................................................................................................... 72
2.3.1.
Podstawy wyra eñ w SpEL .......................................................................................... 73
2.3.2.
Wykonujemy operacje na warto ciach w jÚzyku SpEL .............................................. 76
2.3.3.
Przesiewamy kolekcje za pomocÈ SpEL ...................................................................... 80
Podsumowanie .............................................................................................................................. 83
Kup książkę
Poleć książkę
6
Spis tre ci
Rozdziaï 3. Ograniczamy u ycie jÚzyka XML w konfiguracji Springa
3.1.
85
3.2.
3.3.
3.4.
3.5.
Automatycznie wiÈ emy wïa ciwo ci komponentów ................................................................ 86
3.1.1.
Cztery rodzaje automatycznego wiÈzania .................................................................... 86
3.1.2.
Domy lny styl automatycznego wiÈzania .................................................................... 90
3.1.3.
Mieszamy wiÈzanie automatyczne i jawne .................................................................. 91
WiÈ emy za pomocÈ adnotacji ................................................................................................... 92
3.2.1.
Korzystamy z adnotacji @Autowired ........................................................................... 92
3.2.2.
Stosujemy automatyczne wiÈzanie zgodne ze standardami,
korzystajÈc z adnotacji @Inject .................................................................................... 97
3.2.3.
Posïugujemy siÚ wyra eniami 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
Rozdziaï 4. Aspektowy Spring
4.1.
107
4.2.
4.3.
4.4.
4.5.
4.6.
Czym jest programowanie aspektowe ...................................................................................... 108
4.1.1.
Definiujemy terminologiÚ dotyczÈcÈ AOP ................................................................ 109
4.1.2.
Obsïuga programowania aspektowego w Springu .................................................... 112
Wybieramy punkty zïÈczenia za pomocÈ punktów przeciÚcia .............................................. 115
4.2.1.
Piszemy definicje punktów przeciÚcia ....................................................................... 116
4.2.2.
Korzystamy z desygnatora bean() w Springu ............................................................. 117
Deklarujemy aspekty w jÚzyku 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
C
Z}¥m
2. P
ODSTAWY APLIKACJI
S
PRINGA
Rozdziaï 5. Korzystanie z bazy danych
5.1.
139
5.2.
Filozofia dostÚpu do danych Springa ....................................................................................... 140
5.1.1.
Hierarchia wyjÈtków zwiÈzanych z dostÚpem do danych w Springu ...................... 141
5.1.2.
Szablony dostÚpu do danych ...................................................................................... 143
5.1.3.
Klasy bazowe DAO ..................................................................................................... 145
Konfiguracja ródïa danych ...................................................................................................... 147
5.2.1.
�½ródïa danych JNDI ................................................................................................... 147
5.2.2.
�½ródïa danych z pulÈ ................................................................................................... 147
5.2.3.
�½ródïo danych oparte na sterowniku JDBC .............................................................. 149
Kup książkę
Poleć książkę
Spis tre ci
5.3.
7
5.4.
5.5.
5.6.
U ywanie JDBC w Springu ....................................................................................................... 149
5.3.1.
Kod JDBC a obsïuga wyjÈtków .................................................................................. 150
5.3.2.
Praca z szablonami JDBC ........................................................................................... 153
Integracja Hibernate ze Springiem ......................................................................................... 158
5.4.1.
PrzeglÈd 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 mened erów encji .................................................................... 164
5.5.2.
Klasa DAO na bazie JPA ............................................................................................. 168
Podsumowanie ............................................................................................................................ 169
Rozdziaï 6. ZarzÈdzanie transakcjami
6.1.
171
6.2.
6.3.
6.4.
6.5.
Zrozumienie transakcji .............................................................................................................. 172
6.1.1.
Cztery sïowa kluczowe do zrozumienia transakcji .................................................... 173
6.1.2.
Zrozumienie obsïugi zarzÈdzania 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.
189
7.2.
7.3.
7.4.
7.5.
7.6.
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 obsïugujÈcy dane wprowadzane przez u ytkownika ............................................ 205
7.3.1.
Budowa kontrolera przetwarzajÈcego dane wprowadzane przez u ytkownika ....... 205
7.3.2.
Wy wietlenie widoku .................................................................................................. 207
Przetwarzanie formularzy ......................................................................................................... 208
7.4.1.
Wy wietlenie formularza rejestracyjnego .................................................................. 209
7.4.2.
Przetwarzanie formularza ........................................................................................... 211
7.4.3.
Walidacja przesyïanych danych ................................................................................. 213
Obsïuga plików wysyïanych na serwer .................................................................................... 217
7.5.1.
Dodanie pola selektora plików do formularza ........................................................... 217
7.5.2.
Odbieranie plików wysyïanych na serwer ................................................................. 218
7.5.3.
Konfiguracja Springa do przesyïania plików na serwer ............................................ 221
Podsumowanie ............................................................................................................................ 221
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin