加载中...

Hibernate(六)一对多映射(多对一)

一、Hinbernate中持久化类的关联关系

在数据库中，表表之间是通过外键关联的，在程序中是要转化为持久化类也就是(JAVA Bean)来实例的。

但在Hibernater中持久化的之间的映射关系，不是通外键建立关联，而是通过属性.主要有以下几种

  • 一对一，
  • 一对多(多对一)
  • 多对多

关联方向：

  • 单向关联
  • 双向关联

二、一对多单向关联关系

2.1、建立数据库表

班级表，和学生表，学生生通过班级表中的，班级编号为外键

  1. --班级表
  2. create table grade
  3. (
  4.        gid       number           primary key,  --班级ID
  5.        gname     varchar2(50),                  --班级名称
  6.        gdesc     varchar2(50)                   --班级介绍
  7. );
  8. --学生表
  9. create table student
  10. (
  11.        sid       number           primary key,  --主键ID学生ID
  12.        sname     varchar2(20),            --学生姓名
  13.        sex       varchar2(20),            --学生性别
  14.        gid       number           references grade(gid) ---外键班级ID
  15. );

2.2、建立持久化类和映射配置文件

班级和学生类

  1. package entity;
  4. import java.util.HashSet;
  5. import java.util.Set;
  8. /*
  9.  * 班级类
  10.  */
  11. public class Grade implements java.io.Serializable {
  13.     // Fields
  14.     private static final long serialVersionUID = 1L;
  15.     private int gid;
  16.     private String gname;
  17.     private String gdesc;
  18.     private Set<Student> students = new HashSet<Student> ();
  20.     // Constructors
  21.  
  22.     /** default constructor */
  23.     public Grade() {
  24.     }
  26.     /** minimal constructor */
  27.     public Grade(int gid) {
  28.         this.gid = gid;
  29.     }
  31.     /** full constructor */
  32.     public Grade(int gid, String gname, String gdesc, Set<Student> students) {
  33.         this.gid = gid;
  34.         this.gname = gname;
  35.         this.gdesc = gdesc;
  36.         this.students = students;
  37.     }
  39.     // Property accessors
  40.  
  41.     public int getGid() {
  42.         return this.gid;
  43.     }
  45.     public void setGid(int gid) {
  46.         this.gid = gid;
  47.     }
  49.     public String getGname() {
  50.         return this.gname;
  51.     }
  53.     public void setGname(String gname) {
  54.         this.gname = gname;
  55.     }
  57.     public String getGdesc() {
  58.         return this.gdesc;
  59.     }
  61.     public void setGdesc(String gdesc) {
  62.         this.gdesc = gdesc;
  63.     }
  65.     public Set<Student> getStudents() {
  66.         return this.students;
  67.     }
  69.     public void setStudents(Set<Student> students) {
  70.         this.students = students;
  71.     }
  73. }
View Code

 

学生类

  1. package entity;
  3. /*
  4.  * 学生类
  5.  */
  6. public class Student implements java.io.Serializable {
  8.     // Fields
  9.  
  10.     private static final long serialVersionUID = 1L;
  11.     private int sid;
  12.     
  13.     private String sname;
  14.     private String sex;
  16.     // Constructors
  17.  
  18.     /** default constructor */
  19.     public Student() {
  20.     }
  22.     /** minimal constructor */
  23.     public Student(int sid) {
  24.         this.sid = sid;
  25.     }
  27.     /** full constructor */
  28.     public Student(int sid, String sname, String sex ) {
  29.     
  30.         this.sid = sid;
  32.         this.sname = sname;
  33.         this.sex = sex;
  34.     }
  36.     // Property accessors
  37.  
  38.     public int getSid() {
  39.         return this.sid;
  40.     }
  42.     public void setSid(int sid) {
  43.         this.sid = sid;
  44.     }
  46.     
  48.     public String getSname() {
  49.         return this.sname;
  50.     }
  52.     public void setSname(String sname) {
  53.         this.sname = sname;
  54.     }
  56.     public String getSex() {
  57.         return this.sex;
  58.     }
  60.     public void setSex(String sex) {
  61.         this.sex = sex;
  62.     }
  64. }
