Hibernate对象之间的三种关系
hibernate 对象的三种关系:
one–to–one:身份证<--->人
one–to–many:部门<--->员工
many-to-one:员工<--->部门
many-to-many:学生<--->老师
在实际开发中，如果出现了many-to-many关系，我们应该将其转换成两个one-to-many或者many-to-one,这个程序好控制，同时不会有冗余.
单向多对一(Employee-Department)
Employee映射文件
<many-to-onename=”dept”column=”dept_id”/>
classDepartment{
privateIntegerid;
privateStringname;
}
classEmployee{
privateIntegerid;
privateStringname;
privateDepartmentdept;
}
添加一个部门，并给部门加入二个人
publicstaticvoidadd(){
//把对象模型-》关系模型
//当你获取一个session,就会让hiberate去读取
//hibernate.cfg.xml,这就会加载对象映射文件，从而完成创建
Sessionsession=null;
Transactionts=null;
try{
session=HibernateUtil.getThreadLocalSession();
ts=session.beginTransaction();
//添加一个记录
Departmentd1=newDepartment();
d1.setName("财务部");
Employeee1=newEmployee();
e1.setName("张三");
e1.setDepartment(d1);
Employeee2=newEmployee();
e2.setName("邵阳");
e2.setDepartment(d1);
session.save(d1);
session.save(e1);
session.save(e2);
ts.commit();
}catch(Exceptione){
e.printStackTrace();
if(ts!=null){
ts.rollback();
}
//TODO:handleexception
}finally{
if(session!=null&&session.isOpen()){
session.close();
}
}
}
简述:当我们查询一个对象的时候，在默认情况下,返回的只是该对象的普通属性,当用户去使用对象属性时，才会向数据库发出再一次的查询.这种现象我们称为lazy现象.
解决方法可以这样:
显示初始化Hibernate.initized(代理对象)
修改对象关系文件lazy改写lazy=false
通过过滤器(web项目)openSessionInView
双向一对多(Department-Employee)
Department映射文件添加
<setname=”集合对象属性名”>
<keycolumn=”外键名”/>
<one-to-manyclass=”集合放入的类名”/>
</set>
classDepartment{
privateIntegerid;
privateStringname;
privateSet<Employee>emps
}
一对一(Person-IdCard)
1)基于主键的one-to-one(IdCard的映射文件)
<idname=”id”>
<generatorclass=”foreign”><paramname=”property”>person</param></generator>
<id>
<one-to-onename=”person”constrained=”true”/>
[没有constranedtrue将不会生成外键约束]
Person映射文件：<one-to-onename=“idCard”/>
classPerson{
privateIntegerid;
privateStringname;
privateIdCardidCard
}
classIdCard{
privateIntegerid;
privatejava.util.Dateuseful_life;
privatePersonperson
}
**添加案例***
session=HibernateUtil.getThreadLocalSession();
ts=session.beginTransaction();
//添加一个PersonIdcard
Personp1=newPerson();p1.setName("孙悟空");
IdCardid1=newIdCard();
id1.setUseful_time(newjava.util.Date());
//这句话就可以表示id1是p1这个人.
id1.setPerson(p1);
session.save(p1);//insert
session.save(id1);//insert
2)基于外健的one-to-one，可以描述为多对一，加unique=“true”约束,
IdCard的映射文件中:
<many-to-onename=”person”column=”person_id”unique=”true”not-null=”true”/>
<!-唯一的多对一，其实就便成了一对一了就会在Idcard表生成外键-->
classPerson{
privateIntegerid;
privateStringname;
privateIdCardidCard;
}
classIdCard{
privateIntegerid;
privateDatevalidate,
privatePersonperson;
}
多对多(student-course)
在操作和性能方面都不太理想，所以多对多的映射使用较少，实际使用中最好转换成一对多的对象模型；Hibernate会为我们创建中间关联表，转换成两个一对多。
publicclassStudent{
privateIntegerid;
privateStringname;
privateSet<StuCourse>stuCourses;
}
publicclassStuCourse{
privateIntegerid;
privateStudentstudent;
privateCoursecourse;
privateIntegergrade;
}
publicclassCourse{
privateIntegerid;
privateStringname;
privateSet<StuCourse>stuCourses;
}
<classname="Student">
<idname="id"type="java.lang.Integer">
<generatorclass="sequence">
<paramname="sequence">stu_seq</param>
</generator>
</id>
<propertyname="name"type="java.lang.String">
<columnname="name"length="64"/>
</property>
<!--这里我们配置了one-to-many一个学生可以对应多个选课记录-->
<setname="stuCourses">
<keycolumn="student_id"/>
<one-to-manyclass="StuCourse"/>
</set>
</class>
<classname="StuCourse">
<idname="id"type="java.lang.Integer">
<generatorclass="sequence">
<paramname="sequence">stucourse_seq</param>
</generator>
</id>
<propertyname="grade"type="java.lang.Integer">
<columnname="grade"length="3"/>
</property>
<many-to-onename="course"column="course_id"/>
<many-to-onename="student"column="student_id"/>
</class>
<classname="Course">
<idname="id"type="java.lang.Integer">
<generatorclass="sequence">
<paramname="sequence">course_seq</param>
</generator>
</id>
<propertyname="name"type="java.lang.String">
<columnname="name"length="64"/>
</property>
<!--配置one-to-many表示一门课程可以对应多个选课记录-->
<setname="stuCourses">
<keycolumn="course_id"/>
<one-to-manyclass="StuCourse"/>
</set>
</class>