Spring Framework / 8. časť: Efektívna tvorba javových (nielen) webových aplikácií

Správ­ca en­tít

Správ­ca en­tít (En­ti­ty­Ma­na­ger, poz­ri pred­chá­dza­jú­cu časť) je trie­da, kto­rá má za úlo­hu pos­ky­to­vať pre jed­not­li­vé ob­jek­ty DAO me­tó­dy na sprá­vu kon­krét­nych en­tít, ako je ich se­ria­li­zá­cia či vy­hľa­dá­va­nie. Pri pou­ži­tí oby­čaj­né­ho JPA má­me k dis­po­zí­cii dva spô­so­by na vy­tvá­ra­nie správ­cov en­tít:

1. Lo­ca­lEn­ti­ty­Ma­na­ger­Fac­to­ry­Bean - jed­no­duch­šia ver­zia to­vár­ne pre in­štan­cie správ­cov en­tít, ži­vot­ný cyk­lus je kon­tro­lo­va­ný ap­li­ká­ciou. Je vhod­ná v jed­no­du­chých im­ple­men­tá­ciách, väč­ši­nou fun­gu­jú­cich ako stan­da­lo­ne ap­li­ká­cie.

Lo­cal­Con­tai­ne­rEn­ti­ty­Ma­na­ger­Fac­to­ry­Bean - tá­to to­vá­reň je vhod­nej­šia na kom­plexnej­šie ap­li­ká­cie, pre­to­že pos­ky­tu­je pl­nú pod­po­ru vlas­tnos­tí JPA. Ži­vot­ný cyk­lus je kon­tro­lo­va­ný kon­taj­ne­rom a pa­ra­met­re pos­ky­tu­jú flexibil­né mož­nos­ti ini­cia­li­zá­cie da­ta­bá­zo­vé­ho spo­je­nia vrá­ta­ne mož­nos­ti zís­ka­nia spo­je­nia zo zdro­ja JNDI.

Obe ver­zie správ­cov ma­jú spo­loč­né­ho pred­ka, a tak ich pou­ži­tie je pre Spring tran­spa­ren­tné.

V prí­pa­de pou­ži­tia pr­vej, jed­no­duch­šej ver­zie správ­cu en­tít tre­ba pri­dať do náš­ho kon­fi­gu­rač­né­ho sú­bo­ru con­text.xml nas­le­du­jú­ci bean:

<bean id="en­ti­ty­Ma­na­ger­Fac­to­ry"
 class="org.springfra­mework.orm.jpa.
Lo­ca­lEn­ti­ty­Ma­na­ger­Fac­to­ry­Bean">
 <pro­per­ty na­me="per­sis­ten­ceU­nit­Na­me" va­lue="per­sis­ten­ceU­nit"/>
</bean>

Pri tak­to vy­tvá­ra­ných in­štan­ciách správ­cov en­tít je pot­reb­né, aby bol k dis­po­zí­cii sú­bor per­sis­ten­ce.xml (oby­čaj­ne umies­tne­ný v ad­re­sá­ri ME­TA-INF). Ten­to sú­bor ob­sa­hu­je per­zis­ten­čnú jed­not­ku (per­sis­ten­ce unit), kto­rá ob­sa­hu­je in­for­má­cie o en­ti­tách. For­mát sú­bo­ru mô­že vy­ze­rať tak­to:

<?xml ver­sion="1.0" en­co­ding="UTF-8" ?>
<per­sis­ten­ce xmlns="http://ja­va.sun.com/xml/ns/per­sis­ten­ce"
 xmlns:xsi="http://www.w3.org/2001/XML­Sche­ma-in­stan­ce"
 xsi:sche­ma­Lo­ca­tion="http://ja­va.sun.com/xml/ns/per­sis­ten­ce
 http://ja­va.sun.com/xml/ns/per­sis­ten­ce/per­sis­ten­ce_1_0.xsd" ver­sion="1.0">

 <per­sis­ten­ce-unit na­me="per­sis­ten­ceU­nit">
 <class>Mo­vie</class>
 <pro­per­ties>
 <pro­per­ty na­me="ja­vax.per­sis­ten­ce.jdbc.url"
 va­lue="jdbc://lo­cal­host/dbna­me"/>
 <pro­per­ty na­me="ja­vax.per­sis­ten­ce.jdbc.user" va­lue="ad­min"/>
 <pro­per­ty na­me="ja­vax.per­sis­ten­ce.jdbc.password" va­lue="ad­min"/>
 </pro­per­ties>
 </per­sis­ten­ce-unit>
