Hibernate with Spring

Introduction

Everything so far has used plain Hibernate: a SessionFactory built directly from hibernate.cfg.xml, manual Sessions, and manual transactions. In real Spring and Spring Boot applications, you rarely write that setup code yourself — Spring manages the SessionFactory, the EntityManager, and transaction boundaries for you. This lesson connects what you already know to how it actually looks in a Spring codebase.

Why Combine Them?

Hibernate handles the object-relational mapping; Spring handles dependency injection, configuration, and transaction management around it. Together, Spring removes almost all the manual plumbing you have been writing by hand throughout this course — SessionFactory creation, Session lifecycle, and transaction begin/commit/rollback are all managed declaratively.

Classic Spring: LocalSessionFactoryBean

Before Spring Boot, a classic Spring XML or Java configuration built the Hibernate SessionFactory as a managed bean using LocalSessionFactoryBean, which Spring then injected wherever it was needed.

import org.springframework.context.annotation.*;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
public class HibernateConfig {

    @Bean
    public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setPackagesToScan("com.example.entities");

        Properties props = new Properties();
        props.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        props.put("hibernate.hbm2ddl.auto", "update");
        sessionFactory.setHibernateProperties(props);

        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager(
            org.hibernate.SessionFactory sessionFactory) {
        return new HibernateTransactionManager(sessionFactory);
    }
}

This approach still uses Hibernate's native Session API underneath, just with Spring handling bean creation and transaction management instead of you calling openSession() and beginTransaction() by hand.

Spring Boot Auto-Configuration

Spring Boot removes almost all of that configuration. Add spring-boot-starter-data-jpa and a database driver, set a few properties, and Spring Boot auto-configures a Hibernate-backed EntityManagerFactory for you.

spring.datasource.url=jdbc:mysql://localhost:3306/companydb
spring.datasource.username=root
spring.datasource.password=secret

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Spring Data JPA on Top

Most Spring Boot applications go one layer further and use Spring Data JPA, which generates repository implementations from an interface, so you rarely write EntityManager or Session code directly at all.

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    List<Employee> findBySalaryGreaterThan(Double amount);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    public List<Employee> getHighEarners() {
        return employeeRepository.findBySalaryGreaterThan(60000.0);
    }
}

That findBySalaryGreaterThan method has no implementation anywhere in your code — Spring Data JPA parses the method name and generates a query, which Hibernate then translates into the SQL above. Everything you learned about HQL, fetch types, and caching in this course still applies underneath; Spring Data JPA is a thinner, more convenient layer on top of the same Hibernate engine.

@Transactional

Instead of manually calling beginTransaction(), commit(), and rollback() as in the previous lesson, Spring applications typically annotate a method with @Transactional, and Spring wires the transaction boundary around the whole method automatically.

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PayrollService {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Transactional
    public void giveRaise(Long employeeId, Double amount) {
        Employee emp = employeeRepository.findById(employeeId)
            .orElseThrow(() -> new IllegalArgumentException("Employee not found"));

        emp.setSalary(emp.getSalary() + amount);
        // No explicit save() call needed here inside a @Transactional method —
        // Hibernate's dirty checking flushes the change automatically on commit.
    }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Spring does not replace Hibernate — it automates the setup and transaction plumbing around it. Whether you see LocalSessionFactoryBean, Spring Boot auto-configuration, or a Spring Data JPA repository, Hibernate is still generating the SQL and managing entity state underneath, exactly as it has throughout this course.