Hibernate 一对多双向关联Demo

以Classes[班级]和Student[学生]为例的Demo

//Classes.java

public class Classes implements Serializable {

    private long cid;

    private String cname;

    private String cdesc;

    private Set<Student> students;

     //get和set

}

//Student .java

public class Student implements Serializable {

    private long sid;

    private String sname;

    private String sdesc;

    private Classes classes;

    //get和set

}

 <?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">

 <hibernate-mapping>

     <class name="cn.test.testDoubl.Classes" >

         <id name="cid" type="java.lang.Long" length="5">

             <column name="cid"></column>

             <generator class="increment"></generator>

         </id>

         <property name="cname" type="java.lang.String" length="20"></property>

         <property name="cdesc" type="java.lang.String" length="50"></property>

         <!--

             cascade指的是对象对对象的操作

             inverse指的是对象对关系的操作

          -->

         <set name="students" cascade="all">

             <key>

             <!--

                     通过classes建立与student之间的联系

                  -->

                 <column name="cid"></column>

             </key>

             <one-to-many class="cn.test.testDoubl.Student"/>

         </set>

     </class>

 </hibernate-mapping>

 <?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">

 <hibernate-mapping>

     <class name="cn.test.testDoubl.Student">

         <id name="sid" type="java.lang.Long" length="5">

             <column name="sid"></column>

             <generator class="increment"></generator>

         </id>

         <property name="sname" type="java.lang.String" length="20"></property>

         <property name="sdesc" type="java.lang.String" length="50"></property>

         <!--

             多对一

                注意：在many-to-one中没有inverse属性

                      对student表的修改本身就是维护外键

          -->

         <many-to-one name="classes" class="cn.test.testDoubl.Classes" cascade="all">

         <!--

                 外键

                    描述了通过student建立与classes之间的联系

              -->

             <column name="cid"></column>

         </many-to-one>

     </class>

 </hibernate-mapping>

总结：

