Universitatea "Dunrea de Jos" din Galai

Facultatea de Automatic, Calculatoare, Inginerie

Electric i Electronic

Master anul I - Metode i tehnici avansate n programarea

obiectual

TUTORIAL SPRING
FRAMEWORK

Studeni: Apostol Dan Alexandru

Ciocla Mihai

Galai 2017
 Cuprins
1. Introducere................................................................................................................................3
2. Beneficiile n folosirea Spring..................................................................................................5
3. Folosirea Spring in Eclipse.......................................................................................................7
4. Spring exemplu Hello World..................................................................................................7
5. Spring Inversion of Control (IoC) Inversiunea de control................................................13
6. BeanFactory n Spring.............................................................................................................14
7. ApplicationContext n Spring.................................................................................................16
8. Setter i Constructor Injection n Spring.................................................................................18
9. Injectarea Beans-urilor interioare (inner beans) n Spring......................................................25
10. Injectarea colectiilor in Spring............................................................................................28
11. Bean Autowiring in Spring..................................................................................................33
12. Spring Bean Scopes.............................................................................................................33
13. Folosirea ApplicationContextAware in Spring....................................................................41
14. Spring Bean Definition Inheritance motenirea...............................................................44
15. Spring Bean Life Cycle and Callbacks ciclul de via al bean-ului i reapelri...............48
16. Adnotri n Spring...............................................................................................................55
17. @Autowired Annotation in Spring......................................................................................57
18. Spring JSR-250 adnotri......................................................................................................61
19. Event Handling in Spring Tratarea evenimentelor n Spring...........................................67
20. Spring JDBC Framework....................................................................................................70
21. Spring Transaction Management.........................................................................................81
22. Folosirea Hibernate cu Spring.............................................................................................95
1. Introducere
Spring a fost creat de ctre Rod Johnson in anul 2002 i este un IoC (Inversion of Control)
framework care ne ajuta sa decuplam diversele dependente ale componentelor unui proiect.
Istoricul versiunilor Spring:
Oct 2002- Prima versiune lansata de Rod Johnson (Expert One-on-One J2EE Design and
Development)
Iun 2003- Preia licenta de la Apache si este lansat ca un framework.
Oct 2006- Este lansat Spring 2.0.
Nov 2007- Spring 2.5.
Dec 2009 - Spring 3.0.
Dec 2011- Spring 3.1.
Jun 2012- Spring 3.2.
Spring poate fi gandit ca un cadru de cadre (framework of frameworks) deoarece ofera
suport pentru diferite cadre cum ar fi Struts, Hibernate, Tapestry, EJB, JSF, etc. Cadrul
(framework), in sens mai larg, poate fi definit ca o structura in care gasim solutii la diverse
probleme tehnice. Spring ofer faciliti foarte simple i diverse pentru a integra diverse cadre,
tehnologii i servicii n aplicaii. Unul dintre motivele principale pentru utilizarea Spring este de a
pstra codul ct mai simplu posibil. Spring faciliteaza modul de a dezvolta aplica ii enterprise cu
java beans simple si cuplate slab. Din acest motiv Spring poate fi numit si Plain Old Java Object
(POJO) framework.
Spring este un framework open-source dezvoltat de Spring Source, o divizie a Vmware si
poate fi rezumat n dou moduri:
Container - Spring poate fi descris ca un container cu cerinte reduse, deoarece nu
implic instalarea, configurarea, pornirea i oprirea activitilor asociate cu
containerul. Este doar o simpl colecie de cteva fiiere Java ARchive (JAR), care
trebuie s fie adugate la classpath. Spring ia clasele in aplicatie, creeaz obiecte, i
gestioneaz ciclul de via al acestor obiecte.
Framework - Spring poate fi descris ca un Application Programming Interface (API),
care conine o colecie mare de clase, metode, interfee, adnotri, tag-uri XML care
pot fi utilizate ntr-o aplicaie. API ofer o varietate de clase factory si facade care ne
ajut s utilizam orice cadru sau funcionalitate foarte uor n aplica ia pe care o
dezvoltam.
 Spring cuprinde mai multe module, cum ar fi IoC, AOP, DAO, Context, ORM, WEB MVC
etc. In cele ce urmeaza vom prezenta unele dintre aceste module.

Accesul la date utilizand Java Database Connectivity (JDBC): Spring ofer un suport bogat
pentru lucrul cu JDBC. Un cod de tipic JDBC implic: crearea unei conexiuni, declara ii,
executare interogri i manipulare excepii pentru efectuarea operatiilor asupra unei baze de date.
Spring ofer un set de clase care se ocup de aceste operaii de baz JDBC.

Accesul la date prin utilizarea Object Relational Mapping (ORM): Exist o mulime de
framework-uri ORM, cum ar fi Hibernate, Toplink, etc, care pot fi utilizate n aplica ii Java.
Spring ofer o mulime de clase, aceste clase fcnd lucrul cu ORM foarte uor.

Aspect Oriented Programming (AOP): Una dintre principalele paradigme pe care le utilizeaz
Spring pentru a furniza servicii entreprise pentru aplicaii este AOP. AOP este un mecanism prin
care putei introduce funcionaliti n codul existent, fr a modifica design-ul.

Core Spring Framework: Pachetul de baz (core) este partea fundamental a cadrului i asigur
caracteristici IoC i Dependency Injection. Conceptul de baz aici este BeanFactory, care ofer o
implementare sofisticat a modelului factory pattern i ne permite s decuplm configurarea i
specificarea dependenelor din logica programului.

Spring MVC: ofer un Model-View-Controller (MVC) de implementare pentru web-aplicaii.

MVC-ul ofer o separare clar ntre modelul de cod de domeniu i formularele web i ne permite
s utilizm toate celelalte caracteristici ale Spring.

Obiect XML Mapping: Spring 3.0 introduce modulul OXM, care anterior nu a fost o parte a
cadrului de baz. OXM este un mecanism care convertete obiectele n format XML i vice-
versa. Exist o mulime de cadre OXM, cum ar fi Caster, Xstream, JiBX, Java API for XML
Binding (JAXP) i XMLMeabs. Spring 3.0 ofer un API uniform pentru a avea acces la oricare
dintre aceste cadre OXM.

Dependency Injection (DI): Tehnologia prin care Spring este cel mai des identificat dependency
injection (DI) un tip de inversiune de control (IoC). Inversiunea de control (IoC) este un concept
general i poate fi exprimat n mai multe moduri diferite i dependency injection este doar un
exemplu concret al inversiei de control.
Ce este injecia de dependen (dependency injection) mai exact? S ne uitm la aceste
dou cuvinte separat. Aici partea de dependen se traduce printr-o asociere ntre dou clase. De
exemplu, clasa X depinde de clasa Y. Acum, s ne uitm la partea a doua, injecie. Toate acestea
nseamn c Y va fi injectat n clasa X de IoC. Aici nu avem nevoie s scriem o mul ime de cod
pentru a crea instana claselor dependente. Injecia de dependen promoveaz cuplajul slab. Ea
deschide calea pentru nlturarea claselor de utilitate (utility clesses) pe care le scriem n
aplicaiile noastre.
 2. Beneficiile n folosirea Spring

Spring permite dezvoltatorilor s dezvolte aplicaii enterprise folosind POJO-uri.

Avantajul utilizrii numai de POJO-uri este c nu avei nevoie de un EJB container, cum
ar fi un server de aplicaii, dar avei opiunea de a folosi doar un container servlet robust,
cum ar fi Tomcat.
Spring este organizat ntr-o manier modular. Chiar dac numrul de pachete i clase
sunt substaniale, trebuie s v facei griji doar de cele de care avei nevoie i ignorai
restul.
Spring folosete tehnologii deja existente, cum ar fi ORM frameworks, JEE, cronometre
Quart i JDK, alte tehnologii de vizualizare.
Testarea unei aplicatii scrise cu Spring este simpl, deoarece codul dependent de mediu
este mutat n acest cadru (framework). Mai mult dect att, prin utilizarea POJOs stil
JavaBean, devine mai uor de utilizat dependena de injecie pentru injectarea datelor de
test.
Framework-ul web al Spring este un MVC bine conceput, care ofer o alternativ foarte
bun pentru alte framework-uri web, cum ar fi Struts sau altele mai puin populare.
Spring ofer un API convenabil pentru a traduce excepii specifice unei anumite
tehnologii (generate de JDBC, Hibernate, sau JDO, de exemplu), n excepii consistente.
Containerele IoC, nu necesit resurse de sistem mari, acest lucru fiind benefic pentru
dezvoltarea i implementarea aplicaiilor pe computere cu memorie i CPU limitate.

Dependency Injection (DI) Injectarea dependenelor n Spring

nseamn injectarea dependenei dintre dou obiecte ca pe cerina noastr ca n cererea
noastr, acest lucru ajut la reducerea dependenei ntre ele i mai muli beneficiari la unitatea de
testare a fiecrui obiect independent.
Fiecare aplicaie bazat pe Java are cteva obiecte care lucreaz mpreun pentru a
prezenta ceea ce utilizatorul final vede ca o aplicaie funcional. Atunci cnd scriei o aplicaie
complex Java, clasele ar trebui s fie ct mai independente posibil de alte clase Java pentru a
crete posibilitatea de a reutiliza aceste clase i pentru a le testa in mod independent de alte clase.

Avantajele Dependency Injection (DI)

Reducerea dependenei ntre ele a obiectelor n aplicaie.
Fiecare obiect din aplicaie poate fi testat individual
Cupleaz slab sau promoveaz decuplarea aplicaiei
Promoveaz capacitatea de reutilizare a codului sau obiectelor n aplicaii diferite
Promoveaz abstracia logic a componentelor.

O aplicaie are clasa Drawing. n clasa Drawing exist o clas Shape care poate fi
Triangle sau Circle sau Rectangle.
Dependency with Constructor Injection

1. public class Drawing{

2. private Shape shape;

3. public Drawing(Shape shape) {

4. this.shape = shape;

5. }

6. }

Aici pe Drawing nu-l intereseaz ce form ar trebui s

deseneze. Clasa Shape va fi implementat n mod
independent i va fi furnizat lui Drawing la momentul realizrii instan ierii lui Drawing i toat
aceast procedur este controlat de Spring.

Am eliminat controlul total al Drawing i l-am pstrat n alt parte (de ex. fi ier de configurare
XML) i dependena (de ex. clasa Shape) este injectat n clasa Shape printr-un Class
Constructor. Astfel, fluxul de control a fost "inversat" de Dependency injection (DI), deoarece am
delegat dependena la un sistem extern.

Dependency with Setter Injection

1. public class Drawing{

2. private Shape shape;

3. public void setShape(Shape shape) {

4. this.shape = shape;

5. }

6. }

