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

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
}

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
    }
}

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
    }
}

Hint

Add a comment explaining the rollback behavior of @Transactional.

Practice

1. What is the main purpose of using @Transactional in a Spring Boot application?

easy

A. To ensure multiple database operations are executed as a single unit and rollback on failure

B. To speed up database queries by caching results

C. To automatically generate database schema from entities

D. To log all database queries for debugging

Solution

1. Step 1: Understand the role of @Transactional

   @Transactional groups multiple database operations so they succeed or fail together.

2. Step 2: Identify the effect on data consistency

   If any operation fails, all changes are rolled back to keep data correct.

3. Final Answer:

   To ensure multiple database operations are executed as a single unit and rollback on failure -> Option A

4. Quick Check:

   @Transactional = atomic database actions [OK]

Hint: Think: all-or-nothing for database changes [OK]

Common Mistakes:

• Confusing @Transactional with caching or logging
• Thinking it speeds up queries
• Assuming it auto-generates schema

2. Which of the following is the correct way to apply @Transactional to a method in a Spring Boot service class?

easy

A. @Transactional public void updateData() { ... }

B. public @Transactional void updateData() { ... }

C. public void updateData() @Transactional { ... }

D. public void updateData() { @Transactional ... }

Solution

1. Step 1: Recall correct annotation placement

   Annotations like @Transactional go before the method signature.

2. Step 2: Check each option's syntax

   @Transactional public void updateData() { ... } places @Transactional correctly before the method declaration.

3. Final Answer:

   @Transactional public void updateData() { ... } -> Option A

4. Quick Check:

   Annotation before method = correct syntax [OK]

Hint: Annotations always go before method signature [OK]

Common Mistakes:

• Placing annotation inside method body
• Putting annotation after method signature
• Using annotation as a modifier keyword

3. Consider this Spring Boot service method annotated with @Transactional:

@Transactional
public void saveUserAndAccount(User user, Account account) {
    userRepository.save(user);
    accountRepository.save(account);
    if(account.getBalance() < 0) {
        throw new RuntimeException("Negative balance not allowed");
    }
}

What happens if account.getBalance() < 0 is true during execution?

medium

A. An error is logged but changes are committed

B. Only the user is saved, account save is rolled back

C. Both user and account are saved to the database

D. Neither user nor account is saved; transaction rolls back

Solution

1. Step 1: Understand rollback behavior of @Transactional

   By default, RuntimeExceptions cause the transaction to rollback all changes.

2. Step 2: Analyze the exception thrown

   The method throws RuntimeException if balance is negative, triggering rollback.

3. Final Answer:

   Neither user nor account is saved; transaction rolls back -> Option D

4. Quick Check:

   RuntimeException triggers rollback = no data saved [OK]

Hint: Exception inside @Transactional rolls back all changes [OK]

Common Mistakes:

• Assuming partial saves happen
• Thinking only last save rolls back
• Ignoring exception effect on transaction

4. Given this method in a Spring Boot service:

@Transactional
public void updateRecords() {
    recordRepository.updateA();
    recordRepository.updateB();
    // Missing exception handling
}

If updateB() throws a checked exception (not RuntimeException), what will happen to the transaction?

medium

A. Transaction will rollback automatically

B. Transaction will commit despite the exception

C. Transaction will rollback only if exception is caught and rethrown as RuntimeException

D. Transaction will pause until exception is handled

Solution

1. Step 1: Recall default rollback rules of @Transactional

   By default, only unchecked exceptions (RuntimeException) cause rollback.

2. Step 2: Analyze checked exception behavior

   Checked exceptions do not trigger rollback unless configured or rethrown as RuntimeException.

3. Final Answer:

   Transaction will commit despite the exception -> Option B

4. Quick Check:

   Checked exceptions do not rollback by default [OK]

Hint: Only RuntimeExceptions rollback by default [OK]

Common Mistakes:

• Assuming all exceptions cause rollback
• Not knowing difference between checked and unchecked exceptions
• Expecting rollback without configuration

5. You have a Spring Boot service with two methods:

public void outerMethod() {
    innerMethod();
}

@Transactional
public void innerMethod() {
    // database updates
    if(someCondition) throw new RuntimeException();
}

If outerMethod() is called, will the transaction rollback if innerMethod() throws the exception? Assume default proxy-based Spring transaction management.

hard

A. Yes, but only if outerMethod is also annotated with @Transactional

B. Yes, transaction rolls back because innerMethod is @Transactional

C. No, transaction does not rollback because outerMethod is not @Transactional and calls innerMethod internally

D. No, because RuntimeException does not trigger rollback in this case

Solution

1. Step 1: Understand Spring proxy behavior for @Transactional

   Spring uses proxies, so self-invocation (method calling another in same class) bypasses proxy and ignores @Transactional.

2. Step 2: Analyze effect on transaction rollback

   Since outerMethod calls innerMethod directly, @Transactional on innerMethod is ignored, so no transaction starts and no rollback occurs.

3. Final Answer:

   No, transaction does not rollback because outerMethod is not @Transactional and calls innerMethod internally -> Option C

4. Quick Check:

   Self-call bypasses @Transactional proxy = no rollback [OK]

Hint: Self-calls ignore @Transactional proxy, no transaction started [OK]

Common Mistakes:

• Assuming @Transactional always works on internal calls
• Thinking RuntimeException always triggers rollback here
• Not knowing Spring proxy limitations