这部分的内容基本与Hibernate一致.JPA同样支持3种类型的继承形式:

1.Single Table Strategy ,单表策略,一张表包含基类与子类的所有数据,很多情况下都是采用这样的冗余设计,通过一个discriminator来区分

2.Table Per Class Strategy ,每个子类对应一张表,每张表都拥有基类的属性

3.Join Strategy ,仍然是每个子类对应一张表，但此表中不包含基类的属性,仅仅是此子类的扩展属性,共享基类的属性

以一个例子来说明3种情况:

一.单表策略

比如Pet作为基类,Cat和Dog继承此类并拥有自己的扩展属性,如:

package com.denny_blue.ejb3.inheritance;

import java.io.Serializable;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "animal_type", discriminatorType = DiscriminatorType.STRING)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

public Pet() {
}

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
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;
}

public double getWeight() {
   return weight;
}

public void setWeight(double weight) {
   this.weight = weight;
}

}

Pet类值的注意的就是通过@Inheritance(strategy = InheritanceType.SINGLE_TABLE)确定采用单表策略,通过@DiscriminatorColumn确定了标志值的字段和类型，我想熟悉hibernate的朋友对这些都应该很熟悉.然后是两个子类:

//Cat.java

package com.denny_blue.ejb3.inheritance;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("cat")
public class Cat extends Pet {
private String HairBall;

public String getHairBall() {
   return HairBall;
}

public void setHairBall(String hairBall) {
   HairBall = hairBall;
}

}

//Dog.java

package com.denny_blue.ejb3.inheritance;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("dog")
public class Dog extends Pet {
private String trick;

public String getTrick() {
   return trick;
}

public void setTrick(String trick) {
   this.trick = trick;
}

}

两个子类最值的关注的就是@DiscriminatorValue注释,比如Cat的此值为cat,意味着当Cat类型的Entity存入数据库时,JPA将自动把cat的值赋给animal_type字段,Dog的值则为dog,由此就可以在同一张表中区分开两个不同的子类.

二.Table per Class

采用Table Per Class策略的话，每个子类都将单独建表，并且都独立拥有基类中的所有属性,互相之间不共享,在我们的例子中所要进行的修改很小,像这样:

//基类

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

........

//子类:不需要任何设置

@Entity
public class Dog extends Pet {
private String trick;

.......

.......

}

例：

@Entity
@Table(name = "TEST_A")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class TestA implements java.io.Serializable {

// Fields

/**
*
*/
private static final long serialVersionUID = 5931010626625178698L;
private Long id;
private String name;
private String code;

// Constructors
public TestA() {

}

/** minimal constructor */
public TestA(Long id) {
   this.id = id;
}

/** full constructor */
public TestA(Long id, String name, String code) {
   this.id = id;
   this.name = name;
   this.code = code;
}

// Property accessors
@Id
@Column(name = "ID")
@GeneratedValue(strategy = GenerationType.AUTO, generator = "SEQ")
@SequenceGenerator(name="SEQ", sequenceName = "SEQ_TEMP_VOICE_FILE")
public Long getId() {
   return this.id;
}

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

@Column(name = "NAME", unique = false, nullable = true, insertable = true, updatable = true, length = 200)
public String getName() {
   return this.name;
}

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

@Column(name = "CODE", unique = false, nullable = true, insertable = true, updatable = true, length = 200)
public String getCode() {
   return this.code;
}

public void setCode(String code) {
   this.code = code;
}

}

@Entity
@Table(name = "TEST_B")
public class TestB extends TestA {

// Fields

/**
*
*/
private static final long serialVersionUID = 4942564072409132522L;

/** minimal constructor */
public TestB() {

}
public TestB(Long id) {
   this.setId(id);
}

@Column(name = "FLAG", unique = false, nullable = true, insertable = true, updatable = true, precision = 1, scale = 0)
public Long getFlag() {
   return this.flag;
}

public void setFlag(Long flag) {
   this.flag = flag;
}

}

三.Join策略

每个子类同样独立建表,基类也独立建表，只不过所有的子类的表中只有扩展属性,他们共享基类的表,在我们的例子中修改下即可:

//基类

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

........

//子类

@Entity

@Inheritance(strategy = InheritanceType.JOINED)
public class Dog extends Pet {
private String trick;