Hibernate对象之间的三种关系-CFANZ编程社区

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-one name=”dept” column=”dept_id”/> 
 class Department{
 private Integer id;
 private String name;
 }
 class Employee{
 private Integer id;
 private String name;
 private Department dept;
 }

添加一个部门，并给部门加入二个人

public static void add() {
     //把对象模型-》关系模型
     //当你获取一个session ,就会让hiberate去读取
     //hibernate.cfg.xml,这就会加载对象映射文件，从而完成创建
     Session session=null;
     Transaction ts=null;
     try {            
         session=HibernateUtil.getThreadLocalSession();
         ts=session.beginTransaction();            
         //添加一个记录
         Department d1=new Department();
         d1.setName("财务部");
         Employee e1=new Employee();
         e1.setName("张三");
         e1.setDepartment(d1);
         Employee e2=new Employee();
         e2.setName("邵阳");
         e2.setDepartment(d1);            
         session.save(d1);
         session.save(e1);
         session.save(e2);            
         ts.commit();
     } catch (Exception e) {
         e.printStackTrace();
         if(ts!=null){
             ts.rollback();
         }
         // TODO: handle exception
     }finally{
         if(session!=null&&session.isOpen()){
             session.close();
         }
     }
 }

简述: 当我们查询一个对象的时候，在默认情况下,返回的只是该对象的普通属性,当用户去使用对象属性时，才会向数据库发出再一次的查询.这种现象我们称为 lazy现象 .
解决方法可以这样:
显示初始化 Hibernate.initized(代理对象)
修改对象关系文件 lazy 改写 lazy=false
通过过滤器(web项目) openSessionInView

双向一对多(Department-Employee)

Department映射文件添加
 <set name=”集合对象属性名”>
     <key column=”外键名”/>
     <one-to-many class=”集合放入的类名”/>
 </set> 
 class Department{
 private Integer id;
 private String name;
 private Set<Employee> emps
 }

一对一(Person - IdCard)
1)基于主键的one-to-one(IdCard的映射文件)

<id name=”id”>
     <generator class=”foreign ”><param name=”property”>person</param></generator>
 <id>
 <one-to-one name=” person” constrained=”true”/> 
 [没有constraned true将不会生成外键约束]
 Person映射文件： <one-to-one name=“idCard” />
 class Person{
 private Integer id;
 private String name;
 private IdCard idCard
 }
 class IdCard{
 private Integer id;
 private java.util.Date useful_life;
 private Person person
 }
 **添加案例***
 session =HibernateUtil.getThreadLocalSession();
 ts=session.beginTransaction();
 //添加一个Person Idcard
 Person p1=new Person();p1.setName("孙悟空");
 IdCard id1=new IdCard();
 id1.setUseful_time(new java.util.Date());            
 //这句话就可以表示id1是p1这个人.
 id1.setPerson(p1);
 session.save(p1);//insert
 session.save(id1);//insert

2)基于外健的one-to-one，可以描述为多对一，加unique=“true”约束,
IdCard的映射文件中:

<many-to-one name=”person” column=”person_id” unique=”true” not-null=”true”/>
 <!-唯一的多对一，其实就便成了一对一了就会在Idcard表生成外键-->
 class Person{
 private Integer id;
 private String name;
 private IdCard idCard;
 }
 class IdCard{
 private Integer id;
 private Date validate,
 private Person person;
 }

多对多(student - course)

在操作和性能方面都不太理想，所以多对多的映射使用较少，实际使用中最好转换成一对多的对象模型；Hibernate会为我们创建中间关联表，转换成两个一对多。

public class Student {
     private Integer id;
     private String name;
     private Set<StuCourse> stuCourses;
 }
 public class StuCourse {
     private Integer id;
     private Student student;
     private Course course;
     private Integer grade;
 }
 public class Course {
     private Integer id;
     private String name;
     private Set<StuCourse> stuCourses;
 }

 <class name="Student">
 <id name="id" type="java.lang.Integer">
 <generator class="sequence">
 <param name="sequence">stu_seq</param>
 </generator>
 </id>
 <property name="name" type="java.lang.String">
 <column name="name" length="64"/>
 </property>
 <!-- 这里我们配置了one-to-many 一个学生可以对应多个选课记录 -->
 <set name="stuCourses">
 <key column="student_id"/>
<one-to-many class="StuCourse"/> 
 </set>
 </class>

 <class name="StuCourse" >
 <id name="id" type="java.lang.Integer">
 <generator class="sequence">
 <param name="sequence">stucourse_seq</param>
 </generator>
 </id>
 <property name="grade" type="java.lang.Integer">
 <column name="grade" length="3"/>
 </property>
<many-to-one name="course" column="course_id"/>
 <many-to-one name="student" column="student_id"/> 
 </class>

 <class name="Course">
 <id name="id" type="java.lang.Integer">
 <generator class="sequence">
 <param name="sequence">course_seq</param>
 </generator>
 </id>
 <property name="name" type="java.lang.String">
 <column name="name" length="64"/>
 </property>
 <!-- 配置one-to-many 表示一门课程可以对应多个选课记录 -->
 <set name="stuCourses">
 <key column="course_id"/>
<one-to-many class="StuCourse"/> 
 </set>
 </class>