Java-EE轻量级框架应用开发 Hibernate的关联映射

Java-EE轻量级框架应用开发第6章-

Hibernate的关联映射本章要点·多对一映射·一对多映射·一对一映射·多对多映射·双向映射·Hibernate的主要目的就是Java程序员可以随心所欲的使用对象编程思维来操纵数据库一些数据库表的关系应该可以通过hibernate实现，比方在数据库中常用到的主外键关系；还有一些跟主外键有关的设置，比方主键的信息被删除，外键关联的信息也要删除等等如果把表抽象为实体类，这些关系可以抽象为实体类之间的一对一、多对一、一对多、多对多等关系。在Hibernate正确的配置这些关系以后，

Hibernate能够处理这些复杂的关系，提高了开发的效率多对一映射配置如果规定一个客户〔Customer〕可以建立多个订单〔

Order〕，一个订单只属于一个顾客，这就是一个多对一关联从Order到Customer的多对一单向关联需要在Order类中定义一个Customer属性，而在Customer类中无需定义存放Order对象的集合属性关系数据模型Order表中的customer_id参照customer表的主键id·通过在映射文件中的many-to-one元素，可以定义持久化类间的多对一的关联，这种关系模型实际上是一个对象引用<many-to-one①②③④⑥⑥name="propertyName"column="column_name"class="ClassName"cascade="all|none|save-update|delete"outer-join="true|false|auto"update="true|false"insert="true|false"property-ref="propertyNameFromAssociatedClass"access="field|property|ClassName"⑦⑧/>说明①name：属性名②column〔可选〕：字段名③class〔可选，默认是通过反射得到属性类型〕：关联的类的名字④cascade〔级联〕〔可选〕：指明哪些操作会从父对象级联到关联的对象，cascade属性允许以下值none：:在保存,更新或删除当前对象时,忽略其他关联的对象,它是cascade属性的默认值save-update：当通过Session的save(),update()以及

saveOrUpdate()方法来保存或更新当时对象时,级联保存所有关联的新建的临时对象,并且级联更新所有关联的游离对象delete：当通过Session的delete()方法删除当前对象时,级联删除所有关联的对象all：包含save-update以及delete的行为.此外,对当前对象执行

outer-join〔外连接〕〔可选，默认为自动〕：当设置

hibernate.use_outer_join时，对这个关联允许外连接抓取。outer-join参数允以下3个不同值auto〔默认〕：如果被关联的对象没有代理〔Proxy〕，使用外连接抓取关联〔对象〕true：一直使用外连接来抓取关联false：永远不使用外连接来抓取关联⑥update、insert〔可选，默认为true〕：指定对应的字段是否在用于

UPDATE和/或INSERT的SQL语句中包含。如果二者都是false，那么这是一

个纯粹的“衍生〔Derived〕〞关联，它的值是通过映射到同一个〔或多个〕字段的某些其他属性得到的，或者通过Trigger〔触发器〕，或者其他程序

⑦property-ref：〔可选〕：指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键⑧access〔可选，默认是property〕：Hibernate用来访问属性的策略Hibernate设置多对一关联·以Order和Customer之间的多对一关联为例·

Customer.java·

Order.javaprivate

String

name;return

id;}this.id

=

id;return

name;public

void

setName(String

name)

{

=

name;}public

class

Order

