(转）Hibernate框架基础——多对多关联关系映射

Posted 2020-09-22 疯子加天才

http://blog.csdn.net/yerenyuan_pku/article/details/52756536

多对多关联关系映射

多对多的实体关系模型也是很常见的，比如学生和课程的关系。一个学生可以选修多门课程，一个课程可以被多名学生选修。在关系型数据库中对于多对多关联关系的处理一般采用中间表的形式，将多对多的关系转化成两个一对多的关系。 
为了详细介绍多对多关联关系映射，终究还是应以一个例子来说明比较印象深刻。我们以老师和学生的关系为例来说明这种多对多关联关系映射。

双向多对多

我们最好新建一个普通java工程，如Hibernate_Test，然后在cn.itcast.g_hbm_manyToMany包下新建持久化类——Student.java和Teacher.java。 
持久化类——Student.java的代码如下：

/**
 * 学生
 * @author li ayun
 *
 */
public class Student {
    private Long id;
    private String name;

    private Set<Teacher> teachers = new HashSet<Teacher>(); // 关联的老师们

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Teacher> getTeachers() {
        return teachers;
    }

    public void setTeachers(Set<Teacher> teachers) {
        this.teachers = teachers;
    }

    @Override
    public String toString() {
        return "[Student: id=" + id + ", name=" + name + "]";
    }
}

 

持久化类——Teacher.java的代码如下：

/**
 * 老师
 * @author li ayun
 *
 */
public class Teacher {
    private Long id;
    private String name;

    private Set<Student> students = new HashSet<Student>(); // 关联的学生们

    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }

    @Override
    public String toString() {
        return "[Teacher: id=" + id + ", name=" + name + "]";
    }
}

 

接着我们就要创建各个持久化类相应的映射配置文件了。但在做之前，我们约莫是要知道数据库中三张表的结构的，我画图表示： 

现在再来写各个持久化类相应的映射配置文件，我想应该会容易得多。先在cn.itcast.g_hbm_manyToMany包中创建Student类对应的映射配置文件——Student.hbm.xml。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.g_hbm_manyToMany">
    <class name="Student" table="student">
        <id name="id">
            <generator class="native"></generator> 
        </id>
        <property name="name" />

        <!-- 
            teachers属性，Set集合，表达的是本类与Teacher的多对多的关系 
            table属性：中间表（集合表）
            key子元素：集合外键（引用当前表主键的那个外键）
        -->
        <set name="teachers" table="teacher_student" inverse="false">
            <key column="studentId"></key>
            <many-to-many class="Teacher" column="teacherId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

 

• set元素的两个子元素：key和many-to-many都必须指定column属性，其中，key和many-to-many分别指定本持久化类和关联类在连接表中的外键列名。 
  因此两边的key与many-to-many的column属性交叉相同。也就是说，一边的set元素的key的cloumn值为a，many-to-many的column为b；则另一边的set元素的key的column值b，many-to-many的column值为a。
• 对于双向n-n关联，须把其中一端的inverse设置为true，否则可能会造成主键冲突。

然后也是在该包中创建Teacher类对应的映射配置文件——Teacher.hbm.xml。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.g_hbm_manyToMany">
    <class name="Teacher" table="teacher">
        <id name="id">
            <generator class="native"></generator> 
        </id>
        <property name="name" type="string" column="name" />

        <!-- students属性，Set集合，表达的是本类与Student的多对多的关系  -->
        <set name="students" table="teacher_student" inverse="true">
            <key column="teacherId"></key>
            <many-to-many class="Student" column="studentId"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

 

写到这里，我们就很清楚以下几点了：

1. 双向n-n关联需要两端都使用集合属性。
2. 双向n-n关联必须使用中间表。
3. 集合属性应增加key子元素用以映射外键列，集合元素里还应增加many-to-many子元素关联实体类。
4. 在双向n-n关联的两边都需指定连接表的表名及外键列的列名。两个集合元素set的table元素的值必须指定，而且必须相同。

接下来，我们从以下几个方面来编写代码进行测试：

