Spring Transactions & Custom Repositories

Transaction Architecture & Mental Model

In a standard Spring application, the service layer defines the transaction boundary. Spring intercepts @Transactional methods using dynamic proxies or CGLIB proxies, delegating the actual start, commit, and rollback lifecycles to PlatformTransactionManager (such as JpaTransactionManager).

🏛️ Local Transaction vs Global Transaction (JTA) — In Depth

Understanding when your application needs a simple database transaction versus a distributed multi-resource coordinator is a classic Senior / Architect interview topic.

How Two-Phase Commit (2PC) Works Internally

Programmatic vs Declarative Transactions

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public Integer addEmployee(EmployeeDTO dto) {
    return employeeDAO.addEmployee(dto);
}

transactionTemplate.execute(status -> {
    try {
        employeeDAO.addEmployee(dto);
        return null;
    } catch (RuntimeException ex) {
        status.setRollbackOnly();
        throw ex;
    }
});

Transaction Propagation Behaviors

Visual Flow of Propagation Modes

Rollback Strategy & Exception Handling

@Transactional(rollbackFor = { Exception.class, CustomCheckedException.class })
public void processOrder(OrderDTO order) throws Exception {
    orderDAO.save(order);
    if (paymentFailed()) {
        throw new Exception("Payment failed"); // Will ROLLBACK!
    }
}

@Transactional(noRollbackFor = { WarningNotificationException.class })
public void registerUser(UserDTO user) {
    userDAO.save(user);
    // Warning exception will be thrown but user will still be COMMITTED!
    throw new WarningNotificationException();
}

Spring Data JPA & Custom Repository Pattern

Spring Data JPA automatically generates implementations for repository interfaces. When you need complex native queries or customized behavior, use the Custom Repository Extension Pattern:

Key Annotations Cheat Sheet

• @Query("SELECT e FROM EmployeeEntity e WHERE e.salary >= ?1") — Custom JPQL Query with positional parameter.
• @Query("SELECT e FROM EmployeeEntity e WHERE e.salary >= :salary") — Custom JPQL with named parameter matching @Param("salary").
• @Modifying — Required for UPDATE and DELETE queries executed via @Query.

Complete Connected Project Code

A production-ready Employee Management Application demonstrating JPA, Hibernate, Transactions, and Custom Spring Data Repositories.

1. pom.xml

<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>employee-management</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <spring.version>6.2.9</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>jakarta.persistence</groupId>
            <artifactId>jakarta.persistence-api</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.6.26.Final</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>2.3.232</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
</project>

2. src/main/resources/META-INF/persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence" version="3.1">
    <persistence-unit name="employeePU" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>com.example.employee.entity.DepartmentEntity</class>
        <class>com.example.employee.entity.EmployeeEntity</class>

        <properties>
            <property name="jakarta.persistence.jdbc.driver" value="org.h2.Driver"/>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:h2:mem:employee_db;DB_CLOSE_DELAY=-1"/>
            <property name="jakarta.persistence.jdbc.user" value="sa"/>
            <property name="jakarta.persistence.jdbc.password" value=""/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

3. src/main/resources/applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/data/jpa https://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <context:component-scan base-package="com.example.employee"/>
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="employeePU"/>
    </bean>

    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <jpa:repositories
        base-package="com.example.employee.repository"
        entity-manager-factory-ref="entityManagerFactory"
        transaction-manager-ref="transactionManager"/>
</beans>

4. src/main/java/com/example/employee/entity/EmployeeEntity.java

package com.example.employee.entity;

import jakarta.persistence.*;
import java.time.LocalDate;

@Entity
@Table(name = "employee")
public class EmployeeEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer employeeId;

    @Column(nullable = false)
    private String name;

    private String role;
    private Double salary;
    private LocalDate joiningDate;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "department_id")
    private DepartmentEntity department;

    public Integer getEmployeeId() { return employeeId; }
    public void setEmployeeId(Integer v) { employeeId = v; }
    public String getName() { return name; }
    public void setName(String v) { name = v; }
    public String getRole() { return role; }
    public void setRole(String v) { role = v; }
    public Double getSalary() { return salary; }
    public void setSalary(Double v) { salary = v; }
    public LocalDate getJoiningDate() { return joiningDate; }
    public void setJoiningDate(LocalDate v) { joiningDate = v; }
    public DepartmentEntity getDepartment() { return department; }
    public void setDepartment(DepartmentEntity v) { department = v; }
}

5. src/main/java/com/example/employee/repository/EmployeeRepository.java

package com.example.employee.repository;

import com.example.employee.entity.EmployeeEntity;
import org.springframework.data.jpa.repository.*;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface EmployeeRepository extends CrudRepository<EmployeeEntity, Integer> {

    // Derived Query Method
    List<EmployeeEntity> findBySalaryGreaterThanEqualAndRole(Double salary, String role);

    // Named Parameter Query
    @Query("SELECT e FROM EmployeeEntity e WHERE e.salary >= :salary")
    List<EmployeeEntity> findByMinimumSalaryNamed(@Param("salary") Double salary);

    // Modifying Query
    @Modifying
    @Query("UPDATE EmployeeEntity e SET e.salary = :salary WHERE e.role = :role")
    int updateSalaryByRole(@Param("role") String role, @Param("salary") Double salary);
}

6. src/main/java/com/example/employee/service/EmployeeServiceImpl.java

package com.example.employee.service;

import com.example.employee.dao.DepartmentDAO;
import com.example.employee.dao.EmployeeDAOWrapper;
import com.example.employee.dto.DepartmentDTO;
import com.example.employee.dto.EmployeeDTO;
import com.example.employee.repository.EmployeeRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.*;

@Service
public class EmployeeServiceImpl implements EmployeeService {

    private final EmployeeDAOWrapper employeeDAO;
    private final DepartmentDAO departmentDAO;
    private final EmployeeRepository repository;

    public EmployeeServiceImpl(EmployeeDAOWrapper employeeDAO, DepartmentDAO departmentDAO, EmployeeRepository repository) {
        this.employeeDAO = employeeDAO;
        this.departmentDAO = departmentDAO;
        this.repository = repository;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void createDepartmentWithEmployee(String departmentName, EmployeeDTO employee) {
        Integer departmentId = departmentDAO.addDepartment(new DepartmentDTO(departmentName));
        employee.setDepartmentId(departmentId);
        employeeDAO.addEmployee(employee);
    }

    @Override
    @Transactional(readOnly = true)
    public List<EmployeeDTO> findEmployees(LocalDate start, LocalDate end) {
        return employeeDAO.findByJoiningDate(start, end);
    }
}