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

学生类

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

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;
  2.  
  3. import java.util.Set;
  4.  
  5. import org.hibernate.Session;
  6. import org.hibernate.Transaction;
  7. import org.hibernate.cfg.Configuration;
  8.  
  9. import entity.Grade;
  10. import entity.Student;
  11.  
  12. public class Demo1 {
  13.  
  14.     /**
  15.      * 测试类
  16.      */
  17.     public static void main(String[] args) {
  18.         save();
  19.          find();
  20.         update();
  21.  
  22.     }
  23.  
  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("男");
  35.  
  36.         Student stu2 = new Student();
  37.         stu2.setSid(201504013);
  38.         stu2.setSname("李四");
  39.         stu2.setSex("女");
  40.  
  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.     }
  59.  
  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.     }
  87.  
  88.     // 查询班级
  89.     public static void find() {
  90.  
  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.     }
  105.  
  106. }

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

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

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

二、建立双向关联

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

  1. package entity;
  2.  
  3. /*
  4.  * 学生类
  5.  */
  6. public class Student implements java.io.Serializable {
  7.  
  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;
  16.  
  17.     // Constructors
  18.  
  19.     /** default constructor */
  20.     public Student() {
  21.     }
  22.  
  23.     /** minimal constructor */
  24.     public Student(int sid) {
  25.         this.sid = sid;
  26.     }
  27.  
  28.     /** full constructor */
  29.     public Student(int sid, String sname, String sex ) {
  30.  
  31.         this.sid = sid;
  32.  
  33.         this.sname = sname;
  34.         this.sex = sex;
  35.     }
  36.  
  37.     // Property accessors
  38.  
  39.     public int getSid() {
  40.         return this.sid;
  41.     }
  42.  
  43.     public void setSid(int sid) {
  44.         this.sid = sid;
  45.     }
  46.  
  47.     public String getSname() {
  48.         return this.sname;
  49.     }
  50.  
  51.     public void setSname(String sname) {
  52.         this.sname = sname;
  53.     }
  54.  
  55.     public String getSex() {
  56.         return this.sex;
  57.     }
  58.  
  59.     public void setSex(String sex) {
  60.         this.sex = sex;
  61.     }
  62.  
  63.     public Grade getGrade() {
  64.         return grade;
  65.     }
  66.  
  67.     public void setGrade(Grade grade) {
  68.         this.grade = grade;
  69.     }
  70.  
  71. }

配置文件

  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;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.cfg.Configuration;
  5.  
  6. import entity.Student;
  7.  
  8. public class Demo2 {
  9.  
  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);
  40.  
  41. Student stu2 = new Student();
  42. stu2.setSid(201504013);
  43. stu2.setSname("李四");
  44. stu2.setSex("女");
  45. stu2.setGrade(grade);
  46. // 将学生添加到班级
  47. /*grade.getStudents().add(stu1);
  48. grade.getStudents().add(stu2);*/
  49. // 建立session
  50. Session session = new Configuration().configure().buildSessionFactory()
  51. .openSession();
  52. // 开始事务
  53. Transaction transaction = session.beginTransaction();
  54. // 保存班级
  55. session.save(grade);
  56. // 保存学生
  57. session.save(stu1);
  58. session.save(stu2);
  59. // 提交事务
  60. transaction.commit();
  61. // 关闭session
  62. session.close();
  63. }

三、级联保存和删除

  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;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  6.  
  7. import entity.Grade;
  8. import entity.Student;
  9.  
  10. public class Demo3 {
  11.  
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         save();
  17.  
  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.         Student stu2 = new Student();
  33.         stu2.setSid(201504013);
  34.         stu2.setSname("李四");
  35.         stu2.setSex("女");
  36.         stu2.setGrade(grade);
  37.         // 将学生添加到班级
  38.         grade.getStudents().add(stu1);
  39.         grade.getStudents().add(stu2);
  40.         // 建立session
  41.         Session session = new Configuration().configure().buildSessionFactory()
  42.                 .openSession();
  43.         // 开始事务
  44.         Transaction transaction = session.beginTransaction();
  45.         // 保存班级
  46.         session.save(grade);
  47.         // 保存学生
  48.         //session.save(stu1);
  49.         //session.save(stu2);
  50.         // 提交事务
  51.         transaction.commit();
  52.         // 关闭session
  53.         session.close();
  54.     }
  55. }

反之，在学生类的配置文件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;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  6.  
  7. import entity.Grade;
  8. import entity.Student;
  9.  
  10. public class Demo3 {
  11.  
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         save();
  17.  
  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.         Student stu2 = new Student();
  33.         stu2.setSid(201504013);
  34.         stu2.setSname("李四");
  35.         stu2.setSex("女");
  36.         stu2.setGrade(grade);
  37.         // 将学生添加到班级
  38.         grade.getStudents().add(stu1);
  39.         grade.getStudents().add(stu2);
  40.         // 建立session
  41.         Session session = new Configuration().configure().buildSessionFactory()
  42.                 .openSession();
  43.         // 开始事务
  44.         Transaction transaction = session.beginTransaction();
  45.         // 保存班级
  46.         //session.save(grade);
  47.         // 保存学生
  48.         session.save(stu1);
  49.         session.save(stu2);
  50.         // 提交事务
  51.         transaction.commit();
  52.         // 关闭session
  53.         session.close();
  54.     }
  55. }

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>

测试类

  1. package Test;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  6.  
  7. import entity.Grade;
  8. import entity.Student;
  9.  
  10. public class Demo4 {
  11.  
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         delete() ;
  17.  
  18.     }
  19.  
  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. }

结果：发现班级表中的班级已经删除，而学生表中数据没有删除，只是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>