A doua metod de injectare a dependenei este prin metoda Setter a clasei Drawing, unde vom
crea instana Shape i acest instan va fi folosit pentru a apela metode setter pentru a ini ializa
proprietatile clasei Drawing.
3. Folosirea Spring in Eclipse

Pasul 1 Instalati Java Development Kit (JDK)

Pasul 2 Instalai Apache Common Logging API de aici: http://commons.apache.org/logging/
Pasul 3 Instalati SpringSource Tool Suite (STS) IDE de aici:
http://www.springsource.org/springsource-tool-suite-download .
Pasul 4 Instalati Spring Framework Libraries. Download Spring framework binaries de aici:
http://www.springsour3ce.org/download.

4. Spring exemplu Hello World

n cele ce urmeaz vom crea o aplicaie Spring simpl care va afia mesajul Hello World!

Pasul 1 crearea unui proiect Spring simplu, folosind STS IDE. Urmai: File -> New -> Project
i selectai Spring Project din lista. Acum denumii proiectul ca spring01HelloWorld ca n
imaginea de mai jos:
Odat ce proiectul este creat cu succes, vom avea urmtorul coninut n project explorer:

Pasul 2 - Adugai bibliotecile necesare: adugm bibliotecile Spring framework i common

logging API la proiectul nostru. Pentru a face acest lucru, face i clic dreapta pe numele de proiect
spring01HelloWorld i apoi urmai urmtoarea opiune disponibil n meniul contextual: Build
Path -> Add Libraries:
In fereastra urmtoare click pe User Library >> Next:

La user library adugai spring-lib cu urmtoarele fiiere jar (acestea sunt minimele necesare):
 antlr-runtime-3.0.2

org.springframework.aop-3.2.0.M1

org.springframework.asm-3.2.0.M1

org.springframework.aspects-3.2.0.M1

org.springframework.beans-3.2.0.M1

org.springframework.context.support-3.2.0.M1

org.springframework.context-3.2.0.M1

org.springframework.core-3.2.0.M1

org.springframework.expression-3.2.0.M1

commons-logging-1.1.1

Pasul 3 - Crearea fiierelor surs:

 Acum vom crea fiiere surs n cadrul proiectului spring01HelloWorld. n primul rnd
avem nevoie pentru a crea un pachet numit com.sdnext.dineshonjava.tutorial. Pentru a face acest
lucru, facei clic dreapta pe src n seciunea Explorer pachet i urmai opiunea: New -> Package.

n continuare, vom crea fiiere HelloWorld.java i SpringTestApp.java

HelloWorld.java
SpringTestApp.java

Exist urmtoarele dou puncte importante de reinut despre programul principal:

Primul pas este de a crea ClassPathXmlApplicationContext() unde am folosit API

framework. Acest API ncarc beans-ul de configurare i n cele din urm bazat pe API-
ul furnizat, are grij de crearea i iniializarea tuturor obiectelor.
Al doilea pas este utilizat pentru a obine beans-ul necesar folosind metoda getBean() a
contextului creat. Aceast metod utilizeaz ID-ul bean-ului pentru a returna un obiect
generic. Odat ce avem obiectul, putem utiliza acest obiect pentru a apela orice metod
de clas.

Pasul 4 - Crearea de fiiere de configurare Bean:

Acum trebuie s creai un fiier Bean Configuration, care este un fiier XML care menine
toate clasele obiect ca beans. Este, de asemenea, numit Bean Factory Configuration. Pstra i acest
fiier (spring.xml) pe directorul src al proiectului Spring.
Spring.xml este folosit pentru a atribui ID-uri unice pentru diferitele beans-uri i pentru a
controla crearea de obiecte cu valori diferite, fr a afecta oricare dintre fi ierele surs Spring. De
exemplu, utiliznd fiierul de mai jos putei trece orice valoare pentru variabila "mesaj" i astfel
putei imprima diferite valori ale mesajului, fr a afecta fiierele HelloWorld.java i
SpringTestApp.java.
S vedem cum funcioneaz:
spring.xml
 Dup crearea fiierului de configurare (Spring.xml), punem acest fiier n directorul "src" al
aplicaiei. Apoi acest fiier de configurare (Spring.xml) este ncrcat n ApplicationContext dup
cum urmeaz:

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

Atunci cnd aplicaia Spring este ncrcat n memorie, framework-ul utilizeaz fi ierul de
configurare de mai sus pentru a crea toate beans-urile definite i le atribuie un ID unic definit in
tag. Avei posibilitatea s utilizai tag-ul pentru a trece valorile diferitelor variabile folosite la
momentul crerii obiectului.

Rulm programul i vom avea urmtoarea ieire pe consola:

5.Spring Inversion of Control (IoC) Inversiunea

de control
Inversiunea de control este procesul prin care aplicaia definete dependen a i aceste
dependene sunt apoi ndeplinite n timpul rulrii de Spring framework. Containerul IoC este
principala component a Spring framework. Acesta ofer containerul IoC principal i AOP
framework. Containerul de baz al Spring ofer funcionaliti importante, inclusiv prin injecie
de dependen i managementul ciclului de via al beans-urilor. Putem spune c, IoC sau
inversiunea de control este caracteristica de baz a Spring framework. Dezvoltatorii utilizeaz
containerul IoC pentru a gestiona beans i dependenele n aplicaie. Astfel, simplific punerea n
aplicare a logicii de business in aplicaii.

Spring IoC Container de fapt, vine cu dou containere distincte:

1. Bean Factories - BeanFactory ofer cadrul de configurare i funcionalitatea de baz i suport

pentru injecia de dependen. Org.springframework.beans.factory.BeanFactory este
reprezentarea efectiv a containerului Spring IoC, care este responsabil pentru pstrarea i
gestionarea beans-urilor menionate mai sus. Responsabilitile sale includ instan ierea obiectelor
aplicaiei, configurarea unor astfel de obiecte, precum i asamblarea dependen elor dintre aceste
obiecte.

2. Application Context - Acest container adaug mai multe funcionaliti entreprise, cum ar fi
capacitatea de a rezolva mesajele textuale dintr-un fiier de proprieti i posibilitatea de a publica
evenimente de aplicaie pentru asculttori. Acest container este definit de interfaa
org.springframework.context.ApplicationContext.

6. BeanFactory n Spring
Un BeanFactory este ca o clas de fabric, care conine o colecie de beans. BeanFactory
deine definiiile pentru mai multe beans din cadrul su i apoi instaniaz beans-ul de cte ori
este solicitat de ctre clieni. BeanFactory este capabil de a crea asociatii intre obiecte care
colaboreaz in timp ce aceste obiecte sunt instaniate. Astfel, se elimin povara configuraiei
beans-ului n sine ct i a clienilor beans-ului.
BeanFactory ia parte, de asemenea, n ciclul de via al unui beans, efectuarea de apeluri la
metode de iniializare i distrugere a beans-urilor.
Acesta este cel mai simplu container care furnizeaz suport de baz pentru DI i este definit
de interfaa org.springframework.beans.factory.BeanFactory. BeanFactory i interfeele conexe,
cum ar fi BeanFactoryAware, InitializingBean, DisposableBean, sunt nc prezente n Spring cu
scopul de a asigura compatibilitatea cu numrul mare de framework-uri ale terilor care se
integreaz cu Spring.
n continuare prezentm un scurt exemplu pentru BeanFactory.

triangle.java

spring.xml

drawing.java
 Primul pas este de a crea factory obiect unde am folosit framework API
XmlBeanFactory() pentru a crea factory bean i ClassPathResource () API pentru a ncrca
fiierul de configurare de beans disponibile n CLASSPATH. XmlBeanFactory() API are grij de
crearea i iniializarea tuturor obiectelor, de exemplu beans menionate n fiierul de configurare.
Al doilea pas este utilizat pentru a obine beansul necesar folosind metoda getBean() a
obiectului creat. Aceast metod utilizeaz beans ID-ul pentru a returna un obiect generic. Odat
ce avem obiectul, putem utiliza acest obiect pentru a apela orice metod de clas.
Dupa ce rulm clasa Drawing vom primi urmtoarea ieire pe consol:

7. ApplicationContext n Spring
ApplicationContext este un fel de frate mai mare al lui BeanFactory cu unele func ii
suplimentare, cum ar fi AOP concept, notificri eveniment i adaug mai multe funcionaliti
enterprise specifice, cum ar fi capacitatea de a rezolva mesajele textuale din fiier de proprieti i
posibilitatea de a publica evenimente de aplicaie. Acest container este definit de interfaa
org.springframework.context.ApplicationContext.
ApplicationContext include toate funcionalitile BeanFactory i este recomandat n
general naintea BeanFactory. BeanFactory poate fi utilizat n continuare pentru aplica ii simple,
cum ar fi cele pentru dispozitivele mobile sau aplicaii bazate pe applet.
Cele mai frecvent utilizate sunt implementari ApplicationContext sunt:
FileSystemXmlApplicationContext: Acest container ncarc definiiile beans dintr-un
fiier XML. Aici trebuie s furnizai calea complet a fiierului de configurare XML
beans pentru constructor.
ClassPathXmlApplicationContext: Acest container ncarc definiiile beans-urilor
dintr-un fiier XML. Aici nu trebuie s furnizai calea complet a fiierului XML, dar
trebuie s setai CLASSPATH n mod corespunztor, deoarece acest container va cuta
fiierul beans XML de configurare n CLASSPATH.
WebXmlApplicationContext: Acest container ncarc fiierul XML cu definiii ale
tuturor beans-urilor dintr-o aplicaie web.
triangle.java

spring.xml

drawingapp.java
n momentul n care vom rula exemplul de mai sus vom obine n consol urmtorul mesaj:
Equilateral Triangle Drawn.
8.Setter i Constructor Injection n Spring
Caracteristici:
Setter injection este preferat Constructor injection cnd amndou sunt
specificate.
Constructor nu poate iniializa parial valori.
Dependena circular poate fi obinut cu setter.
Securitatea este mai redus cu setter deoarece poate fi trecut peste.
Constructor asigur n totalitate dependena, setter nu o asigur n totalitate.
Setter poate fi citit mai uor.

Constructor Injection: Ideea de baza este faptul c obiectul nu are valori implicite i n
loc, avei un singur constructor unde toi colaboratorii i valorile trebuie s fie furnizate nainte de
a putea instania obiectul. Acum vom vedea un exemplu cu Constructor Injection:

triangle.java

Clasa bean triangle are dou atribute type i height. Cele dou atribute sunt setate utiliznd
constructor injection.

spring.xml
 Atributul id al elementului bean este folosit pentru a specifica numele bean-ului i atributul
