Hibernate入门（5）：关联映射&继承映射

最新推荐文章于 2018-08-03 15:58:39 发布
最新推荐文章于 2018-08-03 15:58:39 发布
阅读量723 收藏 3
点赞数
分类专栏： Hibernate5 Hibernate5 入门教程 文章标签： hibernate 关联映射 继承映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/al_assad/article/details/77887852
版权

关联映射

1、除了关系型数据库本身提供的基于关系的关联映射，Hibernate 也提供了面向对象的关联映射支持，这些关联关系大大简化了持久层数据的访问；
2、Hibernate提供的关联关系可以分为以下2种， 可以根据需求选择关联形式；
单向关联：只能从一端访问另一端；
双向关联：两端都可以相互访问；

3、单向关联包含以下4种关系：
1-1（一对一）,1-N（一对多），N-1（多对一），N-N（多对多）； 
4、双向关联包含以下3种关系（双向关联中1-N，N-1完全相同 ）：
1-1，1-N，N-N；

5、对于这些关联关系，hibernate 提供了以下4个注解支持：
@OneToOne：1-1关系
@OneToMore：1-N关系
@MoreToOne：N-1关系
@MoreToMore：N-N关系
这些注解支持的常用属性如下：
cascade指定对于关联主体的级联策略，不设置时，不启用级联，可选值如下：
CascadeType.ALL：将所有的持久化操作级联到关联实体；
CascadeType.MERGE：将merge操作级联到关联实体；
CascadeType.PRESIST ：将presist操作级联到关联实体；
CascadeType.REFRESH ：将refresh操作级联到关联实体；
CascadeType.REMOVE ：将remove操作级联到关联实体；
fetch指定抓取关联实体的策略，可选值如下：
FetchType.EAGER：立即抓取
FetchType.:LAZY：延迟抓取（默认值）
mappedBy指定关联实体中那个属性值可以被引用到当前实体，值为关联实体的某个属性名；
当@OneToMany @ManyToMany 指定了该属性后，表明当前实体不能控制关联关系；
当某一段使用mappedBy放弃控制权后，该一段不能使用@JoinColumn，@JoinTable
orphanRemoval设置是否删除“孤儿”实体，如果某个实体所关联的父实体不存在，该实体为孤儿实体
tragetEntity该属性关联实体的类名，默认情况下 hibernate 会通过反射来判断关联实体的类名

6、对于1-N 关联关系，在数据库建模角度来讲，这两个关联的表存在基于外键分别为主表、从表的约束关系，hibernate有2种方式来进行表示：
①组件映射：将从表记录映射为持久化类的组件，参见 04. Hibernate 集合映射&组件映射，这种方式下 Hibernate   默认启用级联操作，组件的声明周期依赖于父对象：父对象保存时，组件被保存，父对象被删除时，组件被删除；
②关联映射：将从表记录映射为持久化实体，这种方式下 hibernate   默认不开启级联操作，从表实体的拥有自己的声明周期，从而允许其他实体共享对其的引用；

7、Hibernate 支持有连接表和无连接表的关联映射；
无连接表时，需要使用   @JoinColumn ，来映射外键列，支持属性如下：
name指定外键列列名
columnDefinition使用指定的SQL片段创建外键列
nullable指定该列是否允许为null，默认值 true
table指定该列的所在数据表的表名
unique指定是否为该列增加唯一约束，默认值 false
referenceColumnName指定所参照的主键列的列名
有连接表时，需要使用   @JoinTable，来映射底层连接表的信息，支持属性如下：
name指定连接表的表名
targetEntity指定关联实体的类名，默认Hibernate通过反射来判断关联实体的类名
joinColumns可接受多个 @JoinColumn，用与配置连接表中的外键列信息，这些外键参照当前实体对应表的主键列
inverseJoinColumns可接受多个 @JoinColumn，用与配置连接表中的外键列信息，这些外键参照关联实体对应表的主键列
uniqueConstrains为链接表增加唯一约束

单向 N-1 关联

1）无连接表的单向 N-1关联
示例使用数据表，多个person 可能拥有同一个address；
tableperson

column		person_id (primary key)
address_id (foreign key)
person_name
tableaddress
columnaddress_id (primary key)
address_detial
Person .java
 
import javax.persistence.*;

