JPA继承详解

因为关系数据库的表之间不存在继承关系，Entity 提供三种基本的继承映射策略：
每个类分层结构一张表(table per class hierarchy)
每个子类一张表(table per subclass)
每个具体类一张表(table per concrete class)

一、每个类分层结构一张表(table per class hierarchy)
       这种映射方式只需为基类创建一个表即可。在表中不仅提供基类所有属性对应的字段，还要提供所有子类属性对应的字段，此外还需要一个字段用于区分子类的具体类型要使用每个类分层结构一张表(table per class hierarchy) 策略，需要把@javax.persistence.Inheritance 注释的strategy属性设置为InheritanceType.SINGLE_TABLE。除非你要改变子类的映射策略，否则@Inheritance 注释只能放在继承层次的基类。通过鉴别字段的值，持久化引掣可以区分出各个类，并且知道每个类对应那些字段。鉴别字段通过@javax.persistence.DiscriminatorColumn 注释进行定义，name 属性定义鉴别字段的列名，discriminatorType 属性定义鉴别字段的类型（可选值有：String, Char, Integer），如果鉴别字段的类型为String 或Char，可以用length 属性定义其长度。@DiscriminatorValue 注释为继承关系中的每个类定义鉴别值，如果不指定鉴别值，默认采用类名
例:
    @SuppressWarnings("serial")
    @Entity
    @Table(name="Vehicle_Hierarchy")
    @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
    @DiscriminatorColumn(name="Discriminator",
                                         discriminatorType = DiscriminatorType.STRING,
                                         length=30)
    @DiscriminatorValue("Vehicle")
    public class Vehicle implements Serializable{       //基类
    private Long id;
    private Short speed;//速度
    @Id
    @GeneratedValue
    @Column(columnDefinition="integer")//指定使用适配Integer长度的数据类型
    public Long getId() {
    return id;
    }
    public void setId(Long id) {
    this.id = id;
    }

    @SuppressWarnings("serial")
    @Entity
    @DiscriminatorValue("Car")
    public class Car extends Vehicle{        //Vehicle的子类
    private String engine;//发动机
    @Column(nullable=true,length=30)
    public String getEngine() {
    return engine;
    }
    public void setEngine(String engine) {
    this.engine = engine;
        }
    }


     @SuppressWarnings("serial")
     @Entity
     @DiscriminatorValue("Camion")
     public class Camion extends Car{         //Car的子类
     private String container;//集装箱
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
          }
     }
分析:
       可以看出，每个子类没有单独的映射，在数据库中没有对应的表存在。而只有一个记录所有自身属性和子类所有属性的表，在基类为Vehicle 的时候，Discriminator 字段的值将为Vehicle,在子类为Car 的时候，Discriminator 字段的值将为Car，子类为Camion 的时候，Discriminator 字段的值将为Camion。那么，如果业务逻辑要求Car 对象的engine 属性不允许为null，显然无法在Vehicle_Hierarchy 表中为engine 字段定义not null 约束，可见这种映射方式无法保证关系数据模型的数据完整性。

二、每个类分层结构一张表(table per class hierarchy)
       这种映射方式为每个类创建一个表。在每个类对应的表中只需包含和这个类本身的属性对应的字段，子类对应的表参照父类对应的表,使用每个子类一张表 (table per subclass)策略，需要把@javax.persistence.Inheritance 注释的strategy 属性设置为InheritanceType.JOINED

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.JOINED)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{      //基类
     private Long id;
     private Short speed;//速度
     @Id
     @GeneratedValue
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
     @PrimaryKeyJoinColumn(name="CarID")     //把主键对应的列名更改为CarID
     public class Car extends Vehicle{                 //Vehicle的子类
     private String engine;//发动机
     @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     @PrimaryKeyJoinColumn(name="CamionID")     //把主键对应的列名更改为CamionID
     public class Camion extends Car{                    //Car的子类
     private String container;
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }
        这种映射方式支持多态关联和多态查询，而且符合关系数据模型的常规设计规则。在这种策略中你可以对子类的属性对应的字段定义not null 约束。该策略的缺点：
        它的查询性能不如上面介绍的映射策略。在这种映射策略下，必须通过表的内连接或左外连接来实现多态查询和多态关联。
选择原则：子类属性非常多，需要对子类某些属性对应的字段进行not null 约束，且对性能要求不是很严格时，优先选择该策略

三、每个具体类一张表(table per concrete class)
       这种映射方式为每个类创建一个表。在每个类对应的表中包含和这个类所有属性（包括从超类继承的属性）对应的字段,使用每个具体类一张表(table per concrete class)策略，需要把@javax.persistence.Inheritance 注释的strategy 属性设置为InheritanceType.TABLE_PER_CLASS

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

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{            //基类
     private Long id;
     private Short speed;//速度
     @Id
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
    public class Car extends Vehicle{               //Vehicle的子类
     private String engine;//发动机
     @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     public class Camion extends Car{              //Car的子类
     private String container;//集装箱
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }

注意:在查询时,例如: from Vehicle v
         查询所有Vehicle时，因为他是最继承树中的根，查询结果会得到所有继承于Vehicle类的记录
(构造的SQL Where部分：where Discriminator in ('Car', 'Camion'))
         delete from Vehicle v
         执行该操作会删除自身对应记录，还会删除所有继承Vehicle的记录,因为他是最继承树中的根，就相当于清除整个表的数据

该策略的优点：
                     在这种策略中你可以对子类的属性对应的字段定义not null 约束。
该策略的缺点：
                     不符合关系数据模型的常规设计规则，每个表中都存在属于基类的多余的字段。同时，为了支持策略的映射，持久化管理者需要决定使用什么方法，一种方法是在 entity 载入或多态关联时，容器使用多次查询去实现，这种方法需要对数据库做几次来往查询，非常影响执行效率。另一种方法是容器通过使用SQLUNIOU 查询来实现这种策略。
选择原则：
                     除非你的现实情况必须使用这种策略，一般情况下不要选择。