clasei este utilizat pentru a specifica numele de clasa al bean-ului. Elementul constructor-arg din
bean element este utilizat pentru a injecta valoarea proprietii prin injectare constructor.
Atributul index al elementului constructor-arg reprezint secvenele de argument constructor care
trec la constructorul clasei.
Precum:
Triangle(String type, int height)
la index = 0 argumentul este type;
la index = 1 argumentul este height;
i aa mai departe.
n cazul n care orice clas are un singur constructor argument, atunci nu exist nici o nevoie
pentru a specifica atributul index al bean in fisierul de configurare bean n Spring. Al doilea
atribut este de type constructor-arg este utilizat pentru tipul de argumentele constructorului.
Precum:
Triangle(String type, int height)
then type = "java.lang.String"
and type = "int"
Aici am stabilit "echilateral" i "20" pentru proprietile bean-ului triangle, tipul i nl imea
respectiv. Urmtoarea Main class este folosit pentru a obine Triangle bean din Spring IoC
container i de a afia valoarea sa in Triangle.

drawingapp.java
Rezultatul rulrii programului va fi in acest caz: Equilateral triangle is drawn of height 20.
Setter Injection: Utilizatorul obiectului poate apela setteri pe obiect pentru a trece peste
colaboratorii obiectului, n scopul de a lega obiectele mpreun sau pentru a nlocui colaboratori
cheie cu dubluri test.

triangle.java

Clasa bean Triangle are dou atribute type i height. Cele dou atribute sunt setate folosind
injectarea setter.
spring.xml

Atributul id al bean este folosit pentru a specifica numele bean-ului i atributul clasei
este utilizat pentru a specifica numele complet de clasa a bean-ului. Elementul property din bean
este utilizat pentru a injecta valoarea lui property prin injectare setter. Atributul name al property
reprezint atributul bean-ului i atributul value specific valoarea proprietii corespunztoare.
Aici am stabilit "echilateral" i "20" pentru Treaingle bean, tipul i nlimea respectiv.
Main class este folosit pentru a obine Triangle bean din IoC container i afia valoarea sa in
Triangle.

drawingapp.java

Rezultatul rulrii programului va fi in acest caz: Equilateral triangle is drawn of height 20.

Injectarea Obiectelor (definite de utilizator) n Bean

n exemplele de mai sus, am fost vzut modul de a defini bean-ul (Triangle) n fiierul
de configurare (spring.xml) i de a iniializa proprietile sale asociate (de tip i nlime). n
exemplele anterioare am folosit numai tipurile primitive de date (int, long, double etc.) i clasa
java definite, cum ar fi cum ar fi String, Integer, etc (de exemplu, tipul este String si inaltimea
este int).
Acum vom un bean (Triangle), cu proprieti definite de utilizator (clasa Point).

Mai jos vom vedea un exemplu de injectare a obiectelor definite de utilizator in beans.

triangle.java

Clasa Triangle are trei puncte de noduri pentru a desena un triunghi i s defineasc
setter toate cele trei puncte pointA, pointB i pointC (numai setter este necesar n Spring
framework). Aici point este, de asemenea, o clas cu dou puncte, unul este axa X i altul este
axa Y.

point.java

Aici definim clasa Punct cu dou proprieti int x, int y. De fapt, clasa Point este, de
asemenea, un bean care este o proprietate a bean-ului Triangle. Acum vom configura ambele
beans cu fiierul de configurare (spring.xml).

spring.xml
 Atributul id al bean-ului este folosit pentru a specifica numele bean-ului i atributul
class este utilizat pentru a specifica numele complet al clasei bean-ului. Property este utilizat
pentru a injecta valoarea proprietii prin injectare setter. Atributul name al elementului property
reprezint atributul bean-ului i atributul ref specific referina unei alte bean sau id al bean
element (Point) property.
Aici ne-am stabilit "pointA", "pointB" i "pointC" pentru bean-ul Triangle cu ref id al
altui bean (Point) "pointA", "pointB" i "pointC". Acum, "pointA" este id-ul elementului bean a
Point class i aa mai departe. Main class este folosit pentru a obine Triangle bean din Spring
IoC container i afia valoarea sa la Triangle.

Drawingapp.java

Rezultatul rularii programului va fi:

PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

9. Injectarea Beans-urilor interioare (inner beans) n Spring

Beans interioare sunt beans interioare sunt beans definite n domeniul de aplicare al
unui alt bean. Oricnd un bean este folosit doar pentru o singur proprietate, este recomandat s-l
declarm ca un bean interior. Este suportat att de setter ct i de constructor.

n fiierul de configurare (spring.xml) exist patru beans (ID-uri sunt triangle, pointA,
pointB i pointC) definite n capitolul anterior. S presupunem c beans (pointB i pointC) din
clasa Point sunt folosite numai pentru definiia bean-ului triangle atunci nu este nevoie s
definim Point bean n mod separat n fiierul de configurare (spring.xml) i pointA este punctul
comun i este definit separat n fiierul de configurare bean (spring.xml). Cea mai bun idee n
aceast situaie trebuie s definim Point bean ca bean interioar cu n bean-ul Triangle.
Triangle.java Point.java
 Acum, vom
vedea cum
s definim
beans ca
beans
interioare, n
urmtoarele
fiiere de
configurare:

Spring.xml

Drawingapp.java

Rezultatul rularii programului va fi identic cu cel prezentat n exemplul precedent:

PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

10. Injectarea colectiilor in Spring

Am vzut cum se configureaz tipul de date primitive folosind atributul value i

referinele obiect folosind atributul ref al tag-ul n fiierul de configurare Bean (spring.xml).
Ambele cazuri se refer la o valoare singular care trece in bean. Acum vom discuta despre
trecerea valorilor multiple de date, cum ar fi List, Set, Collection, Map, Properties. Pentru a face
fa situaiei, Spring ofer patru tipuri de elemente de configurare a colectiilor.

List - folosim- <list> - </ list>

Set - folosim- <set> - </ set>
Map - folosim- <map> - </ map>
Proprieti folosim - <props> - </ props>

1. Utilizarea Listei:
Doar cu valori:
 Cu valori, beans si beans interior:

2. Utilizarea Set:
Doar cu valori:

Cu valori, beans si beans interior:

3. Utilizarea Map:
Doar cu valori:

Cu valori, beans si beans interior:

4. Folosirea Properties:
Si acum sa vedem un exemplu:

Si fiierul de configurare spring.xml cu toate tipurile prezentate:

Drawingapp.java

Dup rularea programului vom obine urmtorul rezultat:

List Elements :[Triangle, Circle, Circle, Rectangle]

Set Elements :[Triangle, Circle, Rectangle]
Map Elements :{1=Triangle, 2=Circle, 3=Circle, 4=Rectangle}
Property Elements :{rectangle=Rectangle, circle2=Circle, triangle=Triangle, circle1=Circle}
11. Bean Autowiring in Spring
Exist mai multe beans in Spring care colaboreaz la dezvoltarea unei aplicaii, iar
autowire ajut n a face relaia dintre ele. Autowiring reduce efortul de a scrie proprieti
sau argumente pentru constructor. Autowiring este caracteristica oferit de Spring pentru a
sri peste unele configurri n fiierele XML.

Moduri Autowiring: Exist cinci moduri autowiring care pot fi folosite pentru a instrui
containerul Spring s utilizeze autowiring pentru injectare de dependen.
No implicit, nu definete autowiring
byName - autowiring se face prin numele proprietii. Spring se uit la
proprietile beans pentru care atributul autowire este setat la byName n fiierul
de configurare XML. Apoi, ncearc s se potriveasc i s lege proprietile sale
cu beans-urile definite de aceleai nume n fiierul de configurare.
byType autowiring se face prin potrivirea tipului de date de numele proprietii.
Spring se uit la proprietile beans-urilor pentru care autowire este setat la
byType n fiierul de configurare XML. Apoi, ncearc s se potriveasc o
proprietate n cazul n care tipul su se potrivete exact cu unul dintre numele
beans-ului n fiierul de configurare. n cazul n care exist mai mult de un astfel
de beans, genereaz fatal exception.
Constructor similar cu byType, dar tipul se aplic argumentelor pentru
constructor. n cazul n care nu exist exact un beans al tipului argumentului
constructorului n container, genereaz fatal error.
Autodetect - Atunci cnd constructorul implicit nu are nici un argument, autowire
n funcie de tipul de date sau autowire cu constructor. Spring ncearc s
foloseasc autowire constructor, n cazul n care nu funcioneaz, Spring va
ncearca s foloseasc byType.

12. Spring Bean Scopes

n Spring vom obine bean-ul container cu o anumit configura ie implicit.
Comportamentul implicit este faptul c fiecare beans din containerul Spring sunt
iniializate atunci cnd fiierul bean de configurare este ncrcat n JVM. De fiecare dat
cnd getBean este apelat containerul recunoscut de bean i de a returneaz acel bean
apelantului. Un alt comportament implicit este c fiecare bean are doar o singur instan
n Spring container.

Bean Scope nseamn c este utilizat pentru a decide ce tip de bean, ar trebui s fie
ntors de la Spring container napoi la apelant. Spring Bean Scopes de baz sunt doar dou tipuri
Singleton:(default) Scopes o singur bean definiie la un singur obiect instan per spring IoC
container. Prototype: o singur bean definiie pentru orice numr de instane de obiect.
Dar, n mediul web spring are inc trei scopes Request scope: la o solicitare HTTP.
Session Scope: la o sesiune HTTP. Global Session: o singur bean definiie pentru ciclul de via
al unei sesiuni HTTP globale.

Noi putem controla nu numai diferitele dependene i valorile de configurare care

urmeaz s fie conectat la un obiect care este creat dintr-o anumit defini ie de fasole, dar, de
asemenea, domeniul de aplicare al obiectelor create dintr-o anumit definiie de beans. Aceast
abordare este foarte puternic i v ofer flexibilitatea de a alege domeniul de aplicare a
obiectelor pe care le creai prin configurare.

Basic Spring Bean Scope - sunt doar dou tipuri prezentate mai jos.
1. Singleton Bean Scope - ntoarcere o singur instan a beans per spring IoC container
2. Prototype Bean Scope - ntoarcere o nou instan a bean-ului de fiecare dat cnd este
solicitat

Singleton Bean Scope - o singur definiie de beans ntr-un singur obiect instan per container
spring IoC. Acesta este comportamentul implicit al containerului spring.

Atunci cnd un beans este un singleton, numai o instan n comun a bean-ului va fi gestionat,
iar toate cererile pentru beans cu id sau id-uri care se potrivesc cu acel bean va avea ca rezultat
faptul c exact acea instan a bean-ului va fi returnat de ctre spring container.