</per­sis­ten­ce>

Ako vi­dí­me, per­zis­ten­čná jed­not­ka ne­sie aj in­for­má­ciu o pri­po­je­ní k da­ta­bá­ze (na­kon­fi­gu­ro­va­nej po­mo­cou JDBC URL). Ta­kis­to ob­sa­hu­je zoz­nam tried ano­to­va­ných ako en­ti­ty. V na­šom prí­pa­de te­da ide o je­di­nú trie­du Mo­vie. V prí­pa­de vy­tvo­re­nia no­vej en­ti­ty sta­čí pri­dať no­vý ria­dok do toh­to sú­bo­ru.

Rov­na­ko je dô­le­ži­té de­fi­no­vať ná­zov per­zis­ten­čnej jed­not­ky, pre­to­že pros­tred­níc­tvom ne­ho je tá po­tom iden­ti­fi­ko­va­ná pri ini­cia­li­zá­cii to­vár­ne pre správ­cov en­tít v sú­bo­re con­text.xml.

Dru­há mož­nosť je pou­ži­tie to­vár­ne spra­vo­va­nej kon­taj­ne­rom. V ta­kom prí­pa­de by sme pri­da­li do náš­ho sú­bo­ru con­text.xml nas­le­du­jú­ci zá­znam:

<bean id="da­ta­sour­ce"
 class="org.springfra­mework.jndi.JndiOb­jec­tFac­to­ry­Bean">
 <pro­per­ty na­me="jndi­Na­me" va­lue="JNDI_me­no_poo­lu"/>
</bean>

<bean id="en­ti­ty­Ma­na­ger­Fac­to­ry" class=
 "org.springfra­mework.orm.jpa.Lo­cal­Con­tai­ne­rEn­ti­ty­Ma­na­ger­Fac­to­ry­Bean">
 <pro­per­ty na­me="da­ta­Sour­ce" ref="da­ta­Sour­ce" />
</bean>

Pr­vý vy­tvo­re­ný bean slú­ži na zís­ka­nie da­ta­bá­zo­vé­ho spo­je­nia zo služ­by JNDI. Ide o po­mer­ne štan­dard­ný spô­sob sprá­vy da­ta­bá­zo­vé­ho spo­je­nia, vďa­ka kto­ré­mu mô­že­me úda­je o pri­po­je­ní (ako pou­ží­va­teľ­ské me­no a hes­lo) od­de­liť od kon­fi­gu­rá­cie ap­li­ká­cie. Nás­led­ne sa ten­to da­ta­bá­zo­vý zdroj pou­ži­je na vy­tvo­re­nie to­vár­ne pre správ­cov en­tít.

Ta­kis­to mož­no zís­kať tú­to to­vá­reň pria­mo zo zdro­ja JNDI v prí­pa­de, že ten­to ob­jekt bol na­kon­fi­gu­ro­va­ný ad­mi­nis­trá­to­rom a po vy­tvo­re­ní kon­taj­ne­rom da­ný k dis­po­zí­cii pros­tred­níc­tvom služ­by JNDI. V ta­kom prí­pa­de by sta­či­lo na­de­fi­no­vať v kon­fi­gu­rač­nom sú­bo­re bean zís­ka­ný z tej­to služ­by:

<beans>
 <jee:jndi-loo­kup id="myEmf" jndi-na­me="JNDI_me­no"/>
</beans>

Te­raz už te­da vie­me, ako správ­ne vy­tvo­riť to­vá­reň pre správ­cov en­tít, či už ma­na­žo­va­nú ap­li­ká­ciou, ale­bo kon­taj­ne­rom.

Ak si spo­me­nie­te na pre­doš­lý di­el, uvied­li sme tam, že ob­jek­ty DAO pou­ží­va­jú at­ri­bút správ­cu en­tít s ano­tá­ciou Per­sis­ten­ce­Con­text. Na to, aby bo­li tie­to at­ri­bú­ty správ­ne ini­cia­li­zo­va­né in­jek­to­va­ný­mi in­štan­cia­mi, je však ne­vyh­nut­ný eš­te je­den krok, a to pri­da­nie nas­le­du­jú­ce­ho bea­nu do náš­ho kon­fi­gu­rač­né­ho sú­bo­ru con­text.xml:

