Hibernate 6 with Maven made simple

In this tutorial we will show how you can create an Hibernate 6 application using annotations. For this purpose we will use a basic Maven archetype and we will enhance so that it uses Hibernate dependencies and MySQL as database.

Project setup

There can be several starting points for setting up an Hibernate projects with Maven. The bare bones approach could be using the maven-archetype-quickstart and then updating the pom.xml file with all Hibernate dependencies.

Provided that you have successfully installed Maven, let’s create the project HibernateExample with the following command:

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=com.mastertheboss -DartifactId=HibernateExample -Dversion=1.0.0

Adding Hibernate Dependencies

Next, we will add Hibernate core and MySQL Dependencies which you need to build our project:



Replace hibernate-version with the correct version of Hibernate. For your reference, the latest version of Hibernate is version 6.4.0.Final ( As of November 2023 )

You can optionally include additional libraries to use Hikari Connection pool. Also, you should add libraries to display logs when running the application:


Coding the Model

Firstly, we need to define our Model. We will use two Classes: a Department Class and an Employee Class which are in a One To Many Relation:

hibernate with maven tutorial.

Here’s the Department class:

package com.mastertheboss.domain;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.*;

public class Department {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private List<Employee> employees = new ArrayList<Employee>();
     // Getters/Setters and Constructors omitted for the sake of brevity

Then, this is is the Employee class:

package com.mastertheboss.domain;

import javax.persistence.*;
public class Employee {
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Department department;

    // Getters/Setters and Constructors omitted for the sake of brevity


Adding a Class to manage Hibernate SessionFactory

In Hibernate, the SessionFactory is a crucial component responsible for creating and managing Hibernate Session instances. It is a thread-safe, immutable, and heavyweight object that is typically instantiated once during the application’s startup process.

In order to manage the Hibernate SessionFactory we will create an Utility class named HibernateUtil:

package com.mastertheboss.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

Testing the Hibernate Project

Finally, we will add a Java Main Class which will test inserting Employees and Departments:

public class App {
        private static final Logger logger = LoggerFactory.getLogger(App.class);
public static void main(String[] args) {

        Session session = HibernateUtil.getSessionFactory().openSession();


        Department department = new Department("java");

        session.persist(new Employee("Jakab Gipsz",department));
        session.persist(new Employee("Captain Nemo",department));


        Query q = session.createQuery("From Employee ", Employee.class);

        List<Employee> resultList = q.list();
        System.out.println("num of employees:" + resultList.size());
        for (Employee next : resultList) {
                System.out.println("next employee: " + next);



Adding the Hibernate Configuration

In order to work, this application requires an hibernate.cfg.xml file which needs to be placed into the resources/META-INF folder of your application. For the purpose of our example, we will suppose you have an active MySQL DB on localhost with a mysqldb database:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    <property name="connection.url">jdbc:mysql://localhost:3306/mysqldb</property>
    <property name="connection.username">root</property>
    <property name="connection.password">my-secret-pw</property>
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="show_sql">true</property>
    <property name="format_sql">true</property>
    <property name="hbm2ddl.auto">create-drop</property>
    <!-- JDBC connection pool (use the built-in) -->
    <property name="connection.pool_size">1</property>
    <property name="current_session_context_class">thread</property>

     <mapping class="com.mastertheboss.domain.Employee" />
     <mapping class="com.mastertheboss.domain.Department" />


Please be aware that by using the property hbm2ddl.auto to create, the tables will be dropped and re-created each time that the application is deployed. Consider using another strategy if you are holding data in your tables.

Here’s how your project source should look like:

└── main
    ├── java
    │   └── com
    │       └── mastertheboss
    │           ├── App.java
    │           ├── domain
    │           │   ├── Department.java
    │           │   └── Employee.java
    │           └── util
    │               └── HibernateUtil.java
    └── resources
        └── hibernate.cfg.xml

Make sure your Maven project contains the following plugin configuration to start the com.mastertheboss.App Class.


With that in place, you can test your application with:

mvn install exec:java


You don’t have MySQL installed to test this example? then you can use Docker to run it:

docker run -d -p 3306:3306 -e MYSQL_DATABASE="mysqldb" -e MYSQL_ROOT_PASSWORD=my-secret-pw mysql


In conclusion, this Hibernate 6 tutorial with Maven has provided a comprehensive overview of utilizing Hibernate in your Java projects. By leveraging the power of Maven, the popular build automation tool, you can easily manage dependencies and streamline the development process.

Source code available here: https://github.com/fmarchioni/mastertheboss/tree/master/hibernate/HibernateExample