Hibernate5.2之多对多关联关系(六)

Hibernate5.2之多对多关联关系(六)

一.简介

  Hibernate中多对多关联关系在工程中使用的频率也是非常高的,例如:大学中学生选课、用户订单等。在本博客中笔者一样通过实例代码为读者阐述Hibernate中的这种关联关系,笔者所采用的是学生选课的案例。

二.数据库的创建

create table courses (
   id number(10,0) not null,
   cname varchar2(255 char),
   primary key (id)
);

create table stu_course (
   student_id number(10,0) not null,
   course_id number(10,0) not null,
   primary key (course_id, student_id)
);

create table students (
   id number(10,0) not null,
   name varchar2(255 char),
   primary key (id)
);

三.hbm配置文件的方式

3.1 POJO类的创建

public class Student {
    private int id;
    private String name;
    private Set<Course> courses;

    //setter and getter
}

public class Course {
    private int id;
    private String name;
    private Set<Student> students;

    //setter and getter
}

3.2 hbm文件的创建

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.demo.hibernate.many2many.Student" table="students">
        <id name="id" type="int" column="id">
            <generator class="increment"></generator>
        </id>

        <property name="name" type="string" column="name"></property>

        <set name="courses" table="stu_course">
            <key column="student_id"></key>
            <many-to-many class="com.demo.hibernate.many2many.Course" column="course_id"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

Course.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.demo.hibernate.many2many.Course" table="courses">
        <id name="id" type="int" column="id">
            <generator class="increment"></generator>
        </id>

        <property name="name" type="string" column="cname"></property>

        <set name="students" table="stu_course" inverse="true">
            <key column="course_id"></key>
            <many-to-many class="com.demo.hibernate.many2many.Student" column="student_id"></many-to-many>
        </set>
    </class>
</hibernate-mapping>

四.注解的方式

Student.java

@Entity
@Table(name="students")
public class Student {

    @Id
    @Column(name="id")
    @GenericGenerator(name="incrementGenerator", strategy="increment")
    @GeneratedValue(generator="incrementGenerator")
    private int id;

    @Column(name="name")
    private String name;

    @ManyToMany
    @JoinTable(name="stu_course",
        joinColumns={@JoinColumn(name="student_id")},
        inverseJoinColumns={@JoinColumn(name="course_id")})
    private Set<Course> courses;

    //setter and getter}

Course.java

@Entity
@Table(name="courses")
public class Course {

    @Id
    @Column(name="id")
    @GenericGenerator(name="incrementGenerator", strategy="increment")
    @GeneratedValue(generator="incrementGenerator")
    private int id;

    @Column(name="cname")
    private String name;

    @ManyToMany(mappedBy="courses")
    private Set<Student> students;