@Entity
@Table(name="persion")
public class Person {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="persion_name")
    private String name;

    //定义Persion实体关联的Address实体
    @ManyToOne(targetEntity = Address.class,cascade = CascadeType.ALL)   //N-1关联，启用所有级联操作
    @JoinColumn(name="address_id",referencedColumnName="address_id" ,nullable = false)    //映射外键列
    private Address address;

    //省略所有getter，setter方法
}

address.java 
import javax.persistence.*;

@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;
    
    //省略所有 getter，setter方法

}
2）有关联表的单向 N-1关联
示例数据表如下：
tableperson

column		person_id (primary key)
person_name
tableaddress
columnaddress_id (primary key)
address_detial
tableperson_address
columnperson_id (foreign key) 
address_id (foreign key)
id (primary key)
Person .java 
import javax.persistence.*;
@Entity
@Table(name="person")
public class Persion {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    //定义Persion实体关联的Address实体
    @ManyToOne(targetEntity = Address.class,cascade = CascadeType.ALL)   //N-1关联，启用所有级联操作
    //映射连接表
    @JoinTable(name="person_address",             //指定连接表名称
        joinColumns = @JoinColumn(name="person_id",referencedColumnName = "person_id",unique=true),    //连接表外键对当前实体主键的参照
        inverseJoinColumns = @JoinColumn(name="address_id",referencedColumnName = "address_id"))  //连接表外键对关联实体主键的参照
    private Address address;

    //省略所有getter，setter方法
}

address.java  同上

单向 1-N 关联

对于 1-N 关联，Hibernate 推荐使用双向关联，同时不让1的一端控制关联关系，而使用N的一端控制关联关系，当程序不得不使用使用单向的 1-N，优先采用连接表的 1-N 关联；

单向 1-1 关联

单向 1-1 关联一般使用的是无连接表的映射方式；
Person .java 
import javax.persistence.*;

@Entity
@Table(name="person")
public class Persion {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    //定义Persion实体关联的Address实体
    @OneToOne(targetEntity = Address.class,cascade = CascadeType.ALL)   //1-1关联，启用所有级联操作
    @JoinColumn(name="address_id",referencedColumnName="address_id" ,nullable = false, unique = true)    //映射外键列
    private Address address;

    //省略所有getter，setter方法
}

单向 N-N 关联

单向 N-N 关联的代码和 单向 1-N 的代码几乎完全相同，控制关系的一端只需要增加一个Set类型的属性即可；
一般 N-N 关联使用连接表的形式进行关联；
Person .java
 
@Entity
@Table(name="person")
public class Persion {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    //定义Persion实体关联的Address实体
    @ManyToMany(targetEntity = Address.class,cascade = CascadeType.ALL)   //N-N关联，启用所有级联操作
    //映射连接表
    @JoinTable(name="person_address",             //指定连接表名称
        joinColumns = @JoinColumn(name="person_id",referencedColumnName = "person_id"),    //连接表外键对当前实体主键的参照
        inverseJoinColumns = @JoinColumn(name="address_id",referencedColumnName = "address_id"))  //连接表外键对关联实体主键的参照
    private Set<Address> addresses = new HashSet<>();

    //省略所有getter，setter方法
}

双向 1-N 关联

大部分时候，双向 1-N 关联使用无连接表的形式进行映射即可；
1）无连接表的双向 1-N 关联
tableperson

column		person_id (primary key)
person_name
tableaddress
columnaddress_id (primary key)
person_id (foreign key)
address_detial
Person.java 
@Entity
@Table(name="person")
public class Person {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    @OneToMany(targetEntity = Address.class,cascade = CascadeType.ALL,mappedBy = "person")   //1-N关联，取消本实体的关联控制
    private Set<Address> addresses = new HashSet<>();

    //省略所有getter，setter方法
}
Address.java 
@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;

    @ManyToOne(targetEntity = Person.class,cascade=CascadeType.ALL)
    @JoinColumn(name="person_id",referencedColumnName = "person_id",nullable = false)
    private Person person;

    //省略所有 getter，setter方法

}