{private

Integer

id;private

String

orderNumber;private

Double

price;private

Customer

customer;//增加了“1〞方的对象为自己的属性public

Inte

er

getId()

{publpiucblcilcasvsoiCdusteotmIedr(I{nteger

id)

{privtahties.Iindte=giedr;id;}public

String

getOrdepruNbulmibcerI(n)te{ger

getId()

{publtihcisv.ooirddseertNIudm(bIenrt=egoerrdeirdN)u{mber;}publriectuSrtnripnrgicge;tName()

{}}public

Cu}stomer

getCustomer()

{return

customer;}public

void

setCustomer(Customer

customer)

{this.customer

=

customer;}}<hibernate-mapping><class

name="entirteyt.uOrndeird";

table="Order

">}<generator

class="increment"

/></id><colurmentunranmeo=r"doerdNeurm_bnearm;e"

length="20"></column></p}roperty><!--manpyu-btloi-conveo关id联se-t-O>rderNumber(String

orderNumber){<many-to-one

name="customer"column="customer_id"

class="entity.Customer"not-null="true">

public

Do}uble

getPrice()

{</many-to-one></clapsusb>lic

vo}id

setPrice(Double

price)

{</hibernate-mappingt>his.price

=

price;测试多对一映射·先保存订单，再保存客户public

void

insert(){·

运行后在控制Se台ssi下on

se会ssi输on=s出essi以onFa下cto语ry.o句penSession();Transaction

transaction=session.beginTransaction();Customer

customer=new

Customer();Hibernate:insert

into

scustomer.sredrO.poh (ectuNsatmoem(e"r张_i三d,"o)r;derNumber,price)values(?,?,?)Hibernate:

insert

into

shop.rucedrO Osrtdoemre=rn(nawe

Omred)evalues;)(r (?)Order.setOrderNumber("0001");Hibernate:update

shop.O/r/d关er联se订t

单cu和st客ome户r_id=?,orderNumber=?,price=?where

id=?Order.setCustomer(customer);//保存订单

session.save(Order);//保存客户session.save(customer);transaction

mit();session.close();}·先保存客户，再保存订单public

void

insert(){Order

Order=new

Order();Order.setOrderNumber("001");//关联订单和客户Order.setCustomer(customer);//保存客户

session.save(customer);//保存订单session.save(Order);transaction

mit();session.close();}·

运行后在控S制essi台on

s下essi会on=输sess出ionF以acto下ry.语open句Session();Transaction

transaction=session.beginTransaction();Hibernate:

insert

into

shCuosp.tcoumsetrocmuesrt(omnearm=en)evwaClusetso(m?e)r();Hibernate:insert

into

schuospt.oOmredre.rs(ectuNsatmoem(e"r张_i三d,"o)r;derNumber,price)values(?,?,?)·保存订单，不保存客户·在代码中注释掉session.save(customer),只保存订单，不保存客户public

void

insert(){·

运行后在控S制essi台on

s下essi会on=s输essi出onF以acto下ry.o语penS句ess,io可n();以看到HibernateTransaction

transaction=session.beginTransaction();对这次数据操Cus作tome的r

cu执stom行er=n流ew

C程ustomer();customer.setName("张三");//关联订单和客户//保存客户·当hibernatOerd持er.s久etOr化derN一umb个er("临o_00时1");对象时，在默认情况下，它不会自动持久Ord化er.s所etCu关sto联mer(的cust其omer他);临时对象，会抛出

TransientOb/j/seescsitonE.sxavcee(cpusttoimeor)n;//保存订单session.save(Order);transaction

mit();session.close();}Hibernate:

insert

into

shOorpd.eOrrOdredre(rc=unsetwoOmredre_ri(d),;orderNumber,

price)

values

(?,

?,

?)·如果设定many-to-one元素的cascade属性为save-update的话，可实现自动持久化所关联的对象，对刚刚order的映射文件里的many-to-one进行修改·再次运行前面的代码，运行后在控制台下会输出以下语句<many-to-one

name="customer"

column="CUSTOMER_ID"

class="entity.Customer"

not-null="true"

cascade="save-update"></many-to-one>Hibernate:

insert

into

shop.customer

(name)

values

(?)·H可iber以nate:看inse到rt

i这nto

s次hop.O会rder自(cus动tome执r_id,行orde了rNum保ber,存pricce)uvasluteso(?m,?e,r?)的操作·多对一映射·一对多映射·一对一映射·多对多映射·双向映射一对多映射配置·

Hibernate提供了一对多关系的标签<one-to-many>，一对多是在一的一端维护多的一端·

一对多关系的对象模型在日常生活中也经常看到，一个客户〔Customer〕可以有多张订单〔Order〕，所以客户和订单的关系也是一对多的关系·

在进行关系映射时需要在一的一端添加对应的set属性，并在它的配置文件中添加set标签，在set标签中配置相应的<one-to-many>标签在Hibernate设置一对多关联set属性，但是只是说明了延性配置对应的对象，属return

Order;·以Order和Customer之间的一对多关联为例<phuibleircncaltaes-smaCpupsitnogm>er

{·<claCsus

nsamtper=oi"vmeanteteirtIyn..tCejugseatrovimdea;r"

table="customer"

catalog="demotest">private

String

name;<generpartiovratcelaSsest=O"ridnecr;ement"

/></•id>Customerpu对bli象c

Set中get使Orde用r()了{迟<}加colu载mn

n的ame=属"nam性e"l，engt并h="2没0">有</co为lumn属></properptuyb>lic

void

setOrder(Set

Order)

{<set性nam的e="O对rder象es"t是ihnivse.要rOsred=在e"rt=r映uOer"d>e射r;文件中来配置的，需要添加set<key>}<标colp签umbnlin，camIen并=t"ecgue在srtgoemsteIred_(it)d标"{/>签中添加<one-to-many>标签</key>

return

id;<one-t}o-many

class="entity.Order"

/></set>

public

void

setId(Integer

id)

{</class>

this.id

=

id;</hibernate-}mapping>public

String

getName()

{return

name;}public

void

setName(String

name)

{

=

name;}}测试多对一映射·写入数据加Order对象时应该使用p·ublic写void入sav数e(){据需要注意的是一对多的关系，所以在添加的Session

session=sessionFactory.openSession();时候需要添加Tran多sact个ionOtrrandsaectri类on=s，essi另on.b外egi由nTra于nsac在tionC()u;stomer中添Order

order1=new

Order();加了对应的soredetr1属.set性Ord，erNu所mber以("00在1")添;session.save(order1);HashSet来添Or加der

，orde这r2=n样ew

O即rder可();实现一对多的关系order2.setOrderNumber("002");session.save(order2);·

运行测试用Cu例stom，er

c生usto成mer=的new对Cust应omer的();SQL语句customer.setName("张三");

Set

Order=new

HashSet();Order.add(order1);Order.add(order2);customer.setOrderes(Order);session.save(customer);transaction

mit();session.close();}Hibernate:

insert

into

shop.Order

(customer_id,

orderNumber,

price)

values

(?,

?,

?)Hibernate:

insert

into

shop.Order

(customer_id,

orderNumber,

price)

values

(?,

?,

?)Hibernate:

insert

into

shop.customer

(name)

values

(?)·读取数据有加载的对象都添加不很高public

void

load(){·

写入Se操ssio作n

se相ssio对n=s简essi单onFa，ctor只y.o需penS要essi把on()所;Transaction

transaction=session.beginTransaction();到Transient/状/获态取主下键为，1的运客户行信息相应的方法就可以插入内容，Customer

customer

=

(Customer)

session.load(Customer.class,1);但是对/应/打的印客读户信取息操作就会稍微复杂点，因为需要迭代获取所有的订//设单置订对单象集合，，通所过客以户这加载种订单一集合对多的关系效率并Set

Order=customer.getOrder();//迭代集合，打印集合中订单的信息for(Iterator

iter=Order.iterator();iter.hasNext();){·

生成的相}应的语句及信息transaction

mit();session.close();H}ibernate:

select

customer0_.id

as

id0_0_,

customer0_.name

as

name0_0_

from

shop.customercustomer0_

where

customer0_.id=?=张三Hibernate:

select

Orderes0_.customer_id

as

customer2_1_,

Orderes0_.id

as

id1_,

Orderes0_.id

as

id1_0_,Orderes0_.customer_id

as

customer2_1_0_,

Orderes0_.orderNumber

as

orderNum3_1_0_,Orderes0_.price

as

price1_0_

from

shop.Order

Orderes0_

where

Orderes0_.customer_id=?order.orderNumber=0001·一对多的关系也是经常用到的，但是这种关系在加载时效率会不高，因为需要维护的数据较多，所以不建议使用一对多的关系，可以考虑多对一的关系，这样在加载时其实是一种一对一的关系，加载的效率较高，关系和对象模型得到了优化·多对一映射·一对多映射·一对一映射·多对多映射·双向映射一对一映射配置·如果规定一个客户〔Customer〕只能建立一个订单〔Order〕，一个Order只属于一个Customer，这就是一个一对一关联从Order到Customer的一对一单向关联需要在Order类中定义一个Customer属性，而在Customer类中无需定义存放Order对象的集合属性关系数据模型Order表中的customer_id参照

customer表的主键id·通过在映射文件中的<one-to-one>元素，可以定义持久化类之间的一对一的关联，这种关系模型实际上是一个对象引用<one-to-one①②③④name="propertyName"class="ClassName"cascade="all|none|save-update|delete"constrained="true|false"outer-join="true|false|auto"property-ref="propertyNameFromAssociatedClass"access="field|property|ClassName"⑥⑦/>说明·

①name：属性的名字②class〔可选-默认是通过反射得到的属性类型〕：被关联的类的名字③cascade〔级联〕〔可选〕说明操作是否从父对象级联到被关联的对象④constrained〔约束〕〔可选〕说明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序

outer-join〔外连接〕〔可选，默认为自动〕：当设置

hibernate.use_outer_join的时候，对这个关联允许外连接抓取⑥property-ref：〔可选〕指定关联类的一个属性，这个属性将会和本外相对应。如果没有指定，会使用对方关联类的主键⑦access〔可选，默认是property〕：Hibernate用来访问属性的策略Hibernate设置一对一关联public

class

Order

{private

Integer

id;

private

String

orderNumber;}public

String

getOrderNumber()

{this.price

=

price;}private

String

name;public

voriedtsuertnIodr(dIenrtNeugmebreird;)

{·以CuprsivtatoeDmoueblre

p和riceO;rder之间的一对一关联为例private

Customer

customer;//增加了另外一方的对象为自己的属性<phuibleircnacltpeau-sbsmlaCipucpsiItnogtm>egre{r

getId()

{<·classCnaumesp=r"tievnoatmieteIyrn.ertOteru.gdrenjri"aidt;v;abale="Order"

catalog="shop"><coplubmlnicnavmoei=d"siedt"I/pd>u(bIlnitcegIenrteigde)r{getId()

{·<geOnrerdateorrc.lajstsha=i"svrn.eaiatduir=vnei"id>d;<;/generator></id>}

}<co}lumn

name="ordetrhNiusm.biedr"=liedn;gth="10"

/></propuebrl}tiyc>void

setOrderNumber(String

orderNumber)

{public

Strhinsg.goertdNeramNeu(m)be{r

=

orderNumber;<co}lumn

name="pricree"tpurencniasmieo;n="22"

scale="0"

/></propuebrl}tiyc>Double

getPrice()

{<!—order到cpusbtloimcerv的oried一tus对rent一Npar映miec(射eS;t-r-i>ng

name){<one-}to-one

name="cutshtiosm.enra"mcel=asnsa=m"ee;ntity.Customer"constrained="true"></onep-utbol}-iocnveo>id

setPrice(Double

price)

{}</class></hibernaptueb-lmiacppCiunsgt>omer

getCustomer()

{return

customer;}public

void

setCustomer(Customer

customer)

{this.customer

=

customer;}}测试一对一映射,可以看到Hibernate对·先保存订单，再保存客户public