View Code

 

 

hibernate.cf.xml和班级、学生的配置文件

  1. <?xml version='1.0' encoding='UTF-8'?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5.  
  6. <hibernate-configuration>
  7.  
  8. <session-factory>
  9.     <property name="dialect">
  10.         org.hibernate.dialect.Oracle9Dialect
  11.     </property>
  12.     <property name="connection.url">
  13.         jdbc:oracle:thin:@localhost:1521:orcl
  14.     </property>
  15.     <property name="connection.username">root</property>
  16.     <property name="connection.password">root</property>
  17.     <property name="connection.driver_class">
  18.         oracle.jdbc.OracleDriver
  19.     </property>
  20.     <property name="show_sql">true</property>
  21.     <property name="format_sql">true</property>
  22.  
  23.     <mapping resource="entity/Grade.hbm.xml" />
  24.     <mapping resource="entity/Student.hbm.xml" />
  25.  
  26. </session-factory>
  27.  
  28. </hibernate-configuration>

持久类配置先来学生类

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Student" table="STUDENT" schema="ROOT">
  7.         <id name="sid" type="java.lang.Integer">
  8.             <column name="SID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="sname" type="java.lang.String">
  12.             <column name="SNAME" length="20" />
  13.         </property>
  14.         <property name="sex" type="java.lang.String">
  15.             <column name="SEX" length="20" />
  16.         </property>
  17.     </class>
  18. </hibernate-mapping>

班级类配置

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Grade" table="GRADE" schema="ROOT">
  7.         <id name="gid" type="java.lang.Integer">
  8.             <column name="GID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="gname" type="java.lang.String">
  12.             <column name="GNAME" length="50" />
  13.         </property>
  14.         <property name="gdesc" type="java.lang.String">
  15.             <column name="GDESC" length="50" />
  16.         </property>
  17.         <!--建立set属性，也可以建立list和持久化类中一致就行  -->
  18.         <set name="students">
  19.             <key>
  20.             <!--这里的列是指学生表中的班级编号  -->
  21.                 <column name="GID" precision="22" scale="0" />
  22.             </key>
  23.             <!-- 通过class属性指定set的属性 -->
  24.             <one-to-many class="entity.Student" />
  25.         </set>
  26.     </class>
  27. </hibernate-mapping>

