La gestion des transactions dans Spring Boot peut être effectuée à l'aide de l'annotation @Transactional. Dans cet article de blog, nous explorerons comment utiliser @Transactional pour garantir la cohérence des données et simplifier la gestion des erreurs dans vos applications Spring Boot.

1. Utilisation de base

Pour utiliser @Transactional, vous le placez généralement sur les méthodes d'une classe de service où vous souhaitez le comportement transactionnel.

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. Niveaux de propagation et d'isolement

Vous pouvez spécifier les niveaux de propagation et d'isolement d'une transaction pour contrôler le comportement de la transaction :

• Propagation : définit le comportement de la transaction lorsqu'une transaction existante est déjà en cours d'exécution.

• Isolement : définit le niveau de visibilité des données de la transaction.
  

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

3. Règles de restauration

Vous pouvez spécifier quelles exceptions doivent déclencher une restauration :

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

4. Transactions en lecture seule

Si votre méthode lit uniquement les données et n'effectue aucune opération d'écriture, vous pouvez la marquer en lecture seule pour optimiser les performances :

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

5. Transactionnel sur les classes

Vous pouvez également placer @Transactional au niveau de la classe pour l'appliquer à toutes les méthodes de la classe :

@Service
@Transactional
public class UserService {

    public void getUser() {
        // transactional code
    }

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

Exemple de service avec des méthodes transactionnelles

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

Résumé

L'utilisation de @Transactional Spring Boot vous permet de gérer les transactions de manière déclarative, en spécifiant exactement comment vous souhaitez que les transactions se comportent dans divers scénarios. Cela permet de garantir la cohérence des données et de simplifier la gestion des erreurs dans vos applications.

Les références

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