Hibernate SessionFactory Spring Boot CRUD Example

🎓 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

This tutorial will guide you through setting up and using Hibernate SessionFactory with Spring Boot and a MySQL database. We will demonstrate how to configure Hibernate, create an entity class (User), and perform basic CRUD operations.

Introduction

What is Hibernate SessionFactory?

The SessionFactory is a factory for Session objects in Hibernate. It is a thread-safe, immutable object representing a single data source or database. The SessionFactory is responsible for creating and managing Session objects, which are the primary interfaces for performing CRUD operations in Hibernate.

Why Use SessionFactory?

• Performance: It is an efficient way to manage database connections, as it uses a connection pool.
• Thread Safety: SessionFactory is thread-safe, ensuring multiple threads can access it without causing concurrency issues.
• Configuration: It holds the configuration details and mappings, making it easy to manage and reuse configurations.

Integration with Spring Boot

Spring Boot simplifies the integration of Hibernate by providing auto-configuration and dependency management. By using Spring Boot, you can focus on building your application without worrying about the boilerplate setup code.

In this tutorial, we will:

1. Set up a Spring Boot project with necessary dependencies.
2. Configure Hibernate to connect to MySQL.
3. Create an entity class (User).
4. Create a repository for CRUD operations.
5. Demonstrate CRUD operations using Hibernate and Spring Boot.

Step 1: Set Up Your Project

1.1 Create a Spring Boot Project

Open your IDE and create a new Spring Boot project.

1.2 Add Dependencies

Update your pom.xml file to include dependencies for Spring Boot, 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://maven.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> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.0.0</version> <relativePath/> <!-- lookup parent from repository --> </parent> <dependencies> <!-- Spring Boot Starter Data JPA --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!-- MySQL Connector --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.29</version> </dependency> <!-- Hibernate Core --> <dependency> <groupId>org.hibernate.orm</groupId> <artifactId>hibernate-core</artifactId> <version>6.4.0.Final</version> </dependency> <!-- Spring Boot Starter Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Boot Starter Test --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> 

Step 2: Configure Hibernate with SessionFactory

2.1 Create application.properties

Create an application.properties file in the src/main/resources directory to configure database connection settings and Hibernate properties.

spring.datasource.url=jdbc:mysql://localhost:3306/hibernate_db spring.datasource.username=root spring.datasource.password=password spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.jpa.show-sql=true spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect spring.jpa.hibernate.ddl-auto=update 

Replace hibernate_db, root, and password with your MySQL database name and credentials.

2.2 Create HibernateConfig Class

Create a HibernateConfig class to configure the SessionFactory bean.