    //setter and getter
}

五.代码测试

A.保存

@Test
public void save(){
    Transaction tx = session.beginTransaction();

    Student s1 = new Student();
    s1.setName("BBB");

    Course c1 = new Course();
    c1.setName("音乐");

    Set<Student> students = new HashSet<Student>();
    Set<Course> courses = new HashSet<Course>();

    students.add(s1);
    courses.add(c1);

    s1.setCourses(courses);
    c1.setStudents(students);

    session.save(s1);
    session.save(c1);

    tx.commit();}

B.更新1

//新开了一门课,然后学生选择了该课程
@Test
public void addCourse(){
    Transaction tx = session.beginTransaction();
    Student student = session.get(Student.class, 1);
    Course c1 = new Course();
    c1.setName("音乐");

    student.getCourses().add(c1);
    session.saveOrUpdate(c1);
    session.saveOrUpdate(student);
    tx.commit();
}

C.更新2

//新增学生,然后学生选择课程
@Test
public void  addStudent(){
    Transaction tx = session.beginTransaction();
    Student s = new Student();
    s.setName("HHH");

    Query<Course> query = session.createQuery("from Course where id in :ids", Course.class);
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    query.setParameter("ids", list);

    Set<Course> courses = new HashSet<Course>(query.getResultList());

    s.setCourses(courses);
    session.save(s);
    tx.commit();
}

D.更新3

//学生改变课程
@Test
public void changeCourse(){
    Transaction tx = session.beginTransaction();
    Student student = session.get(Student.class, 1);

    Course course = session.get(Course.class, 2);
    Set<Course> courses = new HashSet<Course>();
    courses.add(course);

    student.setCourses(courses);

    session.update(student);
    tx.commit();
}

E.删除

//删除了学生
@Test
public void delete(){
    Transaction tx = session.beginTransaction();
    Student s = new Student();
    s.setId(1);

    session.delete(s);
    tx.commit();
}
时间: 2024-10-06 06:48:09

Hibernate5.2之多对多关联关系(六)的相关文章

【SSH三大框架】Hibernate基础第六篇:多对一关联关系的映射、分析及添加、查询

这里举例子用的是:部门与员工的关系. 一个部门可以对应多个员工,这就是很明显的多对一关联关系. 我们需要建立两个实体类:员工(Employee).部门(Department) 员工类:Employee.java(在这里边我们增加了一个Department类型的属性,用来做关联) package cn.itcast.hibernate.domain; public class Employee { private int id; private String name; private Depar

Hibernate系列(六):多对一关联关系的映射、分析及添加、查询

这里举例子用的是:部门与员工的关系. 一个部门可以对应多个员工,这就是很明显的多对一关联关系. 我们需要建立两个实体类:员工(Employee).部门(Department) 员工类:Employee.java(在这里边我们增加了一个Department类型的属性,用来做关联) package cn.itcast.hibernate.domain; public class Employee { private int id; private String name; private Depar

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

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

JPA学习笔记(7)——映射多对一关联关系

多对一关联关系 两个实体类,User和Order,一个User可以有多个Order,一个Order只能有一个User 建立关联关系 使用@ManyToOne注解映射多对一关联关系 User实体类 package com.jpa.helloworld; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.pers

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

本次仍然使用一个示例的方式进行演示,学生与教师之间的关系就是一个典型的多对多关系,一个教师可以有多个学生,同样一个学生也可以有多个教师.在数据库中存储需要一张学生表存储学生信息,一个教师表存储教师信息,为了表示他们之间的关系我们需要一个中间表来表示他们之间的联系. 例如,在教师表中有id,name两个属性,学生表中同样有id,name两个属性.教师表中有两条记录分别是(1,董老师),(2,李老师):学生表中同样有两条(1,张三),(2,李四).在中间表中有两个字段(teacherId,stude

【SSH三大框架】Hibernate基础第八篇:多对多关联关系的操作

在Hibernate中的多对多关联关系,一般是不会使用的,因为对于数据库查询的时候时间复杂度太高. 我们在这里做的是学生和老师,一个学生可以有多个老师,一个老师可以有多个学生. 我们首先建立一个学生实体类:Student.java package cn.itcast.hibernate.domain; import java.util.Set; public class Student { private int id; private String name; private Set<Teac

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

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

《Hibernate学习笔记十》:多对多关联关系详解

<Hibernate学习笔记十>:多对多关联关系 前面介绍了一对一.多对一和一对多的关联关系在Hibernate应如何实现,这篇博文就来介绍下最后一种关联关系:多对多.多对多关联关系在我们现实生活中的例子实在是太多太多,最典型的就是老师和学生的例子:一个老师可以教多个学生,而一个学生又可以被多个老师来教. 了解一点数据库的我们都知道,在数据库中表示多对多的关联关系,是借助于中间表来解决的. 如下: 还是和以往的思路一样,每一种关联关系都分为单向关联和双向关联,我们每种都会进行介绍,对于单向和双

在双向多对一关联关系中如果由两端维护关联的关系会出问题

在双向多对一关联关系中如果由两端维护关联的关系会出问题. 举例: Clazz 为一端,Student为多端.多端的inverse 属性值为"false", 也就是说此时关联关系由两端维护.那么在保存的时候,就会出现一个问题:多端的外键列的所有值总是等于最新保存的一端的主键.