测试类

  1. package Test;
  3. import java.util.Set;
  5. import org.hibernate.Session;
  6. import org.hibernate.Transaction;
  7. import org.hibernate.cfg.Configuration;
  9. import entity.Grade;
  10. import entity.Student;
  12. public class Demo1 {
  14.     /**
  15.      * 测试类
  16.      */
  17.     public static void main(String[] args) {
  18.         save();
  19.          find();
  20.         update();
  22.     }
  24.     public static void save() {
  25.         // 声明班级对象，并赋值
  26.         Grade grade = new Grade();
  27.         grade.setGid(201504);
  28.         grade.setGname("Java一班");
  29.         grade.setGdesc("刚开始学习JAVA");
  30.         // 声明2个学生对象
  31.         Student stu1 = new Student();
  32.         stu1.setSid(201504012);
  33.         stu1.setSname("张三");
  34.         stu1.setSex("男");
  36.         Student stu2 = new Student();
  37.         stu2.setSid(201504013);
  38.         stu2.setSname("李四");
  39.         stu2.setSex("女");
  41.         // 将学生添加到班级
  42.         grade.getStudents().add(stu1);
  43.         grade.getStudents().add(stu2);
  44.         // 建立session
  45.         Session session = new Configuration().configure().buildSessionFactory()
  46.                 .openSession();
  47.         // 开始事务
  48.         Transaction transaction = session.beginTransaction();
  49.         // 保存班级
  50.         session.save(grade);
  51.         // 保存学生
  52.         session.save(stu1);
  53.         session.save(stu2);
  54.         // 提交事务
  55.         transaction.commit();
  56.         // 关闭session
  57.         session.close();
  58.     }
  60.     /*
  61.      * 将基中一个学生更改为别一个班级
  62.      */
  63.     public static void update() {
  64.         // 声明班级对象，并赋值
  65.         Grade grade = new Grade();
  66.         grade.setGid(201506);
  67.         grade.setGname("Java二班");
  68.         grade.setGdesc("学习JAVA二年级");
  69.         // 获取一个学生的信息
  70.         // 建立session
  71.         Session session = new Configuration().configure().buildSessionFactory()
  72.                 .openSession();
  73.         // 开始事务
  74.         Transaction transaction = session.beginTransaction();
  75.         Student stu1=(Student) session.get(Student.class, 201504013);
  76.         //将学生添加到这个新的班级
  77.         grade.getStudents().add(stu1);
  78.         // 保存班级
  79.         session.save(grade);
  80.         // 保存学生
  81.         session.save(stu1);
  82.         // 提交事务
  83.         transaction.commit();
  84.         // 关闭session
  85.         session.close();
  86.     }
  88.     // 查询班级
  89.     public static void find() {
  91.         // 建立session
  92.         Session session = new Configuration().configure().buildSessionFactory()
  93.                 .openSession();
  94.         Grade g = (Grade) session.get(Grade.class, 201504);
  95.         System.out.println("班级信息：" + g.getGid() + "\t" + g.getGname()
  96.                 + g.getGdesc());
  97.         // 通过班级获取这个班级的学生信息
  98.         System.out.println("201504班的学生信息如下:");
  99.         Set<Student> set = g.getStudents();
  100.         for (Student stu : set) {
  101.             System.out.println(stu.getSid() + "\t" + stu.getSname() + "\t"
  102.                     + stu.getSex());
  103.         }
  104.     }
  106. }

以上只上单向关联，一般都会有双向关联

同样要在学生类中添加Grade 属性

在学生类的配置文件中配置关联字段

 二、建立双向关联

2.1、更改学生类和配置文件

  1. package entity;
  3. /*
  4.  * 学生类
  5.  */
  6. public class Student implements java.io.Serializable {
  8.     // Fields
  9.  
  10.     private static final long serialVersionUID = 1L;
  11.     private int sid;
  12.     private String sname;
  13.     private String sex;
  14.     //增加班级属性
  15.     private Grade grade;
  17.     // Constructors
  18.  
  19.     /** default constructor */
  20.     public Student() {
  21.     }
  23.     /** minimal constructor */
  24.     public Student(int sid) {
  25.         this.sid = sid;
  26.     }
  28.     /** full constructor */
  29.     public Student(int sid, String sname, String sex ) {
  30.     
  31.         this.sid = sid;
  33.         this.sname = sname;
  34.         this.sex = sex;
  35.     }
  37.     // Property accessors
  38.  
  39.     public int getSid() {
  40.         return this.sid;
  41.     }
  43.     public void setSid(int sid) {
  44.         this.sid = sid;
  45.     }
  47.     
  49.     public String getSname() {
  50.         return this.sname;
  51.     }
  53.     public void setSname(String sname) {
  54.         this.sname = sname;
  55.     }
  57.     public String getSex() {
  58.         return this.sex;
  59.     }
  61.     public void setSex(String sex) {
  62.         this.sex = sex;
  63.     }
  65.     public Grade getGrade() {
  66.         return grade;
  67.     }
  69.     public void setGrade(Grade grade) {
  70.         this.grade = grade;
  71.     }
  72.     
  74. }

配置文件 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Student" table="STUDENT" schema="ROOT">
  7.         <id name="sid" type="java.lang.Integer">
  8.             <column name="SID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="sname" type="java.lang.String">
  12.             <column name="SNAME" length="20" />
  13.         </property>
  14.         <property name="sex" type="java.lang.String">
  15.             <column name="SEX" length="20" />
  16.         </property>
  17.         <!--配置grade属性  -->
  18.         <many-to-one name="grade" class="entity.Grade">
  19.         <!--指定学生表中的外键  -->
  20.         <column name="GID" />
  21.         </many-to-one>
  22.     </class>
  23. </hibernate-mapping>

