美文网首页
Hibernate 映射关系

Hibernate 映射关系

作者: SYFHEHE | 来源:发表于2017-09-01 17:41 被阅读0次

0. 关联关系映射

关联关系映射，是映射关系中比较复杂的一种映射关系，总的说来有一对一、一对多和多对多几种关系。细分起来他们又有单向和双向之分。下面我们逐一介绍一下。

整个项目的代码，以及用到的类库，我就不一一介绍了，可以参考我的github，在workspace下有许多项目，对应关系如下表所示：

项目名称 描述
HibernateOne2OneUNI 单向一对一
HibernateOne2OneBI 双向一对一
HibernateOne2ManyUNI 单向一对多
HibernateMany2OneUNI 单向多对一
HibernateOne2ManyBI 双向一对多
HibernateMany2ManyUNI 单向多对多
HibernateMany2ManyBI 双向多对多

具体的代码和测试可以参考我的Github，链接为：GitHub地址

1. @OneToOne 单向关联

Hasband 对Wife： OneToOne Husband单向拥有Wife。

  • Hasband.java:
@Entity
public class Husband {
    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue(strategy =GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @OneToOne
    public Wife getWife() {
        return wife;
    }

    public void setWife(Wife wife) {
        this.wife = wife;
    }

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

    public void setId(int id) {
        this.id = id;
    }
}
  • Wife.java:
@Entity
public class Wife {
    private int id;
    private String name;

    @Id
    @GeneratedValue(strategy =GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

2. @OneToOne 双向关联

双向关系有一方为关系的拥有端，另一方是关系的反端，也就是“Inverse”端。在这里例子中 Husband拥有这个关系，而 Wife就是关系的“Inverse”端。Wife中我们定义了一个 husband属性，在这个属性上我们使用了 @OneToOne 注解并且定义了他的“mappedBy”属性，这个在双向关系的“Inverse”端是必需的，在下面将要介绍的双向关系中也要用到这个属性。Hasband.java与单向关系一样， Wife.java如下。

  • Wife.java
@Entity
public class Wife {
    private int id;
    private String name;
    private Husband huaband;

    @OneToOne(mappedBy = "wife")
    public Husband getHuaband() {
        return huaband;
    }

    public void setHuaband(Husband huaband) {
        this.huaband = huaband;
    }

    @Id
    @GeneratedValue(strategy =GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

3. @ManyToOne 单向关联

只需在单这一方写@ManyToOne注解，这里我们用学生和课程举例，学生是One这一方，课程是Many一方。

  • Course.java
@Entity
public class Course {
    private int id;
    private String name;
    private Student student;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
        public String getName() {
        return name;
    }

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

    @ManyToOne
    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

}
  • Student.java
@Entity
public class Student {
    private int id;
    private String name;
        ...

4. @OneToMany 单向关联

只写@OneToMany，Hibernate会认为存在一张中间表，要加@Joincolumn。@Joincolumn的name是studentId，不要写成courseId，因为他出现在course这张表里，表示的是course表中student的ID
这里我们用学生和课程举例，学生是One这一方，课程是Many一方。

  • Student.java
@Entity
public class Student {
    private int id;
    private String name;
    private List<Course> courses = new ArrayList<Course>();

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "studentid")
    public List<Course> getCourses() {
        return courses;
    }

    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }

}
  • Course.java
@Entity
public class Course {
    private int id;
    private String name;

    @Id
    @GeneratedValue(strategy =GenerationType.IDENTITY)
        ...

5. @ManyToOne 双向关联

还是一样，这里我们用学生和课程举例，学生是One这一方，课程是Many一方。双向非常简单，只需要在单的一方加上mappedBy即可。

  • Student.java
@Entity
public class Student {
    private int id;
    private String name;
    private List<Course> courses = new ArrayList<Course>();

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @OneToMany(mappedBy="student")
    public List<Course> getCourses() {
        return courses;
    }

    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }

}

Course.java

@Entity
public class Course {
    private int id;
    private String name;
    private Student student;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @ManyToOne
    public Student getStudent() {
        return student;
    }

    public void setStudent(Student sutdent) {
        this.student = sutdent;
    }

}

6. @ManyToMany 单向关联

使用@ManyToMany， 表示的意思是一个学生可以选多门课程。
@JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = { @JoinColumn(name = "course_id") }为中间表的表名和列名

  • Student.java
@Entity
public class Student {
    private int id;
    private String name;
    private List<Course> courses = new ArrayList<Course>();

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @ManyToMany
    @JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = {
            @JoinColumn(name = "course_id") })
    public List<Course> getCourses() {
        return courses;
    }

    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }

}
  • Course.java
@Entity
public class Course {
    private int id;
    private String name;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

7. @ManyToMany 双向关联使用

@ManyToMany， 表示的意思是一个学生可以选多门课程。一门课程可以有多个学生选择，关系被维护方需要加mappedBy。@JoinTable的解释看第6节。

