EJB---->实体继承

来源：互联网发布：洛阳平安数据科技待遇编辑：程序博客网时间：2024/06/04 17:49

三个类分别是：Vehicle（交通工具），Car（汽车），Camion（卡车），他们的继承关系如下：

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

一、每个类分层结构一张表(table per class hierarchy)

这种映射方式只需为基类Vehicle 创建一个表(Vehicle_Hierarchy)即可。在表中不仅提供Vehicle 所有属性对应的字段，还要提供所有子类属性对应的字段，此外还需要一个字段用于区分子类的具体类型。

要使用每个类分层结构一张表(table per class hierarchy) 策略，需要把@javax.persistence.Inheritance 注释的strategy属性设置为InheritanceType.SINGLE_TABLE。除非你要改变子类的映射策略，否则@Inheritance 注释只能放在继承层次的基类。通过鉴别字段的值，持久化引掣可以区分出各个类，并且知道每个类对应那些字段。鉴别字段通过@javax.persistence.DiscriminatorColumn 注释进行定义，name 属性定义鉴别字段的列名，discriminatorType 属性定义鉴别字段的类型（可选值有：String, Char, Integer），如果鉴别字段的类型为String 或Char，可以用length 属性定义其长度。@DiscriminatorValue 注释为继承关系中的每个类定义鉴别值，如果不指定鉴别值，默认采用类名。

Vehicle.java

package com.foshanshop.ejb3.bean;import java.io.Serializable;import javax.persistence.DiscriminatorColumn;import javax.persistence.DiscriminatorType;import javax.persistence.DiscriminatorValue;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Inheritance;import javax.persistence.InheritanceType;import javax.persistence.Table;@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 static final long serialVersionUID = -3196397365804550797L;private Long id;    private Short speed;//速度        @Id    @GeneratedValue    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;    }}

