Disclosure: This article may contain affiliate links. When you purchase, we may earn a small commission.

Spring Boot + Hibernate Example for Java Developrs

Hello guys, if you want to learn how to use Spring Boot and Hibernate together in a Java application and look for examples and tutorials then you have come to the right place. In the past, I have shared how to use Spring Boot with MyBatis and Spring Boot + Redix example and In this article on Spring Boot, we will discuss how to integrate Spring Boot with Hibernate. We will build a simple Spring Boot application and use Hibernate to store the data. So first, let's look at what is hibernate in Java? Hibernate framework provides an abstraction layer which means programmers need not worry about implementation. Hibernate will implement different modules for developers internally like writing queries to perform CURD operations on the database and establishing connections to different kinds of databases. This is a Java-based solution for object-relational mapping.

The programming technique of object-relational mapping, or ORM, is used to map application domain model objects to relational database tables. Hibernate is a Java-based object-relational mapping (ORM) technology that allows you to map application domain objects to relational database tables and vice versa.

Spring Boot + Hibernate Example for Java Developrs

1. Spring Boot with Hibernate

So first, create a spring boot application with the following options.
   1. Spring Initializer
   2. Use IDE
   3. Use Spring Boot CLI tool

Here, we are using the spring boot CLI and as a part of this, we added the Web, JPA, and MySql dependencies to our application. To start the project, go to the spring boot initializer from https://start.spring.io/ and add the above dependencies. This is shown in the below picture.

This is what your pom.xml will look like after the creation of the project.

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<relativePath/> <!-- lookup parent from repository -->
<description>Demo project for Spring Boot</description>




All maven settings required for each spring project are provided by spring-boot-starter-parentWe also need to include spring-boot-starter-web and spring-boot-starter-data-JPA to run this application with hibernate because we are constructing a web application. 

In this example, we are using MySQL, In case you want to use the h2 database, you can add the h2 dependencies to the pom.xml file without using the Mysql dependencies.

2. Hibernate Configuration

To configure the hibernate in our project, we use the HibernateConfiguration.java class. It is given in the below example code.

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

