Hibernate之jpa实体映射的三种继承关系

转载自:http://blog.sina.com.cn/s/blog_7085382f0100uk4p.html

 

基于代码复用和模型分离的思想，在项目开发中使用JPA的@MappedSuperclass注解将实体类的多个属性分别封装到不同的非实体类中。

 

1.@MappedSuperclass注解只能标准在类上：@Target({java.lang.annotation.ElementType.TYPE})

 

2.标注为@MappedSuperclass的类将不是一个完整的实体类，他将不会映射到数据库表，但是他的属性都将映射到其子类的数据库字段中。

 

3.标注为@MappedSuperclass的类不能再标注@Entity或@Table注解，也无需实现序列化接口。

但是如果一个标注为@MappedSuperclass的类继承了另外一个实体类或者另外一个同样标注了@MappedSuperclass的类的话，他将可以使用@AttributeOverride或@AttributeOverrides注解重定义其父类(无论是否是实体类)的属性映射到数据库表中的字段。

比如可以重定义字段名或长度等属性，使用@AttributeOverride中的子属性@Column进行具体的定义。

注意：对于其父类中标注@Lob注解的属性将不能重载，并且@AttributeOverride里的@Column设置都将不起作用。

JPA规范中对@Lob注解并没有说明不能同时标注@Column注解，但是在实际使用中Hibernate JPA不支持这中标注方式。

 

4.此外，这样的类还可以直接标注@EntityListeners实体监听器，他的作用范围仅在其所有继承类中，并且实体监听器同样可以保被其子类继承或重载。

 

5.标注为@MappedSuperclass的类其属性最好设置为protected或default类型的，以保证其同一个包下的子类可以直接调用它的属性。便于实体监听器或带参数构造函数的操作。

 

6.由于标注为@MappedSuperclass的类将不是一个完整的实体类，因此其不能标注@Table，并且无法使用@UniqueConstraint设置字段的Unique属性，这一点以及对属性类型重载(如重载标注为@Lob的属性)的支持ＪＰＡ规范还有待改进。

 

7.可以同时标注@DiscriminatorValue注解，以设定实体子类的实体标识字段的值。该属性一般是在实体继承的时候使用的较多，但是在实体映射的时候可以不用设置。

 

8.比较实体继承与实体映射的区别：

实体继承的三种策略分别是：SINGLE_TABLE(所有继承的实体都保存在同一张数据库表中),JOINED(每个实体子类都将保存在一个单独的表中),TABLE_PER_CLASS(有继承关系的所有实体类都将保存在单独的表中)。

实体映射最类似于JOINED实体继承方式，他也是将实体子类单独保存为一张表，但是两者最大的区别就在于：查询的时候JOINED使用的是多态查询，在查询父类时其所有实体子类的数据也将同时被查询出，因此查询时间和性能都将有影响。但是实体映射方式的数据库查询等同于没有实体继承关系的查询，也就是说，他仅在实体层体现出一种继承的关系却并没有在数据库中体现这样一种关系，他的操作都是独立的并且将不会影响到实体子类。

 

Hibernate之jpa实体映射的三种继承关系

转载自：http://www.cnblogs.com/shangxiaofei/p/5704321.html

在JPA中，实体继承关系的映射策略共有三种：单表继承策略(table per class)、Joined策略(table per subclass)和Table_PER_Class策略。

 

1.单表继承策略

   

    单表继承策略，父类实体和子类实体共用一张数据库表，在表中通过一列辨别字段来区别不同类别的实体。具体做法如下：

a.在父类实体的@Entity注解下添加如下的注解：

@Inheritance(Strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name=”辨别字段列名”)
@DiscriminatorValue(父类实体辨别字段列值)

 

b.在子类实体的@Entity注解下添加如下的注解：

@DiscriminatorValue(子类实体辨别字段列值) 

 

 

定义了一个父类

 

1. @Entity  
2. @Inheritance(strategy = InheritanceType.SINGLE_TABLE)  
3. @Table(name = "WINDOW_FILE")  
4. @DiscriminatorColumn(name = "DISCRIMINATOR", discriminatorType = DiscriminatorType.STRING, length = 30)  
5. @DiscriminatorValue("WindowFile")  
6. public class WindowFile {  
7.   
8.     @Id  
9.     @GeneratedValue(strategy = GenerationType.AUTO)  
10.     private Integer id;  
11.   
12.     @Basic  
13.     @Column(name = "NAME")  
14.     private String name;  
15.   
16.     @Basic  
17.     @Column(name = "TYPE")  
18.     private String type;  
19.   
20.     @Basic  
21.     @Column(name = "DATE")  
22.     private Date date;  
23.     //省略get set  
24. }  

 