Putem spune n alt mod, atunci cnd definii un bean i este scoped ca singleton, atunci spring
IoC container va crea exact o instan a obiectului definit prin aceast definiia a bean-ului.
Aceast singur instan va fi stocat ntr-un cache de astfel de Singleton beans i toate cererile
ulterioare i referine pentru acel beans va avea ca rezultat ntoarcerea obiectului din cache.

Pentru a defini un Singleton scope, putei seta proprietatea scope la Singleton n fi ierul de
configurare, aa cum se arat mai jos:

Sau folosind adnotari pentru Bean Scope:

i mai jos un exemplu simplu pentru Singleton Bean Scope

Point.java
Spring.xml

Drawingapp.java
 Acest Singleton difer de modelul Singleton n Java Class. Modelul unic n Java
nseamn c putei crea o singur instan aunei clase n JVM. Dar, n spring Singleton bean
scope nseamn c fiecare container poate crea doar un singur bean n spring IoC container, dar
JVM poate avea mai multe Spring IoC Container astfel nct JVM poate avea mai multe beans,
mai degrab dect Singleton bean scope.

Prototype Bean Scope - ntoarcere o nou instan a bean-ului de fiecare dat cnd este solicitat

Pentru a defini un prototype scope, folositi configurarea ca n fiierul beans de configurare, aa

cum se arat mai jos:
Sau folosind adnotri:

i acum s vedem i un exemplu pentru prototype scope:

Point.java
Spring.xml

Drawingapp.java

Acelai exemplu, dar de aceast dat vom folosi adnotrile:

Spring.xml
Point.java

Drawingapp.java
13. Folosirea ApplicationContextAware in Spring

Imaginai-v c avem o aplicaie (web sau swing, de exemplu) i dorim s fie activat -
Spring. Adaugm bibliotecile Spring (spring.jar) i fiierul de configurare (spring.xml) i crem
beans-urile. Dar exist nc unele fiiere de clas vechi pe care nu le putei utiliza n acest fel.
Aceste fiiere nc mai au nevoie de acces la Spring-Honeypot i nu dorim s modificm
aplicaia.
n primul rnd crem clasa "ApplicationContextProvider (clasa Triangle)". Aceast clas
implementeaz ApplicationContextAware. Un bean care implementeaz
ApplicationContextAware-interfa i este implementat n context, va fi apelat la crearea bean-
ului, folosind metoda interfetei setApplicationContext (...), i prevzut cu o trimitere la context,
care poate fi pstrat pentru o interaciune mai trziu cu contextul.
n acest tutorial vom vedea i exemplu de utilizare ApplicationContextAware.
ApplicationContextAware este utilizat atunci cnd un obiect este necesar.

Triangle.java
Point.java

Spring.xml

Drawingapp.java
Cu rezultatul rulrii programului:
Bean name is: triangle
PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

n capitolul precedent am vzut c am creat obiectul applicationcontext prin utilizarea

fiierului de configurare (spring.xml), dar am fcut acest lucru doar o singur dat a folosind
fiierul de configurare (spring.xml) pentru intreaga aplicatie.
n cazul n care am fcut o singur dat crearea de obiect applicationcontext i, de
asemenea, crearea o singur dat a beanului triangle prin metoda getBean(), deoarece are scope
Singleton i beans pointA, pointB & pointC sunt, de asemenea populate, mpreun cu beans
triangle doar o singur dat, atunci cnd beans triangle este iniializat chiar dac pointA, pointB
& pointC sunt prototype n scope.
Dupa aceea nu putem crea noi obiecte bean pointA, pointB & pointC, fr a crea bean
triangle clasa Triangle sau oriunde altundeva, cu excepia aplicaiei principale
(DrawingApp.java).
i, exist unele situaii n care vrem s folosim obiect applicationcontext orice unde
altundeva. S presupunem c beanul Triangle are nevoie de obiect applicationcontext din anumite
motive. S presupunem c dorim s crem noi beans pointA, pointB & pointC din clasa triangle,
atunci trebuie s ne declarm beans pointA, pointB & pointC ca prototype bean scope. Acum,
avem nevoie de a avea acces la applicationContext obiect din clasa bean triangle, astfel folosim
interfaa ApplicationContextAware, deoarece i aceast interfa este pus n aplicare de ctre
clasa Triangle bean pentru accesarea obiectului applicationcontext.

14. Spring Bean Definition Inheritance motenirea

O definiie de beans conine potenial o cantitate mare de informa ii de configurare,
inclusiv informaii specifice containerului i argumente pentru constructor i valorile de
proprietate. O definiie de bean copil motenete date de configurare de la o definiie printe.
Definiia copilului poate trece peste anumite valori, sau adugai altele, dup cum este necesar.
Cu ajutorul definiiilor beans de prini i copii putem salva o mulime de timp de tastare. n mod
eficient, aceasta este o form de templating.
Dac lucrai cu o interfa ApplicationContext programatic, definiii de beans copil sunt
reprezentate de clasa ChildBeanDefinition. Cei mai muli utilizatori nu lucreaz cu ei la acest
nivel, n schimb configurai definiiile de beans n mod declarativ ceva de genul
ClassPathXmlApplicationContext.
Atunci cnd utilizai metadate de configurare bazate pe XML, indicai o definiie de bean copil
prin utilizarea atributului parent, specificnd bean printe ca valoarea acestui atribut.

Motenirea Spring Bean nu are nimic de-a face cu motenirea de clas Java, dar
conceptul de motenire este acelai. Putei defini o definiie un bean printe ca un ablon i beans
copii pot moteni configuraia necesar din bean printe.

Exemplul urmtor ilustreaz motenirea beans cu clasa triangle i clasele sale prini.

Triangle.java
Point.java
Urmtorul este fiierul de configurare spring.xml n care am definit "parentTriangle" bean, care
are o proprietate "pointA". n continuare, exist dou beans "triangle1" i "triangle2" care au fost
definite ca un copil al "parentTriangle" bean cu ajutorul atributului parent. Copilul bean
motenete proprietatea"pointA" ca atare i are prioritate fa de proprietatea "pointA" i
introduce nc dou proprieti "pointB" i "pointC.

Spring.xml

Drawingapp.java
Rezultatul rulrii aplicaiei va fi:
PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

Observm aici c nu am trecut de "pointA", cnd am creat bean-ul "triangle1", dar am trecut din
cauza motenirii definiiei bean-ului.

15. Spring Bean Life Cycle and Callbacks ciclul de via

al bean-ului i reapelri

Spring ofer mai multe metode de reapelare a bean-ului creat i unele metode pentru a fi
distruge bean-ul.

Spring framework ofer mai multe interfee marker pentru a schimba comportamentul
bean-ului n container; ele includ InitializingBean i DisposableBean. Punerea n aplicare a
acestor interfee va face containerul s apeleze afterPropertiesSet () pentru prima i destroy (),
pentru a doua, pentru a permite beanului s efectueze anumite aciuni asupra ini ializrii i
distrugerii.
Ciclul de via al unui bean spring este uor de neles. Atunci cnd un bean este
instaniat, acesta poate fi obligat s efectueze o anumit iniializare pentru a-l aduce ntr-o stare
utilizabil. n mod similar, atunci cnd bean-ul nu mai este necesar i este scos din container,
poate fi necesar curarea.
Beans poate fi notificat dup creare i toate proprietile sunt setate i nainte ca
acestea s fie distruse i ndeprtate din containerul pentru beans. Acest lucru implic specificarea
metodei de reapelare care urmeaz s fie invocat de container. Acest lucru se face n XML prin
specificarea atributelor metoda-init = "myinit", pentru apel invers de iniializare, i metoda-
destroy = "mydestroy", pentru a distruge. "Myinit" i "cleanUp" sunt nume de metode de
exemplu, n clasa bean.
Apelarea de iniializare

Implementarea interfetei org.springframework.beans.factory.InitializingBean permite ca

un bean s efectueze iniializarea dup ce toate proprietile necesare sunt stabilite de ctre
container. Interfaa InitializingBean specific exact o singur metod: Interfaa
org.springframework.beans.factory.InitializingBean furnizeaz iniializarea:

Acum putem pune n aplicare interfaa de mai sus i de a face unele funcionalit i de
iniializare cu aceast metod. Ca mai jos:

n general, utilizarea interfeei InitializingBean poate fi evitat (i este descurajat din

moment ce cupleaz inutil codul de Spring). O definiie de bean ofer suport pentru o metod de
iniializare generic care urmeaz s fie specificat. n cazul metadatelor de configurare bazate pe
XML, acest lucru se face cu ajutorul atributului init-method.
Exemplu myInit:

Sau folosind adnotri din Java:

Apelarea de distrugere:

Implementarea interfetei org.springframework.beans.factory.DisposableBean permite

ca un bean s obin un apel invers atunci cnd recipientul care-l conine este distrus. Interfa a
DisposableBean specific o singur metod:

Acum putem pune n aplicare interfaa de mai sus i de a face unele distruge unele
funcionaliti cu aceast metod. Ca mai jos:

n general, utilizarea interfeei DisposableBean poate fi evitat (i este descurajat din moment ce
cupleaz inutil codul de Spring). O definiie de bean ofer suport pentru o metod generic de
distrugere care urmeaz s fie specificat. Atunci cnd se utilizeaz metadate de configurare
bazate pe XML, acest lucru se face prin intermediul atributului "destroy-method"

Sau folosind adnotri de Java:

 Se recomand s nu utilizai callback InitializingBean sau DisposableBean, deoarece
configurarea XML ofer mult mai mult flexibilitate n ceea ce privete metoda de denumire.

i acum un exemplu:

Triangle.java
Point.java

Urmtorul este fiierul de configurare Spring.xml pentru metodele de iniializare i de distrugere.

Spring.xml
Drawingapp.java

Rezultatul rulrii aplicaiei va fi cel de mai jos:

InitializingBean init method is called for Triangle
My init method is called for Triangle
PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)
DisposableBean destroy method is called for Triangle
cleanUp method is called for Triangle
16. Adnotri n Spring
Spring 2.0 a introdus suport pentru diferite adnotri n scopuri de configurare, cum ar fi
@Transactional, @Required i @PersistenceContext / @ PersistenceUnit. Spring 2.5 introduce
suport pentru un set complet de adnotri de configurare: @Autowired n combinaie cu suport
pentru JSR-250 adnotri @Resource, @PostConstruct i @PreDestroy.

ncepnd cu Spring 2.5 a devenit posibil configurarea injeciei de dependen, folosind

adnotri. Deci, n loc de a folosi XML pentru a descrie o legare a bean-ului, avei posibilitatea s
mutai configuraia de beans ntr-o clasa de componente n sine, prin utilizarea de adnotri pe
clas, metoda, sau declaraia de domeniu relevant.

