hibernate关联关系

hibernate是一个强大的ORM框架，为了使用面向对象的方式管理数据库，hibernate提供了4中关系设置:

1.一对一 （one-to-one）

2.一对多 （one-to-many）

3.多对一 （many-to-one）

4.多对多 （many-to-many）

5最常用的关系是一对多和多对一

6.实现方式：

一对多：在"一方"定义“多方”的集合(set集合)

多对一: 在“多方”定义“一方”的引用(对象属性),多对一和数据库中的关系类似。

多对多：同时在双方设置对方集合

7.双向和单向：单向就是只在一方建立关系，缺点是只能通过一方找到另一方，而无法通过另一方找到一方。双向是在两端都建立关系，这样比较灵活

使用了hibernatr的关联之后，就可以很方便的使用hibernate多表操作

 

//下面是就学生和班级来建立起关系，学生和班级是多对一关系，班级和学生是一对多关系。使用双向同时在两方设置关联

 package model;

 import java.io.Serializable;

 //多对一
 //学生表 n : 1班级表
 //在多的一方定义一方引用
 public class Student implements Serializable {
     private int sid;
     private String sname;
     private String sex;
     private int gid;//班级外键

     //一方的引用
     private Grade grade; 

     public Student(){

     }

     public Student(int sid) {
         super();
         this.sid = sid;
     }

     public int getGid() {
         return this.getGrade().getGid();
     }

     public void setGid(int gid) {
         this.gid = gid;
     }

     public Grade getGrade() {
         return grade;
     }

     public void setGrade(Grade grade) {
         this.grade = grade;
     }

     public Student(String sname, String sex) {
         super();
         this.sname = sname;
         this.sex = sex;
     }

     public int getSid() {
         return sid;
     }
     public void setSid(int sid) {
         this.sid = sid;
     }
     public String getSname() {
         return sname;
     }
     public void setSname(String sname) {
         this.sname = sname;
     }
     public String getSex() {
         return sex;
     }
     public void setSex(String sex) {
         this.sex = sex;
     }

 }

//实体类建立好之后，可以通过hibernate插件自动生成关系

   <!-- 单向多对一配置，在多方关联一方外键 -->
         <many-to-one name="grade" class="model.Grade" access="field" fetch="join">
             <column name="gid" />
         </many-to-one>

//班级表

 package model;

 import java.io.Serializable;
 import java.util.Set;

 public class Grade implements Serializable{
     private int gid;
     private String gname;
     private String gdesc;

     private Set<Student> student; //定义学生集合，一对多，在一方定义多方集合

     public Set<Student> getStudent() {
         return student;
     }

     public void setStudent(Set<Student> student) {
         this.student = student;
     }

     public Grade(){

     }

     public Grade(int gid, String gname, String gdesc) {
         super();
         this.gid = gid;
         this.gname = gname;
         this.gdesc = gdesc;
     }

     public Grade(int gid) {
         super();
         this.gid = gid;
     }

     public Grade(String gname, String gdesc) {
         super();
         this.gname = gname;
         this.gdesc = gdesc;
     }

     public int getGid() {
         return gid;
     }

     public void setGid(int gid) {
         this.gid = gid;
     }

     public String getGname() {
         return gname;
     }

     public void setGname(String gname) {
         this.gname = gname;
     }

     public String getGdesc() {
         return gdesc;
     }

     public void setGdesc(String gdesc) {
         this.gdesc = gdesc;
     }

 }

//班级表关系配置

  <!-- 配置一对多关系，设置多方集合 -->
         <set name="student" inverse="true" cascade="all">
            <key column="gid"></key>
            <one-to-many class="model.Student"/>
         </set>

//测试类

 package test;

 import java.util.Set;

 import org.hibernate.Session;
 import org.hibernate.Transaction;

 import util.HibernateUtil;
 import model.Grade;
 import model.Student;

 public class Test {
     public static void main(String[] args) {
 //        save();
 //        findGradeByStudent(1);
         findStudentByGrade(1);
     }

     //保存,比较鸡肋，主要用于关联查询，删除等
     public static void save(){
         Grade grade = new Grade(1);
         Student student2 = new Student("廖海2", "男");

         //设置多对一关联关系(外键)
         student2.setGrade(grade); 

         //执行操作
         Session session = HibernateUtil.getSession();
         Transaction tx = session.beginTransaction();//开启事务
         session.save(student2);
         System.out.println("save is ok!");
         tx.commit(); //事务落地
         HibernateUtil.closeSession();//关闭连接

     }

     //根据学生id查询出学生所在班级信息
     public static void findGradeByStudent(int sid){
         //执行操作
         Session session = HibernateUtil.getSession();
         //查询学生
         Student student1 = (Student) session.get(Student.class, new Integer(sid)); //使用Integer封装，类才能序列化，变量不能序列化
         System.out.println(student1.getSname());
         //输出班级信息
         System.out.println(student1.getSid() + student1.getGrade().getGname() + student1.getGrade().getGdesc());
         //关闭连接
         HibernateUtil.closeSession();
     }

     //根据学生班级id，查询出班级中所有学生的信息
     public static void findStudentByGrade(int gid){
         Session session = HibernateUtil.getSession();
         //查询班级
         Grade grade = (Grade) session.get(Grade.class, gid);
         //查询班级中的学生集合
         Set<Student> studentSet = grade.getStudent();
         for(Student student : studentSet){
             System.out.println("班级id:"  + student.getGid());
             System.out.println("学生id:"  + student.getSid());
             System.out.println("学生姓名:"  + student.getSname());
             System.out.println("学生性别:"  + student.getSex());
             System.out.println("=============================");
         }

     }    

 }

//设置好关系之后，运行hibernate，hibernate会自动帮我们在数据库中为表关联外键。