在学习过第一节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类代码如下：
package hiber.bean;
import java.io.Serializable;
public class Person implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/** 成员属性 */
/** 递增序列的ID */
private int id;
/** 用户的名称 */
private String name;
/** 用户的住址 */
private Address addr;
/** 默认的构造器 */
public Person() {
}
/** 带有参数的构造器 */
public Person(String name, Address addr) {
this.name = name;
this.addr = addr;
}
/** 生成set get方法 */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
}
Address类代码如下：
package hiber.bean;
import java.io.Serializable;
public class Address implements Serializable {
/** 成员属性 */
/** 递增序列的ID */
private int id;
/** 用户的住址 */
private String content;
/** 默认的构造器 */
public Address() {
}
/** 带有参数的构造器 */
public Address(String content) {
this.content = content;
}
/** 相应的set get 方法 */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
在同一个包下为这两个类创建一个配置文件paddr.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping package="hiber.bean">
<!-- Person类的映射文件 -->
<class name="Person" table="person">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" length="40" />
<one-to-one name="addr" class="Address" constrained="true"
cascade="all">
</one-to-one>
</class>
<!-- Address类的映射文件 -->
<class name="Address" table="address">
<id name="id">
<generator class="native"></generator>
</id>
<property name="content" length="100" />
</class>
</hibernate-mapping>
在hibernate.cfg.xml引用映射文件
<mapping resource="hiber/bean/paddr.hbm.xml" />
创建表：两种方式
1、<!-- 创建表 -->
<property name="hibernate.hbm2ddl.auto">true</property>
<property name="hibernate.show_sql">true</property>
通过以上配置在解析配置文件时,即可创建表。
2、创建一个CreateTable的类
public class CreateTable {
public static void main(String[] args) {
/**解析配置文件*/
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
se.create(true, true);
}
}
以下是相应的操作：
/** 插入的操作 */
public void insert() {
/** 获取Session对象 */
Session session = HSFactory.getSession();
/** 定义一个事物的对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
for (int i = 10; i < 20; i++) {
Address addr = new Address("河南商丘" + i);
Person p = new Person("redamy" + i, addr);
/** 保存用户时 级联保存address */
session.save(p);
}
tx.commit();
} catch (Exception ex) {
/** 事务回滚操作 */
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
/** 关闭session */
HSFactory.closeSession();
}
}
/** 用户信息更新的操作 */
public void update() {
/** 获取Session对象 */
Session session = HSFactory.getSession();
/** 定义一个事物的对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
Address addr = new Address();
addr.setId(8);
addr.setContent("河南 郑州");
Person p = new Person();
p.setId(8);
p.setName("lihui");
p.setAddr(addr);
session.update(p);
/** 保存的是人的信息 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
}
/**
* 删除Person对象并不会级联删除Person的地址信息
*/
public void delete() {
/** 获取Session对象 */
Session session = HSFactory.getSession();
/** 定义一个事物的对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
Person p = new Person();
p.setId(1);
/** 删除Person执行语句是：Hibernate: delete from person where id=? */
session.delete(p);
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
}
/**
* 删除地址对象,当地址有对应的用户时会报异常信息 Hibernate: delete from address where id=?
* org.hibernate.exception.ConstraintViolationException: Could not execute
* JDBC batch update 因此在删除地址对象时候应先删除该用户的信息才能够删除用户的地址
*/
public void deleteAddr() {
/** 获取Session对象 */
Session session = HSFactory.getSession();
/** 定义一个事物的对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
Address addr = new Address();
addr.setId(2);
/** 删除地址对象?在这里你可以自己实现? */
session.delete(addr);
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
}
/** 根据用户ID查询用户信息操作 */
public Person getById(int id) {
/** 获取Session对象 */
Session session = HSFactory.getSession();
Person p = null;
try {
p = (Person) session.get(Person.class, id);
/**
* 在这里可以直接输出用户的属性值.....如果在这里没有返回返回对象之后就不能返回到
* 地址信息了?因为session已经关闭,可采用<hibernate-mapping>标签中 加入
* default-lazy="false"解决此问题。 也可以在这里使用
* hibernate.initialize(p.getAddr()); 初始化地址对象。
*/
} catch (Exception ex) {
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
return p;
}
设置cascade="all"，插入，更新，查询可以级联，但是删除不能级联 为什么呢？可以思考?
答：当<one to one>标签设置constrained="true" cascade="all" 级联删除失效
二、 hibernate一对多关联
创建两个javabean：User和Message
Message类代码如下：
package hiber.bean1;
import java.io.Serializable;
import java.sql.Timestamp;
public class Message implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/** 递增序列的ID */
private int id;
/** 用户的留言内容 */
private String content;
/** 用户留言时间 */
private Timestamp ldate;
/** 默认的构造器 */
public Message() {
}
/** 带有参数的构造器 */
public Message(String content, Timestamp ldate) {
this.content = content;
this.ldate = ldate;
}
/**set get 方法*/
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Timestamp getLdate() {
return ldate;
}
public void setLdate(Timestamp ldate) {
this.ldate = ldate;
}
}
User类代码如下：
package hiber.bean1;
import java.io.Serializable;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/** 成员属性 */
/** 递增序列的ID */
private int id;
/** 用户的名称 */
private String name;
/** 用户的密码 */
private String pass;
/** 用户的邮箱 */
private String email;
/** 用户注册的时间 */
private Timestamp rdate;
/** 用户留言信息的集合 */
private Set<Message> allMsg = new HashSet<Message>();
/** 默认的构造器 */
public User() {
}
/** 带有参数的构造器 */
public User(String name, String pass, String email, Timestamp rdate,
Set<Message> allMsg) {
this.name = name;
this.pass = pass;
this.email = email;
this.rdate = rdate;
this.allMsg = allMsg;
}
/** set get方法 */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Set<Message> getAllMsg() {
return allMsg;
}
public void setAllMsg(Set<Message> allMsg) {
this.allMsg = allMsg;
}
public Timestamp getRdate() {
return rdate;
}
public void setRdate(Timestamp rdate) {
this.rdate = rdate;
}
}
创建配置文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping package="hiber.bean1" default-lazy="false">
<class name="User" table="user">
<id column="id" name="id">
<generator class="native" />
</id>
<property column="name" length="20" name="name" type="string"/>
<property column="pass" length="12" name="pass" type="string" />
<property column="email" length="40" name="email" type="string" />
<property name="rdate" type="timestamp" />
<set name="allMsg" cascade="delete,save-update" lazy="false" inverse="true">
<key>
<column name="uid"></column>
</key>
<one-to-many class="Message"/>
</set>
</class>
<class name="Message" table="message">
<id name="id">
<generator class="native"/>
</id>
<property name="content" />
<property name="ldate" />
</class>
</hibernate-mapping>
记得要在hiberante.cfg.xml文件中添加Mapping
操作关联
/** 插入记录 */
public void insert() {
/** 获取Session对象 */
Session session = HSFactory.getSession();
/** 定义一个事物的对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/**为每个用户添加十条留言信息*/
for (int i = 0; i < 10; i++) {
User u = new User();
u.setName("redarmy" + i);
u.setPass("123" + i);
u.setEmail("redarmy" + i + "[email protected]");
u.setRdate(new Timestamp(System.currentTimeMillis()));
for (int j = 0; j < 10; j++) {
Message msg = new Message();
msg.setContent("你好" + j);
msg
.setLdate(new Timestamp(System.currentTimeMillis()
* (j)));
u.getAllMsg().add(msg);
}
/**级联保存 message*/
session.save(u);
/**
* 当在<set 才用默认的inverse="false"的时候></set>
* 执行语句：
* Hibernate: insert into user (name, pass, email, rdate) values (?, ?, ?, ?)
* Hibernate: insert into message (content, ldate) values (?, ?)
* ..............
* 执行插入完后回执行
* Hibernate: update message set uid=? where id=?
* Hibernate: update message set uid=? where id=?
* ...会吧所有的留言信息更新一遍
*
* 当在<set 采用inverse="true"的时候></set>
* 执行的语句：
* Hibernate: insert into user (name, pass, email, rdate) values (?, ?, ?, ?)
* Hibernate: insert into message (content, ldate) values (?, ?)
* 会在处理的时候不会执行update语句 一次插入
* 但是执行的结果呢?在查看数据库的时候可以查看呀!
* 自己一定要动手呀！
* */ }
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
}
public User getById(int id) {
User entity = null;
/** 获取Session对象 */
Session session = 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 (Exception ex) {
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
return entity;
}
对于更新..删除可以自己动手实验一下?
注意当你删除Use的对象时候,会通过级联删除所有用户的留言信息
三、 hibernate多对一关联
创建两个javabean：User和Message
Message类代码如下：
package hiber.bean2;
import java.io.Serializable;
import java.sql.Timestamp;
public class Message implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/** 递增序列的ID */
private int id;
/** 用户的留言内容 */
private String content;
/** 用户留言时间 */
private Timestamp ldate;
/**创建一个用户的对象*/
private User user;
/** 默认的构造器 */
public Message() {
}
/** 带有参数的构造器 */
public Message(String content, Timestamp ldate,User user) {
this.content = content;
this.ldate = ldate;
this.user=user;
}
/**set get 方法*/
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Timestamp getLdate() {
return ldate;
}
public void setLdate(Timestamp ldate) {
this.ldate = ldate;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
User类代码如下：
package hiber.bean2;
import java.io.Serializable;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/** 成员属性 */
/** 递增序列的ID */
private int id;
/** 用户的名称 */
private String name;
/** 用户的密码 */
private String pass;
/** 用户的邮箱 */
private String email;
/** 用户注册的时间 */
private Timestamp rdate;
/** 默认的构造器 */
public User() {
}
/** 带有参数的构造器 */
public User(String name, String pass, String email, Timestamp rdate) {
this.name = name;
this.pass = pass;
this.email = email;
this.rdate = rdate;
}
/** set get方法 */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Timestamp getRdate() {
return rdate;
}
public void setRdate(Timestamp rdate) {
this.rdate = rdate;
}
}
创建hbm.xml配置文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping default-lazy="false" package="hiber.bean2">
<class name="User" table="user">
<id column="id" name="id">
<generator class="native" />
</id>
<property column="name" length="20" name="name" type="string" />
<property column="pass" length="12" name="pass" type="string" />
<property column="email" length="40" name="email" type="string" />
<property name="rdate" type="timestamp" />
</class>
<class name="Message" table="message">
<id name="id">
<generator class="native" />
</id>
<property name="content" />
<property name="ldate" />
<many-to-one name="user" class="User" column="uid"
cascade="save-update" />
</class>
</hibernate-mapping>
记得要在hiberante.cfg.xml文件中添加Mapping
操作关联
/** 多对一单向关联案例 */
/** 插入的操作 */
public void insert() {
/** 获取session */
Session session = HSFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/** 实现对一个用户插入10个留言信息 */
for (int i = 1; i <= 10; i++) {
User user = new User("liulan", "123", "[email protected]",
new Timestamp(System.currentTimeMillis() / (i)));
for (int j = 1; j <= 10; j++) {
Message msg = new Message();
msg.setContent("redarmy!hello" + j);
msg.setLdate(new Timestamp(System.currentTimeMillis()
/ (j + 10)));
msg.setUser(user);
/** 保存Msg信息 */
session.save(msg);
}
}
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HSFactory.closeSession();
}
}
对于Msg表的删除,修改,查询可以自己动手实现?
但是在这种多对一关联的时候,如果想要实现在一对多的功能显然比较费劲,但是在实际开发中我们使用下面的双向关联。
四、 hibernate一对多的双向关联
创建两个javabean：User和Message
Message成员属性
private Integer id;
private User user;
private String content;
private Timestamp ldate;
User成员属性
private Integer id;
private String name;
private String pass;
private String email;
private Timestamp rdate;
private Set messages = new HashSet(0);
以上的量类中各自包含了对方这就是双向关联,并且省略了构造器和setget 方法,如果您对关系关联还不理解,请参考：
http://student.csdn.net/space.php?uid=1394199&do=blog&id=51397
创建配置文件
User.Hbm.xml的配置文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="hiber.bean.User" table="user" catalog="houtai">
<id name="id" type="java.lang.Integer">
<column name="id" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="name" length="20" />
</property>
<property name="pass" type="java.lang.String">
<column name="pass" length="12" />
</property>
<property name="email" type="java.lang.String">
<column name="email" length="40" />
</property>
<property name="rdate" type="java.sql.Timestamp">
<column name="rdate" length="19" />
</property>
<set name="messages" inverse="true">
<key>
<column name="uid" />
</key>
<one-to-many class="hiber.bean.Message" />
</set>
</class>
</hibernate-mapping>
Message.hbm.xml的配置文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="hiber.bean.Message" table="message" catalog="houtai">
<id name="id" type="java.lang.Integer">
<column name="id" />
<generator class="native" />
</id>
<many-to-one name="user" class="hiber.bean.User" cascade="save-update" >
<column name="uid" />
</many-to-one>
<property name="content" type="java.lang.String">
<column name="content" />
</property>
<property name="ldate" type="java.sql.Timestamp">
<column name="ldate" length="19" />
</property>
</class>
</hibernate-mapping>
操作关联
/** 为每一个用户添加10条留言信息的操作*/
public void insert() {
/** 获取session */
Session session = HibernateSessionFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/** 为每个用户添加十个留言信息 */
for (int j = 1; j <= 10; j++) {
User user = new User();
user.setName("name" + j);
user.setEmail("email" + j);
user.setPass("123");
user.setRdate(new Timestamp(System.currentTimeMillis()
/ (10 * j)));
for (int i = 1; i <= 10; i++) {
Message msg = new Message();
msg.setContent("redarmy!hello" + i);
msg.setLdate(new Timestamp(System.currentTimeMillis() / i));
/** 为该留言指明留言的用户 */
msg.setUser(user);
/**
* 由于在UserJava中声明并创建Set<Message> messages的集合和setget方法
* 所以可以获取该User用户的messages的集合并给该用户添加相应的留言信息
*/
user.getMessages().add(msg);
/**
* 保存Msg信息 的时候通过设置了在<many to one>标签中设置
* cascade="save-update",所以在保存留言信息的时候,会自动先保存
* 一端User的信息,在保存Many端的Msg信息 执行代码如下： Hibernate: insert into
* houtai.user (name, pass, email, rdate) values (?, ?, ?,
* ?) Hibernate: insert into houtai.message (uid, content,
* ldate) values (?, ?, ?) 通过以上两行代码可以看出设置级联是先执行一端的插入
* 然后执行多端的插入.
* */
session.save(msg);
}
}
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
}
/** 插入User一方一条记录 观察是否影响到Message多端 */
public void insertUser() {
/** 获取session */
Session session = HibernateSessionFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/** 在多对一关系映射中在一端插入一条记录不影响多端 */
User user = new User();
user.setName("redarmy");
session.save(user);
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
}
/** 删除用户时,应当删除用户所有留言信息实现方式如下 */
public void deleteUser() {
/** 获取session */
Session session = HibernateSessionFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/** 第一步获取删除的用户信息 */
User user = (User) session.get(User.class, 11);
/** 获取该用户的所有留言信息 */
Set<Message> allMsg = user.getMessages();
for (Message msg : allMsg) {
/** 当删除用户的留言信息,并不影响一端,如果要先删除一端User必须手动删除 */
session.delete(msg);
}
/**
* 删除用户信息的时候,应先删除该用户的所有留言,不然会出现异常信息如下：
* org.hibernate.exception.ConstraintViolationException: Could not
* execute JDBC batch update
*/
session.delete(user);
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
}
/** 删除Msg信息 观察是否影响到一端User端 */
public void deleteMsg() {
/** 获取session */
Session session = HibernateSessionFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/**在删除留言信息的时候,虽然有外键关联,但也可以删除并不影响一端的关联*/
Message msg = (Message) session.get(Message.class, 96);
session.delete(msg);
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
}
/** 更新Msg信息 */
public void updateMsg() {
/** 获取session */
Session session = HibernateSessionFactory.getSession();
/** 定义事务对象 */
Transaction tx = null;
try {
/** 获取事务 */
tx = session.getTransaction();
/** 开始事务 */
tx.begin();
/** 在双向关联体现 */
Message msg = (Message) session.get(Message.class, 9);
User user = (User) session.get(User.class, 1);
msg.setContent("ssssssssssssssssssssss");
msg.setUser(user);
session.update(msg);
/** 提交事务的操作 */
tx.commit();
} catch (Exception ex) {
if (tx != null) {
tx.rollback();
}
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
}
/** 查询某个留言 */
public Message findMsgById(int id ) {
Message msg = null;
/** 获取session */
Session session = HibernateSessionFactory.getSession();
try {
msg = (Message) session.get(Message.class, id);
} catch (Exception ex) {
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
return msg;
}
/**查询某个用户的所有留言信息*/
public Message findUserMsgsById(int id) {
Message msg = null;
/** 获取session */
Session session = HibernateSessionFactory.getSession();
try {
User entity = (User) session.get(User.class, id);
System.out.println(entity.getMessages().size());
} catch (Exception ex) {
ex.printStackTrace();
} finally {
HibernateSessionFactory.closeSession();
}
return msg;
}
以上中用到了inverse与cascade如果您此不理解请参考下次内容
希望以上内容对学员学习hibernate有所帮助,以上内容属redarmy_chen版权所有,如要转发请注明出处。愿你有所收获！
