Hibernate Example with MySQL Database

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this tutorial, we will learn how to create Hibernate 6 Application and connect with the MySQL database. We use Maven as a dependency management tool.

Learn and master Hibernate framework at https://www.javaguides.net/p/hibernate-tutorial.html

In this tutorial, we use Java-based configuration and JPA annotations for mapping.

For XML-based configuration, check out Hibernate XML Configuration Example.

Technologies and tools used

• Hibernate 6.1.7.Final
• IDE - Eclipse
• Maven 3.5.3
• JavaSE 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

Open the pom.xml file in your Hibernate project and add the below code to it:

<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> <parent> <groupId>net.javaguides.hibernate</groupId> <artifactId>hibernate-tutorial</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <artifactId>hibernate-java-config-example</artifactId> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.32</version> </dependency> <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>6.1.7.Final</version> </dependency> </dependencies> <build> <sourceDirectory>src/main/java</sourceDirectory> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <configuration> <source>17</source> <target>17</target> </configuration> </plugin> </plugins> </build> </project>

Note that we are using the mysql-connector-java driver dependency to connect the Java Hibernate application to the MySQL database:

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

We are using Hibernate core dependency:

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

We are using the maven-compiler-plugin to compile the Java Hibernate application with JRE 17 version:

 <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <configuration> <source>17</source> <target>17</target> </configuration> </plugin>

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 an 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.

Let's create a Student entity class under net.javaguides.hibernate.entity package as follows.

package net.javaguides.hibernate.entity; import jakarta.persistence.*; @Entity @Table(name = "student") public class Student { @Id @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; } @Override 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"); configuration.setProperties(settings); configuration.addAnnotatedClass(Student.class); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder() .applySettings(configuration.getProperties()).build(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); } catch (Exception e) { e.printStackTrace(); } } return sessionFactory; } }

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 session.save(student); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } 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", "rameshfadatare@javaguides.com"); studentDao.saveStudent(student); List < Student > students = studentDao.getStudents(); students.forEach(s - > System.out.println(s.getFirstName())); } }

Output

GitHub Repository

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

Conclusion

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 the MySQL database.

You can learn more about Hibernate ORM Framework at Hibernate Tutorial

Related Hibernate Tutorials

• Hibernate One to Many CRUD Example
• Hibernate One-to-One CRUD Example
• Hibernate Example with MySQL Database
• Hibernate Framework Overview - Architecture and Basics
• Hibernate 5 - Save an Entity Example 
• Hibernate 5 - Persist an Entity Example 
• Hibernate 5 - saveOrUpdate() Method Example 
• Hibernate 5 - get(), load(), and byId() Method Examples 
• Hibernate 5 - merge() Example
• Hibernate 5 - Delete or Remove an Entity Example 
• Hibernate 5 - load() Method Example 
• Hibernate Session.evict() Method Example
• Hibernate Session.clear() Method Example
• Hibernate 5 c3p0 Connection Pool Example
• Hibernate Session Interface Methods with Examples