Adnotarea se efectueaz nainte de injectarea prin XML, prin urmare, aceasta din urm
o va suprascrie pe prima pentru proprietile legate prin ambele abordri.

Legarea prin adnotare nu este pornit n spring container implicit. Aa c, nainte de a

putea folosi legarea bazat pe adnotare, vom avea nevoie s o activm n fiierul nostru de
configurare Spring. Aa c vom lua n considerare urmtorul fiier de configurare, n cazul n care
dorim s utilizm orice adnotare n aplicaia spring.

Acum, s explicm noile configuraii n fiierul de mai sus (spring.xml). Elementul

<context: annotation-config /> este folosit pentru a nregistra n mod automat toate post-
procesoarele Spring pentru configurarea bazat pe adnotare.

Element: annotation-config
Activeaz diverse adnotri pentru a fi detectate n clase beans: @Required i
@Autowired, precum i JSR 250 @PostConstruct, @PreDestroy i @Resource (dac este
disponibil), JAX-WS @WebServiceRef (dac este disponibil), @EJB EJB3 (dac este
disponibil) i JPA @PersistenceContext i @PersistenceUnit (dac este disponibil). Ca
alternativ, putei alege s activai BeanPostProcessors individuale pentru aceste adnotri.
S vedem cteva adnotri importante pentru a nelege modul n care acestea funcioneaz:
Adnotarea @Required:
Descriere: adnotarea @Required este utilizat pentru a specifica faptul c valoarea unei
proprieti a bean-ului este necesar pentru a fi injectat dependen a. Asta nseamn c, o eroare
este cauzat n cazul n care o valoare nu este specificat pentru proprietatea respectiv.

Adnotarea @Autowired:
Descriere: @Autowired pot fi folosite i pentru "dependen ele rezolvabile": interfaa
BeanFactory, interfaa ApplicationContext, interfaa ResourceLoader, interfaa
ApplicationEventPublisher i interfaa MessageSource.

Adnotarea @Qualifier:
Descriere: pot exista situaii cnd creai mai mult de un beans de acela i tip i dori i s
legai doar unul dintre ele cu o proprietate, n acest caz, putei utiliza adnotarea @Qualifier
mpreun cu @Autowired pentru a elimina confuzia prin specificarea exact a bean-ului ce va fi
legat.

Adnotarea @Aspect:
Descriere: pentru a utiliza aspecte @AspectJ ntr-o configuraie Spring trebuie s
activai suportul Spring pentru AOP bazat pe aspectele @AspectJ i autoproxying beans. Prin
autoproxying nelegem c dac Spring stabilete c un bean este recomandat de ctre unul sau
mai multe aspecte, aceasta va genera automat un proxy pentru acel bean pentru a intercepta
metoda invocri i s se asigure c este executat n funcie de necesiti.

Adnotrile JSR-250
int: metode setter i non setter
Descriere: Spring suport adnotri JSR-250 care includ @Resource, @PostConstruct i
@PreDestroy. JSR 250, ca o Java Specification Request, are obiectivul de a defini un set de
adnotri care abordeaz concepte semantice comune i, prin urmare, pot fi folosite de mai multe
componente de Java EE i Java SE. Acest lucru este de a evita adnotri redundante peste aceste
componente. JSR 250 a fost lansat pe data de 11 05 2006. Ca o configuraie bazat pe adnotare
declarativ este mai mult folosit n framework i aplicaii Java, de exemplu Spring face mai multe
componente ale framework-ului su configurabil prin intermediul adnotrilor, importana JSR
250 este probabil s creasc n viitor.

Adnotrile Stereotipe
int: Clase marcate cu adnotri stereotip
Descriere: Clasele marcate cu adnotri stereotip sunt candidati pentru auto-detecie de
Spring atunci cnd se utilizeaz configuraie bazat pe adnotare i scanare classpath.
Adnotarea @Component este stereotipul principal care indic faptul c o clas adnotat
este o "component".
 Adnotarea @Service este folosit pentru a decora clasa legate de punerea n aplicare a
serviciilor este o form specializat a adnotrii @Component.
Adnotarea @Repository este nc un alt stereotip, care a fost introdus n Spring 2.0. O
clas care servete n stratul de persistena cererii ca obiect de acces la date (DAO), altfel
cunoscut ca un depozit n alte tehnologii.
@Controller O component controler n stratul de prezentare a cererii, care se refer la
o aplicaie proiectat MVC.

17. @Autowired Annotation in Spring

n Spring, putem utiliza adnotare @Autowired pentru a lega bean prin metoda settera,
constructor sau un cmp. Mai mult, poate auto-lega proprieti ntr-un anumit bean.

@Autowired pe metoda Setter:

Avem posibilitatea s utilizm adnotare @Autowired pe metode setter pentru a obine
ref id al elementului <property> n fiierul de configurare XML (spring.xml). Atunci Spring
gsete o adnotare @Autowired utilizat cu metode setter, ncearc s efectueze byType
autowiring asupra metodei.

A se vedea exemplul urmtor pentru a demonstra utilizarea @Autowired.

Circle.java
Point.java

Spring.xml
Drawingapp.java

@Autowired pe Properties: Avem posibilitatea s utilizm adnotare @Autowired pe propriet i

pentru a obine ref id al metodei setter. Atunci cnd va trece valorile propriet ilor autowired
folosind Spring va atribui n mod automat acele proprieti cu valorile transmise sau referine.

Circle.java

@Autowired pe constructori: Putem aplica @Autowired constructorilor de asemenea. O adnotare

constructor @Autowired indic faptul c constructorul trebuie s fie autowired la crearea beans,
chiar i n cazul n care nu sunt utilizate <constructor-arg /> n timpul configurrii pentru beans n
fiierul XML.

Circle.java

@Autowired cu opiunea (necesar = fals):

n mod implicit, adnotarea @Autowired are dependena necesar, dar putem stabili dependen a
necesar cu fals ca mai jos:

Circle.java
18. Spring JSR-250 adnotri
Adnotri JSR-250 care includ @PostConstruct, @PreDestroy i adnotri @Resource.
JSR-250 adnotri sau adnotri comune pentru platforma Java au fost introduse ca parte a Java EE
5 i sunt folosite de obicei pentru adnotri EJB3.
@PostContruct - Aceast adnotare este aplicat la o metod pentru a indica faptul c trebuie
invocat dup ce injecia de dependena este complet.
@PreDestroy - Aceasta se aplic la o metod pentru a indica faptul c trebuie invocat nainte ca
bean-ul s fie scos din contextul Spring, adic exact nainte de a fi distrus.
@Resource - Aceasta dubleaz funcionalitatea @Autowired combinat cu @Qualifier i ve i
obine avantajul suplimentar de a fi capabil de a numi care bean este injectat, fr a fi nevoie de
dou adnotri.

Adnotarea @Resource:
int: clasa component, sau cmpuri sau metode ale clasei componente.
: adnotarea @Resource marcheaz o resurs necesar de aplicaie. Aceast adnotare
poate fi aplicat la o clas de componente aplicaii, sau cmpuri sau metode ale clasei
componente. Cnd adnotarea este aplicat la un cmp sau metod, containerul va injecta o
instan a resursei solicitate n componenta aplicaiei atunci cnd componenta este iniializat. n
cazul n care adnotarea este aplicat clasei componente, adnotarea declar o resurs pe care
aplicaia o va cuta n timpul rulrii.

Chiar dac aceast adnotare nu este marcat ca motenire, instrumentele de

implementare trebuie s examineze toate superclasele oricrei clase componente pentru a
descoperi toate utilizrile acestei adnotari n toate superclasele. Toate aceste cazuri de adnotare
specific resursele de care are nevoie componenta aplicaiei. Reinei c aceast adnotare poate
aprea pe cmpuri private i metode ale superclaselor; containerul trebuie s efectueze injecie i
n aceste cazuri.
@Resource ia un atribut de "name" i implicit Spring va interpreta aceast valoare ca
numele beanului care urmeaz s fie injectat.

n cazul n care nu este specificat un nume explicit, atunci numele implicit va fi derivat
din numele cmpului sau metoda setter: In cazul unui cmp, acesta va fi pur i simplu echivalent
cu numele cmpului; n cazul unei metode setter, acesta va fi echivalent cu numele propriet ii
bean-ului. Aa c exemplul urmtor va avea bean-ul cu numele "center" injectat n metoda setter:

i acum un exemplu:
Circle.java

Point.java
Spring.xml

Drawingapp.java

Adnotarea @PostContruct:
int: Metode ale clasei componente.
Descriere: Adnotarea @PostConstruct este utilizat pe o metod care trebuie s fie executat
dup ce se face injecia de dependen pentru a efectua orice iniializare. Aceast metod trebuie
s fie invocat n faa clasei este pus n funciune. Aceast adnotare trebuie s fie suportat pe
toate clasele care suport injectarea de dependena. Metoda adnotat cu @PostConstruct trebuie
s fie invocat chiar i n cazul n care clasa nu solicit resurse pentru ca s fie injectat. Doar o
singur metod poate fi adnotat cu aceast adnotare. Metoda pe care se aplic adnotare
@PostConstruct trebuie s ndeplineasc toate criteriile urmtoare - metoda nu trebuie s aib
parametri, cu excepia cazului interceptoarelor EJB, n cazul n care este nevoie de un obiect aa
cum Invocation Context definit prin caietul de sarcini EJB. - Tipul de retur al metodei trebuie s
fie nul. - Metoda nu trebuie s arunce o excepie verificat. - Metoda pe care se aplic
@PostConstruct pot fi publice, protejate, pachetul privat sau privat. - Metoda nu trebuie sa fie
static, cu excepia clientului aplicaiei. - Metoda poate fi definitiv. - n cazul n care metoda
arunc o excepie neverificat, clasa nu trebuie s fie pus n funciune, cu excep ia, n cazul n
care EJB-urile se pot ocupa de excepii i chiar se pot recupera.

Adnotarea @PreDestroy:
int: Metode ale clasei componente.
Descriere: Adnotarea @PreDestroy este utilizat pe metode ca o notificare de apel invers pentru a
semnala c instana este n curs de a fi ndeprtat de container. Metoda adnotat cu @PreDestroy
este de obicei folosit pentru a elibera resursele pe care le-a folosit. Aceast adnotare trebuie s
fie susinut de ctre toate obiectele container gestionate care accept @PostConstruct cu
excepia containerului client aplicaie n Java EE 5. Metoda pe care se aplic adnotare
@PreDestroy trebuie s ndeplineasc toate criteriile urmtoare - - Metoda nu trebuie s aib
parametri cu excepia cazului interceptoarelor EJB, n cazul n care este nevoie de un obiect
InvocationContext astfel cum este definit n specificaia EJB. - Tipul de retur al metodei trebuie
s fie nul. - Metoda nu trebuie s arunce o excep ie verificat. - Metoda pe care se aplic
PreDestroy pot fi publice, protejate, pachet privat sau privat. - Metoda nu trebuie s fie static. -
Metoda poate fi definitiv. - n cazul n care metoda arunc o excepie neverificat este ignorat,
cu excepia, n cazul n care EJB-urile se pot ocupa de excepii.
n cele ce urmeaz vom prezenta un exemplu pentru adnotrile @PostConstruct and
@PreDestroy n JSR-250 cu Spring:

