SessionFactory
in Hibernate 6.4 using a MySQL database. We will use the Employee
entity for this example.Introduction
The SessionFactory
is a crucial component in Hibernate and is responsible for creating Session
instances. It is a factory for Session
objects and is designed to be instantiated once per application, as it is thread-safe and expensive to create. In this tutorial, we will set up a Hibernate project and demonstrate the use of SessionFactory
to manage Hibernate sessions.
In this tutorial, we will:
- Set up a Maven project with Hibernate and MySQL dependencies.
- Configure Hibernate.
- Create an entity class (
Employee
). - Implement an example to demonstrate the use of
SessionFactory
. - Demonstrate the
SessionFactory
usage using 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 MySQL.
<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://www.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>hibernate-sessionfactory-example</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>
<!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.29</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
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.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_db</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">password</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
</session-factory>
</hibernate-configuration>
Replace hibernate_db
, root
, and password
with your MySQL database name and credentials.
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
andhibernate.connection.password
specify the database credentials.hibernate.hbm2ddl.auto
specifies the schema generation strategy.hibernate.show_sql
specifies whether to show SQL statements in the logs.
Step 2: Create the Entity Class
Create an entity class Employee
that will be mapped to a table in the database. This class uses annotations to define the entity and its fields.
package com.example.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
@Entity
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String department;
private double salary;
// 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 String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
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 theSessionFactory
from thehibernate.cfg.xml
configuration file. - The
getSessionFactory
method returns the singleton instance ofSessionFactory
. - The
shutdown
method closes theSessionFactory
to release resources.
Step 4: Demonstrate the Use of SessionFactory
Create a MainApp
class to demonstrate the use of SessionFactory
. This class initializes the SessionFactory
, opens a session, performs an operation, and then closes the session and shuts down the SessionFactory
.
package com.example.main;
import com.example.entity.Employee;
import com.example.util.HibernateUtil;
import org.hibernate.Session;
public class MainApp {
public static void main(String[] args) {
// Get the SessionFactory
Session session = HibernateUtil.getSessionFactory().openSession();
try {
// Begin transaction
session.beginTransaction();
// Perform some operation
Employee employee = new Employee();
employee.setName("John Doe");
employee.setDepartment("IT");
employee.setSalary(5000.00);
session.save(employee);
// Commit transaction
session.getTransaction().commit();
System.out.println("Employee saved successfully");
} catch (Exception e) {
if (session.getTransaction() != null) {
session.getTransaction().rollback();
}
e.printStackTrace();
} finally {
session.close();
}
// Shut down Hibernate
HibernateUtil.shutdown();
}
}
Explanation:
-
Get the
SessionFactory
:Session session = HibernateUtil.getSessionFactory().openSession();
The
getSessionFactory
method ofHibernateUtil
is called to obtain theSessionFactory
, and a new session is opened. -
Begin Transaction:
session.beginTransaction();
A transaction is started for the session.
-
Perform Some Operation:
Employee employee = new Employee(); employee.setName("John Doe"); employee.setDepartment("IT"); employee.setSalary(5000.00); session.save(employee);
An
Employee
entity is created and saved to the database. -
Commit Transaction:
session.getTransaction().commit();
The transaction is committed to persist the changes.
-
Handle Exceptions:
if (session.getTransaction() != null) { session.getTransaction().rollback(); }
If an exception occurs, the transaction is rolled back.
-
Close the Session:
session.close();
The session is closed to release resources.
-
Shut Down Hibernate:
HibernateUtil.shutdown();
The
shutdown
method of
HibernateUtil
is called to close the SessionFactory
and release resources.
Sample Output
When you run the MainApp
class, you should see the following output:
Employee saved successfully
This output indicates that the employee was successfully saved using Hibernate's SessionFactory
.
Conclusion
In this tutorial, we have successfully demonstrated how to use SessionFactory
in Hibernate. We set up a Hibernate project, configured Hibernate, created an entity class, implemented a Hibernate utility class to manage SessionFactory
, and demonstrated the use of SessionFactory
with a sample application. This guide provides a solid foundation for managing Hibernate sessions using SessionFactory
in your applications.
Comments
Post a Comment