2.2、测试类

建立双向关联后，就可以通过学生来获取班级信息

清空数据表中的数据

  1. package Test;
  3. import org.hibernate.Session;
  4. import org.hibernate.cfg.Configuration;
  6. import entity.Student;
  8. public class Demo2 {
  10.     /**
  11.      * 测试类
  12.      */
  13.     public static void main(String[] args) {
  14. 　save();
  15. findByStu();
  16.     }
  17.     
  18.     public static void findByStu(){
  19.         Session session = new Configuration().configure().buildSessionFactory()
  20.                 .openSession();
  21.         //获取一个学生的信息 get方法为通过主键查询
  22.         Student stu=(Student) session.get(Student.class, 201504013);
  23.         System.out.println("学生信息:\t"+stu.getSid()+"\t"+stu.getSname()+"\t"+stu.getSex());
  24.         //通过学生信息得到班级信息
  25.         System.out.println("这个学生的班级信息："+stu.getGrade().getGid()+"\t"+stu.getGrade().getGname()+"\t"+stu.getGrade().getGdesc());
  26.     }
  27. }
  28. public static void save() {
  29. // 声明班级对象，并赋值
  30. Grade grade = new Grade();
  31. grade.setGid(201504);
  32. grade.setGname("Java一班");
  33. grade.setGdesc("刚开始学习JAVA");
  34. // 声明2个学生对象
  35. Student stu1 = new Student();
  36. stu1.setSid(201504012);
  37. stu1.setSname("张三");
  38. stu1.setSex("男");
  39. stu1.setGrade(grade);
  42. Student stu2 = new Student();
  43. stu2.setSid(201504013);
  44. stu2.setSname("李四");
  45. stu2.setSex("女");
  46. stu2.setGrade(grade);
  47. // 将学生添加到班级
  48. /*grade.getStudents().add(stu1);
  49. grade.getStudents().add(stu2);*/
  50. // 建立session
  51. Session session = new Configuration().configure().buildSessionFactory()
  52. .openSession();
  53. // 开始事务
  54. Transaction transaction = session.beginTransaction();
  55. // 保存班级
  56. session.save(grade);
  57. // 保存学生
  58. session.save(stu1);
  59. session.save(stu2);
  60. // 提交事务
  61. transaction.commit();
  62. // 关闭session
  63. session.close();
  64. }

三、级联保存和删除

  1. 能不能只保存学生时，同时保存班级呢，或者保存班级时，同时保存学生呢

3.1、cascade属性

 

保存班级时，同时保存学生信息

修改班级配置，在set标签中添加cascade属性,设置为save-update

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Grade" table="GRADE" schema="ROOT">
  7.         <id name="gid" type="java.lang.Integer">
  8.             <column name="GID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="gname" type="java.lang.String">
  12.             <column name="GNAME" length="50" />
  13.         </property>
  14.         <property name="gdesc" type="java.lang.String">
  15.             <column name="GDESC" length="50" />
  16.         </property>
  17.         <!--建立set属性，也可以建立list和持久化类中一致就行  -->
  18.         <set name="students" cascade="save-update">
  19.             <key>
  20.             <!--这里的列是指学生表中的班级编号  -->
  21.                 <column name="GID" precision="22" scale="0" />
  22.             </key>
  23.             <!-- 通过class属性指定set的属性 -->
  24.             <one-to-many class="entity.Student" />
  25.         </set>
  26.     </class>
  27. </hibernate-mapping>