void

insert(){·运行后在控Ses制sion台sessi下on=s会essi输onFac出tory以.ope下nSess语ion(句);Transaction

transaction=session.beginTransaction();Customer

customer=new

Customer();custo这mer.次setN数ame("据张三操");作的执行流程Order

Order=new

Order();Hibernate:insert

into

sOhrodpe.rO.rsdetrO(rdoerrdNeurmNbuemrb(e"r0,0p0r1i"c)e;)values(?,?)

Hibernate:insert

into

s/h/o关p.联cu订st单om和er客(n户ame)values(?)Order.setCustomer(customer);//保存订单

session.save(Order);//保存客户session.save(customer);transaction

mit();session.close();}·多对一映射·一对多映射·一对一映射·多对多映射·双向映射多对多映射配置学生〔Student〕和老师〔Teacher〕就是多对多的关系。一个Student有多个老师，一个Teacher教多个学生多对多映射引入两边的主键作为外键持久化对象之间多对多的关联关系是通过<many-to-many>元素定义的<many-to-manycolumn="column_name"①class="ClassName"②outer-join="true|false|auto"③/>说明·①column〔必需〕：这个元素的外键关键字段名②class〔必需〕：关联类的名称③outer-join〔可选，默认为auto〕：在Hibernate系统参数中hibernate.use_outer_join被翻开的情况下，该参数用来允许使用outer

