Dans les applications, la gestion des transactions est un concept très important. Une transaction est une séquence d'opérations qui réussissent toutes ou échouent toutes. Dans Spring Boot, les annotations de transaction peuvent être utilisées pour gérer les transactions. Lors de l'utilisation d'annotations de transaction, un concept très important est le comportement de propagation des transactions.
Qu'est-ce que le comportement de propagation des transactions ?
Le comportement de propagation de transaction fait référence au comportement de transaction qui se produit lorsqu'une méthode appelle une autre méthode. Dans Spring Boot, le comportement de propagation des transactions est géré par le framework Spring. Le framework Spring utilise certaines règles pour décider comment gérer les transactions dans différentes situations.
Annotations de transaction dans Spring Boot
Spring Boot fournit une @Transactionalannotation pour contrôler les transactions. Cette annotation peut être placée sur la méthode ou sur la classe. Si elle est placée sur une classe, toutes les méthodes hériteront de cette annotation.
@TransactionalLes annotations ont des propriétés très importantes, notamment propagationet isolation. propagationLes attributs sont utilisés pour spécifier le comportement de propagation des transactions et isolationles attributs sont utilisés pour spécifier le niveau d'isolement des transactions.
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public void doSomething() {
// ...
}
Dans le code ci-dessus, propagationl'attribut spécifie le comportement de propagation de la transaction Propagation.REQUIRED, ce qui signifie que si une transaction existe déjà, utilisez cette transaction ; s'il n'y a pas de transaction en cours, créez une nouvelle transaction. isolationL'attribut spécifie le niveau d'isolement de la transaction Isolation.READ_COMMITTED, ce qui signifie lire les données validées.
Principes de transaction dans Spring Boot
Dans Spring Boot, les transactions sont gérées par le framework Spring. Le framework Spring utilise la technologie AOP (programmation orientée aspect) pour implémenter la gestion des transactions. Plus précisément, le framework Spring implémente la gestion des transactions via un mécanisme de proxy.
Lorsqu'une méthode est @Transactionalannotée, Spring crée un objet proxy pour la méthode. Lorsque cette méthode est appelée, elle appelle en fait la méthode de l'objet proxy. L'objet proxy démarrera une transaction avant l'exécution de la méthode et décidera de valider la transaction ou de l'annuler en fonction du résultat de l'exécution après l'exécution de la méthode.
Le framework Spring utilise un TransactionInterceptorintercepteur pour implémenter la gestion des transactions. Cet intercepteur interceptera avant et après l'exécution de la méthode, et décidera d'ouvrir une nouvelle transaction ou d'utiliser une transaction existante en fonction du comportement de propagation et des conditions anormales de la transaction, et décidera de valider la transaction ou de la renvoyer en fonction du résultat de l'exécution. après l'exécution de la méthode.
Utilisation des transactions dans Spring Boot
Dans Spring Boot, nous pouvons utiliser @Transactionaldes annotations pour contrôler les transactions. Lorsque vous utilisez @Transactionaldes annotations, vous devez faire attention aux points suivants :
@TransactionalLes annotations ne peuvent être placées que sur des méthodes publiques.- La méthode doit être non statique.
@TransactionalLes transactions ne fonctionneront pas si la méthode annotée est appelée dans la même classe . En effet, Spring implémente la gestion des transactions via des proxys, et les proxys ne peuvent prendre effet que lorsqu'une méthode est appelée.- Si plusieurs méthodes annotées existent dans une classe en même temps
@Transactional, ces méthodes partageront la même transaction. - Lorsque vous utilisez
@Transactionaldes annotations, veillez à vous assurer que les annotations sont correctement configurées, sinon la transaction risque de ne pas être annulée ou l'annulation peut être incomplète.
Voici un @Transactionalexemple utilisant des annotations :
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Transactional(rollbackFor = Exception.class)
public void addUser(User user) {
userRepository.save(user);
// ...
## 代码解读
在上面的代码中，我们定义了一个`UserService`类，这个类使用了`@Transactional`注解来控制事务。在`addUser`方法中，我们首先调用了`userRepository.save(user)`方法来保存用户信息。由于这个方法上使用了`@Transactional`注解，因此在调用`userRepository.save(user)`方法之前，Spring框架会开启一个事务。如果在`userRepository.save(user)`方法执行期间发生了异常，那么这个事务将会被回滚。
`@Transactional`注解还有一些其他的属性，包括`readOnly`、`timeout`和`noRollbackFor`等。这些属性可以帮助我们更好地控制事务的行为。例如，`readOnly`属性可以指定事务是否为只读事务；`timeout`属性可以指定事务超时时间；`noRollbackFor`属性可以指定哪些异常不应该回滚事务。
```java
@Transactional(readOnly = true, timeout = 30, noRollbackFor = IllegalArgumentException.class)
public void doSomething() {
// ...
}
Dans le code ci-dessus, nous avons utilisé @Transactionalles attributs readOnly, timeoutet noRollbackFor. Cette méthode est spécifiée comme une transaction en lecture seule avec un délai d'attente de 30 secondes. Si une exception se produit lors de l'exécution de la méthode IllegalArgumentException, la transaction ne sera pas annulée.
Résumer
Dans Spring Boot, la gestion des transactions est un concept très important. Nous pouvons utiliser des annotations de transaction pour contrôler le comportement des transactions. Lors de l'utilisation des annotations de transaction, nous devons prêter attention au comportement de propagation de la transaction, au niveau d'isolation de la transaction et aux autres propriétés de configuration. Le framework Spring utilise la technologie AOP pour implémenter la gestion des transactions, en particulier via un mécanisme de proxy. Lors de l'utilisation d'annotations de transaction, nous devons nous assurer que les annotations sont configurées correctement, sinon la transaction peut ne pas être annulée ou l'annulation peut être incomplète.