测试类

  1. package Test;
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  7. import entity.Grade;
  8. import entity.Student;
  10. public class Demo3 {
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         save();
  18.     }
  19.     public static void save() {
  20.         // 声明班级对象，并赋值
  21.         Grade grade = new Grade();
  22.         grade.setGid(201504);
  23.         grade.setGname("Java一班");
  24.         grade.setGdesc("刚开始学习JAVA");
  25.         // 声明2个学生对象
  26.         Student stu1 = new Student();
  27.         stu1.setSid(201504012);
  28.         stu1.setSname("张三");
  29.         stu1.setSex("男");
  30.         stu1.setGrade(grade);
  31.         
  32.         
  33.         Student stu2 = new Student();
  34.         stu2.setSid(201504013);
  35.         stu2.setSname("李四");
  36.         stu2.setSex("女");
  37.         stu2.setGrade(grade);
  38.         // 将学生添加到班级
  39.         grade.getStudents().add(stu1);
  40.         grade.getStudents().add(stu2);
  41.         // 建立session
  42.         Session session = new Configuration().configure().buildSessionFactory()
  43.                 .openSession();
  44.         // 开始事务
  45.         Transaction transaction = session.beginTransaction();
  46.         // 保存班级
  47.         session.save(grade);
  48.         // 保存学生
  49.         //session.save(stu1);
  50.         //session.save(stu2);
  51.         // 提交事务
  52.         transaction.commit();
  53.         // 关闭session
  54.         session.close();
  55.     }
  56. }

反之，在学生类的配置文件one-many中添加cascade属性设置为save-update

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Student" table="STUDENT" schema="ROOT">
  7.         <id name="sid" type="java.lang.Integer">
  8.             <column name="SID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="sname" type="java.lang.String">
  12.             <column name="SNAME" length="20" />
  13.         </property>
  14.         <property name="sex" type="java.lang.String">
  15.             <column name="SEX" length="20" />
  16.         </property>
  17.         <!--配置grade属性  -->
  18.         <many-to-one name="grade" class="entity.Grade" cascade="save-update">
  19.         <!--指定学生表中的外键  -->
  20.         <column name="GID" />
  21.         </many-to-one>
  22.     </class>
  23. </hibernate-mapping>
  1. package Test;
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  7. import entity.Grade;
  8. import entity.Student;
  10. public class Demo3 {
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         save();
  18.     }
  19.     public static void save() {
  20.         // 声明班级对象，并赋值
  21.         Grade grade = new Grade();
  22.         grade.setGid(201504);
  23.         grade.setGname("Java一班");
  24.         grade.setGdesc("刚开始学习JAVA");
  25.         // 声明2个学生对象
  26.         Student stu1 = new Student();
  27.         stu1.setSid(201504012);
  28.         stu1.setSname("张三");
  29.         stu1.setSex("男");
  30.         stu1.setGrade(grade);
  31.         
  32.         
  33.         Student stu2 = new Student();
  34.         stu2.setSid(201504013);
  35.         stu2.setSname("李四");
  36.         stu2.setSex("女");
  37.         stu2.setGrade(grade);
  38.         // 将学生添加到班级
  39.         grade.getStudents().add(stu1);
  40.         grade.getStudents().add(stu2);
  41.         // 建立session
  42.         Session session = new Configuration().configure().buildSessionFactory()
  43.                 .openSession();
  44.         // 开始事务
  45.         Transaction transaction = session.beginTransaction();
  46.         // 保存班级
  47.         //session.save(grade);
  48.         // 保存学生
  49.         session.save(stu1);
  50.         session.save(stu2);
  51.         // 提交事务
  52.         transaction.commit();
  53.         // 关闭session
  54.         session.close();
  55.     }
  56. }
View Code

 

3.2、inverse属性

 