Circle.java
Point.java

Drawingapp.java
 n mod implicit, Spring nu va fi contient de adnotare @PostConstruct i @PreDestroy.
Pentru a-l activa, trebuie s nregistrm "CommonAnnotationBeanPostProcessor" sau
specificm <context: / annotation-config/> n fiierul de configurare al bean (spring.xml).

Folosind CommonAnnotationBeanPostProcessor

Folosind <context:annotation-config />

19. Event Handling in Spring Tratarea evenimentelor n
Spring

Spring Framework furnizeaz, de asemenea, o alt caracteristic pentru a promova

cuplarea slab i aceasta este Application Event Handling. Cu ajutorul evenimentelor, un obiect
editor de evenimente poate comunica cu alte obiecte, fr mcar s tie ce obiect este asculttor i
asculttorul poate lucra fr s tie care obiect public evenimentele. Publisher publica
evenimentul sau apeleaz evenimentul i Listener ascult ntotdeauna evenimentele care apar.

Pentru a face un eveniment personalizat extinde clasa cu ApplicationEvent class.

ApplicationEventPublisher conine publishEvent (), metod care permite s publice
ApplicationEvents (Evenimentele personalizate). Oricare ApplicationListener, care este
nregistrat cu metoda onApplicationEvent () n aplicaie, ascult evenimentele.

Pentru a nelege mai bine Tratarea Evenimentelor s ilustrm cu un exemplu simplu:

Circle.java
Point.java

MyEventListener.java

DrawEvent.java
Spring.xml

Drawingapp.java

Dup rularea cu succes a aplicaiei vom obine rezultatul:

Circle is Drawn
Draw event occurred
20. Spring JDBC Framework

In acest cele ce urmeaz vom discuta despre JDBC Framework Spring. n vechiul
JDBC API, cnd lucrm cu baza de date utiliznd framework-ul JDBC vechi, atunci trebuie s
avem grij de o mulime de responsabiliti sau devine greoi s scriem cod inutil care s se ocupe
de excepii, de deschidere i nchidere a conexiunilor bazei de date, etc. Spring JDBC Framework
are grij de toate detaliile de nivel de baz pornind de la deschiderea conexiunii, s pregteasc i
s execute instruciunea SQL, excepiile de proces, tratarea tranzaciilor i n cele din urm
nchide conexiunea.
Deci, ce avem fcut este doar s definim parametrii de conexiune i specificm
instruciunea SQL care urmeaz s fie executate i de a face munca necesar pentru fiecare
iteraie n timp ce preia datele din baza de date.
Spring ofer template-uri JDBC pentru a accesa datele din baza de date cu uurin .
Spring prevede org.springframework.jdbc.core.JdbcTemplate care preia atribuiile de stabilire a
conexiunii la baza de date.

Spring JDBC Frramework prevede mai multe abordri i n mod corespunztor, clase
diferite pentru interfaa cu baza de date.

Ierarhia pachetului (package hierarchy)

Spring Framework JDBC este format din patru pachete diferite, i anume core,
dataSource, object i support.

Pachetul org.springframework.jdbc.core conine clasa JdbcTemplate i diferitele sale

interfee de apel, plus o varietate de clase nrudite.

Pachetul org.springframework.jdbc.datasource conine o clas de utilitate pentru un

acces facil la DataSource, precum i diverse implementri DataSource simple, care pot fi
utilizate pentru testarea i rularea codului JDBC nemodificat n afara unui container J2EE. Clasa
de utilitate ofer metode statice pentru a obine conexiuni de la JNDI i pentru a nchide
conexiunile, dac este necesar. Acesta are suport pentru conexiunile legate thread, de ex pentru a
fi utilizate cu DataSourceTransactionManager.

n continuare, pachetul org.springframework.jdbc.object conine clase care reprezint

interogri RDBMS, actualizri i proceduri stocate, obiecte reutilizabile. Aceast abordare este
modelat de JDO, dei, desigur, obiectele returnate de interogri sunt "deconectate" de la baza de
date. Acest nivel mai ridicat de abstracie JDBC depinde de abstracia de nivel inferior n
pachetul org.springframework.jdbc.core.

n cele din urm, pachetul org.springframework.jdbc.support este locul unde gsii

funcionalitatea SQLException i unele clase de utilitate. Excepiile aruncate n timpul procesrii
JDBC sunt traduse n excepii definite n pachetul org.springframework.dao. Acest lucru
nseamn c, folosind codul de abstractizare Spring JDBC nu are nevoie s implementeze JDBC
sau RDBMS error handling specifice. Toate excepiile traduse nu sunt verificate, oferindu-v
posibilitatea de capturare a excepiilor pe care le pot recupera, permi nd n acela i timp ca i alte
excepii s fie propagate apelantului.

JdbcTemplate

Clasa JdbcTemplate este clasa central n pachetul de baz JDBC. Aceasta simplific
utilizarea JDBC, deoarece ea se ocup de crearea i eliberarea de resurse. Acest lucru ajut pentru
a evita erorile comune, cum ar fi uitarea de a nchide ntotdeauna conexiunea. Execut fluxul de
lucru JDBC de baz cum ar fi crearea de declaraii i de execuie, lsnd codul de aplicaie pentru
a furniza SQL i a extrage rezultatele. Aceast clas execut interogri SQL, instruc iunile de
actualizare sau apelurile de proceduri stocate, imitnd iterarea peste ResultSet i extragerea
valorilor parametrilor returnai. De asemenea, ea prinde excepii JDBC i le traduce n genericele
i mai informative excepii, definite n pachetul org.springframework.dao.

Codul folosind JdbcTemplate are nevoie doar pentru a pune n aplicare interfee de apel,
oferindu-le un contract clar definit. Interfaa de apel PreparedStatementCreator creeaz o
declaraie pregtit pentru o anumit conexiune prevzut de aceast clas, oferind SQL i orice
parametri
necesari.
Acelai lucru este valabil i pentru interfaa CallableStatementCreator care creeaz
declaraii apelabile. Interfaa RowCallbackHandler extrage valorile din fiecare rnd al unui
ResultSet.

JdbcTemplate poate fi utilizat ntr-o punere n aplicare DAO prin instanierea direct cu
o referin DataSource, sau poate fi configurat ntr-un container Spring IoC i dat DAO ca o
referin de bean.
Not: DataSource trebuie s fie ntotdeauna configurat ca un bean n containerul Spring
IoC, n primul caz dat serviciul direct, n al doilea caz la template-ul pregtit.
Not: Instanele clasei JdbcTemplate sunt threadsafe o dat configurate. Astfel nct s
putei configura o singur instan a unui JdbcTemplate i apoi se poate injecta n siguran
aceast referin partajat n mai multe DAO.

NamedParameterJdbcTemplate - mpacheteaz un JdbcTemplate pentru a oferi parametri

numii n locul "?" din JDBC. Aceast abordare ofer o mai bun documentare i u urin a de
utilizare, atunci cnd avei mai muli parametri pentru o instruc iune SQL.
NamedParameterJdbcTemplate ofer abordare mai bun dect JdbcTemplate, n cazul n care mai
muli parametri sunt utilizai pentru o instruciune SQL. Ea a eliminat nevoia de "?" din JDBC
tradiionale i s furnizeaz parametrii numii. Este uor de utilizat i ofer o mai bun
documentaie. Funcionalitatea este similar cu JdbcTemplate cu excepia faptului c include
parametri numii n loc de "?".
n JdbcTemplate, parametrii SQL sunt reprezentai printr-un simbol placeholder "?" i
se leag prin poziie. Problema este de fiecare dat cnd ordinea de parametrului este schimbat,
trebuie s modificai i parametrii de legtur, lucru care este predispus la erori i este dificil
meninut.
Parametrii numii sunt suportai doar n SimpleJdbcTemplate i
NamedParameterJdbcTemplate.

Mai jos vom vedea un exemplu pentru cele prezentate:

Empdao.java
EmployeeDaompl.java
EmployeeMapper.java
Spring.xml

SimpleJdbcTemplate - combin cele mai frecvent utilizate operaiuni de JdbcTemplate i

NamedParameterJdbcTemplate. SimpleJdbcTemplate are toate caracteristicile vechi ale
JdbcTemplate i suport, de asemenea, unele caracteristici ale Java 5, varargs i autoboxing. Este
cel mai potrivit atunci cnd nu avei nevoie de a accesa toate caracteristicile JdbcTemplate.
Acesta are un API mai simplu construit pentru a sprijini Java 5. De aceea are mai multe metode
de a exploata varargs.
Metoda getJdbcOperations() este folosit pentru a accesa acele metode care sunt
definite n JdbcTemplate. Trebuie s apelezi aceste metode pe SimpleJdbcTemplate.
Iat cteva exemple pentru a arta cum se utilizeaz interogarea SimpleJdbcTemplate (),
metode pentru a interoga sau de a extrage date din baza de date.
Not: SimpleJdbcTemplate nu este un nlocuitor pentru JdbcTemplate, este doar un
supliment de-java5.

Not: Clasa SimpleJdbcTemplate ofer doar un subset al metodelor expuse pe clasa

JdbcTemplate. Dac avei nevoie s utilizai o metod de JdbcTemplate care nu este definit pe
SimpleJdbcTemplate, putei accesa ntotdeauna JdbcTemplate care stau la baza prin apelarea
getJdbcOperations(), metoda pe SimpleJdbcTemplate, care apoi v permite s invoce metoda pe
care dorii. Singurul dezavantaj este faptul c metodele pe interfaa JdbcOperations nu sunt
generice.

Stil JdbcTemplate:

Stil SimpleJdbcTemplate:
SimpleJdbcInsert i SimpleJdbcCall

SimpleJdbcInsert i SimpleJdbcCall optimizeaz metadatele bazei de date pentru a

limita cantitatea de configurare necesar. Aceast abordare simplific codificarea, astfel nct
trebuie doar s furnizm numele tabelului sau a procedurii i o hart a parametrilor de potrivire a
numelor coloanelor. Aceasta funcioneaz numai n cazul n care baza de date furnizeaz
metadate corespunztoare. n cazul n care baza de date nu furnizeaz aceste metadate, va trebui
s asigurm configurarea explicit a parametrilor.

