正文
java框架之Hibernate(3)-一对多和多对多关系操作
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
一对多
例：一个班级可以有多个学生，而一个学生只能属于一个班级。
模型
package com.zze.bean;import java.util.HashSet;import java.util.Set;public class Class { private Integer id; private String name; private Set<Student> students = new HashSet<>(); public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Set<Student> getStudents() { return students; } public void setStudents(Set<Student> students) { this.students = students; }}
班级：com.zze.bean.Class
package com.zze.bean;import java.util.Date;public class Student { private Integer id; private String name; private Integer age; private Date birthday; private String address; private Class clazz; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public Class getClazz() { return clazz; } public void setClazz(Class clazz) { this.clazz = clazz; }}
学生：com.zze.bean.Student
配置文件
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Class" table="class"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <!-- set : name : ‘多’的一方在当前类中的属性名 --> <set name="students"> <!-- key : column : 外键表中的关联当前类对应表的外键名称 --> <key column="cid"/> <!-- one-to-many : 标识一对多关系 class : ‘多’的一方全限定类名 --> <one-to-many class="com.zze.bean.Student"/> </set> </class></hibernate-mapping>
com/zze/bean/Class.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <!-- many-to-one : 标识多对一关系 name : ‘一’的一方在当前类中属性名 column : 外键名称 class : ‘一’的一方的全限定类名 --> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class"/> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://192.168.208.153:3306/test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.format_sql">true</property> <property name="current_session_context_class">thread</property> <property name="hibernate.hbm2ddl.auto">create</property> <mapping resource="com/zze/bean/Class.hbm.xml"></mapping> <mapping resource="com/zze/bean/Student.hbm.xml"></mapping> </session-factory></hibernate-configuration>
hibernate.cfg.xml
普通操作
@Testpublic void test1() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); // 创建一个班级 Class clazz = new Class(); clazz.setName("1班"); // 创建两个学生 Student student1 = new Student(); student1.setName("张三"); Student student2 = new Student(); student2.setName("李四"); // 让班级关联学生 clazz.getStudents().add(student1); clazz.getStudents().add(student2); // 让学生关联班级 student1.setClazz(clazz); student2.setClazz(clazz); // 保存班级 session.save(clazz); // 保存学生 session.save(student1); session.save(student2); transaction.commit();}
例 1：两方关联，保存两方 - 新建一个班级，新建两个学生，班级主动关联学生，学生也主动关联班级，保存班级，再保存学生，成功
@Testpublic void test2() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); // 创建一个班级 Class clazz = new Class(); clazz.setName("1班"); // 创建两个学生 Student student1 = new Student(); student1.setName("张三"); Student student2 = new Student(); student2.setName("李四"); // 让班级关联学生 clazz.getStudents().add(student1); clazz.getStudents().add(student2); // 让学生关联班级 student1.setClazz(clazz); student2.setClazz(clazz); // 保存班级 session.save(clazz); transaction.commit(); /* 抛异常：org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: com.zze.bean.Student 原因是：保存班级时，班级关联的学生为瞬时态对象，不能与瞬时态对象建立关系。 */}
例 2：两方关联，保存一方 - 新建一个班级，新建两个学生，班级主动关联学生，学生也主动关联班级，只保存班级，异常，需使用下面的级联保存。
级联操作
级联指的是：操作一个对象的时候，是否会同时操作其关联的对象。
操作一的一方的时候，是否会同时操作到多的一方。
操作多的一方的时候，是否会同时操作到一的一方。
级联保存或更新
保存‘一’级联保存‘多’：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Class" table="class"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <set name="students" cascade="save-update"> <key column="cid"/> <one-to-many class="com.zze.bean.Student"/> </set> </class></hibernate-mapping>
com/zze/bean/Class.hbm.xml：修改‘一’（班级）的映射文件，在 set 标签中添加属性 cascade="save-update"
@Testpublic void test3() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); // 创建一个班级 Class clazz = new Class(); clazz.setName("1班"); // 创建两个学生 Student student1 = new Student(); student1.setName("张三"); Student student2 = new Student(); student2.setName("李四"); // 让班级关联学生 clazz.getStudents().add(student1); clazz.getStudents().add(student2); // 保存班级级联保存学生 session.save(clazz); transaction.commit();}
例 3：‘一’方关联，保存‘一’方 - 新建一个班级，新建两个学生，班级主动关联学生，只保存班级，级联保存了学生，成功
保存‘多’级联保存‘一’：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update"/> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml：修改‘多’（学生）的映射文件，在 many-to-one 标签中添加属性 cascade="save-update"
@Testpublic void test4(){ Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); // 创建一个班级 Class clazz = new Class(); clazz.setName("1班"); // 创建两个学生 Student student1 = new Student(); student1.setName("张三"); Student student2 = new Student(); student2.setName("李四"); // 让学生关联班级 student1.setClazz(clazz); student2.setClazz(clazz); // 保存学生级联保存班级 session.save(student1); session.save(student2); transaction.commit();}
例 4：‘多’方关联，保存‘多’方 - 新建一个班级，新建两个学生，学生主动关联班级，只保存学生，级联保存了班级，成功
级联删除
假如表中已有如下数据：
删除‘一’级联删除‘多’：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Class" table="class"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <set name="students" cascade="save-update,delete"> <key column="cid"/> <one-to-many class="com.zze.bean.Student" /> </set> </class></hibernate-mapping>
com/zze/bean/Class.hbm.xml：修改‘一’（班级）的映射文件，在 set 标签中添加属性 cascade="delete"
@Testpublic void test5() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Class clazz = session.get(Class.class, 1); session.delete(clazz); transaction.commit();}
例 5：删除班级，级联删除该班级下所有学生。
删除‘多’级联删除‘一’：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update,delete"/> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml：修改‘多’（学生）的映射文件，在 many-to-one 标签中添加属性 cascade="delete"
@Testpublic void test6() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = session.get(Student.class, 1); session.delete(student); transaction.commit(); // 级联删除‘一’的一方，将其它关联‘一’的一方的数据的外键设为 null。 // 如果‘一’的一方也设置了级联删除，那么所有关联‘一’的一方的数据都会被删除。}
例 6：删除学生，级联删除该学生所属班级。
原因是当‘一’的一方维护关系时，Hibernate 会额外发出一条 select 语句查出它所关联的所有的多的一方，显然没必要。而多的一方维护关系就比较简单了，直接 update 它本身的外键即可。
看到过一个有趣应景的说法：十三亿人民（‘多’）记住（维护）国家领导人的名字很简单，但要想国家领导人（‘一’）记住（维护）十三亿就不可能了。
@Testpublic void test8() { // com/zze/bean/Class.hbm.xml 的 set 中设置了 cascade="save-update"、inverse="true" Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = new Student(); student.setName("王五"); Class clazz = session.get(Class.class, 2); // 获取 1 班 clazz.getStudents().add(student); session.save(clazz); transaction.commit(); /* 上述代码执行结果会是怎么样？ 先明确 cascade 和 inverse 的作用： cascade：为 save-update，即 Class 会级联保存和更新 Student。 inverse：为 true，即 Class 放弃维护外键关系。 首先 session 保存的是 clazz，clazz 是持久态对象。 在事务提交时 clazz 的外键字段 students 发生了变化，添加了 student， 班级有级联操作学生的能力,所以“王五”这个 student 会被保存到数据库。 而班级放弃了维护外键关系，所以“王五”这个 student 添加到数据库后对应的外键字段为 null。 结果如下： mysql> select * from student; +----+--------+------+----------+---------+------+ | id | name | age | birthday | address | cid | +----+--------+------+----------+---------+------+ | 1 | 张三 | NULL | NULL | NULL | 1 | | 2 | 王五 | NULL | NULL | NULL | NULL | +----+--------+------+----------+---------+------+ 2 rows in set (0.00 sec) */}
例 8：
级联保存或更新
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update,delete"/> <set name="courses" table="student_course" cascade="save-update"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="studentId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Course" column="courseId"/> </set> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml：修改 set 标签，添加属性 cascade="save-update"
@Testpublic void test10() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = new Student(); student.setName("张三"); Course course = new Course(); course.setName("数学"); student.getCourses().add(course); session.save(student); transaction.commit();}
例 10：一方关联，保存一方 - 新建一个学生，新建一个课程，让学生主动关联课程，保存学生，级联保存了课程，成功
级联删除
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update,delete"/> <set name="courses" table="student_course" cascade="save-update,delete"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="studentId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Course" column="courseId"/> </set> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml：修改 set 标签，添加属性 cascade="delete"
@Testpublic void test11() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = session.get(Student.class, 1); session.delete(student); transaction.commit();}
例 11：删除学生，级联删除该学生所选的课程
放弃维护外键关系
假入表中已有如下数据：
先要把张三从 1 班转到 2 班：
@Testpublic void test7(){ Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = session.get(Student.class, 1); // 获取张三 Class clazz = session.get(Class.class, 1); // 获取 2 班 clazz.getStudents().add(student); student.setClazz(clazz); transaction.commit(); /* 此时会执行一下两条 SQL： Hibernate: update student set name=?, age=?, birthday=?, address=?, cid=? where id=? Hibernate: update student set cid=? where id=? */}
例 7：
执行两条 SQL 的原因是：在上述代码中获取了两个持久态对象，并且在事务提交时两个持久态对象的属性都发生了变化，所以 Hibernate 发出了两条 SQL。
但显然这个操作其实一条 SQL 就能搞定的，这个时候就需要控制一方不维护外键关系了。
‘一’的一方放弃维护外键关系：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Class" table="class"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <set name="students" cascade="save-update" inverse="true"> <key column="cid"/> <one-to-many class="com.zze.bean.Student" /> </set> </class></hibernate-mapping>
com/zze/bean/Class.hbm.xml：修改‘一’（班级）映射文件，在 set 标签中添加属性 inverse="true"
依旧是执行上述“例 7”代码，会发现只会由‘多’（学生）的一方发出一条 update 语句。
在 Hibernate 中，‘多’的一方不可以放弃维护外键关系。
多对多
例：一名学生可以选多门课程，一门课程也可以被多名学生选择：
模型
package com.zze.bean;import java.util.Date;import java.util.HashSet;import java.util.Set;public class Student { private Integer id; private String name; private Integer age; private Date birthday; private String address; private Class clazz; private Set<Course> courses = new HashSet<>(); public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public Class getClazz() { return clazz; } public void setClazz(Class clazz) { this.clazz = clazz; } public Set<Course> getCourses() { return courses; } public void setCourses(Set<Course> courses) { this.courses = courses; }}
学生：com.zze.bean.Student
package com.zze.bean;import java.util.HashSet;import java.util.Set;public class Course { private Integer id; private String name; private Set<Student> students = new HashSet<>(); public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Set<Student> getStudents() { return students; } public void setStudents(Set<Student> students) { this.students = students; }}
课程：com.zze.bean.Course
配置文件
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update,delete"/> <set name="courses" table="student_course"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="studentId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Course" column="courseId"/> </set> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Course" table="course"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <set name="students" table="student_course"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="courseId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Student" column="studentId"/> </set> </class></hibernate-mapping>
com/zze/bean/Course.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://192.168.208.153:3306/test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.format_sql">true</property> <property name="current_session_context_class">thread</property> <property name="hibernate.hbm2ddl.auto">create</property> <mapping resource="com/zze/bean/Class.hbm.xml"></mapping> <mapping resource="com/zze/bean/Student.hbm.xml"></mapping> <mapping resource="com/zze/bean/Course.hbm.xml"></mapping> </session-factory></hibernate-configuration>
hibernate.cfg.xml
普通操作
@Testpublic void test9() { Session session = HibernateUtil.getCurrentSession(); Transaction transaction = session.beginTransaction(); Student student = new Student(); student.setName("张三"); Course course = new Course(); course.setName("数学"); student.getCourses().add(course); course.getStudents().add(student); session.save(student); session.save(course); transaction.commit(); /* 抛异常：org.hibernate.exception.ConstraintViolationException: could not execute statement 原因：因为多对多关系的维护是依赖第三张中间表，而中间表的字段是两个分别关联多对多这两张表的主键的外键， 且这两个外键在中间表中组成了联合主键，而上述代码实际上进行了两次 insert 操作，这两次操作的内容违 反了联合主键约束，所以会抛出异常。 */}
例 9：两方关联，保存两方 - 新建一个学生，新建一个课程，让学生主动关联课程，也让课程主动关联学生，保存学生与课程，异常
分析原因后，可以得出结论，在多对多中两方关联时，必须有一方得放弃维护外键关系（一般是被动方放弃，即 Course 放弃），下面配置二选一：
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Student" table="student"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <property name="age"/> <property name="birthday"/> <property name="address"/> <many-to-one name="clazz" column="cid" class="com.zze.bean.Class" cascade="save-update,delete"/> <set name="courses" table="student_course" inverse="true"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="studentId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Course" column="courseId"/> </set> </class></hibernate-mapping>
com/zze/bean/Student.hbm.xml：修改 set 标签，添加属性 inverse="true"
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping> <class name="com.zze.bean.Course" table="course"> <id name="id"> <generator class="native"/> </id> <property name="name" length="32"/> <set name="students" table="student_course" inverse="true"> <!-- key : column : 当前对象类对应中间表的外键名称 --> <key column="courseId"/> <!-- many-to-many : 标识多对多关系 class : 对方类全路径 column : 对方对应中间表的外键名称 --> <many-to-many class="com.zze.bean.Student" column="studentId"/> </set> </class></hibernate-mapping>
com/zze/bean/Course.hbm.xml：修改 set 标签，添加属性 inverse="true"
修改配置后，再次执行 “例 9” 中代码，成功。
