O gerenciamento de transações no Spring Boot pode ser feito usando a anotação @Transactional. Nesta postagem do blog, exploraremos como usar @Transactional para garantir a consistência dos dados e simplificar o tratamento de erros em seus aplicativos Spring Boot.

1. Uso Básico

Para usar @Transactional, você normalmente o coloca em métodos de uma classe de serviço onde deseja o comportamento transacional.

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. Níveis de propagação e isolamento

Você pode especificar os níveis de propagação e isolamento de uma transação para controlar como a transação se comporta:

• Propagação: define como a transação se comporta quando uma transação existente já está em execução.

• Isolamento: Define o nível de visibilidade dos dados da transação.
  

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

3. Regras de reversão

Você pode especificar quais exceções devem acionar uma reversão:

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

4. Transações somente leitura

Se o seu método apenas lê dados e não executa nenhuma operação de gravação, você pode marcá-lo como somente leitura para otimizações de desempenho:

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

5. Transacional em Classes

Você também pode colocar @Transactional no nível da classe para aplicá-lo a todos os métodos da classe:

@Service
@Transactional
public class UserService {

    public void getUser() {
        // transactional code
    }

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

Exemplo de serviço com métodos transacionais

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

Resumo

Usar @Transactional Spring Boot permite gerenciar transações de forma declarativa, especificando exatamente como você deseja que as transações se comportem em vários cenários. Isso ajuda a garantir a consistência dos dados e simplifica o tratamento de erros em seus aplicativos.

Referências

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