hibernate3学习之路第二节原创

最新推荐文章于 2024-10-01 18:51:18 发布

iteye_10189

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量86

点赞数

文章标签： java php 数据库

在学习过第一节hibernate之后,您对hibernate3有了初步的认识和了解,在第二节中我们重点讲解基于xml的常用映射语法及关系映射,希望通过这一节的内容,你能够对hibernate3有更深一步的认识,愿你有更大的进步…

基于xml的常用映射语法
1、表与类的映射需要hbm.xml配置文件，这个文件的根标签是<hibernate-mapping>
他常用的属性有：
1、default-cascade默认的级联方式nono
2、default-lary默认延时加载true
3、package类的名称，映射配置文件中的类不必再写类名
2、类与表的映射用<class>标签，配置类和表的属性
他的常用属性有：
1、name类的名称
2、table制定表的名字，若没有指定表名，默认类的名称做表的名字
3、主键和ID属性的映射用<id>标签
他的常用属性有：
1、name类的该属性的变量名
2、column对应表主键的列名
面试题：业务主键的生成方式：composite-id
<property>标签
他的常用属性有：
1、namejava代码中的属性变量名
2、type类型名
3、length该类型的长度
4、column对应表的列名
5、unique是否允许更新
6、insert是否运行插入
7、not-null是够允许为空
一、复杂映射
一对一的关系映射
一对多的关系映射
多对多的关系映射
类的继承关系映射
组件映射
表与表之间的实体的映射关系：
一对一，一对多，多对一，多对多
类于类的实体关系：
继承（泛化），依赖，关联，聚合，组合
详解见：http://student.csdn.net/space.php?uid=1394199&do=blog&id=51397
hibernate一对一关联
建立一个java项目，添加hibernate类库，添加基本配置文件，搭建好开发环境。
如果不会详解见：http://student.csdn.net/space.php?uid=1394199&do=blog&id=53227
1、创建两个javabean类：Person和Address
Person类代码如下：
packagehiber.bean;
importjava.io.Serializable;
publicclassPersonimplementsSerializable{
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
/**成员属性*/
/**递增序列的ID*/
privateintid;
/**用户的名称*/
privateStringname;
/**用户的住址*/
privateAddressaddr;
/**默认的构造器*/
publicPerson(){
}
/**带有参数的构造器*/
publicPerson(Stringname,Addressaddr){
this.name=name;
this.addr=addr;
}
/**生成setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicAddressgetAddr(){
returnaddr;
}
publicvoidsetAddr(Addressaddr){
this.addr=addr;
}
}
Address类代码如下：
packagehiber.bean;
importjava.io.Serializable;
publicclassAddressimplementsSerializable{
/**成员属性*/
/**递增序列的ID*/
privateintid;
/**用户的住址*/
privateStringcontent;
/**默认的构造器*/
publicAddress(){
}
/**带有参数的构造器*/
publicAddress(Stringcontent){
this.content=content;
}
/**相应的setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetContent(){
returncontent;
}
publicvoidsetContent(Stringcontent){
this.content=content;
}
}
在同一个包下为这两个类创建一个配置文件paddr.hbm.xml
<?xmlversion="1.0"encoding="utf-8"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
MappingfileautogeneratedbyMyEclipsePersistenceTools
-->
<hibernate-mappingpackage="hiber.bean">
<classname="Person"table="person">
<idname="id">
<generatorclass="native"></generator>
</id>
<propertyname="name"length="40"/>
<one-to-onename="addr"class="Address"constrained="true"
cascade="all">
</one-to-one>
</class>
<classname="Address"table="address">
<idname="id">
<generatorclass="native"></generator>
</id>
<propertyname="content"length="100"/>
</class>
</hibernate-mapping>
在hibernate.cfg.xml引用映射文件
<mappingresource="hiber/bean/paddr.hbm.xml"/>
创建表：两种方式
1、
<propertyname="hibernate.hbm2ddl.auto">true</property>
<propertyname="hibernate.show_sql">true</property>
通过以上配置在解析配置文件时,即可创建表。
2、创建一个CreateTable的类
publicclassCreateTable{
publicstaticvoidmain(String[]args){
/**解析配置文件*/
Configurationcfg=newConfiguration().configure();
SchemaExportse=newSchemaExport(cfg);
se.create(true,true);
}
}
以下是相应的操作：
/**插入的操作*/
publicvoidinsert(){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
/**定义一个事物的对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
for(inti=10;i<20;i++){
Addressaddr=newAddress("河南商丘"+i);
Personp=newPerson("redamy"+i,addr);
/**保存用户时级联保存address*/
session.save(p);
}
tx.commit();
}catch(Exceptionex){
/**事务回滚操作*/
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
/**关闭session*/
HSFactory.closeSession();
}
}
/**用户信息更新的操作*/
publicvoidupdate(){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
/**定义一个事物的对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
Addressaddr=newAddress();
addr.setId(8);
addr.setContent("河南郑州");
Personp=newPerson();
p.setId(8);
p.setName("lihui");
p.setAddr(addr);
session.update(p);
/**保存的是人的信息*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
}
/**
*删除Person对象并不会级联删除Person的地址信息
*/
publicvoiddelete(){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
/**定义一个事物的对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
Personp=newPerson();
p.setId(1);
/**删除Person执行语句是：Hibernate:deletefrompersonwhereid=?*/
session.delete(p);
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
}
/**
*删除地址对象,当地址有对应的用户时会报异常信息Hibernate:deletefromaddresswhereid=?
*org.hibernate.exception.ConstraintViolationException:Couldnotexecute
*JDBCbatchupdate因此在删除地址对象时候应先删除该用户的信息才能够删除用户的地址
*/
publicvoiddeleteAddr(){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
/**定义一个事物的对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
Addressaddr=newAddress();
addr.setId(2);
/**删除地址对象?在这里你可以自己实现?*/
session.delete(addr);
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
}
/**根据用户ID查询用户信息操作*/
publicPersongetById(intid){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
Personp=null;
try{
p=(Person)session.get(Person.class,id);
/**
*在这里可以直接输出用户的属性值.....如果在这里没有返回返回对象之后就不能返回到
*地址信息了?因为session已经关闭,可采用<hibernate-mapping>标签中加入
*default-lazy="false"解决此问题。也可以在这里使用
*hibernate.initialize(p.getAddr());初始化地址对象。
*/
}catch(Exceptionex){
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
returnp;
}
设置cascade="all"，插入，更新，查询可以级联，但是删除不能级联为什么呢？可以思考?
答：当<onetoone>标签设置constrained="true"cascade="all"级联删除失效
二、hibernate一对多关联
创建两个javabean：User和Message
Message类代码如下：
packagehiber.bean1;
importjava.io.Serializable;
importjava.sql.Timestamp;
publicclassMessageimplementsSerializable{
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
/**递增序列的ID*/
privateintid;
/**用户的留言内容*/
privateStringcontent;
/**用户留言时间*/
privateTimestampldate;
/**默认的构造器*/
publicMessage(){
}
/**带有参数的构造器*/
publicMessage(Stringcontent,Timestampldate){
this.content=content;
this.ldate=ldate;
}
/**setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetContent(){
returncontent;
}
publicvoidsetContent(Stringcontent){
this.content=content;
}
publicTimestampgetLdate(){
returnldate;
}
publicvoidsetLdate(Timestampldate){
this.ldate=ldate;
}
}
User类代码如下：
packagehiber.bean1;
importjava.io.Serializable;
importjava.sql.Timestamp;
importjava.util.HashSet;
importjava.util.Set;
publicclassUserimplementsSerializable{
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
/**成员属性*/
/**递增序列的ID*/
privateintid;
/**用户的名称*/
privateStringname;
/**用户的密码*/
privateStringpass;
/**用户的邮箱*/
privateStringemail;
/**用户注册的时间*/
privateTimestamprdate;
/**用户留言信息的集合*/
privateSet<Message>allMsg=newHashSet<Message>();
/**默认的构造器*/
publicUser(){
}
/**带有参数的构造器*/
publicUser(Stringname,Stringpass,Stringemail,Timestamprdate,
Set<Message>allMsg){
this.name=name;
this.pass=pass;
this.email=email;
this.rdate=rdate;
this.allMsg=allMsg;
}
/**setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetPass(){
returnpass;
}
publicvoidsetPass(Stringpass){
this.pass=pass;
}
publicStringgetEmail(){
returnemail;
}
publicvoidsetEmail(Stringemail){
this.email=email;
}
publicSet<Message>getAllMsg(){
returnallMsg;
}
publicvoidsetAllMsg(Set<Message>allMsg){
this.allMsg=allMsg;
}
publicTimestampgetRdate(){
returnrdate;
}
publicvoidsetRdate(Timestamprdate){
this.rdate=rdate;
}
}
创建配置文件
<?xmlversion="1.0"encoding="utf-8"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
MappingfileautogeneratedbyMyEclipsePersistenceTools
-->
<hibernate-mappingpackage="hiber.bean1"default-lazy="false">
<classname="User"table="user">
<idcolumn="id"name="id">
<generatorclass="native"/>
</id>
<propertycolumn="name"length="20"name="name"type="string"/>
<propertycolumn="pass"length="12"name="pass"type="string"/>
<propertycolumn="email"length="40"name="email"type="string"/>
<propertyname="rdate"type="timestamp"/>
<setname="allMsg"cascade="delete,save-update"lazy="false"inverse="true">
<key>
<columnname="uid"></column>
</key>
<one-to-manyclass="Message"/>
</set>
</class>
<classname="Message"table="message">
<idname="id">
<generatorclass="native"/>
</id>
<propertyname="content"/>
<propertyname="ldate"/>
</class>
</hibernate-mapping>
记得要在hiberante.cfg.xml文件中添加Mapping
操作关联
/**插入记录*/
publicvoidinsert(){
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
/**定义一个事物的对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**为每个用户添加十条留言信息*/
for(inti=0;i<10;i++){
Useru=newUser();
u.setName("redarmy"+i);
u.setPass("123"+i);
u.setEmail("redarmy"+i+".@gmail.com");
u.setRdate(newTimestamp(System.currentTimeMillis()));
for(intj=0;j<10;j++){
Messagemsg=newMessage();
msg.setContent("你好"+j);
msg
.setLdate(newTimestamp(System.currentTimeMillis()
*(j)));
u.getAllMsg().add(msg);
}
/**级联保存message*/
session.save(u);
/**
*当在<set才用默认的inverse="false"的时候></set>
*执行语句：
*Hibernate:insertintouser(name,pass,email,rdate)values(?,?,?,?)
*Hibernate:insertintomessage(content,ldate)values(?,?)
*..............
*执行插入完后回执行
*Hibernate:updatemessagesetuid=?whereid=?
*Hibernate:updatemessagesetuid=?whereid=?
*...会吧所有的留言信息更新一遍
*
*当在<set采用inverse="true"的时候></set>
*执行的语句：
*Hibernate:insertintouser(name,pass,email,rdate)values(?,?,?,?)
*Hibernate:insertintomessage(content,ldate)values(?,?)
*会在处理的时候不会执行update语句一次插入
*但是执行的结果呢?在查看数据库的时候可以查看呀!
*自己一定要动手呀！
**/}
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
}
publicUsergetById(intid){
Userentity=null;
/**获取Session对象*/
Sessionsession=HSFactory.getSession();
try{
entity=(User)session.get(User.class,id);
/**当session关闭后在使用getAllMsg方法获取该用户的所有留言信息时
*会出现：org.hibernate.LazyInitializationException:异常
*此异常为延迟加载的异常
*解决方法1可以为hibernate-mapping跟标签加上default-lazy=false解决
*解决方法2可以为<set.标签加上lazy=false解决
*解决方法3：可以使用hibernate.initialize(entity.getAllMsg());
*解决方法4可以在关闭session之前使用一次getAllMsg的方法即可代码如下*///System.out.println(entity.getAllMsg().size()+"留言的数量");
}catch(Exceptionex){
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
returnentity;
}
对于更新..删除可以自己动手实验一下?
注意当你删除Use的对象时候,会通过级联删除所有用户的留言信息
三、hibernate多对一关联
创建两个javabean：User和Message
Message类代码如下：
packagehiber.bean2;
importjava.io.Serializable;
importjava.sql.Timestamp;
publicclassMessageimplementsSerializable{
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
/**递增序列的ID*/
privateintid;
/**用户的留言内容*/
privateStringcontent;
/**用户留言时间*/
privateTimestampldate;
/**创建一个用户的对象*/
privateUseruser;
/**默认的构造器*/
publicMessage(){
}
/**带有参数的构造器*/
publicMessage(Stringcontent,Timestampldate,Useruser){
this.content=content;
this.ldate=ldate;
this.user=user;
}
/**setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetContent(){
returncontent;
}
publicvoidsetContent(Stringcontent){
this.content=content;
}
publicTimestampgetLdate(){
returnldate;
}
publicvoidsetLdate(Timestampldate){
this.ldate=ldate;
}
publicUsergetUser(){
returnuser;
}
publicvoidsetUser(Useruser){
this.user=user;
}
}
User类代码如下：
packagehiber.bean2;
importjava.io.Serializable;
importjava.sql.Timestamp;
importjava.util.HashSet;
importjava.util.Set;
publicclassUserimplementsSerializable{
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
/**成员属性*/
/**递增序列的ID*/
privateintid;
/**用户的名称*/
privateStringname;
/**用户的密码*/
privateStringpass;
/**用户的邮箱*/
privateStringemail;
/**用户注册的时间*/
privateTimestamprdate;
/**默认的构造器*/
publicUser(){
}
/**带有参数的构造器*/
publicUser(Stringname,Stringpass,Stringemail,Timestamprdate){
this.name=name;
this.pass=pass;
this.email=email;
this.rdate=rdate;
}
/**setget方法*/
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetPass(){
returnpass;
}
publicvoidsetPass(Stringpass){
this.pass=pass;
}
publicStringgetEmail(){
returnemail;
}
publicvoidsetEmail(Stringemail){
this.email=email;
}
publicTimestampgetRdate(){
returnrdate;
}
publicvoidsetRdate(Timestamprdate){
this.rdate=rdate;
}
}
创建hbm.xml配置文件
<?xmlversion="1.0"encoding="utf-8"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
MappingfileautogeneratedbyMyEclipsePersistenceTools
-->
<hibernate-mappingdefault-lazy="false"package="hiber.bean2">
<classname="User"table="user">
<idcolumn="id"name="id">
<generatorclass="native"/>
</id>
<propertycolumn="name"length="20"name="name"type="string"/>
<propertycolumn="pass"length="12"name="pass"type="string"/>
<propertycolumn="email"length="40"name="email"type="string"/>
<propertyname="rdate"type="timestamp"/>
</class>
<classname="Message"table="message">
<idname="id">
<generatorclass="native"/>
</id>
<propertyname="content"/>
<propertyname="ldate"/>
<many-to-onename="user"class="User"column="uid"
cascade="save-update"/>
</class>
</hibernate-mapping>
记得要在hiberante.cfg.xml文件中添加Mapping
操作关联
/**多对一单向关联案例*/
/**插入的操作*/
publicvoidinsert(){
/**获取session*/
Sessionsession=HSFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**实现对一个用户插入10个留言信息*/
for(inti=1;i<=10;i++){
Useruser=newUser("liulan","123","liulan@gmail.com",
newTimestamp(System.currentTimeMillis()/(i)));
for(intj=1;j<=10;j++){
Messagemsg=newMessage();
msg.setContent("redarmy!hello"+j);
msg.setLdate(newTimestamp(System.currentTimeMillis()
/(j+10)));
msg.setUser(user);
/**保存Msg信息*/
session.save(msg);
}
}
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HSFactory.closeSession();
}
}
对于Msg表的删除,修改,查询可以自己动手实现?
但是在这种多对一关联的时候,如果想要实现在一对多的功能显然比较费劲,但是在实际开发中我们使用下面的双向关联。
四、hibernate一对多的双向关联
创建两个javabean：User和Message
Message成员属性
privateIntegerid;
privateUseruser;
privateStringcontent;
privateTimestampldate;
User成员属性
privateIntegerid;
privateStringname;
privateStringpass;
privateStringemail;
privateTimestamprdate;
privateSetmessages=newHashSet(0);
以上的量类中各自包含了对方这就是双向关联,并且省略了构造器和setget方法,如果您对关系关联还不理解,请参考：
http://student.csdn.net/space.php?uid=1394199&do=blog&id=51397
创建配置文件
User.Hbm.xml的配置文件
<?xmlversion="1.0"encoding="utf-8"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
MappingfileautogeneratedbyMyEclipsePersistenceTools
-->
<hibernate-mapping>
<classname="hiber.bean.User"table="user"catalog="houtai">
<idname="id"type="java.lang.Integer">
<columnname="id"/>
<generatorclass="native"/>
</id>
<propertyname="name"type="java.lang.String">
<columnname="name"length="20"/>
</property>
<propertyname="pass"type="java.lang.String">
<columnname="pass"length="12"/>
</property>
<propertyname="email"type="java.lang.String">
<columnname="email"length="40"/>
</property>
<propertyname="rdate"type="java.sql.Timestamp">
<columnname="rdate"length="19"/>
</property>
<setname="messages"inverse="true">
<key>
<columnname="uid"/>
</key>
<one-to-manyclass="hiber.bean.Message"/>
</set>
</class>
</hibernate-mapping>
Message.hbm.xml的配置文件
<?xmlversion="1.0"encoding="utf-8"?>
<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
MappingfileautogeneratedbyMyEclipsePersistenceTools
-->
<hibernate-mapping>
<classname="hiber.bean.Message"table="message"catalog="houtai">
<idname="id"type="java.lang.Integer">
<columnname="id"/>
<generatorclass="native"/>
</id>
<many-to-onename="user"class="hiber.bean.User"cascade="save-update">
<columnname="uid"/>
</many-to-one>
<propertyname="content"type="java.lang.String">
<columnname="content"/>
</property>
<propertyname="ldate"type="java.sql.Timestamp">
<columnname="ldate"length="19"/>
</property>
</class>
</hibernate-mapping>
操作关联
/**为每一个用户添加10条留言信息的操作*/
publicvoidinsert(){
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**为每个用户添加十个留言信息*/
for(intj=1;j<=10;j++){
Useruser=newUser();
user.setName("name"+j);
user.setEmail("email"+j);
user.setPass("123");
user.setRdate(newTimestamp(System.currentTimeMillis()
/(10*j)));
for(inti=1;i<=10;i++){
Messagemsg=newMessage();
msg.setContent("redarmy!hello"+i);
msg.setLdate(newTimestamp(System.currentTimeMillis()/i));
/**为该留言指明留言的用户*/
msg.setUser(user);
/**
*由于在UserJava中声明并创建Set<Message>messages的集合和setget方法
*所以可以获取该User用户的messages的集合并给该用户添加相应的留言信息
*/
user.getMessages().add(msg);
/**
*保存Msg信息的时候通过设置了在<manytoone>标签中设置
*cascade="save-update",所以在保存留言信息的时候,会自动先保存
*一端User的信息,在保存Many端的Msg信息执行代码如下：Hibernate:insertinto
*houtai.user(name,pass,email,rdate)values(?,?,?,
*?)Hibernate:insertintohoutai.message(uid,content,
*ldate)values(?,?,?)通过以上两行代码可以看出设置级联是先执行一端的插入
*然后执行多端的插入.
**/
session.save(msg);
}
}
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
}
/**插入User一方一条记录观察是否影响到Message多端*/
publicvoidinsertUser(){
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**在多对一关系映射中在一端插入一条记录不影响多端*/
Useruser=newUser();
user.setName("redarmy");
session.save(user);
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
}
/**删除用户时,应当删除用户所有留言信息实现方式如下*/
publicvoiddeleteUser(){
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**第一步获取删除的用户信息*/
Useruser=(User)session.get(User.class,11);
/**获取该用户的所有留言信息*/
Set<Message>allMsg=user.getMessages();
for(Messagemsg:allMsg){
/**当删除用户的留言信息,并不影响一端,如果要先删除一端User必须手动删除*/
session.delete(msg);
}
/**
*删除用户信息的时候,应先删除该用户的所有留言,不然会出现异常信息如下：
*org.hibernate.exception.ConstraintViolationException:Couldnot
*executeJDBCbatchupdate
*/
session.delete(user);
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
}
/**删除Msg信息观察是否影响到一端User端*/
publicvoiddeleteMsg(){
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**在删除留言信息的时候,虽然有外键关联,但也可以删除并不影响一端的关联*/
Messagemsg=(Message)session.get(Message.class,96);
session.delete(msg);
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
}
/**更新Msg信息*/
publicvoidupdateMsg(){
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
/**定义事务对象*/
Transactiontx=null;
try{
/**获取事务*/
tx=session.getTransaction();
/**开始事务*/
tx.begin();
/**在双向关联体现*/
Messagemsg=(Message)session.get(Message.class,9);
Useruser=(User)session.get(User.class,1);
msg.setContent("ssssssssssssssssssssss");
msg.setUser(user);
session.update(msg);
/**提交事务的操作*/
tx.commit();
}catch(Exceptionex){
if(tx!=null){
tx.rollback();
}
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
}
/**查询某个留言*/
publicMessagefindMsgById(intid){
Messagemsg=null;
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
try{
msg=(Message)session.get(Message.class,id);
}catch(Exceptionex){
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
returnmsg;
}
/**查询某个用户的所有留言信息*/
publicMessagefindUserMsgsById(intid){
Messagemsg=null;
/**获取session*/
Sessionsession=HibernateSessionFactory.getSession();
try{
Userentity=(User)session.get(User.class,id);
System.out.println(entity.getMessages().size());
}catch(Exceptionex){
ex.printStackTrace();
}finally{
HibernateSessionFactory.closeSession();
}
returnmsg;
}
以上中用到了inverse与cascade如果您此不理解请参考下次内容