2）有连接表的双向 1-N 关联
Persion.java 
@Entity
@Table(name="person")
public class Person {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    @OneToMany(targetEntity = Address.class,cascade = CascadeType.ALL,mappedBy = "person")   //1-N关联，取消本实体的关联控制
    private Set<Address> addresses = new HashSet<>();
    //省略所有getter，setter方法
}
Address.java 
@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;

    @ManyToOne(targetEntity = Person.class,cascade=CascadeType.ALL)
    @JoinTable(name="person_address",
        joinColumns = @JoinColumn(name="adddress_id",referencedColumnName = "address_id",unique=true),
        inverseJoinColumns = @JoinColumn(name="person_id",referencedColumnName = "person_id"))
    private Person person;
    
    //省略所有 getter，setter方法

}


双向 1-1 关联
双向 1-1 关联一般使用无连接表的形式进行映射
Person.java 
@Entity
@Table(name="person")
public class Person {
    @Id @Column(name="person_id")
    private int id;
    @Column(name="person_name")
    private String name;

    @OneToOne(targetEntity = Address.class,cascade = CascadeType.ALL,mappedBy="person")   //1-N关联，取消本实体的关联控制
    private Address address;
    //省略所有getter，setter方法
}
address.java 
@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;

    @ManyToOne(targetEntity = Person.class,cascade=CascadeType.ALL)
    @JoinColumn(name="person_id",referencedColumnName = "person_id",unique=true)
    private Person person;

    //省略所有 getter，setter方法

}

双向 N-N 关联

一般双向N-N关联，使用连接表的形式映射；
Person.java 
@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;

    @ManyToOne(targetEntity = Person.class,cascade=CascadeType.ALL)
    @JoinColumn(name="person_id",referencedColumnName = "person_id",unique=true)
    private Person person;

    //省略所有 getter，setter方法

}
Address.java 
@Entity
@Table(name="address")
public class Address {
    @Id @Column(name="address_id")
    private int id;
    @Column(name="addrrss_detail")
    private String detial;

    @ManyToOne(targetEntity = Person.class,cascade=CascadeType.ALL)
    @JoinTable(name="person_address",
        joinColumns = @JoinColumn(name="adddress_id",referencedColumnName = "address_id"),
        inverseJoinColumns = @JoinColumn(name="person_id",referencedColumnName = "person_id"))
    private Set<Person> persons = new HashSet<>();
    //省略所有 getter，setter方法

}


继承映射


hibernate 支持将继承层次结构与数据表进行映射，其定义了3种继承映射的策略：
① 每个类层次对应一张表的映射策略；
② 每个具体类对应一张表的映射策略；
③ 连接子类的映射策略；

以下使用图示的继承层次进行示例说明：

每个类层次对应一张表的映射策略

这是Hibernate默认的继承映射策略，在这种策略下，整个继承层次结构都储存在一张表中，如上继承层次中 Employee，Regular_Emplee，Constract_Employee 3个实体都储存在同一张表中；
使用这种策略时，Hibernate 会为该表额外创建一列，该列用于区分每行记录为哪一个类的实例，该列为辨别者列（discriminiator）， 使用@DiscriminatorColumn配置辨别者列，

Employee.java 
@Entity  
@Table(name = "employee")  
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)           //标注继承方式为单表方式
@DiscriminatorColumn(name="type",discriminatorType=DiscriminatorType.STRING)       //指定辨别者列的数据类型
@DiscriminatorValue(value="employee")    //指定该实体的辨别者列值
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private int id;

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

    // setters and getters
}
Regular_Employee.java 
@Entity  
@DiscriminatorValue("regularemployee")  
public class Regular_Employee extends Employee {

    @Column(name = "salary")
    private float salary;

    @Column(name = "bonus")
    private int bonus;
    
    // setters and getters
}
Contract_Employee.java 
@Entity  
@DiscriminatorValue("contractemployee")  
public class Contract_Employee extends Employee {
    
    @Column(name = "pay_per_hour")
    private float pay_per_hour;

    @Column(name = "contract_duration")
    private String contract_duration;
    
    // setters and getters
}

每个具体类对应一张表的映射策略

这一种策略为每一个具体类对应一个具体的数据表，一般不会使用这种策略，因为有可能会导致数据过渡冗余；
Employee.java 
@Entity
@Table(name = "employee")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private int id;

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

    // setters and getters

}

Regular_Employee.java 
@Entity
@Table(name = "regularemployee")
@AttributeOverrides({
        @AttributeOverride(name = "id", column = @Column(name = "id")),
        @AttributeOverride(name = "name", column = @Column(name = "name")) })
