Table per hierarchy with Annotation


Let us understand about Table Per Hierarchy with Annotation


We have already discussed Table per hierarchy with xml.

Please go through Table per hierarchy with xml article before going through the same using annotation.

Let’s create hibernate project using Annotation

Step 1

Create hibernate project

Please refer Hibernate setup in eclipse article on how to do it.

Project Structure

TPH_Annotation_Proj_structure

Step 2

Update pom.xml with Hibernate and Mysql dependencies

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.  
  6.     <groupId>TablePerHierarchyAnnotation</groupId>
  7.     <artifactId>TablePerHierarchyAnnotation</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  10.  
  11.     <name>TablePerHierarchyAnnotation</name>
  12.     <url>http://maven.apache.org</url>
  13.  
  14.     <properties>
  15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.     </properties>
  17.  
  18.     <dependencies>
  19.  
  20.         <dependency>
  21.             <groupId>junit</groupId>
  22.             <artifactId>junit</artifactId>
  23.             <version>3.8.1</version>
  24.             <scope>test</scope>
  25.         </dependency>
  26.  
  27.         <dependency>
  28.             <groupId>org.hibernate</groupId>
  29.             <artifactId>hibernate-core</artifactId>
  30.             <version>5.2.6.Final</version>
  31.         </dependency>
  32.  
  33.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  34.         <dependency>
  35.             <groupId>mysql</groupId>
  36.             <artifactId>mysql-connector-java</artifactId>
  37.             <version>6.0.5</version>
  38.         </dependency>
  39.  
  40.         <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-annotations -->
  41.         <dependency>
  42.             <groupId>org.hibernate</groupId>
  43.             <artifactId>hibernate-annotations</artifactId>
  44.             <version>3.5.6-Final</version>
  45.         </dependency>
  46.  
  47.     </dependencies>
  48. </project>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>TablePerHierarchyAnnotation</groupId>
	<artifactId>TablePerHierarchyAnnotation</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>TablePerHierarchyAnnotation</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>5.2.6.Final</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>6.0.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-annotations -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-annotations</artifactId>
			<version>3.5.6-Final</version>
		</dependency>

	</dependencies>
</project>

Step 3

Create Employee class

  1. package com.kb.model;
  2.  
  3. import javax.persistence.Column;
  4. import javax.persistence.DiscriminatorColumn;
  5. import javax.persistence.DiscriminatorType;
  6. import javax.persistence.DiscriminatorValue;
  7. import javax.persistence.Entity;
  8. import javax.persistence.GeneratedValue;
  9. import javax.persistence.GenerationType;
  10. import javax.persistence.Id;
  11. import javax.persistence.Inheritance;
  12. import javax.persistence.InheritanceType;
  13. import javax.persistence.Table;
  14.  
  15. @Entity
  16. @Table(name = "Employee")
  17. @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
  18. @DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
  19. @DiscriminatorValue(value = "E")
  20.  
  21. public class Employee {
  22.  
  23.     @Id
  24.     @GeneratedValue(strategy = GenerationType.AUTO)
  25.     @Column(name = "id")
  26.     private int id;
  27.  
  28.     @Column(name = "name")
  29.     private String name;
  30.  
  31.     public int getId() {
  32.         return id;
  33.     }
  34.  
  35.     public void setId(int id) {
  36.         this.id = id;
  37.     }
  38.  
  39.     public String getName() {
  40.         return name;
  41.     }
  42.  
  43.     public void setName(String name) {
  44.         this.name = name;
  45.     }
  46. }
package com.kb.model;

import javax.persistence.Column;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
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.Table;

@Entity
@Table(name = "Employee")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue(value = "E")

public class Employee {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@Column(name = "id")
	private int id;

	@Column(name = "name")
	private String name;

	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;
	}
}

Step 4

Create PermanentEmployee class

  1. package com.kb.model;
  2.  
  3. import javax.persistence.Column;
  4. import javax.persistence.DiscriminatorValue;
  5. import javax.persistence.Entity;
  6.  
  7. @Entity
  8. @DiscriminatorValue(value = "PE")
  9. public class PermanentEmployee extends Employee {
  10.  
  11.     @Column(name = "salary")
  12.     private double salary;
  13.  
  14.     public double getSalary() {
  15.         return salary;
  16.     }
  17.  
  18.     public void setSalary(double salary) {
  19.         this.salary = salary;
  20.     }
  21.  
  22. }
package com.kb.model;

import javax.persistence.Column;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue(value = "PE")
public class PermanentEmployee extends Employee {

	@Column(name = "salary")
	private double salary;

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

}

Step 5

Create ContractEmployee class

  1. package com.kb.model;
  2.  
  3. import javax.persistence.Column;
  4. import javax.persistence.DiscriminatorValue;
  5. import javax.persistence.Entity;
  6.  
  7. @Entity
  8. @DiscriminatorValue(value = "CE")
  9. public class ContractEmployee extends Employee {
  10.    
  11.     @Column(name = "hourlyRate")
  12.     private double hourlyRate;
  13.  
  14.     public double getHourlyRate() {
  15.         return hourlyRate;
  16.     }
  17.  
  18.     public void setHourlyRate(double hourlyRate) {
  19.         this.hourlyRate = hourlyRate;
  20.     }
  21.  
  22. }
