Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

NPI – JPA Buddy – JPA (partner)
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

1. Overview

In this tutorial, we'll learn how to use Spring Boot with Hibernate.

We’ll build a simple Spring Boot application and demonstrate how easy it is to integrate it with Hibernate.

2. Bootstrapping the Application

We’ll use Spring Initializr to bootstrap our Spring Boot application. For this example, we’ll use only the needed configurations and dependencies to integrate Hibernate, adding the Web, JPA, and H2 dependencies. We'll explain these dependencies in the next section.

Now let's generate the project and open it in our IDE. We can check the generated project structure and identify the configuration files we’ll need.

This is what the project structure will look like:

spring boot hibernate project

3. Maven Dependencies

If we open up pom.xml, we’ll see that we have spring-boot-starter-web and spring-boot-starter-test as maven dependencies. As their names suggest, these are the starting dependencies in Spring Boot.

Let’s have a quick look at the dependency that pulls in JPA:


This dependency includes JPA API, JPA Implementation, JDBC, and the other necessary libraries. Since the default JPA implementation is Hibernate, this dependency is actually enough to bring it in as well.

Finally, we’ll use H2 as a very lightweight database for this example:


We can use the H2 console to check that the DB is up and running, and also for a user-friendly GUI for our data entry. We'll go ahead and enable it in application.properites:


That's everything we need to configure to include Hibernate and H2 in our example. We can check that the configuration was successful on the logs when we start up the Spring Boot application:

HHH000412: Hibernate Core {#Version}

HHH000206: hibernate.properties not found

HCANN000001: Hibernate Commons Annotations {#Version}

HHH000400: Using dialect: org.hibernate.dialect.H2Dialect

We can now access the H2 console on localhost http://localhost:8080/h2-console/.

4. Creating the Entity

To check that our H2 is working properly, we’ll first create a JPA entity in a new models folder:

public class Book {

    private Long id;
    private String name;

    // standard constructors

    // standard getters and setters

We now have a basic entity, which H2 can create a table from. Restarting the application and checking the H2 console, a new table called Book will be created.

To add some initial data to our application, we need to create a new SQL file with some insert statements, and put it in our resources folder. We can use import.sql (Hibernate support) or data.sql (Spring JDBC support) files to load data.

Here are our example data:

insert into book values(1, 'The Tartar Steppe');
insert into book values(2, 'Poem Strip');
insert into book values(3, 'Restless Nights: Selected Stories of Dino Buzzati');

Again, we can restart the Spring Boot application and check the H2 console; the data is now in the Book table.

5. Creating the Repository and Service

We'll continue creating the basic components in order to test our application. First, we'll add the JPA Repository in a new repositories folder:

public interface BookRepository extends JpaRepository<Book, Long> {

We can use the JpaRepository interface from the Spring framework, which provides a default implementation for the basic CRUD operations.

Next, we'll add the BookService in a new services folder:

public class BookService {

    private BookRepository bookRepository;

    public List<Book> list() {
        return bookRepository.findAll();

To test our application, we need to check that the data created can be fetched from the list() method of the service.

We’ll write the following SpringBootTest:

public class BookServiceUnitTest {

    private BookService bookService;

    public void whenApplicationStarts_thenHibernateCreatesInitialRecords() {
        List<Book> books = bookService.list();

        Assert.assertEquals(books.size(), 3);

By running this test, we can check that Hibernate creates the Book data, which are then fetched successfully by our service. And that's it, Hibernate is running with Spring Boot.

6. Uppercase Table Name

Sometimes, we may need to have the table names in our database written in uppercase letters. As we already know, Hibernate will generate the names of the tables in lowercase letters by default.

We can try to explicitly set the table name:

public class Book {
    // members, standard getters and setters

However, that won't work. We need to set this property in application.properties:


Then we can check in our database that the tables are created successfully with uppercase letters.

7. Conclusion

In this article, we discovered how easy it is to integrate Hibernate with Spring Boot. We used the H2 database as a very lightweight in-memory solution.

We gave a full example of an application using all of these technologies. Then we gave a small hint how to set the table names in uppercase in our database.

As always, all of the code snippets mentioned in this article can be found on our GitHub repository.

Persistence bottom

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

Persistence footer banner
Inline Feedbacks
View all comments
Comments are closed on this article!