public class Regular_Employee extends Employee {

    @Column(name = "salary")
    private float salary;

    @Column(name = "bonus")
    private int bonus;

    // setters and getters

}
Contract_Employee.java 
@Entity
@Table(name = "contractemployee")
@AttributeOverrides({
        @AttributeOverride(name = "id", column = @Column(name = "id")),
        @AttributeOverride(name = "name", column = @Column(name = "name")) })
public class Contract_Employee extends Employee {

    @Column(name = "pay_per_hour")
    private float pay_per_hour;

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

     // setters and getters
}


连接子类的映射策略

采用这种映射策略时，父类的实体保存在父类表里，而子类的实体则由父类表和子类表共同储存，即将子类和父类共同的属性存储在父类表中；
Employee.java 
@Entity
@Table(name = "employee")
@Inheritance(strategy = InheritanceType.JOINED)
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private int id;

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

   // setters and getters
}
Regular_Employee.java 
@Entity
@Table(name = "regularemployee")
@PrimaryKeyJoinColumn(name = "id")
public class Regular_Employee extends Employee {
    @Column(name = "salary")
    private float salary;
     
    @Column(name = "bonus")
    private int bonus;
    
   // setters and getters
}
Contract_Employee.java 
@Entity
@Table(name = "contractemployee")
@PrimaryKeyJoinColumn(name = "id")
public class Contract_Employee extends Employee {

    @Column(name = "pay_per_hour")
    private float pay_per_hour;

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

    // setters and getters

}