<bean class= "org.springfra­mework.orm.jpa.sup­port.Per­sis­ten­ceAn­no­ta­tion­Bean­PostPro­ces­sor"/>

Ten­to bean pred­sta­vu­je postpro­ce­sor, te­da trie­du, kto­rá sa sta­rá o post-spra­co­va­nie in­štan­cií ma­na­žo­va­ných Sprin­gom, kto­rý nám za­bez­pe­čí už spo­mí­na­nú pot­reb­nú ini­cia­li­zá­ciu re­fe­ren­cií na in­štan­cie správ­cov en­tít.

Pri­da­nie DAO bea­nov

Te­raz má­me Spring sí­ce na­kon­fi­gu­ro­va­ný na prá­cu s en­ti­ta­mi, ale za­tiaľ eš­te stá­le neexis­tu­je žiad­na in­štan­cia dis­po­nu­jú­ca na­ším roz­hra­ním DAO, kto­rú by sme moh­li pou­žiť na spra­co­va­nie na­šich en­tít. Pre­to mu­sí­me pri­dať do sú­bo­ru ap­li­kač­né­ho kon­textu con­text.xml eš­te je­den bean:

<bean id="mo­vie­DAO" class="Mo­vie­DAOImpl" />

Te­raz už má­me k dis­po­zí­cii kom­plet­nú pod­po­ru pre per­zis­ten­čné ope­rá­cie s en­ti­ta­mi Mo­vie a mô­že­me si vy­tvo­riť nap­rík­lad trie­du con­troller pre tú­to en­ti­tu:

class Mo­vie­Con­troller {
 @Re­sour­ce(na­me="mo­vie­DAO")
 pri­va­te Mo­vie­DAO mo­vie­DAO;

 pub­lic void ad­dNewMo­vie(String na­me, String ty­pe) {
 Mo­vie mo­vie = new Mo­vie();
 mo­vie.set­Na­me(na­me);
 mo­vie.set­Ty­pe(ty­pe);
 mo­vie­DAO.sa­ve(mo­vie);
 }
}

V prík­la­de vi­dí­me, že at­ri­bút mo­vie­DAO je in­jek­to­va­ný bea­nom z kon­texto­vé­ho kon­fi­gu­rač­né­ho sú­bo­ru, tak­že nie je ini­cia­li­zo­va­ný pria­mo v kó­de. Vďa­ka to­mu mô­že­me pou­ží­vať roz­hra­nie Mo­vie­DAO bez nut­nos­ti od­ka­zo­va­nia na kon­krét­nu im­ple­men­tá­ciu.

Ob­dob­ne by sme pri­da­li me­tó­dy na ak­tua­li­zá­ciu ale­bo zma­za­nie en­ti­ty z da­ta­bá­zy.

Na uve­de­nom prík­la­de sto­jí za pov­šim­nu­tie i to, že in­štan­cii Mo­vie ne­nas­ta­vu­je­me at­ri­bút id. Pre­to oča­ká­va­me, že je­ho hod­no­ta bu­de auto­ma­tic­ky vy­ge­ne­ro­va­ná da­ta­bá­zou, napr. z ne­ja­kej sek­ven­cie. Pre ta­ké­to sprá­va­nie však mu­sí­me eš­te uči­niť jed­nu ma­lú zme­nu v trie­de Mo­vie, a to pri­da­nie ano­tá­cie Ge­ne­ra­ted­Va­lue:

@En­ti­ty
@Tab­le(na­me="mo­vie")
class Mo­vie im­ple­ments Se­ria­li­zab­le {

 @Id
 @Co­lumn(na­me="id", nullab­le=fal­se)
 @Ge­ne­ra­ted­Va­lue(stra­te­gy=Ge­ne­ra­tion­Ty­pe.AUTO, ge­ne­ra­tor="gen_na­me") 
 pri­va­te int id;

 // zvy­šok kó­du trie­dy ...

}

Zdroj: IW 6-7/2012

---

 

---