Hibernate Automatic Table Creation

This tutorial will guide you through setting up and demonstrating automatic table creation using Hibernate 6 with Java 21. We'll create a simple application that automatically generates database tables based on entity classes.

Introduction

Hibernate can automatically generate database tables based on the entity classes defined in your application. This feature is useful for quickly setting up the database schema without manually creating tables. The hibernate.hbm2ddl.auto property controls the schema generation process.

In this tutorial, we will:

1. Set up a Maven project with Hibernate and an H2 database dependency.
2. Configure Hibernate for automatic table creation.
3. Create entity classes (Product and Category).
4. Demonstrate automatic table creation with a sample application.

Step 1: Set Up Your Project

1.1 Create a Maven Project

Open your IDE and create a new Maven project.

1.2 Add Dependencies

Update your pom.xml file to include the necessary dependencies for Hibernate and H2 (an in-memory database for simplicity).

<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>com.example</groupId>
    <artifactId>hibernate-auto-table-creation</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- Hibernate ORM -->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.4.0.Final</version>
        </dependency>

        <!-- H2 Database -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>2.1.214</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.3 Configure Hibernate for Automatic Table Creation

Create a file named hibernate.cfg.xml in the src/main/resources directory to configure Hibernate. This file contains the database connection settings and Hibernate properties.

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
    </session-factory>
</hibernate-configuration>

Explanation:

• hibernate.dialect specifies the SQL dialect to be used.
• hibernate.connection.driver_class specifies the JDBC driver class.
• hibernate.connection.url specifies the JDBC URL for the database connection.
• hibernate.connection.username and hibernate.connection.password specify the database credentials.
• hibernate.hbm2ddl.auto specifies the schema generation strategy. The update value will update the database schema based on the entity mappings.
• hibernate.show_sql specifies whether to show SQL statements in the logs.

Step 2: Create Entity Classes

2.1 Create the Product Entity Class

Create an entity class Product that will be mapped to a table in the database.

package com.example.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

2.2 Create the Category Entity Class

Create an entity class Category that will be mapped to a table in the database.

package com.example.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Category {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

Explanation:

• The @Entity annotation specifies that the class is an entity and is mapped to a database table.
• The @Id annotation specifies the primary key of the entity.
• The @GeneratedValue(strategy = GenerationType.IDENTITY) annotation specifies that the primary key is auto-incremented.

Step 3: Create the Hibernate Utility Class

Create a utility class HibernateUtil to manage the Hibernate SessionFactory. This class ensures a single instance of SessionFactory is created and provides a method to close it.

package com.example.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, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        // Close caches and connection pools
        getSessionFactory().close();
    }
}

Explanation:

• The buildSessionFactory method creates the SessionFactory from the hibernate.cfg.xml configuration file.
• The getSessionFactory method returns the singleton instance of SessionFactory.
• The shutdown method closes the SessionFactory to release resources.

Step 4: Demonstrate Automatic Table Creation

Create a MainApp class to demonstrate automatic table creation functionality. This class performs CRUD operations on the Product and Category entities.

package com.example.main;

import com.example.entity.Category;
import com.example.entity.Product;
import com.example.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class MainApp {
    public static void main(String[] args) {
        // Create product
        Product product = new Product();
        product.setName("Laptop");
        product.setPrice(1500.00);

        // Create category
        Category category = new Category();
        category.setName("Electronics");

        // Save product and category
        saveProduct(product);
        saveCategory(category);

        // Shut down Hibernate
        HibernateUtil.shutdown();
    }

    public static void saveProduct(Product product) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;

        try {
            transaction = session.beginTransaction();
            session.save(product);
            transaction.commit();
            System.out.println("Product saved successfully");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    public static void saveCategory(Category category) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;

        try {
            transaction = session.beginTransaction();
            session.save(category);
            transaction.commit();
            System.out.println("Category saved successfully");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

Explanation:

1. Create Product:

   Product product = new Product();
   product.setName("Laptop");
   product.setPrice(1500.00);
   

   A Product entity is created and its properties are set.

2. Create Category:

   Category category = new Category();
   category.setName("Electronics");
   

   A Category entity is created and its property is set.

3. Save Product and Category:

   saveProduct(product);
   saveCategory(category);
   

   The saveProduct and saveCategory methods are called to save the Product and Category entities, respectively.

4. Shut Down Hibernate:

   HibernateUtil.shutdown();
   

   The shutdown method is called to close the SessionFactory and release resources.

Sample Output

When you run the MainApp class, you should see the following output:

Product saved successfully
Category saved successfully

This output indicates that the product and category were successfully saved, demonstrating the functionality of automatic table creation in Hibernate.

Conclusion

In this tutorial, we have successfully demonstrated how to use Hibernate to automatically create database tables based on entity classes. We set up a Hibernate project, configured Hibernate for automatic table creation, created entity classes, and demonstrated CRUD operations on these entities. This guide provides a solid foundation for setting up your database schema automatically using Hibernate.