Al_assad
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate学习(3) (继承映射,配置文件和注解版)
shengge01的博客
05-28 1579
hibernate 映射
mysql 协议的ColumnDefinition包及解析
seaboat——a free boat on the sea.（公众号：远洋号）
02-02 2300
githttps://github.com/sea-boat/mysql-protocol概况ColumnDefinition包属于服务端返回ResultSet时的其中一部分包，用于描述结果集的字段信息。mysql通信报文结构 类型 名字 描述 int<3> payload长度 按照the least significant byte first存储，3个字节的payload和
Hibernate继承映射详解
鹏霄万里展雄飞
02-21 2356
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继承体系下
【Hibernate 5】继承映射配置及多态查询
该怎么解释？我懒得解释
07-09 1311
一、继承实现的三种策略 1.1，单表继承。每棵类继承树使用一个表(table per class hierarchy) ——>本文主要介绍的继承策略 类继承树对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤： 1，父类用普通的标签定义，在父类中
【Hibernate步步为营】--继承映射详解
热门推荐
航帆远洋
05-30 1万+
继承是面向对象很重要的特性，它实现了代码的服用，在关系模型中同样也有继承关系，这种继承关系其实可以看做是一种枚举关系，一种类型中可以枚举出很多子类型，这些子类型和父对象形成了继承关系，能够对其进行枚举的大部分都可以看做是一种继承映射，所以这种枚举关系可以看做是继承映射，
hibernate的继承映射
u011526599的专栏
04-24 4618
hibernate的继承映射探究
hibernate一对多关联映射学习小结
08-29
主要介绍了hibernate一对多关联映射学习小结,需要的朋友可以参考下
Hibernate映射解析之关联映射详解
08-31
所谓关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。下面这篇文章详细的给大家介绍了Hibernate映射解析之关联映射的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
Java的Hibernate框架中的继承映射学习教程
09-02
Hibernate中的映射可以将类与表对应,并利用类的继承特性,这里我们就来看一下Java的Hibernate框架中的继承映射学习教程
精通Hibernate之映射继承关系（六）
02-04
Company与Employee类之间为一对多多态关联关系，如果继承关系树的根类对应一个表，或者每个类对应一个表，那么就能映射Company类的employees集合。本节介绍如何映射多对一多态关联。如图14-11所示，ClassD与ClassA为...
精通Hibernate之映射继承关系（三）
02-22
这种映射方式只需为继承关系树的Employee根类创建一张表EMPLOYEES。如图14-4所示，在EMPLOYEES表中不仅提供和Employee类的属性对应的字段，还要提供和它的两个子类的所有属型对应的字段，此外，EMPLOYEES表中需要...
Hibernate5入门（四）映射之自身关联
半清半醒半明白
08-03 654
目录 一、实体类Menu.java 二、映射文件Menu.hbm.xml 三、测试类   学习笔记，为了加强记忆和深入理解在此记录备忘。如有错误和理解不当之处，还望指正。万分感谢！ 另外，实例和内容有些是参照网络其他博文，如有侵权可联系删掉。 以菜单为例介绍自关联一对多，父菜单对应多个子菜单。 一、实体类Menu.java package demo.entity; impor...
Hibernate第九篇【组件映射、继承映射】
3y
05-08 381
前言 到目前位置，我们已经学习了一对一、一对多、多对一、多对多映射了…既然Hibernate是ORM实现的框架，它还提供了组件映射和继承映射..本博文主要讲解组件映射和继承映射 Java主要的类主要有两种方式 组合关系，组合关系对应的就是组件映射 继承关系，继承关系对应的就是继承映射 组件映射 组件映射实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表 有的...
详解Hibernate Session & Transaction
x_i_y_u_e的专栏
08-23 1137
HIbernate中的Session 　　Session是JAVA应用程序和Hibernate进行交互时使用的主要接口，它也是持久化操作核心API， 注意这里的Session的含义，它与传统意思上web层的HttpSession并没有关系，Hibernate Session之与Hibernate，相当于JDBC Connection相对与JDBC。 　　 　　Session对象是有生命周期的
hibernate组件映射和继承映射
JC.Lin的博客
12-25 304
组件映射与继承映射，表关系实现类的关系。
hibernate5实体映射注解配置注解全面解析
championSuiyang的博客
05-23 3810
版权声明：转载请注明本文源地址 目录(?)[+] 相对于经典风格的实体配置xxx.hbm.xml,新版本hibernate使用JPA(Java Persistence API)注解配置能使我们的开发更加敏捷便利.在本系列前面部分的文章中,我们围绕JPA注解风格配置来逐步深入学习。 配置实例 下面先看一个实体类的配置实例： package com.z
三、Hibernate组件映射与继承映射
vincentpu2009的博客
12-15 140
**组件映射与继承映射** 类的关系 组合关系 一个类中包含了另外一个类。这2个类中就是组合关系。 需求： 汽车与车轮 继承关系 一个类继承另外一个类。这2个类中就是继承关系。 需求：动物 猫 猴子1、组件映射 类组合关系的映射，也叫做组件映射！ 注意：组件类和被包含的组件类，共同映射到一张表！（所
新手上路之Hibernate（5）：继承映射
步春良
09-19 4023
之前的几篇文章主要介绍的是关系映射。之所以用好几篇的文章来介绍关系映射，其重要性与常用行可见一斑。还有一种映射，也就是今天要介绍的——继承映射，也是很重要的一种映射模式。 继承映射的实现有三种策略： 1、单表继承。每棵类继承树使用一个表。 2、具体表继承。每个子类一个表。 3、类表继承。每个具体类一个表。 下面将通过实例来具体说明这三种策略。我们以Animal类、Pig类、Bir
(8)hibernate四种继承映射
jianfpeng241241的专栏
11-20 938
一 一个类继承体系一张表 二 每个子类不同的部分用一张表 三 继承关系与内连接结合 四 每个具体类一张表
hibernate框架关联关系映射操作
最新发布
05-14
Hibernate框架提供了对象关系映射（ORM）功能，可以将Java对象映射到数据库表中，并且可以使用关联关系映射来描述对象之间的关系。下面是一些常见的Hibernate关联关系映射操作： 1. 一对一映射：在一个实体中定义一个引用另一个实体的属性。可以使用@OneToOne注释来映射一对一关系。 2. 一对多映射：在一个实体中定义一个集合属性，该集合中存储另一个实体的多个实例。可以使用@OneToMany注释来映射一对多关系。 3. 多对一映射：在一个实体中定义一个引用另一个实体的属性，该属性可以引用多个实例。可以使用@ManyToOne注释来映射多对一关系。 4. 多对多映射：在两个实体之间定义一个集合属性，该集合中存储两个实体之间的多个实例。可以使用@ManyToMany注释来映射多对多关系。 以上是Hibernate中一些常见的关联关系映射操作，还有其他高级的关系映射操作，如嵌套对象、组合关系等。在使用Hibernate进行关联关系映射时，需要仔细设计实体类之间的关系，以便能够正确地映射到数据库表中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值