RDBMS Objects inclusiv MappingSqlQuery, SqlUpdate i StoredProcedure v cere s

creai obiecte reutilizabile i obiecte thread-safe n timpul iniializrii stratului de acces la date.
Aceast abordare este modelat dup JDO Query n care ai defini irul de interogare, s declare
parametrii i compila interogarea. Odat ce ai fcut acest lucru, metodele de execu ie pot fi
apelate de mai multe ori cu diferite valori ale parametrilor.

Configurarea DataSource

Spring obine o conexiune la baza de date printr-o DataSource. O sursa de date este o
parte din specificaiile JDBC i este o fabric de conexiune generalizat. Acesta permite unui
container sau a unui framework s ascund problemele de punere n comun de conectare i de
gestionare a tranzaciei din codul aplicaiei. Ca dezvoltator, nu avei nevoie s ti i detalii despre
modul n care se conecteaz la baza de date; aceasta este responsabilitatea administratorului care
stabilete DataSource. Cel mai probabil avei ambele roluri pe msur ce se dezvolt aplica ia i
se testeaz, dar nu trebuie neaprat s tii cum este configurat sursa de date de producie.

Atunci cnd se utilizeaz stratul JDBC Spring, obinei o surs de date de la JNDI sau
v configurai conexiune furnizat de ctre o ter parte. Implementrile populare sunt Apache
Jakarta Commons DBCP i C3P0. Implementrile n distribuia Spring sunt destinate numai
pentru scopuri de testare i nu ofer punerea n comun.
Acum, s vedem cum crem un tabel Employee n baza de date DAVDB. Presupunem
c lucrai cu baza de date MySQL, n cazul n care lucrai cu orice alt baz de date, atunci pute i
schimba DDL i interogrile SQL n mod corespunztor.
 Acum avem nevoie de a furniza o DataSource la JdbcTemplate astfel nct s se poate
configura pentru a obine acces la baze de date. Aici este un exemplu de modul n care se
configureaz un DriverManagerDataSource n cod Java.

i configuraia xml corespunztoare:

Urmtoarele exemple arat conectivitatea de baz i configuraia pentru DBCP i C3P0:

DBCP configurare:

C3P0 configurare:

Data Access Object (DAO)

DAO s-ar traduce prin obiect de acces la date, care este frecvent utilizat pentru
interaciunea bazei de date. DAO exist pentru a furniza un mijloc de a citi i a scrie date la baza
de date i acestea ar trebui s expun aceast funcionalitate printr-o interfa prin care restul
aplicaiei le va accesa.

Suportul DAO n Spring va face uor modul de a lucra cu tehnologii de acces la date,
cum ar fi JDBC, Hibernate, JPA sau JDO ntr-un mod coerent.

DataSourceUtils: Clasa DataSourceUtils este o clas de ajutor convenabil i puternic, care

ofer metode statice pentru a obine conexiuni de la JNDI i legturi strnse dac este necesar.
Suport conexiuni thread-bound cu, de exemplu, DataSourceTransactionManager.
SmartDataSource: Interfaa SmartDataSource ar trebui s fie pus n aplicare de clase care pot
oferi o conexiune la o baz de date relaional. Acesta extinde interfaa DataSource pentru a
permite claselor care o folosesc pentru a interoga dac conexiunea ar trebui s fie nchis dup o
anumit operaiune. Aceast utilizare este eficient atunci cnd tii c vei reutiliza o conexiune.

AbstractDataSource: este o clasa abstracta de baza pentru implementari Spring DataSource,

care pune n aplicare codul care este comun pentru toate implementrile DataSource. Extinde i
clasa AbstractDataSource dac scriei propria implementare DataSource.

SingleConnectionDataSource: Clasa SingleConnectionDataSource este o implementare a

interfeei SmartDataSource care nfoar o singur conexiune care nu este nchis dup fiecare
utilizare. Evident, acest lucru nu este capabil de multi-threading. n cazul n care orice cod client
solicit aproape n ipoteza unei conexiuni grupat, ca atunci cnd se utilizeaz instrumente
persistena, setai proprietatea suppressClose la true. Aceast setare returneaz un proxy close-
suppressing pentru conexiunea fizic. Fii contieni de faptul c nu va mai putea face acest lucru
ntr-o conexiune nativ Oracle sau altele asemenea.

Aceasta este n primul rnd o clas de test. De exemplu, acesta permite testarea u oar a codului
n afara unui server de aplicaii, mpreun cu un mediu JNDI simplu. Spre deosebire de
DriverManagerDataSource, se reutilizeaz aceeai conexiune tot timpul, evitnd crearea de
excesiv a conexiunilor fizice.

DriverManagerDataSource: Clasa DriverManagerDataSource este o implementare a interfeei

DataSource standard care configureaz un driver simplu JDBC prin proprietile beans-ului i
returneaz o nou conexiune de fiecare dat.

Aceast implementare este util pentru testare i medii stand-alone n afara unui container Java
EE, fie ca un bean DataSource ntr-un container Spring IOC, sau n combinaie cu un mediu JNDI
simplu. Apelul Connection.close() va nchide pur i simplu conexiunea, astfel nct orice cod de
persistenta DataSource ar trebui s funcioneze. Cu toate acestea, folosind pool-uri de conectare
de tip JavaBean, cum ar fi commons-dbcp este att de uor, chiar i ntr-un mediu de test, c este
aproape ntotdeauna de preferat s se foloseasc o astfel de conexiune peste
DriverManagerDataSource.
DataSourceTransactionManager: Clasa DataSourceTransactionManager este o implementare
PlatformTransactionManager pentru un singur datasources JDBC. Acesta leag o conexiune
JDBC de la sursa de date specificat la firul de executare n prezent, poten ial pentru a permite o
conexiune pentru fiecare surs de date.

Codul de aplicaie este necesar pentru a prelua conexiunea JDBC prin

DataSourceUtils.getConnection (DataSource) n loc de DataSource.getConnection din standardul
Java EE. Ea arunc excepii org.springframework.dao n loc de SQLException. Toate clasele
framework, cum ar fi JdbcTemplate folosesc aceast strategie implicit. n cazul n care nu este
utilizat cu acest manager de tranzacii, strategia de cutare se comport exact ca cea comun -
poate fi astfel utilizat n orice caz.

Clasa DataSourceTransactionManager accept niveluri de izolare personalizate i timeout-uri

care se aplic cnd declaraiile JDBC corespunztoare timeouts. Pentru a sprijini aceasta din
urm, n codul de aplicaie trebuie s utilizai JdbcTemplate sau apelai metoda
DataSourceUtils.applyTransactionTimeout () pentru fiecare statement creat.

Aceast implementare poate fi folosit n loc de JtaTransactionManager n caz unic de resurse,

deoarece nu are nevoie de container pentru a sprijini JTA. Comutarea ntre ambele este doar o
chestiune de configurare, n cazul n care rmnem la modelul de cutare de conexiune necesar.
JTA nu accept niveluri de izolare personalizat!

21. Spring Transaction Management

Un manager de tranzacie este acea parte a unei cereri, care este responsabil pentru
coordonarea tranzaciilor peste una sau mai multe resurse. n Spring, managerul de tranzacie este
efectiv rdcina sistemului de tranzacii. Prin urmare, dac dorii s activai tranzac iile unei
componente n Spring, creai de obicei un beans manager de tranzacie i trece-l la component.
 Managementul de gestionare a tranzaciei este esenial n orice form de aplicaii care
vor interaciona cu baza de date.
O tranzacie n baz de date este o secven de aciuni, care sunt tratate ca o singur
unitate de lucru. Aceste aciuni ar trebui s fie completate n totalitate sau s nu aib niciun efect.
Transaction Management este o parte important a RDBMS orientate spre aplicatii enterprise
pentru a asigura integritatea i coerena datelor. Conceptul de tranzacie poate fi descris cu
urmtoarele patru proprieti eseniale descrise ca ACID:
Atomicitate: O tranzacie trebuie s fie tratat ca o singur unitate de operare, ceea ce
nseamn c fie ntreaga secven de operaii se realizeaz cu succes sau nereuit.
Consisten: Aceasta reprezint coerena integritii refereniale a bazei de date, cheile
primare unice n tabele, etc.
Izolarea: Pot exista mai multe tranzacii de prelucrare cu aceleai date stabilite n acela i
timp, fiecare tranzacie ar trebui s fie izolate de alte persoane pentru a preveni coruperea
datelor.
Durabilitate: Odat ce o tranzacie s-a finalizat, rezultatele acestei tranzac ii trebuie s fie
permanente i nu pot fi terse din baza de date din cauza defectrii sistemului.

O tranzacie simpl este de obicei emis pentru sistemul de baze de date ntr-un limbaj
cum ar fi SQL n aceast form:
1. ncepe tranzacia
2. Executa mai multe interogri (dei orice actualizri ale bazei de date nu sunt de fapt
vizibile pentru lumea exterioar nc)
3. Se angajeaz tranzacia (actualizri devin vizibile n cazul n care tranzacia este de
succes)

Spring framework ofer un strat abstract pe partea de sus a diferitelor API-uri care stau
la baza de management al tranzaciei. Suportul Spring pentru tranzacie i propune s ofere o
alternativ la tranzaciile EJB prin adugarea de capabiliti de tranzacionare la POJOs. Spring
susine att managementul programatic ct i cel declarativ al tranzac iei. EJBs necesit un server
de aplicaii, dar gestiunea tranzaciilor n Spring poate fi pus n aplicare fr a fi nevoie de
server de aplicaii.

Managerii de tranzacii locali: Un manager de tranzacie local este un manager de tranzacii

care poate coordona tranzaciile peste doar o singur resurs. n acest caz, punerea n aplicare a
managerului de tranzacii este de obicei ncorporat n resursa n sine, iar managerul de tranzac ie
Spring este doar un nveli subire n jurul acestui manager de tranzacii built-in.

Managementul tranzaciei locale poate fi util ntr-un mediu de calcul centralizat, n cazul n care
componentele i resursele aplicaiei sunt localizate ntr-un singur site, iar gestiunea tranzaciilor
implic doar un manager de date locale care ruleaz pe o singur main. operaiunile locale sunt
mai uor de pus n aplicare.

Manageri de tranzacii globali: Un manager de tranzacii la nivel global este un manager de

tranzacii care poate coordona tranzaciile pe mai multe resurse. n acest caz, nu te po i baza pe
managerul de tranzacie construit n resursa n sine. n schimb, avei nevoie de un sistem extern,
denumit uneori un monitor de procesare a tranzaciilor (monitor TP), care este capabil de a
coordona tranzacii n diferite resurse.