首先在班级类中设置invers属性为false时，删除班级

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Grade" table="GRADE" schema="ROOT">
  7.         <id name="gid" type="java.lang.Integer">
  8.             <column name="GID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="gname" type="java.lang.String">
  12.             <column name="GNAME" length="50" />
  13.         </property>
  14.         <property name="gdesc" type="java.lang.String">
  15.             <column name="GDESC" length="50" />
  16.         </property>
  17.         <!--建立set属性，也可以建立list和持久化类中一致就行  -->
  18.         <set name="students" cascade="save-update" inverse="false">
  19.             <key>
  20.             <!--这里的列是指学生表中的班级编号  -->
  21.                 <column name="GID" precision="22" scale="0" />
  22.             </key>
  23.             <!-- 通过class属性指定set的属性 -->
  24.             <one-to-many class="entity.Student" />
  25.         </set>
  26.     </class>
  27. </hibernate-mapping>
View Code

测试类

  1. package Test;
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  7. import entity.Grade;
  8. import entity.Student;
  10. public class Demo4 {
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         delete() ;
  18.     }
  20.     public static void delete() {
  21.         
  22.         // 建立session
  23.         Session session = new Configuration().configure().buildSessionFactory()
  24.                 .openSession();
  25.         // 开始事务
  26.         Transaction transaction = session.beginTransaction();
  27.         // 保存班级
  28.         Grade grade=(Grade) session.get(Grade.class, 201504);
  29.         // 保存学生
  30.         session.delete(grade);
  31.         // 提交事务
  32.         transaction.commit();
  33.         // 关闭session
  34.         session.close();
  35.     }
  36. }
View Code

结果：发现班级表中的班级已经删除，而学生表中数据没有删除，只是GID字段为NULL

下面将inverse设置为true时，添加新学生，和新的班级

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4.  
  5. <hibernate-mapping>
  6.     <class name="entity.Grade" table="GRADE" schema="ROOT">
  7.         <id name="gid" type="java.lang.Integer">
  8.             <column name="GID" precision="22" scale="0" />
  9.             <generator class="assigned" />
  10.         </id>
  11.         <property name="gname" type="java.lang.String">
  12.             <column name="GNAME" length="50" />
  13.         </property>
  14.         <property name="gdesc" type="java.lang.String">
  15.             <column name="GDESC" length="50" />
  16.         </property>
  17.         <!--建立set属性，也可以建立list和持久化类中一致就行  -->
  18.         <set name="students" cascade="save-update" inverse="true">
  19.             <key>
  20.             <!--这里的列是指学生表中的班级编号  -->
  21.                 <column name="GID" precision="22" scale="0" />
  22.             </key>
  23.             <!-- 通过class属性指定set的属性 -->
  24.             <one-to-many class="entity.Student" />
  25.         </set>
  26.     </class>
  27. </hibernate-mapping>
View Code

测试类

  1. package Test;
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  7. import entity.Grade;
  8. import entity.Student;
  10. public class Demo4 {
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         delete() ;
  18.     }
  20.     public static void delete() {
  21.         
  22.         // 声明班级对象，并赋值
  23.                 Grade grade = new Grade();
  24.                 grade.setGid(201509);
  25.                 grade.setGname("Java三班");
  26.                 grade.setGdesc("ASP.NET");
  27.                 // 声明2个学生对象
  28.                 Student stu1 = new Student();
  29.                 stu1.setSid(201509009);
  30.                 stu1.setSname("王五");
  31.                 stu1.setSex("女");
  32.                 stu1.setGrade(grade);
  33.                 
  34.                 Student stu2 = new Student();
  35.                 stu2.setSid(201509045);
  36.                 stu2.setSname("赵六");
  37.                 stu2.setSex("女");
  38.                 stu2.setGrade(grade);
  39.         
  40.         // 建立session
  41.         Session session = new Configuration().configure().buildSessionFactory()
  42.                 .openSession();
  43.         // 开始事务
  44.         Transaction transaction = session.beginTransaction();
  45.     
  46.         
  47.         // 保存学生
  48.         session.save(stu1);
  49.         session.save(stu2);
  50.         // 提交事务
  51.         transaction.commit();
  52.         // 关闭session
  53.         session.close();
  54.     }
  55. }
View Code

结果发现，我并没有用班级添加学生，也没有保存班级，只是保存了学生，班级信息一起保存了 

还没有评论.