Understanding @Transactional in Spring Boot
Tags: java, springboot, transactional, annotations
Published: 2024-07-05 08:04:26

Managing transactions in Spring Boot can be done using @Transactional annotation. In this blog post, we'll explore how to use @Transactional to ensure data consistency and simplify error handling in your spring boot applications.

## 1. Basic Usage

To use @Transactional, you typically place it on methods of a service class where you want the transactional behaviour.

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

@Service
public class UserService{

    @Transactional
    public void createUser() {
        // enter your transactional code here
    }
}
```

## 2. Propagation and Isolation Levels

You can specify the propagation and isolation levels of a transaction to control how the transaction behaves:

- Propagation: Defines how the transaction behaves when an existing transaction is already running.

- Isolation: Defines the data visibility level of the transaction.

```
@Transactional(propagation = Propagation.REQUIRED, 
              isolation = Isolation.READ_COMMITTED)
public void createUser() {
    // enter your transactional code here
}
```

## 3. Rollback Rules

You can specify which exceptions should trigger a rollback:

```
@Transactional(rollbackFor = Exception.class)
public void createUser() {
    // your transactional code here
}
```

## 4. Read-Only Transactions

If your method only reads data and does not perform any write operations, you can mark it as read-only for performance optimizations:

```
@Transactional(readOnly = true)
public void getUser() {
    // your read-only code here
}
```

## 5. Transactional on Classes

You can also place @Transactional at the class level to apply it to all methods in the class:

```
@Service
@Transactional
public class UserService {

    public void getUser() {
        // transactional code
    }

    public void createUser() {
        // transactional code
    }
}
```

## Example Service with Transactional Methods

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

@Service
public class UserService {

    @Transactional
    public void saveUser() {
        // code to save data
    }

    @Transactional(readOnly = true)
    public void fetchUser() {
        // code to fetch data
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void newTransaction() {
        // code to execute in a new transaction
    }

    @Transactional(rollbackFor = {CustomException.class})
    public void performWithRollback() {
        // risky code that may throw CustomException
    }
}
```

## Summary

Using @Transactional Spring Boot allows you to manage transactions declaratively, specifying exactly how you want transactions to behave in various scenarios. This helps ensure data consistency and simplifies error handling in your applications.

## References

https://www.baeldung.com/spring-transactions-read-only

https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Transactional.html

**Github:** https://github.com/tharindu1998/transactional-blog