Transaction management with @Transactional in Spring Boot - Mini Project: Build & Apply

Transaction management with @Transactional

📖 Scenario: You are building a simple banking application where users can transfer money between accounts. To keep the data consistent, you need to make sure that both the withdrawal from one account and the deposit to another happen together or not at all.

🎯 Goal: Build a Spring Boot service class that manages money transfers between accounts using the @Transactional annotation to ensure the operations are atomic.

📋 What You'll Learn

Create a simple Account class with id and balance fields.

Create a service class called BankService with a method transferMoney.

Use the @Transactional annotation on the transferMoney method.

Inside transferMoney, deduct money from one account and add it to another.

Simulate an error to show rollback behavior.

💡 Why This Matters

🌍 Real World

Transaction management is critical in banking and e-commerce applications to ensure data consistency when multiple related operations must succeed or fail together.

💼 Career

Understanding @Transactional is essential for backend developers working with Spring Boot to build reliable and consistent applications that handle complex data operations.

1

Create Account class with id and balance

Create a simple Java record called Account with two fields: Long id and double balance.

Spring Boot

// Your code here

Need a hint?

Use the record keyword to create a simple immutable data class.

2

Add BankService class with transferMoney method

Create a Spring service class called BankService with a public method transferMoney that takes three parameters: Account fromAccount, Account toAccount, and double amount. For now, leave the method body empty.

Spring Boot

public class BankService {
    // Create transferMoney method here
    // Your code here
}

Need a hint?

Use @Service annotation to mark the class as a Spring service.

3

Add @Transactional and implement transfer logic

Add the @Transactional annotation to the transferMoney method. Inside the method, subtract amount from fromAccount's balance and add it to toAccount's balance. Then simulate an error by throwing a RuntimeException if amount is greater than 1000.

Spring Boot

import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {
    @Transactional
    public void transferMoney(Account fromAccount, Account toAccount, double amount) {
        // Implement transfer logic here
        // Your code here
    }
}

Need a hint?

Use @Transactional above the method and throw RuntimeException to trigger rollback.

4

Complete BankService with final transactional behavior

Complete the BankService class by adding comments explaining that the @Transactional annotation ensures atomicity, and that if an exception occurs, all changes are rolled back. Keep the existing code intact.

Spring Boot

public record Account(Long id, double balance) {}

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

@Service
public class BankService {
    @Transactional
    public void transferMoney(Account fromAccount, Account toAccount, double amount) {
        double newFromBalance = fromAccount.balance() - amount;
        double newToBalance = toAccount.balance() + amount;

        // Normally, you would update the accounts in a database here
        // For this example, we just simulate by creating new Account instances
        Account updatedFrom = new Account(fromAccount.id(), newFromBalance);
        Account updatedTo = new Account(toAccount.id(), newToBalance);

        if (amount > 1000) {
            throw new RuntimeException("Transfer amount too large, rolling back transaction");
        }
        // Add comment about transactional behavior here
        // Your code here
    }
}

Need a hint?

Add a comment explaining the rollback behavior of @Transactional.