Project to handle to Hibernate SessionFactory in the Spring application
Now, we will demonstrate how to the handle to Hibernate SessionFactory in the Spring application.
Step 1: We can create the spring project using Spring STS IDE including the below mentioned dependencies into the project.
Dependencies:
- Spring Web
- Lombok
- Spring Data JPA
- MySQL Driver
Once complete the creation of the spring project then the spring project file structure look like the below image.
Step 2: Open application.properties file, and write the below code for the server port and mongodb database configuration to the project.
spring.application.name=HibernateSessionFactory
server.port=8082
# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/example
spring.datasource.username=root
spring.datasource.password=
# Hibernate Configuration
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.ddl-auto=update
Step 3: Create the new package and it named as the model in that package create the new Java class and it named as Product.
Go to src > org.example.hibernatesessionfacotry > model > Product and put the below code.
package org.example.hibernatesessionfactory.model;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private double price;
}
Step 4: Create a new package and named it as the repository. In that package, create the new Java interface and named it as ProductRepository.
Go to src > org.example.hibernatesessionfacotry > repository > ProductRepository and put the below code.
package org.example.hibernatesessionfactory.repository;
import org.example.hibernatesessionfactory.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
/**
* Repository interface for accessing Product entities.
* Extends JpaRepository to provide CRUD operations for Product entities.
*/
}
Step 5: Create the new package and it named as the configuration in that package create the new Java class and it named as HibernateConfig.
Go to src > org.example.hibernatesessionfacotry > configuration > HibernateConfig and put the below code.
package org.example.hibernatesessionfactory.configuration;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "org.example.hibernatesessionfactory.repository")
public class HibernateConfig {
/**
* Configuration class for Hibernate.
*/
}
Step 6: Create the new package and it named as the service in that package create the new Java class and it named as ProductService.
Go to src > org.example.hibernatesessionfacotry > service > ProductService and put the below code.
package org.example.hibernatesessionfactory.service;
import jakarta.transaction.Transactional;
import org.example.hibernatesessionfactory.model.Product;
import org.example.hibernatesessionfactory.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
@Service
public class ProductService {
@Autowired
private ProductRepository productRepository;
@Transactional
public Product saveProduct(Product product) {
return productRepository.save(product);
}
public List<Product> getAllProducts() {
return productRepository.findAll();
}
}
Step 7: Create a new package named as the controller, in that package, create the new Java class and it named as ProductController.
Go to src > org.example.hibernatesessionfacotry > controller > ProductController and put the below code.
package org.example.hibernatesessionfactory.controller;
import org.example.hibernatesessionfactory.model.Product;
import org.example.hibernatesessionfactory.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/products")
public class ProductController {
@Autowired
private ProductService productService;
/**
* Creates a new product.
*/
@PostMapping
public Product createProduct(@RequestBody Product product) {
return productService.saveProduct(product);
}
/**
* Retrieves all products.
*/
@GetMapping
public List<Product> getAllProducts() {
return productService.getAllProducts();
}
}
Step 8: Open the main class and write the below code.
package org.example.hibernatesessionfactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HibernateSessionFactoryApplication {
public static void main(String[] args) {
SpringApplication.run(HibernateSessionFactoryApplication.class, args);
}
}
Step 9: After completing the project, it will run as spring application and once it runs successfully, then it starts at port 8082.
Output:
Save Product Endpoint:
POST http://localhost:8082/products
Output in Postman:
GET the Products Endpoint:
GET http://localhost:8082/products
Output in Postman:
If we follow the above steps, then we can demonstrate how to the handle to the Hibernate SessionFactory of the Spring application.
Spring Boot – Handle to Hibernate SessionFactory
In Spring Boot applications, we use Hibernate as a JPA provider and it can manage the Hibernate SessionFactory. It is crucial for efficient database interactions. The SessionFactory acts as the factory for the Hibernate Sessions which can be used to perform the database operations. In this article, we will learn the process of managing the SessionFactory in the Spring Boot application and how it can ensure smooth database interactions and optimal performance.
The SessionFactory in Hibernate represents the single data source and is responsible for creating Session instances. In the Spring Boot application, the SessionFactory is typically managed by the Spring LocalSessionFactoryBean or LocalSessionFactoryBuilder. This bean is configured with the data source information, and entity mappings and hibernate the properties to create the SessionFactory instance.
Key Terminologies:
- HibernateSessionFactory: A SessionFactory in Hibernate is a thread-safe object application startup and it is used throughout the application lifecycle. It represents the single data source and it is responsible for managing the database connections and handling the entity mappings.
- JPA: JPA is defined as Java Persistence API and it is Java specification for accessing, managing, and persisting data between the Java objects and relational databases. It can provides the set of interfaces and it annotates for the defining entity classes, mapping the database tables and performing the CRUD operations
- Datasource: It is an interface provided by the JDBC( Java Database Connectivity) for the establishing the connection with the database. It can provides the methods for obtaining the database connections which are used by the Hibernate to the perform the database operations.
- Hibernate Dialect: It is the configuration setting that can specifies the SQL dialect of the underlying the database. It can determines the SQL statements generated by the Hibernate based on the database vendors syntax and features of the application.
- Hibernate Properties: It is the configuration settings used to the customize the Hibernate behavior. These properties can includes the settings related to the database connection, caching, fetching strategies and logging of the application.