Hibernate Java Configuration Example with Maven + Eclipse + MySQL

In the previous article, we discussed the Hibernate 5 XML Configuration Example. In this article, we will show you how to create a Hibernate Application using Java configuration without using hibernate.cfg.xml to connect to the MySQL database.
The below diagram shows Java code for Hibernate settings equivalent to hibernate.cfg.xml's properties

Technologies and tools used

  • Hibernate 6.1.7.Final
  • IDE - Eclipse IDE
  • Maven 3.5.3
  • Java 17
  • MySQL - 8.0.32
Let's start developing step by step Hibernate application using Maven as a project management and build tool.

Development Steps

  1. Create a Simple Maven Project
  2. Project Directory Structure
  3. Add jar Dependencies to pom.xml
  4. Creating the JPA Entity Class(Persistent class)
  5. Create a Hibernate configuration file - Java Configuration
  6. Create StudentDao Class
  7. Create the Main class and Run an Application

1. Create a Simple Maven Project

Use the How to Create a Simple Maven Project in Eclipse article to create a simple Maven project in Eclipse IDE.

2. Project Directory Structure

The project directory structure for your reference -

3. Add jar Dependencies to pom.xml

 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
Note that we are using Hibernate version 6.1.7.Final and Java version 17.

4. Creating the JPA Entity Class(Persistent class)

Let's create a Student persistent class that is mapped to a student database table:
A simple Persistent class should follow some rules:
  • A no-arg constructor: It is recommended that you have a default constructor at least package visibility so that hibernate can create the instance of the Persistent class by the newInstance() method.
  • Provide an identifier property: It is better to assign an attribute as id. This attribute behaves as a primary key in a database.
  • Declare getter and setter methods: The Hibernate recognizes the method by getter and setter method names by default.
  • Prefer non-final class: Hibernate uses the concept of proxies, which depends on the persistent class. The application programmer will not be able to use proxies for lazy association fetching.
Create a Student entity class under net.javaguides.hibernate.entity package as follows.
package net.javaguides.hibernate.entity;

import jakarta.persistence.*;

@Table(name = "student")
public class Student {

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

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

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

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

    public Student() {


    public Student(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;

    public int getId() {
        return id;

    public void setId(int id) {
        this.id = id;

    public String getFirstName() {
        return firstName;

    public void setFirstName(String firstName) {
        this.firstName = firstName;

    public String getLastName() {
        return lastName;

    public void setLastName(String lastName) {
        this.lastName = lastName;

    public String getEmail() {
        return email;

    public void setEmail(String email) {
        this.email = email;

    public String toString() {
        return "Student [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", email=" + email + "]";
JPA annotations are used in mapping java objects to the database tables, columns, etc.
JPA annotations that we are using in the Student entity:
@Entity - This annotation specifies that the class is an entity. 
@Table - This annotation specifies the table in the database with which this entity is mapped.
@Column - The @Column annotation is used to specify the mapping between a basic entity attribute and the database table column. 
@Id -  This annotation specifies the primary key of the entity
@GeneratedValue - This annotation specifies the generation strategies for the values of primary keys.

5. Create a Hibernate configuration file - Java Configuration

The HibernateUtil Java configuration file contains information about the database and mapping file.
Let's create a HibernateUtil file and write the following code in it.
package net.javaguides.hibernate.util;

import java.util.Properties;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.service.ServiceRegistry;

import net.javaguides.hibernate.entity.Student;

public class HibernateUtil {
    private static SessionFactory sessionFactory;
    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                Configuration configuration = new Configuration();

                // Hibernate settings equivalent to hibernate.cfg.xml's properties
                Properties settings = new Properties();
                settings.put(Environment.DRIVER, "com.mysql.cj.jdbc.Driver");
                settings.put(Environment.URL, "jdbc:mysql://localhost:3306/hibernate_db?useSSL=false");
                settings.put(Environment.USER, "root");
                settings.put(Environment.PASS, "root");

                settings.put(Environment.SHOW_SQL, "true");

                settings.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread");

                settings.put(Environment.HBM2DDL_AUTO, "create-drop");



                ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()

                sessionFactory = configuration.buildSessionFactory(serviceRegistry);
            } catch (Exception e) {
        return sessionFactory;

The SessionFactory is used to create and manage sessions in Hibernate.

Here's a breakdown of the above code:

  1. The class is declared as public, which means it can be accessed from other classes.

  2. The sessionFactory variable is declared as private and static, which means it can be accessed from other methods in the class and is shared across all instances of the class.

  3. The getSessionFactory() method is declared as public and static, which means it can be accessed from other classes without creating an instance of the HibernateUtil class.

  4. The method checks if the sessionFactory variable is null. If it is null, it creates a new SessionFactory using Hibernate's Configuration class.

  5. The Configuration object is used to configure Hibernate settings, such as the database driver, URL, username, password, and dialect.

  6. The addAnnotatedClass() method is used to specify which class should be mapped to a database table using Hibernate's annotations.

  7. The StandardServiceRegistryBuilder is used to build a ServiceRegistry object, which is used by Hibernate to manage services.

  8. The sessionFactory is created by calling buildSessionFactory() on the Configuration object, passing in the ServiceRegistry.

  9. If an exception occurs while creating the sessionFactory, the stack trace is printed to the console.

  10. Finally, the sessionFactory is returned.

6. Create StudentDao Class

Let's create a separate StudentDao class to separate out Hibernate and database-related stuff.
package net.javaguides.hibernate.dao;

import java.util.List;

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

import net.javaguides.hibernate.entity.Student;
import net.javaguides.hibernate.util.HibernateUtil;

public class StudentDao {
    public void saveStudent(Student student) {
        Transaction transaction = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            // start a transaction
            transaction = session.beginTransaction();
            // save the student object
            // commit transaction
        } catch (Exception e) {
            if (transaction != null) {

    public List < Student > getStudents() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery("from Student", Student.class).list();

7. Create the main App class and Run an Application

Let's test Hibernate application to connect to the MySQL database.
package net.javaguides.hibernate;

import java.util.List;

import net.javaguides.hibernate.dao.StudentDao;
import net.javaguides.hibernate.entity.Student;

public class App {
    public static void main(String[] args) {
        StudentDao studentDao = new StudentDao();
        Student student = new Student("Ramesh", "Fadatare", "[email protected]");

        List < Student > students = studentDao.getStudents();
        students.forEach(s - > System.out.println(s.getFirstName()));


GitHub Repository

The complete source code of this article is available on my GitHub Repository - https://github.com/RameshMF/Hibernate-ORM-Tutorials


In this article, we have created a step-by-step hibernate application to demonstrate the use of Java-based configuration without using hibernate.cfg.xml to connect to the MySQL database.
You can learn more about Hibernate ORM Framework at Hibernate Tutorial