package com.kb.model;

import javax.persistence.Column;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue(value = "CE")
public class ContractEmployee extends Employee {
	
	@Column(name = "hourlyRate")
	private double hourlyRate;

	public double getHourlyRate() {
		return hourlyRate;
	}

	public void setHourlyRate(double hourlyRate) {
		this.hourlyRate = hourlyRate;
	}

}

Step 6

Create hibernate.cfg.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5.  
  6. <hibernate-configuration>
  7.  
  8.     <session-factory>
  9.  
  10.         <!-- Database connection properties -->
  11.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  12.         <property name="connection.url">jdbc:mysql://localhost/javainsimpleway</property>
  13.         <property name="connection.username">root</property>
  14.         <property name="connection.password">root</property>
  15.  
  16.         <!-- JDBC connection pool (using the built-in) -->
  17.         <property name="connection.pool_size">100</property>
  18.  
  19.         <!-- SQL dialect -->
  20.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
  21.  
  22.         <!-- Disable the second-level cache -->
  23.         <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>
  24.  
  25.         <!-- Echo all executed SQL to stdout -->
  26.         <property name="show_sql">true</property>
  27.  
  28.         <!-- Format the generated Sql -->
  29.         <property name="format_sql">true</property>
  30.  
  31.         <!-- Dont Drop and re-create the database schema on startup,Just update
  32.             it -->
  33.         <property name="hbm2ddl.auto">update</property>
  34.  
  35.         <mapping class="com.kb.model.Employee" />
  36.         <mapping class="com.kb.model.ContractEmployee" />
  37.         <mapping class="com.kb.model.PermanentEmployee" />
  38.  
  39.     </session-factory>
  40.  
  41. </hibernate-configuration>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
       "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

	<session-factory>

		<!-- Database connection properties -->
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost/javainsimpleway</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>

		<!-- JDBC connection pool (using the built-in) -->
		<property name="connection.pool_size">100</property>

		<!-- SQL dialect -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

		<!-- Disable the second-level cache -->
		<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

		<!-- Echo all executed SQL to stdout -->
		<property name="show_sql">true</property>

		<!-- Format the generated Sql -->
		<property name="format_sql">true</property>

		<!-- Dont Drop and re-create the database schema on startup,Just update 
			it -->
		<property name="hbm2ddl.auto">update</property>

		<mapping class="com.kb.model.Employee" />
		<mapping class="com.kb.model.ContractEmployee" />
		<mapping class="com.kb.model.PermanentEmployee" />

	</session-factory>

</hibernate-configuration>


We have defined the entire database configuration in hibernate.cfg.xml this file

hbm2ddl.auto property is defined in the config file which helps in automatic creation of tables in the database based on the mapping.

We have also provided the mapping class names where we have added the annotations using “mapping” tag.

Step 7

Create Hibernate util class

  1. package com.kb.util;
  2.  
  3. import org.hibernate.SessionFactory;
  4. import org.hibernate.cfg.Configuration;
  5.  
  6. public class HibernateUtil {
  7.     private static final SessionFactory sessionFactory = buildSessionFactory();
  8.  
  9.     private static SessionFactory buildSessionFactory() {
  10.         try {
  11.             // Create the SessionFactory from hibernate.cfg.xml
  12.             return new Configuration().configure().buildSessionFactory();
  13.         } catch (Throwable ex) {
  14.             // Make sure you log the exception to track it
  15.             System.err.println("SessionFactory creation failed." + ex);
  16.             throw new ExceptionInInitializerError(ex);
  17.         }
  18.     }
  19.  
  20.     public static SessionFactory getSessionFactory() {
  21.         return sessionFactory;
  22.     }
  23.    
  24.     public static void shutdown() {
  25.         // Optional but can be used to Close caches and connection pools
  26.         getSessionFactory().close();
  27.     }
  28.  
  29. }
package com.kb.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception to track it
            System.err.println("SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    public static void shutdown() {
    	// Optional but can be used to Close caches and connection pools
    	getSessionFactory().close();
    }

}

Step 8