Car.java( Car 继承Vehicle，并有自己的属性engine）

package com.foshanshop.ejb3.bean;import javax.persistence.Column;import javax.persistence.DiscriminatorValue;import javax.persistence.Entity;@Entity@DiscriminatorValue("Car")public class Car extends Vehicle{private static final long serialVersionUID = -8744304233821634737L;private String engine;//发动机    @Column(nullable=true,length=30)    public String getEngine() {        return engine;    }    public void setEngine(String engine) {        this.engine = engine;    }}

Camion.java (Camion 继承Car，并有自己的属性container)

package com.foshanshop.ejb3.bean;import javax.persistence.Column;import javax.persistence.DiscriminatorValue;import javax.persistence.Entity;@Entity@DiscriminatorValue("Camion")public class Camion extends Car{private static final long serialVersionUID = -1266718346507357439L;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 约束，可见这种映
射方式无法保证关系数据模型的数据完整性。

EntityInheritanceDAOBean.java

package com.foshanshop.ejb3.impl;import java.util.List;import javax.ejb.Remote;import javax.ejb.Stateless;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import javax.persistence.Query;import com.foshanshop.ejb3.EntityInheritanceDAO;import com.foshanshop.ejb3.bean.Car;import com.foshanshop.ejb3.bean.Vehicle;import com.foshanshop.ejb3.bean.Camion;@Stateless@Remote (EntityInheritanceDAO.class)public class EntityInheritanceDAOBean implements EntityInheritanceDAO {    @PersistenceContext protected EntityManager em;      public void initializeData(){        //添加Vehicle        Vehicle vehicle = new Vehicle();            vehicle.setSpeed((short)100);        em.persist(vehicle);        //添加Car        Car car = new Car();            car.setSpeed((short)300);            car.setEngine("A发动机");        em.persist(car);        //添加Camion        Camion camion = new Camion();            camion.setSpeed((short)200);            camion.setEngine("B发动机");            camion.setContainer("2吨集装箱");        em.persist(camion);    }        @SuppressWarnings("unchecked")public List<Vehicle> getVehicle() {         //查询所有Vehicle时，因为它是最继承树中的根，查询结果会得到所有继承于Vehicle类的记录        //转绎成的SQL片断：select * from Vehicle_Hierarchy              Query query = em.createQuery("select v from Vehicle v");        return (List<Vehicle>)query.getResultList();    }     @SuppressWarnings("unchecked")    public List<Car> getCar() {         //查询所有Car时，除了得到Car类的记录，也会得到所有继承于Car类的记录        //构造的SQL Where部分：where Discriminator in ('Car', 'Camion')        Query query = em.createQuery("select c from Car c");        return (List<Car>)query.getResultList();    }    @SuppressWarnings("unchecked")    public List<Camion> getCamion() {                Query query = em.createQuery("select c from Camion c");        return (List<Camion>)query.getResultList();    }          public void deleteVehicle() {          //执行该操作会删除自身对应记录，还会删除所有继承Vehicle的记录，        //因为它是最继承树中的根，就相当于清除整个表的数据        Query query = em.createQuery("delete from Vehicle v");        query.executeUpdate();    }  }

该策略的优点：
SINGLE_TABLE 映射策略在所有继承策略中是最简单的，同时也是执行效率最高的。他仅需对一个表进行管理及操作，持久化引掣在载入entiry 或多态连接时不需要进行任何的关联，联合或子查询，因为所有数据都存储在一个表。
该策略的缺点：
这种策略最大的一个缺点是需要对关系数据模型进行非常规设计，在数据库表中加入额外的区分各个子类的字段，此外，不能为所有子类的属性对应的字段定义not null 约束，此策略的关系数据模型完全不支持对象的继承关系。
选择原则：查询性能要求高，子类属性不是非常多时，优先选择该策略。

2 每个子类一张表(table per subclass)

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

Vehicle.java

package com.foshanshop.ejb3.bean;import java.io.Serializable;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Inheritance;import javax.persistence.InheritanceType;@Entity@Inheritance(strategy=InheritanceType.JOINED)public class Vehicle implements Serializable{private static final long serialVersionUID = -3196397365804550797L;private Long id;    private Short speed;//速度        @Id    @GeneratedValue    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;    }}

Car.java

import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.PrimaryKeyJoinColumn;@Entity@PrimaryKeyJoinColumn(name="CarID")public class Car extends Vehicle{private static final long serialVersionUID = -8744304233821634737L;private String engine;//发动机    @Column(nullable=true,length=30)    public String getEngine() {        return engine;    }    public void setEngine(String engine) {        this.engine = engine;    }}

Camion .java

package com.foshanshop.ejb3.bean;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.PrimaryKeyJoinColumn;@Entity@PrimaryKeyJoinColumn(name="CamionID")public class Camion extends Car{private static final long serialVersionUID = -1266718346507357439L;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 约束，且对性能要求不是很严格时，优先选择该策略。

3 每个具体类一张表(table per concrete class)

这种映射方式为每个类创建一个表。在每个类对应的表中包含和这个类所有属性（包括从超类继承的属性）对应
的字段。

要使用每个具体类一张表(table per concrete class)策略，需要把@javax.persistence.Inheritance 注释的strategy 属性设置为InheritanceType.TABLE_PER_CLASS。

Vehicle.java

package com.foshanshop.ejb3.bean;import java.io.Serializable;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.Inheritance;import javax.persistence.InheritanceType;import javax.persistence.TableGenerator;@Entity@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)public class Vehicle implements Serializable{private static final long serialVersionUID = -3196397365804550797L;private Long id;    private Short speed;//速度        @Id   @TableGenerator(name="VehicleID_Generator",//为该生成方式取个名称            table="VehicleID_Generator",//定义用于生成ID的表            pkColumnName="PRIMARY_KEY_COLUMN",//主键字段的名称            valueColumnName="VALUE_COLUMN",//存放生成ID值的字段            pkColumnValue="vehicle",//主键字段的值(该值用于定位某条记录，然后累加其ID值)            allocationSize=1             )    @GeneratedValue(strategy=GenerationType.TABLE, generator="VehicleID_Generator")    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;    }    }

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

Car.java

package com.foshanshop.ejb3.bean;import javax.persistence.Column;import javax.persistence.Entity;@Entitypublic class Car extends Vehicle{private static final long serialVersionUID = -8744304233821634737L;private String engine;//发动机    @Column(nullable=true,length=30)    public String getEngine() {        return engine;    }    public void setEngine(String engine) {        this.engine = engine;    }    }

Camion.java

package com.foshanshop.ejb3.bean;import javax.persistence.Column;import javax.persistence.Entity;@Entitypublic class Camion extends Car{private static final long serialVersionUID = -1266718346507357439L;private String container;//集装箱    @Column(nullable=true,length=30)    public String getContainer() {        return container;    }    public void setContainer(String container) {        this.container = container;    }    }

Session Bean

package com.foshanshop.ejb3.impl;import java.util.List;import javax.ejb.Remote;import javax.ejb.Stateless;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import javax.persistence.Query;import com.foshanshop.ejb3.EntityInheritanceDAO;import com.foshanshop.ejb3.bean.Car;import com.foshanshop.ejb3.bean.Vehicle;import com.foshanshop.ejb3.bean.Camion;@Stateless@Remote (EntityInheritanceDAO.class)public class EntityInheritanceDAOBean implements EntityInheritanceDAO {    @PersistenceContext protected EntityManager em;      public void initializeData(){        //添加Vehicle        Vehicle vehicle = new Vehicle();            vehicle.setSpeed((short)100);        em.persist(vehicle);        //添加Car        Car car = new Car();            car.setSpeed((short)300);            car.setEngine("A发动机");        em.persist(car);        //添加Camion        Camion camion = new Camion();            camion.setSpeed((short)200);            camion.setEngine("B发动机");            camion.setContainer("2吨集装箱");        em.persist(camion);    }        @SuppressWarnings("unchecked")public List<Vehicle> getVehicle() {         //查询所有Vehicle时，因为它是最继承树中的根，查询结果会得到所有继承于Vehicle类的记录        //转绎成的SQL片断：select * from Vehicle_Hierarchy              Query query = em.createQuery("select v from Vehicle v");        return (List<Vehicle>)query.getResultList();    }     @SuppressWarnings("unchecked")    public List<Car> getCar() {         //查询所有Car时，除了得到Car类的记录，也会得到所有继承于Car类的记录        //构造的SQL Where部分：where Discriminator in ('Car', 'Camion')        Query query = em.createQuery("select c from Car c");        return (List<Car>)query.getResultList();    }    @SuppressWarnings("unchecked")    public List<Camion> getCamion() {                Query query = em.createQuery("select c from Camion c");        return (List<Camion>)query.getResultList();    }          public void deleteVehicle() {          //执行该操作会删除自身对应记录，还会删除所有继承Vehicle的记录，        //因为它是最继承树中的根，就相当于清除整个表的数据        Query query = em.createQuery("delete from Vehicle v");        query.executeUpdate();    }  }

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