java框架之Hibernate(3)-一对多和多对多关系操做

时间 2019-12-14

原文原文链接

一对多

例：一个班级能够有多个学生，而一个学生只能属于一个班级。java

模型

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

普通操做

@Test
public 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：两方关联，保存两方 - 新建一个班级，新建两个学生，班级主动关联学生，学生也主动关联班级，保存班级，再保存学生，成功

@Test
public 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：两方关联，保存一方 - 新建一个班级，新建两个学生，班级主动关联学生，学生也主动关联班级，只保存班级，异常，需使用下面的级联保存。

级联操做

级联：: 级联指的是：操做一个对象的时候，是否会同时操做其关联的对象。mysql

级联的方向性：

操做一的一方的时候，是否会同时操做到多的一方。sql

操做多的一方的时候，是否会同时操做到一的一方。数据库

级联保存或更新

保存‘一’级联保存‘多’：session

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

@Test
public 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：‘一’方关联，保存‘一’方 - 新建一个班级，新建两个学生，班级主动关联学生，只保存班级，级联保存了学生，成功

保存‘多’级联保存‘一’：app

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

@Test
public 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：‘多’方关联，保存‘多’方 - 新建一个班级，新建两个学生，学生主动关联班级，只保存学生，级联保存了班级，成功

级联删除

假如表中已有以下数据：ide

删除‘一’级联删除‘多’：this

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

@Test
public void test5() {
    Session session = HibernateUtil.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    Class clazz = session.get(Class.class, 1);
    session.delete(clazz);
    transaction.commit();
}

例 5：删除班级，级联删除该班级下全部学生。

删除‘多’级联删除‘一’：url

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

@Test
public void test6() {
    Session session = HibernateUtil.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    Student student = session.get(Student.class, 1);
    session.delete(student);
    transaction.commit();
    // 级联删除‘一’的一方，将其它关联‘一’的一方的数据的外键设为 null。
    // 若是‘一’的一方也设置了级联删除，那么全部关联‘一’的一方的数据都会被删除。
}

例 6：删除学生，级联删除该学生所属班级。

放弃维护外键关系

假入表中已有以下数据：spa

先要把张三从 1 班转到 2 班：

@Test
public 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 中，‘多’的一方不能够放弃维护外键关系。

为何‘多’的一方不能放弃维护外键关系？换句话说为何 Hibernate 要让多的一方来维护关系？

缘由是当‘一’的一方维护关系时，Hibernate 会额外发出一条 select 语句查出它所关联的全部的多的一方，显然不必。而多的一方维护关系就比较简单了，直接 update 它自己的外键便可。

看到过一个有趣应景的说法：十三亿人民（‘多’）记住（维护）国家领导人的名字很简单，但要想国家领导人（‘一’）记住（维护）十三亿就不可能了。

理解 inverse 和 cascade：

@Test
public 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：

多对多

例：一名学生能够选多门课程，一门课程也能够被多名学生选择：

模型

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

普通操做

@Test
public 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” 中代码，成功。

级联操做

级联保存或更新

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

@Test
public 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"

@Test
public void test11() {
    Session session = HibernateUtil.getCurrentSession();
    Transaction transaction = session.beginTransaction();
    Student student = session.get(Student.class, 1);
    session.delete(student);
    transaction.commit();
}

例 11：删除学生，级联删除该学生所选的课程