We define the category relationships between Employee and Person, as well as between Author and Person, using the JPA annotations. At first we create the Person class as shown below:

@Entity @Table(name="persons")
@Inheritance(strategy=InheritanceType.JOINED)
@DiscriminatorColumn(name="category", 
    discriminatorType=DiscriminatorType.STRING, length=16)
public abstract class Person {
  @Id @NotNull(message="A person ID is required!")
  private Integer personId;
  @NotNull(message="A name is required!") @Column(nullable=false)
  private String name;
  ...
}

Comparing with the Book hierarchy shown in Test Case 1, the @Inheritance annotations defines now the strategy=InheritanceType.JOINED. This means, for every class in the inheritance hierarchy, a database table is used. The @DiscriminatorColumn(name="category") specifies the column in the corresponding table (i.e., persons) of the top hierarchy class (i.e., Person) which stores the discriminator values used to identify the stored type of each entry (table row).

Notice that the Java class Person is declared as being abstract, which means it can't be initialized, instead we can and we initialize subclasses derived from it (i.e., Employee and Author). This also mean that we don't declare a @DiscriminatorValue because no direct instance of Person is stored in the database table.

Further, we define the Author class as follows:

@Entity @Table(name="authors")
@DiscriminatorValue( value="AUTHOR")
@ManagedBean(name="author") @ViewScoped
public class Author extends Person {
  @NotNull(message="A biography is required!")
  private String biography;
  ...
}

The Author class inherits Person, therefore the get and set methods corresponding to personId and name properties are available. The @DiscriminatorValue(value="AUTHOR") specifies that the column category of the persons table stores the value AUTHOR for every entry which comes from persisting an Author instance.

Finally, we define the Employee class:

@Entity @Table(name="employees")
@DiscriminatorValue(value="EMPLOYEE")
@ManagedBean(name="employee") @ViewScoped
public class Employee extends Person {
  @Column( nullable=false)
  @NotNull( message="An employee ID is required!")
  private Integer empNo;
  @Column( nullable=false, length=32)
  @Enumerated( EnumType.STRING)
  private EmployeeCategoryEL type;
  @Column( nullable=true, length=64)
  private String department;
  ...
}

Notice the type property used to identify the Employee type, such as Manager. Its values are defined by the EmployeeCategoryEL enumeration.

As a result of the annotation

@Inheritance( strategy = InheritanceType.JOINED)

for each class in the inheritance hierarchy, one database table is created. The corresponding simplified SQL-DDL scripts used by JPA to create the persons, authors and employees tables are shown below:

CREATE TABLE IF NOT EXISTS `persons` (
  `PERSONID` int(11) NOT NULL,
  `category` varchar(16) DEFAULT NULL,
  `NAME` varchar(255) NOT NULL
);
CREATE TABLE IF NOT EXISTS `authors` (
  `PERSONID` int(11) NOT NULL,
  `BIOGRAPHY` varchar(255) DEFAULT NULL
);
ADD CONSTRAINT `FK_authors_PERSONID` FOREIGN KEY (`PERSONID`) 
    REFERENCES `persons` (`PERSONID`);
CREATE TABLE IF NOT EXISTS `employees` (
  `PERSONID` int(11) NOT NULL,
  `DEPARTMENT` varchar(64) DEFAULT NULL,
  `EMPNO` int(11) NOT NULL,
  `TYPE` varchar(32) DEFAULT NULL
);
ADD CONSTRAINT `FK_employees_PERSONID` FOREIGN KEY (`PERSONID`) 
  REFERENCES `persons` (`PERSONID`);

As we can see, every table contains the direct properties as defined by the corresponding Java bean class. Additionally, the authors and employees tables are created with a foreign key constraing for the PERSONID column refering to to the PERSONID column from the persons table.