join来载入此集合的数据Hibernate设置多对多关联<generator

class="native"></generator></id>}·以Student和Teacher之间的一对一关联为例p<uhbiblblieicrncaltaes-smSTatepupadciehnegtr>

{<hibern·ate-mp<pSarcpiltpvaviasuntsgedn>IaIenmtene=g"tern实tidt;体y.Te类acher"table="teacher">private

Str<ricinlngagsnsamnmeae;m;e=<"iedntniatmye.=S"tiud"etnytp"et=a"bilnet=">student">

privateISnete<gSetrudtenatc>hesr<tiud;enatmse=n"eiwd<"HcatosylhpuSeme=nt"<niSantmtue"d=>e"nitd>"(>)<;/c/o/l增um加n>学生属性·

pSubtliucdInetengetr

g映etId射(){文<cgeo件nleurmantnoarmec=l"asisd"=">n</actiolvue"mn><>/generator>r<re/etitudur>rn

id;·

pTubeliaccvohides<reste实Itd(n(IaI体nmntete=eg"g类esertruide)n{t{s"table="student_teacher"cascade="all">this.id

=

id;<key

column="teacher_id"></key>}

</—c!l配ass置>many-to-many--></hiber·nate-pTmuabeplpiaicncSgt>hriengrg映etNa射me()文{<ma件ny-to-many

class="entity.Student"column="student_id"></mraentyu-rtnon-namamamene;y;>}

</set>p<pu/ubcbliacscsv>oid

setName(String

name)

{</hibernate-mapping>

=

name;}publicISnete<gSetrudgentT>eagcehteSrtiud(e)nt{s()

{returntsetaucdhenrts;}public

void

setTSetaucdhenrtisd(SIent<eSgteurdetneta>chsetruide)nt{s)

{this.steuadcehnetrsid==stuedaecnhtesr;id;}}测试多对多映射·保存教师信息·解除学生跟老师的关系删除学生、删除老工解除public

void

save(){·

运行测试S用essi例on

s，essi生on=成sess的ionF对acto应ry.的openSSeQssLio语n()句;Transaction

transaction=session.beginTransaction();session.close();}ins

r

into

student_teacher

(t

ach

r_id,

student_id)

values

(?,

?)Hpiubelrincavtoei:dibnusielrdt(i)n{to

tetaecahcheerr(2n.asmet)Nvaamleu(e"s李(老?)师");Teacher

teacher=(T

acher)

s

ssion.get(Teacher.

lass,

2)

;师，因为老ses师sio是n.sa关vet(rt系aenascah维cetri1护o)n;者mit(，);所以可以直接解除老师session.saves(etsesaicohne.rc2l)o;se();}与学生的关tra系nsa，ctio不n

m用it()手;Hibernate:

select

teach

rest0u_d.eindta.2

sedtN_am_e("te李c四e"r)0;s

i

4

0

, a

h

_.name

as

name4_0_

from

teacher

teacher0_

whereHibernate:

insert

into

steuadcenhte_rt2e.agcehteSrtu(dtenatcsh(e)r._aid,(student_2i);d)

values

(?,

?)pubHlibcervnoaitde:reimnosver(t)i{nto

teTaecahcherer(ntaemaec)hevra1l=unesw(T?e)acher();·Hi为bern老ate:师inse添rt

in加to

st一uedaecnh个etr(1n.asS学mets)Nsvai生amolenu(s"es王ss(老i?)o师n="s)e;ssionFactory.openSession();Hibernate:

insert

into

stTuedaecnhter(nteaTamrcea)hnevsra2lc=utneiesown(Tt?e)racnhsearc(t)i;on=session.beginTransaction();Hibernate:insert

into

stsutduednetn_tt1e.asTecehtaTeNcrahame(nerts(eta"eac张acthci三ehoren"_r)ti=;rd(a,Tnesatacuchdteirno)tns_=eisde)sisvoianol.nug.ebste(g?Ti,enaT?cr)haenrs.acltaisosn,()1;);Hibernate:

insert

into

stSutduednent_ttsetatucedhaecnrhte(2rt=.negeaewcthSetru_diedn,ts()(t)u;d.ernetm_oivde)(svtaulduenst()?;,

?)Htiebaecrhneart0e_:.idn=s?ert

into

stSutduednetn_ttsetasucedhseSesntrituo3(dn=te.nenuaetpcwdshSateturued_d(eitendnet,ta=(scnt)he;uewdrSe)tn;utd_eindt)(v)a;lues

(?,

?)Hibernate:select

studenstsu0d_e.nte3a.cshetrsN_taiumd

e(ans"t王t.es五aect"hN)ea;rm2e_(4"_赵1_六,s"t)u;dents0_.student_id

as

student1_1_,stu·dent1删_.id除as

i学d2_0生_,st，teuadceh因entr1为_.gt.nerata学tmSnetsauacd生shtenirato.msn不g(e)2tm_.是Sa0itd_tu(dfd)(r关e;sontmtusds系(et)nu.dtae1维dn)d;t(_护steuadc者ehnetr)，s;tud所ents以0_

i需nner要joi先n

st手udentstudent1_

on

students0_.tsetaucdhenrt1_.igsde=tsSstiuodne.nctl1so_(s.e)i.(d)a;wdhde(sretusdteundte3n)t;s0_.teacher_id=?Hibern工ate:解}ins除ert

i老nto师stueda与cenhet学r(2n.agm生et)sSevt的suasldiueoen关nst.s(u(?联p)d.atd，ed(tset然aucdhen后rt)1;)再;多H多ib·ern对at运e:i多n行多ser测t

i性nt试o

sSt用能utdueden例tnt不(ns，taSmutedue)生S佳d佳nevtsna1slt成=iunsoet，nswu的s(dSe?etsn)ust对di数=数eo(nSt=t应(su)ed;据se的snito)nsSF量e量aQscstLior语ny大.goep句te(nS时teusdseinot应n.(c)l;as尽s尽,2);可能防防止使使用·多对一映射·一对多映射·一对一映射·多对多映射·双向映射双向一对多映射双向一对多与双向多对一是完全相同的两种情形。双向一对多需要在一的一端可以访问多的一端,反之依然从Order到Customer的多对一双向关联需要在

Order类中定义一个Customer属性,还要在

Customer类中需定义存放Order对象的集合属性Hibernate设置双向多对一关联·Order.java·

在Order中需要定义Customer属性件中，使用<one-to-many>元素来映在Order的映射文件中，使用<many-to-one>元素来映射this.id

=

id;this.orderNumber

=

orderNumber;return

this.price;private

Integer

id;private

SCturstinomgenracmeus;tomer;

//定义Customer属性private

StertiOnrgdoerdeesr=NunembweHra;shSet(0);//定义Order属性purbivlaitceInDtoeugbeler

gpretiIcde;()

{·CustpuoblmiceInrte.grejertguaertnvItdah(i)s{.id;}

return

this.id;·

在}publCicuvsoitd

soemtIed