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

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();
    }
}

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

单向多对多

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

时间： 2024-08-24 09:28:31

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

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

http://blog.csdn.net/yerenyuan_pku/article/details/52746413 上一篇文章Hibernate框架基础——映射集合属性详细讲解的是值类型的集合(即集合元素是普通类型).现在从本文开始我们就要介绍实体类型的集合(即集合元素是另一个实体)了. 一对多关联关系映射 我们还是以一个活生生的例子来详解一对多关联关系映射吧!就以部门和员工的关系为例. 单向关联:仅仅建立从Employee到Department的多对一关联,即仅仅在Employee类中定义

SSH：Hibernate框架（七种关联关系映射及配置详解）

概念 基本映射是对一个实体进行映射,关联映射就是处理多个实体之间的关系,将关联关系映射到数据库中,所谓的关联关系在对象模型中有一个或多个引用. 分类 关联关系分为上述七种,但是由于相互之间有各种关系,可以简化,例如:多对一与一对多映射,只是侧重的角度不对而已. 映射技巧 映射技巧是小编写映射文件的过程,总结的经典内容,总共分为四步,咋看不是特别易懂,但是效果很好.下面我们以实例看技巧. (1)写注释 格式为:?属性,表达的是本对象与?的?关系. 解释:在写映射文件之前先写注释,将问号的地方填上相

Hibernate框架单向多对一关联映射关系

建立多对一的单向关联关系    Emp.java            private Integer empNo //员工编号            private String empName //员工姓名            //private Integer deptNo;  //部门编号            private Dept dept;    //所属部门    Dept.java            private Byte deptNo;              

Hibernate ManyToOne Mappings 多对一关联映射

Hibernate框架的使用步骤: 1.创建Hibernate的配置文件(hibernate.cfg.xml) 2.创建持久化类,即其实例需要保存到数据库中的类(Employee.java) 3.创建对象-关系映射文件(Employee.hbm.xml) 4.通过Hibernate API编写访问数据库的代码 例子:多个员工对应一个地址. 一.创建hibernate.cfg.xml 配置文件: 注意数据库名.用户名.密码是否填写正确. <?xml version="1.0" en

Hibernate框架基础

Hibernate框架基础 Hibernate框架 ORM概念 O, Object 对象 R, Realtion 关系 (关系型数据库: MySQL, Oracle-) M,Mapping 映射 ORM, 对象关系映射! ORM, 解决什么问题? 存储: 能否把对象的数据直接保存到数据库? 获取: 能否直接从数据库拿到一个对象? 想做到上面2点,必须要有映射! 总结: Hibernate与ORM的关系? Hibernate是ORM的实现! Hibernate HelloWorld案例 搭建一个H

Hibernate—— 一对多 和 多对多关联关系映射（xml和注解）总结（转载）

One to Many 映射关系 多对一单向外键关联(XML/Annotation) 一对多单向外键关联(XML/Annotation) 懒加载和积极加载 一对多双向外键关联(XML/Annotation) Many to Many 映射关系 多对多单向外键关联(XML/Annotation) 多对多双向外键关联(XML/Annotation) set的inverse元素详解 问题小结 关联关系的优缺点 多对一单向外键关联关系 注意多对一关联是多方持有一方的引用.看一个例子,去淘宝购物,那么一个

Hibernate之实现多对多关联映射关系

直接以老师与学生的关系为例.在多对多关联关系中,其中一方都可通过Set保留另一方的所有信息,这样的关联是双向关联.在多对多关联关系中,也只能是双向关联.老师和学生分别对应一张表,通过一张有双方id的中间表来维护多对多的关联. 实体类 package test.hibernate.hbmManyToMany; import java.util.HashSet; import java.util.Set; public class Teacher { private Integer id; priv

（转）Hibernate框架基础——Hibernate API及Hibernate主配置文件

Hibernate的学习路线图 Hibernate API简介 Configuration Configuration类负责管理Hibernate的配置信息,包括如下内容: Hibernate运行的底层信息:数据库的URL.用户名.密码.JDBC驱动类,数据库Dialect,数据库连接池等(对应hibernate.cfg.xml文件). 持久化类与数据表的映射关系(*.hbm.xml文件). 创建Configuration的两种方式: 属性文件(hibernate.properties) Con

（转）Hibernate框架基础——映射集合属性

http://blog.csdn.net/yerenyuan_pku/article/details/52745486 集合映射 集合属性大致有两种: 单纯的集合属性,如像List.Set或数组等集合属性. Map结构的集合属性,每个属性值都有对应的Key映射. 集合映射的元素大致有如下几种: list:用于映射List集合属性. set:用于映射Set集合属性. map:用于映射Map集合性. array:用于映射数组集合属性. bag:用于映射无序集合. idbag:用于映射无序集合,但为集