后定义2个子类

 

1. @Entity  
2. @DiscriminatorValue("Folder")  
3. public class Folder extends WindowFile {  
4.   
5.     @Basic  
6.     @Column(name = "FILE_COUNT")  
7.     private Integer fileCount;  
8.     //省略get set  
9. }  

 

1. @Entity  
2. @DiscriminatorValue("Document")  
3. public class Document extends WindowFile {  
4.   
5.     @Basic  
6.     @Column(name = "SIZE")  
7.     private String size;  
8.     //省略get set  
9. }  

 

 以上通过列DISCRIMINATOR的不同，区分具体父子实体。

 

实际表结构如下：

WINDOW_FILE  DISCRIMINATOR,ID,NAME,DATE,TYPE,SIZE,FILE_COUNT

 

当你使用WindowFile实体时，实际表的字段为DISCRIMINATOR='WindowFile',SIZE与FILE_COUNT永远是空

当使用Folder实体时，DISCRIMINATOR='Folder',SIZE永远是空,FILE_COUNT为实际值。

Document同理，与Folder类似。

 

2.Joined策略

 

    父类实体和子类实体分别对应数据库中不同的表，子类实体的表中只存在其扩展的特殊属性，父类的公共属性保存在父类实体映射表中。具体做法：

 

 

 

 

 

@Inheritance(Strategy=InheritanceType.JOINED)

 

子类实体不需要特殊说明。

 

 

1. @Entity  
2. @Table(name = "T_ANIMAL")  
3. @Inheritance(strategy = InheritanceType.JOINED)  
4. public class Animal {  
5.   
6.     @Id  
7.     @Column(name = "ID")  
8.     @GeneratedValue(strategy = GenerationType.AUTO)  
9.     private Integer id;  
10.   
11.     @Column(name = "NAME")  
12.     private String name;  
13.   
14.     @Column(name = "COLOR")  
15.     private String color;  
16.     //省略get set  
17. }  

 

1. @Entity  
2. @Table(name = "T_BIRD")  
3. @PrimaryKeyJoinColumn(name = "BIRD_ID")  
4. public class Bird extends Animal {  
5.   
6.     @Column(name = "SPEED")  
7.     private String speed;  
8.     //省略get set  
9. }  

 

1. @Entity  
2. @Table(name = "T_DOG")  
3. @PrimaryKeyJoinColumn(name = "DOG_ID")  
4. public class Dog extends Animal {  
5.   
6.     @Column(name = "LEGS")  
7.     private Integer legs;  
8.     //省略get set  
9. }  

 

 

实际表结构如下：

T_ANIMAL  ID,COLOR,NAME

T_BIRD  SPEED,BIRD(既是外键，也是主键)

T_DOG  LEGS,DOG_ID(既是外键，也是主键)

 

3.Table_PER_Class策略：

 

Table_PER_Class策略，父类实体和子类实体每个类分别对应一张数据库中的表，子类表中保存所有属性，包括从父类实体中继承的属性。具体做法：

只需在父类实体的@Entity注解下添加如下注解：

@Inheritance(Strategy=InheritanceType.TABLE_PER_CLASS)

 

1. @Entity  
2. @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)  
3. @Table(name = "T_VEHICLE")  
4. public class Vehicle { // 基类  
5.   
6.     @Id  
7.     // @GeneratedValue  
8.     @Column(name = "ID")  
9.     private Integer id;  
10.   
11.     @Column(name = "SPEED")  
12.     private Integer speed;// 速度  
13.     //省略get set  
14. }  

 

1. @Entity  
2. @Table(name = "T_CAR")  
3. public class Car extends Vehicle {  
4.   
5.     @Column(name = "ENGINE")  
6.     private String engine;// 发动机  
7.     //省略get set  
8. }  

 

一旦使用这种策略就意味着你不能使用AUTO generator 和IDENTITY generator，即主键值不能采用数据库自动生成。

 

实际表结构如下：

T_VEHICLE  ID,SPEED

T_CAR  ID,SPEED,ENGINE

来源：https://www.cnblogs.com/chrischris/p/5952290.html