package com.example.config; import org.hibernate.SessionFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.orm.hibernate5.LocalSessionFactoryBean; import org.springframework.orm.hibernate5.HibernateTransactionManager; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; import java.util.Properties; @Configuration @EnableTransactionManagement public class HibernateConfig { @Autowired private DataSource dataSource; @Bean public LocalSessionFactoryBean sessionFactory() { LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean(); sessionFactory.setDataSource(dataSource); sessionFactory.setPackagesToScan("com.example.entity"); sessionFactory.setHibernateProperties(hibernateProperties()); return sessionFactory; } @Bean public PlatformTransactionManager hibernateTransactionManager(SessionFactory sessionFactory) { HibernateTransactionManager transactionManager = new HibernateTransactionManager(); transactionManager.setSessionFactory(sessionFactory); return transactionManager; } private Properties hibernateProperties() { Properties hibernateProperties = new Properties(); hibernateProperties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect"); hibernateProperties.setProperty("hibernate.show_sql", "true"); hibernateProperties.setProperty("hibernate.format_sql", "true"); hibernateProperties.setProperty("hibernate.hbm2ddl.auto", "update"); return hibernateProperties; } } 

Explanation:

• The @Configuration annotation indicates that the class is a Spring configuration class.
• The @EnableTransactionManagement annotation enables Spring's annotation-driven transaction management.
• The sessionFactory method creates a LocalSessionFactoryBean bean, configuring the Hibernate SessionFactory.
• The hibernateTransactionManager method creates a HibernateTransactionManager bean for managing transactions.
• The hibernateProperties method sets Hibernate properties.

Step 3: Create the Entity Class

Create an entity class User that will be mapped to a table in the database. This class uses annotations to define the entity and its fields.

3.1 Create User Entity

package com.example.entity; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; // 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 getEmail() { return email; } public void setEmail(String email) { this.email = email; } } 

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 4: Create the DAO Class

Create a DAO class to manage database operations using Hibernate.

4.1 Create UserDAO

package com.example.dao; import com.example.entity.User; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import java.util.List; @Repository public class UserDAO { @Autowired private SessionFactory sessionFactory; @Transactional public void saveUser(User user) { Session session = sessionFactory.getCurrentSession(); session.saveOrUpdate(user); } @Transactional public User getUserById(Long id) { Session session = sessionFactory.getCurrentSession(); return session.get(User.class, id); } @Transactional public List<User> getAllUsers() { Session session = sessionFactory.getCurrentSession(); return session.createQuery("from User", User.class).list(); } @Transactional public void deleteUser(Long id) { Session session = sessionFactory.getCurrentSession(); User user = session.byId(User.class).load(id); session.delete(user); } } 

Explanation:

• The UserDAO class contains methods to interact with the database using Hibernate.
• The @Repository annotation indicates that the class is a Spring repository component.
• The @Transactional annotation is used to manage transactions for each method.
• The saveUser, getUserById, getAllUsers, and deleteUser methods perform CRUD operations using the SessionFactory.

Step 5: Create the Service Class

Create a service class to encapsulate the business logic for managing users.

5.1 Create UserService

package com.example.service; import com.example.dao.UserDAO; import com.example.entity.User; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service public class UserService { @Autowired private UserDAO userDAO; public void saveUser(User user) { userDAO.saveUser(user); } public User getUserById(Long id) { return userDAO.getUserById(id); } public List<User> getAllUsers() { return userDAO.getAllUsers(); } public void deleteUser(Long id) { userDAO.deleteUser(id); } } 

Explanation:

• The UserService class contains methods to perform CRUD operations using the UserDAO.
• The @Service annotation indicates that the class is a Spring service component.
• The @Autowired annotation is used to inject the UserDAO dependency.

Step 6: Create the Controller Class

Create a controller class to handle HTTP requests for user operations.

6.1 Create UserController

package com.example.controller; import com.example.entity.User; import com.example.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/users") public class UserController { @Autowired private UserService userService; @PostMapping public ResponseEntity<User> createUser(@RequestBody User user) { userService.saveUser(user); return ResponseEntity.ok(user); } @PutMapping public ResponseEntity<User> updateUser(@RequestBody User user) { userService.saveUser(user); return ResponseEntity.ok(user); } @GetMapping("/{id}") public ResponseEntity<User> getUserById(@PathVariable Long id) { User user = userService.getUserById(id); if (user == null) { return ResponseEntity.notFound().build(); } return ResponseEntity.ok(user); } @GetMapping public ResponseEntity<List<User>> getAllUsers() { List<User> users = userService.getAllUsers(); return ResponseEntity.ok(users); } @DeleteMapping("/{id}") public ResponseEntity<Void> deleteUser(@PathVariable Long id) { userService.deleteUser(id); return ResponseEntity.noContent().build(); } } 

Explanation:

• The UserController class handles HTTP requests for user operations.
• The @RestController annotation indicates that the class is a Spring REST controller.
• The @RequestMapping("/users") annotation maps the controller to the /users URL path.
• The @Autowired annotation is used to inject the UserService dependency.

Step 7: Run the Application

1. Ensure your MySQL database is running and the connection details in application.properties are correct.
2. Run the Spring Boot application using your IDE or the command line.

7.1 Main Application Class

package com.example; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class HibernateSessionFactoryExampleApplication { public static void main(String[] args) { SpringApplication.run(HibernateSessionFactoryExampleApplication.class, args); } } 

Conclusion

In this tutorial, we have successfully demonstrated how to integrate Hibernate SessionFactory with Spring Boot, configure it to connect to a MySQL database, create an entity class, and perform basic CRUD operations using Hibernate and Spring Boot. This guide provides a solid foundation for using Hibernate with Spring Boot in your applications.