  • Student.java
@Entity
public class Student {
    private int id;
    private String name;
    private List<Course> courses = new ArrayList<Course>();

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @ManyToMany
    @JoinTable(name = "s_c", joinColumns = { @JoinColumn(name = "student_id") }, inverseJoinColumns = {
            @JoinColumn(name = "course_id") })
    public List<Course> getCourses() {
        return courses;
    }

    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }

}
  • Course.java
@Entity
public class Course {
    private int id;
    private String name;
    private List<Student> students = new ArrayList<Student>();

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @ManyToMany(mappedBy = "courses")
    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
}

7. 关键字

MappedBy

mappedBy的意思就是“被映射”，即mappedBy这方不用管关联关系，关联关系交给另一方处理

规律：
凡是双向关联，mapped必设，因为根本都没必要在2个表中都存在一个外键关联，在数据库中只要定义一边就可以了

  • 只有OneToOne,OneToMany，ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；
  • mappedBy标签一定是定义在the owned side(被拥有方的)，他指向the owning side(拥有方)；
  • mappedBy的含义，应该理解为，拥有方能够自动维护 跟被拥有方的关系；
    当然，如果从被拥有方，通过手工强行来维护拥有方的关系也是可以做到的。
  • mappedBy跟JoinColumn/JoinTable总是处于互斥的一方，可以理解为正是由于拥有方的关联被拥有方的字段存在，拥有方才拥有了被 拥有方。mappedBy这方定义的JoinColumn/JoinTable总是失效的，不会建立对应的字段或者表

Cascade

hibernate一对多关系中,会用到级联操作.即:有collection的一端操作，被关联的表被自动操作.
这时有collection一端需要配置<set cascade="?">，即用在一对多的一方。

Cascade 属性值：

  • none:在保存、删除修改对象的时候，不考虑其附属物的操作。
  • save-update:在保存、更新当前对象时，级联保存、更新附属物。
  • delete:在删除当前对象时，级联删除附属物。
  • all: 包含save-update和delete的操作，但不包括delete-orphan的操作。
  • delete-orphan:删除和当前对象解除关系的附属对象。
  • all-delete-orphan:所用情况。

fetch

  • fetch = FetchType.EAGER： 那么表示取出这条数据时，它关联的数据也同时取出放入内存中，因为在内存里，所以在session外也可以取。

  • fetch = FetchType.LAZY：取出这条数据时，它关联的数据并不取出来，在同一个session中，什么时候要用，就什么时候取(再次访问数据库)。 但是，在session外，就不能再取了。用EAGER时。

一般只在一边设Eager，JPA接口默认为一对多为Lazy，多对一为Eager，但是Hibernate反向工程生成Entity时，多对一为Lazy，需要手动改为Eager。

而两边都设Eager，那么代码中取一条记录时，会发2次SQL。

@GeneratedValue

理解JPA注解@GeneratedValue

相关文章

  • 4.hibernate映射(多对一)

    映射关系 映射是对象到表，映射关系是多个对象的关系映射到多张表的关系！ cascade级联 hibernate的级...

  • Hibernate介绍

    Hibernate的介绍： （开放源代码的对象关系映射框架） Hibernate是一个开放源代码的对象关系映射框架...

  • Hibernate入门（一）之基本配置

    Hibernate是什么? Hibernate是一个开源的持久层ORM(对象关系映射)框架. Hibernate能...

  • Hibernate 映射关系

    0. 关联关系映射 关联关系映射，是映射关系中比较复杂的一种映射关系，总的说来有一对一、一对多和多对多几种关系。细...

  • hibernate映射关系

    多对一单项关联 例：学生和班级的关系，学生为多方，班级为一方实现 最终实现效果就是相当于在Student表中再添加...

  • Hibernate映射关系

    分类： 关系：OneToOne，OneToMany，ManyToOne，ManyToMany（Join Table...

  • Hibernate映射关系

    映射组成关系 建立域模型和关系型数据库模型有着不同的出发点域模型：由程序代码组成，通过细化持久化类的粒度可以提高代...

  • Hibernate映射关系

    在 Hibernate 中，可以对多张存在关联关系的表进行操作，但需要在映射文件中，将对象的关联关系与数据库表的外...

  • Hibernate入门1-基本用法

    Hibernate 快速入门1 - 基本用法 Hibernate简介 ORM:对象关系映射（ORM, Object...

  • Hibernate的学习

    一.HIbernate框架介绍 什么是Hibernate： Hibernate是一个开放源代码的对象关系映射框架，...

网友评论

      本文标题：Hibernate 映射关系

      本文链接：https://www.haomeiwen.com/subject/yhykjxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Hibernate 映射关系|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！