转载了篇hibernate 一对一、一对多、多对多的情况的文章
这些个例子中,将考虑到表之间的一对一、一对多、多对多的情况。如图1所示:
![](https://p-blog.csdn.net/images/p_blog_csdn_net/myst_aa/EntryImages/20080828/image001.png)
在上面的数据模型图中,Student是所有表的核心,它和Classes表是一对多的关系,和Course表是多对多的关系(通过Student_Course_Link表来链接),和Address表是一对一的关系。
通过分析,我们可以把上面的数据模型转换成如下的Java持久对象,如图2所示。
![](https://p-blog.csdn.net/images/p_blog_csdn_net/myst_aa/EntryImages/20080828/image003.png)
可以看出,数据模型图和Java持久对象的类图有非常大的相似性,但是不完全相同。比如Classes表和Student表是一对多的关系;在类图中,两者仍然是一对多的关系,但是在Classes类中添加了一个student属性,属性的类型是java.util.Set,它表示Classes对象中包含的所有Student对象。
创建Hibernate持久对象
已经对数据模型经过了分析,现在就可以创建持久对象了。持久对象之间的关系由图2所示的类图指定。
我们首先来看Student类,它是这个关系映射的核心,代码如例程1所示。
例程1 Student持久对象(Student.java)
package com.hellking.study.hibernate;
import java.util.Set; /** *在hibernate中代表了Students表的类。 */
public class Student { /**属性,和students表中的字段对应**/
private String id;
private String name; /**和其它类之间的映射关系**/
private Set courses;
private Classes classes;
private Address address; /**属性的访问方法,必须是公共的方法**/
public void setId(String string) { id = string; }
public String getId() { return id; }
public void setName(String name) { this.name=name; }
public String getName() { return this.name; } /**操作和其它对象之间的关系**/
public void setCourses(Set co) { this.courses=co; }
public Set getCourses() { return this.courses; }
public void setAddress(Address ad) { this.address=address; }
public Address getAddress() { return this.address; }
public void setClasses(Classes c) { this.classes=c; }
public Classes getClasses() { return this.classes; } }
|
在Student类中,由于Students表和Classes的表是多对一的关系,故它包含了一个类型为Classes的classes属性,它的实际意义是一个学生可以有一个班级;Students表和Address的表是一对一的关系,同样也包含了一个类型为Address的address属性,它的实际意义是一个学生有一个地址;Students表和Course是多对多的关系,故它包含了一个类型为java.util.Set的course属性,它的实际意义是一个学生可以学习多门课程,同样,某个课程可以由多个学生来选修。
Classes对象和Student对象是一对多的关系。Classes对象包含一个类型为java.util.Set的students属性,它的代码如例程2所示。
例程2 Classes持久对象(Classes.java)
package com.hellking.study.hibernate;
import java.util.Set; /** *在hibernate中代表了Classes表的类。 */
public class Classes { /**属性,和classes表的字段一致**/
private String id;
private String name; /**和其它类之间的映射关系**/
private Set students; /**属性的访问方法,必须是公共的方法**/
public void setId(String string) { id = string; }
public String getId() { return id; }
public void setName(String name) { this.name=name; }
public String getName() { return this.name; } /**操作和其它对象之间的关系**/
public void setStudents(Set stud) { this.students=stud; }
public Set getStudents() { return this.students; } }
|
Course持久对象在前一篇文章已经介绍,在这里就不再列举。Address持久对象比较简单,除了表字段定义的属性外,没有引入其它的属性,请参考本文的代码。
描述对象之间的关系
现在我们已经编写好了持久对象,下面的任务就是描述它们之间的关系。首先我们看Student持久对象的描述,如例程3所示。
例程3 Student持久对象的描述(Student.hbm.xml)
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="com.hellking.study.hibernate.Student" table="Students" dynamic-update="false" >
<!-- 描述ID字段-->
<id name="id" column="StudentId" type="string" unsaved-value="any" >
<generator class="assigned"/> </id>
<!-- 属性-->
<property name="name" type="string"
update="true"
insert="true"
column="Name" /> <!-- 描述Student和Course多对多的关系-->
<set name="courses" table="Student_Course_Link"
lazy="false" inverse="false" cascade="all" sort="unsorted" >
<key column="StudentId" />
<many-to-many class="com.hellking.study.hibernate.Course"
column="CourseId"
outer-join="auto" />
</set> <!-- 描述Student和Classes之间多对一的关系-->
<many-to-one name="classes" class="com.hellking.study.hibernate.Classes"
cascade="none"
outer-join="auto"
update="true"
insert="true"
column="ClassesId"
/>
<!-- 描述Student和Address之间一对一的关系-->
<one-to-one
name="address"
class="com.hellking.study.hibernate.Address"
cascade="none"
outer-join="auto"
constrained="false" />
</class> </hibernate-mapping>
|
在Student.hbm.xml描述符中,共描述了三种关系。第一种是Student和Address之间一对一的关系,它是最简单的关系,使用:
<one-to-one name="" class="">
|
来描述,这里的name表示的是Student对象中名称为address的属性;class表示的是address属性的类型:com.hellking.study.hibernate.Address。
接下来看Student和Classes之间多对一的关系,使用:
<many-to-one name="classes" class="com.hellking.study.hibernate.Classes" column="ClassesId" … />
|
来描述。同样,name表示的是Student对象中名称为classes的属性;class表示的是classes属性的类型,column表示Student表引用Classes表使用的外部键名称。对应的,在Classes类中也引用了Student类,它使用了以下的描述符来描述这个关系:
<set name="students" table="Students" lazy="false"
inverse="false"
cascade="all"
sort="unsorted"
>
<key column="ClassesId" />
<one-to-many class="com.hellking.study.hibernate.Student" /></set>
|
在描述Student和Course之间多对多关系时,使用了以下的方法:
<set name="courses" table="Student_Course_Link"
lazy="false"
inverse="false"
cascade="all"
sort="unsorted" >
<key column="StudentId" />
<many-to-many class="com.hellking.study.hibernate.Course"
column="CourseId"
outer-join="auto" />
</set>
|
在映射多对多关系时,需要另外使用一个链接表,这个表的名字由table属性指定,链接表包含了两个字段:CourseId和StudentId。以下的描述:
指定了Student对象在Student_Course_Link链接表中的外部键。对应的,在Course持久对象使用了以下的描述符来描述这个关系:
<set name="students" table="Student_Course_Link" lazy="false" inverse="false"
cascade="all"
sort="unsorted" >
<key column="CourseId" />
<many-to-many class="com.hellking.study.hibernate.Student"
column="StudentId"
outer-join="auto" />
</set>
|
由于其它持久对象的描述基本一样,在这里就不一一列举了,请参考本文的源代码。最后别忘了在hibernate.cfg.xml里增加这几个对象的描述。
<!-- Mapping files -->
<mapping resource="Address.hbm.xml"/>
<mapping resource="Student.hbm.xml"/>
<mapping resource="Classes.hbm.xml"/>
<mapping resource="Course.hbm.xml"/
|
使用映射关系
下面我们开发一个简单的实例来测试这个映射。持久对象使用最频繁的操作是增加数据、查询数据、删除数据、更新数据。对于更新数据的操作的情况,多个表的操作和单个表没有两样,在这里不举例了。
添加数据到数据库
我们在这里测试前三种操作,首先来看添加数据到数据库的情况,如例程4所示。
例程4 测试持久对象之间的映射关系之添加数据(MapTestBean.java部分代码)
/** *在数据库中添加数据 */
public void addData(String studentId,String classesId,String coursesId)
throws HibernateException {
try { /***以下的代码添加了一个Student,同时为Student指定了 *Address、Courses和Classses。 */
beginTransaction();
//创建一个Student对象 。
Student student = new Student();
student.setName("hellking2");
student.setId(studentId);
//创建一个Address对象。
Address addr=new Address();
addr.setCity("beijing");
addr.setState("bj");
addr.setStreet("tsinghua");
addr.setZip("100083");
addr.setId(student.getId()); //设置Student和address的关系。
student.setAddress(addr);
Set set=new HashSet();
set.add(student); //创建一个course对象。
Course course=new Course ();
course.setId(coursesId);
course.setName("computer_jsp"); //设置course和student对象之间的关系。
course.setStudents(set); //创建一个classes对象。
Classes cl=new Classes();
cl.setId(classesId);
cl.setName("engine power"); //设置某个classes对象包含的students对象。
cl.setStudents(set); //由于是双向的关系,student对象也需要设置一次。
student.setClasses(cl); //保存创建的对象到session中。
session.save(cl);
session.save(course);
session.save(student);
session.save(addr); //提交事务,使更改生效。
endTransaction(true); }
catch(HibernateException e) {
System.out.println("在添加数据时出错!");
e.printStackTrace();
throw e; } }
|
在例程4中,添加数据到数据库之前,首先设置持久对象的各个属性,如:
student.setName("hellking2");
|
这种设置属性的方式和普通的类没有什么区别,设置完所有的属性后,就设置持久对象之间的关系,如:
student.setAddress(addr);
|
如果存在对象之间的多重关系,那么可能需要把对象保存在Set集合中,然后再进行设置,如:
Set set=new HashSet(); set.add(student); course.setStudents(set);
|
当设置完所有的属性和对象关系之后,就可以调用:
session.save(persistentObject);
|
方法把持久对象保存到Hibernate会话中。最后,调用endTransaction来提交事务,并且关闭Hibernate会话。
数据查询
在复杂的实体对象映射中,往往查询也比较复杂。作为演示,我们在这里也提供了几个查询方法,如例程5所示。
例程5 测试持久对象之间的映射关系之查询数据(MapTestBean.java部分代码)
/** *获得某个给定studentid的Student的地址信息 */
public Address getAddress(String id) throws HibernateException {
beginTransaction();
Student st=(Student)session.load(Student.class,id);
Address addr=(Address)session.load(Address.class,st.getId());
endTransaction(false);
return addr; } /***获得某个给定studentid的Student的所有课程 */
public Set getCourses(String id)throws HibernateException {
beginTransaction();
Student st=(Student)session.load(Student.class,id);
endTransaction(false);
return st.getCourses(); } /***测试获得某个给定studentid的Student所属的Classes */
public Classes getClasses(String id)throws HibernateException {
beginTransaction();
Student st=(Student)session.load(Student.class,id);
System.out.println(st.getClasses().getId());
endTransaction(false);
return st.getClasses(); }
|
这里提供了三种查询方法,分别是:
- 查询给定id的Student的Address信息;
- 查询给定id的Student的所有Courses信息;
- 查询给定id的Student所属的Classes信息。
在查询时,首先使用beginTransaction()方法创建一个Hibernate会话对象,并且开始一个新Hibernate事务;然后通过session.load()方法获得给定ID的Student对象,如:
Student st=(Student)session.load(Student.class,id);
|
最后调用student.getXXX()方法返回指定的对象。
删除数据
在表的关系比较复杂时,要删除数据,往往存在级联删除的情况,由于级联删除的情况比较复杂,在这里就不举例了。假设我们要删除和某个给定id的student对象的所有相关的记录,就可以使用例程6所示的方法。
例程6 测试持久对象之间的映射关系之删除数据(MapTestBean.java部分代码)
/***删除和某个学生相关的所有信息*(这里只是测试,我们暂且不说这种操作的意义何在)。*/
public void delteStudent(String id)throws HibernateException{
beginTransaction();
Student st=(Student)session.load(Student.class,id);
Address addr=(Address)session.load(Address.class,st.getId()); //删除address信息。
session.delete(addr); //删除classes信息。
session.delete(st.getClasses()); /***逐个删除course。*/
for(Iterator it=st.getCourses().iterator();it.hasNext();) {
Course c=(Course)it.next();
session.delete(c); }//最后,删除student对象。
session.delete(st);
endTransaction(true); }
|
同样,在执行删除前,首先使用beginTransaction()方法创建一个新Hibernate会话和一个新Hibernate事务,然后把要删除的对象Load进来,接下来调用session.delete()方法来删除指定对象。
如果要删除的是集合中的对象,那么可以通过一个迭代来逐个删除,如例程6中删除courses的方法。