• 保存新数据，并有关联关系。
• 获取数据，可以获取到关联的对方。
• 解除关联关系。
• 删除对象，看对关联对象的影响。

我们首先从保存新数据，并有关联关系第一个方面开始测试，测试代码如下：

public class App {
    private static SessionFactory sessionFactory = new Configuration() //
            .configure() //
            .addClass(Student.class) // 添加Hibernate实体类（加载对应的映射文件）
            .addClass(Teacher.class) // 添加Hibernate实体类（加载对应的映射文件）
            .buildSessionFactory();

    // 保存，有关联关系
    @Test
    public void testSave() {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // -------------------------------------------

        // 新建对象
        Student student1 = new Student();
        student1.setName("王同学");

        Student student2 = new Student();
        student2.setName("李同学");

        Teacher teacher1 = new Teacher();
        teacher1.setName("赵老师");

        Teacher teacher2 = new Teacher();
        teacher2.setName("蔡老师");

        // 关联起来
        student1.getTeachers().add(teacher1);
        student1.getTeachers().add(teacher2);
        student2.getTeachers().add(teacher1);
        student2.getTeachers().add(teacher2);

        teacher1.getStudents().add(student1);
        teacher1.getStudents().add(student2);
        teacher2.getStudents().add(student1);
        teacher2.getStudents().add(student2);

        // 保存
        session.save(student1);
        session.save(student2);
        session.save(teacher1);
        session.save(teacher2);

        // -------------------------------------------
        session.getTransaction().commit();
        session.close();
    }
}

 

测试，顺利通过，大发！ 
接下来我们从获取数据，可以获取到关联的对方第二个方面来进行测试。但我们只打算从老师这一方获取，然后显示学生那方的数据。

public class App {
    private static SessionFactory sessionFactory = ...

    // 获取，可以获取到关联的对方
    @Test
    public void testGet() {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // -------------------------------------------

        // 获取一方，并显示另一方信息
        Teacher teacher = (Teacher) session.get(Teacher.class, 1L);
        System.out.println(teacher);
        System.out.println(teacher.getStudents());

        // -------------------------------------------
        session.getTransaction().commit();
        session.close();
    }
}

 

测试，顺利通过，大发！ 
紧接着我们从解除关联关系第三个方面来进行测试。 
无论从哪一方解除关联关系，均与inverse属性的值有关系，如果inverse=false就可以解除，如果inverse=true就不可以解除（删除中间表中的记录）。

public class App {
    private static SessionFactory sessionFactory = ...

    // 解除关联关系
    @Test
    public void testRemoveRelation() {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // -------------------------------------------

        // 如果inverse=false就可以解除，如果为true就不可以解除（删除中间表中的记录）
        Teacher teacher = (Teacher) session.get(Teacher.class, 1L);
        teacher.getStudents().clear();

        // -------------------------------------------
        session.getTransaction().commit();
        session.close();
    }
}

 

最后，我们从删除对象，看对关联对象的影响第四个方面来进行测试。我们打算删除老师这一方。

• 如果没有关联的对方：能删除。
• 如果有关联的对方且inverse=false，由于可以维护关联关系，它就会先删除关联关系，再删除自己。
• 如果有关联的对方且inverse=true，由于不能维护关联关系，所以会直接执行删除自己，就会有异常。

public class App {
    private static SessionFactory sessionFactory = ...

    // 删除对象，对关联对象的影响
    @Test
    public void testDelete() {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // -------------------------------------------

        // 删除老师方
        // a，如果没有关联的对方：能删除
        // b，如果有关联的对方且inverse=false，由于可以维护关联关系，它就会先删除关联关系，再删除自己。
        // c，如果有关联的对方且inverse=true，由于不能维护关联关系，所以会直接执行删除自己，就会有异常
        Teacher teacher = (Teacher) session.get(Teacher.class, 2L);
        session.delete(teacher);

        // -------------------------------------------
        session.getTransaction().commit();
        session.close();
    }
}

 

测试，顺利通过，大发！ 
结论：维护关联关系是指在中间表中插入或删除数据。

单向多对多

去掉双向多对多关联中的任一方，即是单向多对多