Create main class to interact with DB

  1. package com.kb.db;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.Transaction;
  6.  
  7. import com.kb.model.ContractEmployee;
  8. import com.kb.model.Employee;
  9. import com.kb.model.PermanentEmployee;
  10. import com.kb.util.HibernateUtil;
  11.  
  12. public class Main {
  13.     public static void main(String[] args) {
  14.         //Get session factory using Hibernate Util class
  15.         SessionFactory sf = HibernateUtil.getSessionFactory();
  16.         //Get session from Sesson factory
  17.         Session session = sf.openSession();
  18.        
  19.         //Begin transaction
  20.         Transaction t=session.beginTransaction();  
  21.  
  22.         //Creating Employee base class record
  23.         Employee employee=new Employee();  
  24.         employee.setName("John");  
  25.        
  26.         //Creating Permanent Employee subclass record
  27.         PermanentEmployee permanentEmployee=new PermanentEmployee();  
  28.         permanentEmployee.setName("Jacob");  
  29.         permanentEmployee.setSalary(30000);  
  30.        
  31.        //Creating Contract Employee subclass record
  32.         ContractEmployee contractEmployee=new ContractEmployee();  
  33.         contractEmployee.setName("Raj");  
  34.         contractEmployee.setHourlyRate(2000);  
  35.        
  36.         //persist all the employee records
  37.         session.persist(employee);  
  38.         session.persist(permanentEmployee);  
  39.         session.persist(contractEmployee);  
  40.        
  41.         //Commit the transaction and close the session
  42.         t.commit();  
  43.         session.close();  
  44.         System.out.println("successfully persisted all the Employee records");  
  45.     }
  46.  
  47. }
package com.kb.db;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.kb.model.ContractEmployee;
import com.kb.model.Employee;
import com.kb.model.PermanentEmployee;
import com.kb.util.HibernateUtil;

public class Main {
	public static void main(String[] args) {
		//Get session factory using Hibernate Util class
		SessionFactory sf = HibernateUtil.getSessionFactory();
		//Get session from Sesson factory
		Session session = sf.openSession();
		
		//Begin transaction
		Transaction t=session.beginTransaction();  

		//Creating Employee base class record
		Employee employee=new Employee();  
		employee.setName("John");  
	    
		//Creating Permanent Employee subclass record
	    PermanentEmployee permanentEmployee=new PermanentEmployee();  
	    permanentEmployee.setName("Jacob");  
	    permanentEmployee.setSalary(30000);  
	    
	   //Creating Contract Employee subclass record
	    ContractEmployee contractEmployee=new ContractEmployee();  
	    contractEmployee.setName("Raj");  
	    contractEmployee.setHourlyRate(2000);  
	    
	    //persist all the employee records
	    session.persist(employee);  
	    session.persist(permanentEmployee);  
	    session.persist(contractEmployee);  
	    
	    //Commit the transaction and close the session
	    t.commit();  
	    session.close();  
	    System.out.println("successfully persisted all the Employee records");  
	}

}


We have created 3 records, one for each Employee, PermanentEmployee and ContractEmployee class.

When we persist these 3 records of different objects, It will be saved in a Single table.

Step 9

Run the above class to check the output

Hibernate: 
    
    create table Employee1 (

       id integer not null,

        discriminator varchar(255) not null,

        name varchar(255),

        salary double precision,

        hourlyRate double precision,

        primary key (id)
    )

select
        next_val as id_val 

    from
        hibernate_sequence for update
      

      
Hibernate: 

    update
        hibernate_sequence 

    set
        next_val= ? 

    where
        next_val=?


Hibernate: 

    select
        next_val as id_val 

    from
        hibernate_sequence for update
  
          
Hibernate: 

    update
        hibernate_sequence 

    set
        next_val= ? 

    where
        next_val=?


Hibernate: 

    select
        next_val as id_val 

    from
        hibernate_sequence for update
         
  
Hibernate: 

    update
        hibernate_sequence 

    set
        next_val= ? 

    where
        next_val=?


Hibernate: 

    insert 
    into
        Employee
        (NAME, TYPE, ID) 
    values
        (?, 'E', ?)


Hibernate: 
    insert 
    into
        Employee
        (NAME, SALARY, TYPE, ID) 
    values
        (?, ?, 'PE', ?)


Hibernate: 
    insert 
    into
        Employee
        (NAME, HOURLYRATE, TYPE, ID) 
    values
        (?, ?, 'CE', ?)


successfully persisted all the Employee records


We can see that Create statement is executed only once as it creates a Single table for all the classes.

We can see 3 statements for updating the auto generated primary key for ID is executed.

3 insert statements one for each object we persisted is executed.

Check the Table in MYSQL workbench

SELECT * FROM javainsimpleway.employee1;

TPH_Output1

Check Table in MYSQL console

E:\MySql_Install\bin
Mysql –u root –p
Enter password

SELECT * FROM javainsimpleway.employee1;

TPH_Output2

We can see NULL values are stored in Salary column for Contract employee and NULL values is stored in HourlyRate column for Permanent employees.

We can see NULL values stored in salary and hourlyRate columns for Employee record.

We can see that discriminator column can be used to identify the type of the record.

Download this project TablePerHierarchyAnnotation.zip

About the Author

Raj
Founder of javainsimpleway.com
I love Java and open source technologies and very much passionate about software development.
I like to share my knowledge with others especially on technology 🙂
I have given all the examples as simple as possible to understand for the beginners.
All the code posted on my blog is developed,compiled and tested in my development environment.
If you find any mistakes or bugs, Please drop an email to kb.knowledge.sharing@gmail.com

Connect with me on Facebook for more updates

Share this article on