当发生transaction.commit的时候，hibernate内部会检查所有的持久化对象会对持久化对象做一个更新,因为classes是一个持久化状态的对象，所以hibernate 内部要对classes进行更新，因为在classes.hbm.xml文件中<set name="students" cascade="all" inverse="true"> 意味着在更新classes的时候，要级联操作student,而student是一个临时状态的对象所以要对student进行保存，在保存student的时候，就把外键更新了。

 package cn.test.testDoubl;

 import java.util.HashSet;

 import java.util.Set;

 import org.hibernate.Session;

 import org.hibernate.SessionFactory;

 import org.hibernate.Transaction;

 import org.hibernate.cfg.Configuration;

 import org.junit.Test;

 public class DoTestDoubl {

     private static SessionFactory sessionFactory;

     static{

         Configuration configuration=new Configuration();

         configuration.configure("cn/test/testDoubl/hibernate.cfg.xml");

         sessionFactory=configuration.buildSessionFactory();

     }

     /**

      * 1、保存班级

      * 2、保存学生

      * 3、保存班级的时候同时保存学生

      * 4、保存班级的时候同时保存学生，并且建立班级和学生之间的关系

      * 5、已经存在一个班级，新建一个学生，并且建立该学生和该班级之间的关系

      * 6、已经存在一个学生，新建一个班级，并且建立该学生和该班级之间的关系

      * 7、已经存在一个学生，已经存在一个班级，解除该学生和原来班级之间的关系，建立该学生和新班级之间的关系

      * 8、已经存在一个学生，解除该学生和该学生所在班级之间的关系

      * 9、解除该班级和所有的学生之间的关系，再重新建立该班级和一些新的学员之间的关系

      * 10、解除该班级和所有的学生之间的关系

      * 11、删除班级

      *      *

      *          *  解除该班级和所有的学生之间的关系

      *          *  删除该班级

      *      *

      *          删除班级的同时删除学生

      * 12、删除学生

      *      同删除班级

      */

     //3、保存班级的时候同时保存学生

     /*

      *  Hibernate: select max(cid) from Classes

         Hibernate: select max(sid) from Student

         Hibernate: insert into Classes (cname, cdesc, cid) values (?, ?, ?)

         Hibernate: insert into Student (sname, sdesc, cid, sid) values (?, ?, ?, ?)

         Hibernate: update Student set cid=? where sid=?

      */

     @Test

     public void testSaveClassesandStudent(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Student student=new Student();

         student.setSname("1111");

         student.setSdesc("111111111111");

         Set<Student> set=new HashSet<Student>();

         set.add(student);

         Classes classes=new Classes();

         classes.setCname("oo1");

         classes.setCdesc("我们都是No。1");

         classes.setStudents(set);

         session.save(classes);

         transaction.commit();

         session.close();

     }

     //4、保存班级的时候同时保存学生，并且建立班级和学生之间的关系

     /*

      *  Hibernate: select max(sid) from Student

         Hibernate: select max(cid) from Classes

         Hibernate: insert into Classes (cname, cdesc, cid) values (?, ?, ?)

         Hibernate: insert into Student (sname, sdesc, cid, sid) values (?, ?, ?, ?)

      */

     @Test

     public void testSaveClassesandStudent2(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Student student=new Student();

         student.setSname("1111");

         student.setSdesc("111111111111");

         Classes classes=new Classes();

         classes.setCname("oo1");

         classes.setCdesc("我们都是No。1");    

         student.setClasses(classes);//通过student来维护classes

                                     //对student的增、删、改本身就是对外键的操作，所以这里不再发出update语句

                                      //一对多，多的一方维护关系，效率比较高

         session.save(student);

         transaction.commit();

         session.close();

     }

     //5、已经存在一个班级，新建一个学生，并且建立该学生和该班级之间的关系

     /*

      *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, classes0_.cdesc as cdesc0_0_ from Classes classes0_ where classes0_.cid=?

         Hibernate: select max(sid) from Student

         Hibernate: insert into Student (sname, sdesc, cid, sid) values (?, ?, ?, ?)

      */

     @Test

     public void testSaveStudentToClasses(){

         Session session =sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 1L);

         Student student=new Student();

         student.setSname("王尼玛");

         student.setSdesc("暴走漫画，就是劲爆");

         student.setClasses(classes);

         session.save(student);

         transaction.commit();

         session.close();

     }

     //6、已经存在一个学生，新建一个班级，并且建立该学生和该班级之间的关系

     /*

      *  Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, student0_.sdesc as sdesc1_0_, student0_.cid as cid1_0_ from Student student0_ where student0_.sid=?

         Hibernate: select max(cid) from Classes

         Hibernate: insert into Classes (cname, cdesc, cid) values (?, ?, ?)

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

      */

     @Test

     public void testSaveClassesToStudent(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Student student=(Student) session.get(Student.class, 1L);

         Classes classes=new Classes();

         classes.setCname("黑客集训");

         classes.setCdesc("里面都是牛人");

         student.setClasses(classes);

         session.save(classes);

         transaction.commit();

         session.close();

     }

     //7、已经存在一个学生，已经存在一个班级，解除该学生和原来班级之间的关系，建立该学生和新班级之间的关系

     /*

      *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, classes0_.cdesc as cdesc0_0_ from Classes classes0_ where classes0_.cid=?

         Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, student0_.sdesc as sdesc1_0_, student0_.cid as cid1_0_ from Student student0_ where student0_.sid=?

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

      */

     @Test

     public void testToRebuild(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 1L);

         Student student=(Student) session.get(Student.class, 1L);

         student.setClasses(classes);

         transaction.commit();

         session.close();

     }

     //8、已经存在一个学生，解除该学生和该学生所在班级之间的关系

     /*

      *  Hibernate: select student0_.sid as sid1_0_, student0_.sname as sname1_0_, student0_.sdesc as sdesc1_0_, student0_.cid as cid1_0_ from Student student0_ where student0_.sid=?

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

      */

     @Test

     public void testToRomove(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Student student=(Student) session.get(Student.class, 1L);

         student.setClasses(null);

         transaction.commit();

         session.close();

     }

     //9、解除该班级和所有的学生之间的关系，再重新建立该班级和一些新的学员之间的关系

     /*

      *  Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, classes0_.cdesc as cdesc0_0_ from Classes classes0_ where classes0_.cid=?

         Hibernate: select students0_.cid as cid0_1_, students0_.sid as sid1_, students0_.sid as sid1_0_, students0_.sname as sname1_0_, students0_.sdesc as sdesc1_0_, students0_.cid as cid1_0_ from Student students0_ where students0_.cid=?

         Hibernate: select max(sid) from Student

         Hibernate: insert into Student (sname, sdesc, cid, sid) values (?, ?, ?, ?)

         Hibernate: insert into Student (sname, sdesc, cid, sid) values (?, ?, ?, ?)

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

         Hibernate: update Student set sname=?, sdesc=?, cid=? where sid=?

         Hibernate: update Student set cid=? where sid=?

         Hibernate: update Student set cid=? where sid=?

      */

     @Test

     public void testremoveAndRebuild(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 2L);

         Set<Student> students=classes.getStudents();

         for(Student student:students)

         {

             student.setClasses(null);

         }

         Student student=new Student();

         student.setSname("新建1");

         student.setSdesc("新建轩辕rtyuio");

         Student student2=new Student();

         student2.setSname("新建2");

         student2.setSdesc("新建轩sdfghyujikol;辕rtyuio");

         students.add(student);

         students.add(student2);

         transaction.commit();

         session.close();

     }

     //10、解除该班级和所有的学生之间的关系

     @Test

     public void testRemoveAllStudents(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 2L);

         Set<Student> students= classes.getStudents();

         for(Student student:students){

             student.setClasses(null);

         }

         transaction.commit();

         session.close();

     }

     //11、删除班级

     //先解除关系，再删除班级

     @Test

     public void testDeleteClasses(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 1L);

         Set<Student> set=classes.getStudents();

         for(Student student:set){

             student.setClasses(null);

         }

         session.delete(classes);

         transaction.commit();

         session.close();

     }

     //在删除班级的时候，同时删除整个班级的学生

     @Test

     public void testDeleteClasses2(){

         Session session=sessionFactory.openSession();

         Transaction transaction=session.beginTransaction();

         Classes classes=(Classes) session.get(Classes.class, 2L);

         Set<Student> set=classes.getStudents();

         for(Student student:set){

             student.setClasses(null);

             break;

         }

         //session.delete(classes);

         transaction.commit();

         session.close();

     }

 }

一对多双向关联例子

巴特西

Hibernate 一对多双向关联Demo

最新文章

热门文章