Managementul tranzaciilor la nivel global este necesar ntr-un mediu de calcul distribuit n
cazul n care toate resursele sunt distribuite pe mai multe sisteme. ntr-o astfel de tranzac ie de
gestionare de caz trebuie s se realizeze att la nivel local ct i la nivel global. O tranzac ie
global distribuit este executat pe mai multe sisteme, iar executarea acestuia necesit o
coordonare ntre sistemul de management al tranzaciei la nivel global i toi managerii de date
locale ale tuturor sistemelor implicate.

Spring susine dou tipuri de managemnt de tranzacie:

Management de tranzacie programatic : Acest lucru nseamn c trebuie s gestionai

tranzacia cu ajutorul programrii. V ofer o flexibilitate extrem, dar este dificil s se meninut.

Management de tranzacie declarativ: Aceasta nseamn c separa gestionarea tranzaciei de

codu. Utilizai numai adnotri sau configurare bazat pe XML pentru a gestiona tranzaciile.
Managementul tranzaciilor declarativ este de preferat peste managementul tranzaciilor
programatic, dei este mai puin flexibil dect cel programatic, care v permite s controla i
tranzaciile prin cod. Managementul tranzaciilor declarativ poate fi modularizat cu abordarea
AOP. Spring susine gestiunea tranzaciilor declarativ prin Spring AOP Framework.

Management de tranzacie programatic

Acest lucru nseamn c vom gestiona tranzacia cu ajutorul programrii, care ne ofer
o flexibilitate extrem, dar este dificil s se menin. Acest tip de gestionare a tranzac iei este de
obicei o idee bun doar dac avei un numr mic de operaii de tranzacie. De exemplu, dac avei
o aplicaie web care necesit operaiuni numai pentru anumite operaiuni de actualizare, este
posibil s nu dorii s configurai proxy-uri de tranzac ie folosind Spring sau orice alt
tehnologie. n acest caz, folosind TransactionTemplate poate fi o bun abordare. Fiind capabil de
a seta numele de tranzacie explicit este, de asemenea, ceva ce se poate face numai folosind
abordarea programatic a gestionrii tranzaciei.
Pe de alt parte, n cazul n care aplicaia are numeroase operaiuni de tranzac ionare,
gestiunea tranzaciilor declarativ este, de obicei, cea care merit s fie folosit. Atunci cnd se
utilizeaz Spring, mai degrab dect EJB CMT, costul de configurare al gestionrii tranzaciei
declarative este redus foarte mult.
S vedem un exemplu, dar nainte de a ncepe, este important s avem cel pu in o tabel
a bazei de date pe care s putem efectua diverse operaii CRUD cu ajutorul tranzac iilor. S lum
tabela Employee, care pot fi creat n baza de date MySQL DAVDB cu urmtoarea DDL:
EmpDAO.java
EmployeeDaoImpl.java
Employee.java
EmployeeMapper.java

EmpMainApp.java
Spring.xml

La rularea aplicaiei rezultatul va fi urmtorul:

Created Record Name = Raaz Age = 25 Salary = 50000

Management de tranzacie declarativ:

Managementul tranzaciilor declarativ este cea mai comun de implementare a Spring, deoarece
are cel mai mic impact asupra codului de aplicaie. Abordarea declarativ XML configureaz
atributele tranzaciei ntr-un fiier de bean de configurare. Gestiunea tranzaciilor declarativ n
Spring are avantajul de a fi mai puin invaziv. Nu este nevoie de a schimba codul aplicaiei
atunci cnd se utilizeaz tranzacii declarative. Tot ce trebuie s facei este de a modifica
contextul aplicaiei.
Abordarea declarativ de management al tranzaciei v permite s gestiona i tranzacia cu
ajutorul configuraiei n loc de a o codifica n codul surs. Utilizai numai adnotri sau
configurare bazat pe XML pentru a gestiona tranzaciile. Configura ia bean-ului va specifica
metodele de tranzacie.

Manageri de resurse, cum ar fi bazele de date relaionale furnizeaz un manager de tranzacii i

un API pentru a controla tranzaciile. Cei familiariza i cu JDBC vor ti c n mod implicit o
tranzacie este pornit din cauza stabilirii autocommit = true. Fiecare declaraie care modific
baza de date se angajeaz n mod automat. Acest comportament poate fi modificat prin setarea
autocommit la false. Acum programatorul trebuie s nceap n mod explicit o tranzac ie i apoi
commita sau derula napoi tranzacia.
n cele ce urmeaz, vom discuta cu un exemplu, de gestiunea tranzaciilor declarative cu
Spring.
S adugm suport de tranzacii pentru EmpDAOImpl.java. Aceast clas are metoda
createEmployee(), care creeaz un angajat n baza de date. S modificm metoda pu in pentru a
arunca o RuntimeException dup inseria n baza de date. Se adaug excep ia de runtime pentru a
pretinde c a aprut o eroare n timpul actualizrii bazei de date.

n aceast metod, ai atepta ca inseria s fie angajat la baza de date? Rspunsul este
da, dei acest lucru nu este comportamentul dorit. Comportamentul implicit al JDBC este
autocommit = true, ceea ce nseamn c, fiecare inserie sau actualizare este efectuat imediat. Ai
putea seta autocommit = false i explicit comitarea sau derularea napoi la sfritul metodei. Dar
este mult mai uor s lsai containerul se ocupe de acest lucru.
Pentru a aduga gestiunea tranzaciilor declarative la metoda de mai sus utilizai
urmtorii pai:

Pasul 1: Definirea unui manager de tranzacii n spring.xml

Pasul 2: Activai suport pentru adnotri de tranzacie n spring.xml

Pasul 3: Adugai adnotarea @Transactional la metoda createEmployee:

Conceptual, apelarea unei metode pe un proxy tranzacional arat n acest fel:

 S vedem acum un exemplu, dar nainte de a ncepe, este important s avem cel pu in o
tabel a bazei de date pe care s putem efectua diverse operaii CRUD cu ajutorul tranzaciilor. S
lum tabela Employee, care pot fi creat n baza de date MySQL DAVDB cu urmtoarea DDL:

EmpDAO.java
EmployeeDaoImpl.java
Employee.java
EmployeeMapper.java
EmpMainApp.java

Spring.xml
22. Folosirea Hibernate cu Spring

Hibernate este o tehnologie puternic pentru persistena datelor n orice tip de aplicaie.
Spring, pe de alt parte, este un cadru de injec ie de dependen care suport IoC. Frumuse ea
Spring este c se poate integra bine cu cele mai multe dintre tehnologiile cele mai populare.

Spring si Hibernate: ca o condiie prealabil, s nelegem necesitatea unei astfel de integrri

nainte de a intra efectiv n integrarea dintre aceste dou tehnologii. Este bine cunoscut faptul c
Hibernate este un instrument puternic ORM care se afl ntre aplica ii i baze de date. Aceasta
permite aplicaiei s acceseze date din orice baz de date ntr-o manier independent de
platform. Nu este nevoie ca aplicaia s depind de detaliile JDBC de nivel baz, cum ar fi
gestionarea conexiunii, declaraii i seturi de rezultate. Toate detaliile necesare pentru accesarea
unei anumite surse de date este uor configurabil n fiiere xml. Un alt lucru bun este c
Hibernare poate fi cuplat bine cu aplicaii J2SE i aplicaii J2EE.

Una dintre problemele folosirii Hibernate este c aplicaia client care acceseaz baza de date
folosind Hibernate trebuie s depind de API-uri Hibernate, cum ar fi Configuration,
SessionFactory i Session. Aceste obiecte vor continua s fie mprtiate n codul aplicaiei. Mai
mult dect att, codul aplicaiei trebuie s menin manual i s gestioneze aceste obiecte. n
cazul Spring, obiectele pot fi extrem de configurabile cu ajutorul IoC Container. Starea unui
obiect poate fi externalizat din codul de aplicaiei. Aceasta nseamn c acum este posibil s se
utilizeze obiectele Hibernate ca Spring Beans i se pot bucura de toate facilit ile pe care le ofer
Spring.

Folosirea fiierului de mapare Hibernate cu Spring:

1. Crearea de bazei de date i a tabelei (Employee)
2. Crearea clasei Employee (Employee.java)
3. Crearea unui fiier de mapare Hibernate pentru tabela Employee (Employee.hbm.xml)
4. Crearea fiierului de configurare Spring (spring.xml)
5. Crearea de clasei DAO (EmployeeDao.java)
 6. Crearea de clasei de aplicaie pentru folosirea lor.

Putem folosi, de asemenea, adnotarea cu urmtorii pai.

1. Crearea de bazei de date i a tabelei (Employee)
2. Crearea de clasei Employee cu ajutorul adnotrii @Entity (Employee.java)
3. Crearea fiierului de configurare Spring (spring.xml), crearea bean-ului cu ajutorul
adnotarii
4. Crearea clasei DAO (EmployeeDao.java)
5. Crearea de clasei de aplicaie pentru folosirea lor.

i acum s vedem exemplul:

1. Crearea de bazei de date i a tabelei (Employee)

2. Crearea clasei Employee (Employee.java)

3. Crearea fiierului de configurare Spring (spring.xml)
4. Crearea de clasei DAO (EmployeeDao.java)
SuperHibernateDaoSupport.java

EmployeeDaoImpl.java
5. Crearea de clasei de aplicaie

Cu rezultatul rulrii aplicaiei:

log4j:WARN No appenders could be found for logger

(org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
------Records Creation--------
Hibernate: insert into Employee (AGE, NAME, SALARY) values (?, ?, ?)
------Listing Multiple Records--------
Hibernate: select employee0_.EMPID as EMPID0_, employee0_.AGE as AGE0_, employee0_.NAME as
NAME0_, employee0_.SALARY as SALARY0_ from Employee employee0_
EMPLOYEE{empid- 1 name- Dinesh age- 25 salary- 50000}EMPLOYEE{empid- 2 name- Anamika age-
20 salary- 30000}EMPLOYEE{empid- 3 name- Nimmo age- 24 salary- 30020}EMPLOYEE{empid- 4
name- Adesh age- 24 salary- 30011}EMPLOYEE{empid- 5 name- Vinesh age- 22 salary-
20011}EMPLOYEE{empid- 6 name- Rajesh age- 25 salary- 50000}EMPLOYEE{empid- 7 name- DAV
age- 21 salary- 50000}
------find one Records--------
Hibernate: select employee0_.EMPID as EMPID0_0_, employee0_.AGE as AGE0_0_,
employee0_.NAME as NAME0_0_, employee0_.SALARY as SALARY0_0_ from Employee
employee0_ where employee0_.EMPID=?
EMPLOYEE{empid- 3 name- Nimmo age- 24 salary- 30020}
------Delete one Records--------
Hibernate: delete from Employee where EMPID=?