public class HibernateConfiguration {
private String DRIVER;

private String PASSWORD;

private String URL;

private String USERNAME;

private String DIALECT;

private String SHOW_SQL;

private String HBM2DDL_AUTO;

private String PACKAGES_TO_SCAN;

public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
return dataSource;

public LocalSessionFactoryBean sessionFactory() {
LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
Properties hibernateProperties = new Properties();
hibernateProperties.put("hibernate.dialect", DIALECT);
hibernateProperties.put("hibernate.show_sql", SHOW_SQL);
hibernateProperties.put("hibernate.hbm2ddl.auto", HBM2DDL_AUTO);

return sessionFactory;

public HibernateTransactionManager transactionManager() {
HibernateTransactionManager transactionManager = new HibernateTransactionManager();
return transactionManager;

In the above, you can see that we have used the @Bean and @Configuration annotations. These annotations are used to define beans in spring. @Value annotation is used to inject variables from properties files.

So let's have a look into our application.properties file in the spring boot application.



2. Model Class

Create a model class named Student.java. This is the file that is using @Entity annotation and for this class, you will have the corresponding table in the database.

The model class which used in this application is given below.

package com.student.crudapp.model;

import javax.persistence.*;

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

@Column(name = "id")
private int id;

@NotBlank(message = "Name is mandatory")
@Column(name = "name")
private String name;

@NotBlank(message = "Email is mandatory")
@Column(name = "email")
private String email;

@NotBlank(message = "Grade is mandatory")
@Column(name = "grade")
private String grade;

public int getId() {
return id;

public void setId(int 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;

public String getGrade() {
return grade;

public void setGrade(String grade) {
this.grade = grade;

public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", email='" + email + '\'' +
", grade='" + grade + '\'' +

When creating a persistent pojo class, @Entity is utilized. You will have a comparable table in the database for this Java class. @Column is used to link annotated attributes to their respective table columns.
We have now a basic entity, which H2 can create a table from. Restarting the application and checking H2 console, a new table called Book will be created.

3. Repository Layer

Add the StudentRepository.java class to the application in order to handle the SQL data.

package com.student.crudapp.repository;

import com.student.crudapp.model.Student;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface StudentRepository extends JpaRepository<Student, Integer> {

List<Student> findAll();
Student findById(int id);
int deleteById(int id);


The spring data JPA will generate implementation code for the most common CRUD operations and you do not need to stick with customized queries

4. Service Class

Create a service class named StudentService.java and attached the following code there. This is used to get the 
package service;

import com.student.crudapp.model.Student;
import com.student.crudapp.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.ArrayList;
import java.util.List;

public class StudentService {

StudentRepository studentRepository;

//Get all the students
public List<Student> getAllStudents() {
List<Student> students = studentRepository.findAll();
return students;

//display one student by id
public Student getStudentById(int id) {
return studentRepository.findById(id);

//save student in database
public void saveStudent(Student student) {
catch(Exception e){

//delete stuednt by id
public void deleteStudent(int id) {
}catch(Exception e){



5. Controller Class 

This is the class which is dealing with RESTful APIs for CRUD operations.
package com.student.crudapp.controller;

import com.student.crudapp.model.Student;
import com.student.crudapp.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

public class StudentController {

StudentRepository studentRepository;

//check the api's working correctly api
@RequestMapping(value="/ping", method=RequestMethod.GET)
public String healthCheck() {
return "This is working well";

@RequestMapping(value="/students", method=RequestMethod.GET)
public List<Student> getAllStudents() {
return studentRepository.findAll();

@RequestMapping(value="/student", method=RequestMethod.POST)
public Student addStudent(Student student) {
return studentRepository.save(student);

@RequestMapping(value="/findstudent", method = RequestMethod.GET)
public Student findStudent(@RequestParam("studentId") int studentId) {
return studentRepository.findById(studentId);

@RequestMapping(value= "/updatestudent", method = RequestMethod.GET)
public Student updateStudent(@RequestBody Student student){
return studentRepository.save(student);

@RequestMapping(value="/deletestudent", method = RequestMethod.GET)
public int deleteStudent(@RequestParam("studentId") int studentId) {
return studentRepository.deleteById(studentId);

Here, the @Controller annotation is used to expose the RESTful APIs. The rest controller still takes advantage of the spring's dependency injection.

Hibernate used in Spring

As you see in the above model class, Student.java we used the tables names in upper case letters. As we already know, by default hibernate will generate the names of the tables in lowercase letters.

@Table(name = "STUDENT")
public class Student {
    //your code here

But this will not work unless you setting this property in application.properties file. This will allow you to create your tables names in database in upper case.

When should we use Hibernate along with Spring and also what is the advantage?

When you use spring, you use IOC to resolve the 'plumbing' code that connects the various application layers. As a result, Spring functions as a middleware, allowing any other compatible technology to access your data layer through a context without requiring explicit data dependencies. 

The hibernate configuration will be affected by changes in your database, but you can specify how many changes you want to translate into your application. I wouldn't recommend these frameworks for really high performance/esoteric applications because they were built with enterprise application requirements and design principles in mind.

Two benefits that you get from using hibernate with spring,
    1. Spring provides a transaction abstraction to make transaction management easier and also provides declarative transactions. Furthermore, spring will handle hibernate's sessions for you.
    2. Spring also provides a hibernate helper class (HibernateDaoSupport). It's much easier to write DAO implementation with it.


In this article, we discussed how to integrate hibernate with spring boots. We used Mysql as the database. Hope you understand how to create your application using the spring hibernate, see you in the next tutorial. Until then bye!

Other Spring Framework articles you may like to explore 

    Thanks for reading this article so far. If you find this Spring Boot and Hiberante example tutorial useful, please share them with your friends and colleagues. If you have any questions or feedback, then please drop a note.

    No comments :

    Post a Comment