测试类

  1. package Test;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.Transaction;
  5. import org.hibernate.cfg.Configuration;
  6.  
  7. import entity.Grade;
  8. import entity.Student;
  9.  
  10. public class Demo4 {
  11.  
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         delete() ;
  17.  
  18.     }
  19.  
  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.         session.save(stu1);
  48.         session.save(stu2);
  49.         // 提交事务
  50.         transaction.commit();
  51.         // 关闭session
  52.         session.close();
  53.     }
  54. }

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

Hibernate(六)一对多映射(多对一)的更多相关文章

  1. 一口一口吃掉Hibernate（六）——多对多关联映射

    今天来说说hibernate中的多对多关联映射,多对多关联映射涉及到单向映射和双向映射2种. 首先举个多对多关联例子:用户User和角色Role,一个用户可以属于多个角色,一个角色可以有多个用户.这就 ...

  2. hibernate进阶--一对多映射配置

    hibernate作为一款优秀的ORM框架,广受大家喜爱,也被Java社区公认为持久层的首选.虽然jdbc为Java数据库操 作带来了诸多便利,但是并没有统一SQL语句的写法,而且具体操作数据库的代码 ...

  3. Hibernate-ORM:12.Hibernate中的多对多关联关系

    ------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 本篇博客将讲述Hibernate中的多对多关联关系的操作,准备的篇幅较少,望海涵 一,讲述多对多 多对多的关联 ...

  4. Hibernate中双向多对多的两种配置方式

    Hibernate中双向多对多的两种配置方式 1.建立多对多双向关联关系 package cn.happy.entitys; import java.util.HashSet; import java ...

  5. Hibernate ManyToOne Mappings 多对一关联映射

    Hibernate ManyToOne Mappings 多对一关联映射 Hibernate框架的使用步骤: 1.创建Hibernate的配置文件(hibernate.cfg.xml)2.创建持久化类 ...

  6. hibernate关联关系（多对多）

    数据库的多对多数据库中不能直接映射多对多 处理:创建一个桥接表(中间表),将一个多对多关系转换成两个一对多 注:数据库多表联接查询 永远就是二个表的联接查询 注2:交叉连接 注3:外连接:left(左 ...

  7. Hibernate（六）——多对多关联映射

    前面几篇文章已经较讲解了三大种关联映射,多对多映射就非常简单了,不过出于对关联映射完整性的考虑,本文还是会简要介绍下多对多关联映射. 1.单向多对多关联映射 情景:一个用户可以有多个角色,比如数据录入 ...

  8. --------------Hibernate学习(四) 多对一映射 和 一对多映射

    现实中有很多场景需要用到多对一或者一对多,比如上面这两个类图所展现出来的,一般情况下,一个部门会有多名员工,一名员工只在一个部门任职. 多对一关联映射 在上面的场景中,对于Employee来说,它跟D ...

  9. hibernate之一对多映射

    目录 第一章 课程简介 第二章 Hibernate中的单向一对多关联 2-1 一对多映射简介 2-2 hibernate的基础配置 2-3 创建HibernateUtil工具类 2-4 在mysql数 ...

随机推荐

  1. Redis_常见JedisConnectionException异常分析

    最近项目开发中用到了Redis, 选择了官网推荐的java client Jedis.Redis常用命令学习:http://redis.io/commandsRedis官方推荐Java客户端Jedis ...

  2. Latest SQLite binary for January 2015

    Latest SQLite binary for January 2015 Well I went through quite a few threads to find an updated, de ...

  3. Effective JavaScript Item 35 使用闭包来保存私有数据

    本系列作为EffectiveJavaScript的读书笔记. JavaScript的对象系统从其语法上而言并不鼓舞使用信息隐藏(Information Hiding).由于当使用诸如this.name ...

  4. NHibernate的调试技巧和Log4Net配置

    1.查看nhibernate写在控制台里的sql语句 在配置文件中有这么个选项,假如把它设置为true,nhibernate会把执行的sql显示在控制台上. <property name=&qu ...

  5. Spring初始化完成后直接执行一个方法，初始化数据（解决方法被重复执行两次的情况）

    在做WEB项目时,经常在项目第一次启动时利用WEB容器的监听.Servlet加载初始化等切入点为数据库准备数据,这些初始化数据 是系统开始运行前必须的数据,例如权限组.系统选项.默认管理员等等.但是项 ...

  6. 【hihoCoder】【挑战赛#12】

    模拟+枚举+模拟……+构造 QAQAQQQ rank12求杯子! A 顺子 ……模拟题,分类讨论一下就好了……比如当前四张牌是不是同一花色……是不是连续的四张牌,如果是连续的四张牌,是不是两边的……( ...

  7. Android触摸事件

    简单介绍: 做了一个语音发送UI的小demo. 按下显示语音窗体,依据音量调节UI音量显示,上划至窗体显示取消发送. 原理: 1:获取什么事件来运行操作: 给Button加入setOnTouchLis ...

  8. Why游戏作品合集

    之前曾经发过一个套WhyEngine游戏作品合集,里面有十几个小游戏和若干个屏保程序和若干个DEMO程序.而这次发的与上次不一样,因为这是我花了两天时间将所有的程序集成到一个工程后的成果.为了能将所有 ...

  9. 容器list使用之erase(其他容器也通用)

    今天无论如何要写点东西,算是搞清楚了一点东西吧.有点小小的成就感. 之前在程序里面使用了list容器,其中用到了erase()函数,之前一直没出现问题,这两天突然莫名奇妙.花了点时间,搞清楚了eras ...

  10. super-pow

    // https://discuss.leetcode.com/topic/50489/c-clean-and-short-solution class Solution { ; int powMod ...