Dans Spring Boot Transaction Management, implémentez la plate-forme d'auto-interface.
Interface publique PlatformTransactionManager {org.springframework.transaction.transactionstatus getTransaction (org.springframework.transaction.transactionDefinition TransactionDefinition) lève org.springframework.transaction.transactionException; void commit (org.springframework.transaction.transactionstatus transactionstatus) lève org.springframework.transaction.transactionException; void Rollback (org.springframework.transaction.transactionstatus transactionstatus) lève org.springframework.transaction.transactionException;}Lorsque nous utilisons la dépendance Spring-Boot-Starter-JDBC, le framework injectera automatiquement DataSourceTransactionManager par défaut. Nous n'avons donc pas besoin de configuration supplémentaire pour utiliser l'annotation @transactionnelle pour l'utilisation des transactions.
Gestionnaire de transactions JDBC
En service, la méthode annotée par @Transactional prendra en charge les transactions. Si l'annotation est sur une classe, toutes les méthodes de l'ensemble de la classe prennent en charge les transactions par défaut.
Situation du gestionnaire multi-transaction
1: Vous pouvez implémenter l'interface TransactionManagementConfigurer et la valeur de retour de la méthode à l'intérieur est le gestionnaire de transaction par défaut.
2: Vous pouvez définir la valeur sur la méthode d'exécution spécifique
S'il y a plusieurs instances PlatformTransactionManager dans le conteneur Spring et que l'interface TransactionManagementConfigurer n'est pas implémentée pour spécifier la valeur par défaut, lorsque nous utilisons l'annotation @Transactional sur la méthode, nous devons le spécifier avec une valeur. S'il n'est pas spécifié, une exception sera lancée.
// @ InteableTransActionManagement // Activer la gestion des transactions d'annotation, ce qui équivaut à <tx: annotation-driven /> @ SpringbootApplicationPublic ProfilEmoApliccation implémente TransactionManagementConfigurer {@Resource (name = "txManager2") Private PlatepransactionManager TxManageR2; // Créer manuellement les transactions Manager 1 Le cadre DataSource sera automatiquement injecté // Dans le conteneur de printemps, nous annoter manuellement @Bean sera chargé en premier, et le cadre ne réinstruera pas d'autres classes d'implémentation PlatformTransactionManager. @Bean (name = "TxManager1") Public PlatformTransactionManager TxManager (DataSource DataSource) {return new DataSourceTransactionManager (DataSource); } // Créer TransactionManager 2 @Bean (name = "TxManager2") Public PlatformTransactionManager TxManager2 (EntityManagerFactory Factory) {return new JPAtRansactionManager (Factory); } // Implémentez la méthode Interface TransactionManagementConfigurer dont la valeur de retour représente le gestionnaire de transaction utilisé par défaut si vous avez plusieurs gestionnaires de transactions @Override public PlatformTransactionManager AnnotationDriventRansActionManager () {return txManager2; } public static void main (String [] args) {SpringApplication.run (ProfileDemoApplication.class, args); }}Implémentation spécifique
@ComponentPublic class DevSendMessage implémente SendMessage {// Utiliser la valeur pour spécifier le gestionnaire de transaction à utiliser @Transactional (value = "txManager1") @Override public void Send () {System.out.println (">>>>>>>>>>>>>> Dev Send () <<<<<<<<<" "); send2 (); } @Transactional public void send2 () {System.out.println (">>>>>>>>>>>> Dev Send2 () <<<<<<<<<" "); }}Niveau d'isolement
Public Enum Isolation {Default (TransactionDefinition.isolation_Default), read_uncmitted (TransactionDefinition.isolation_Read_Uncitmis), Read_Committed (TransactionDefinition.isolation_Read_Committed), Repeatable_Read (TransactionDefinition.isolation_repeatable_read),, Serialisable (transactionDefinition.isolation_serializable); valeur int privée int; Isolement (int value) {this.value = valeur; } public int value () {return this.value; }} Spécifiez la méthode: défini en utilisant la propriété d'isolement, par exemple:
@Transactional (isolement = isolation.default)
Comportement de communication
Le comportement soi-disant de propagation des transactions fait référence à cela si un contexte de transaction existe déjà avant le démarrage de la transaction actuelle, plusieurs options peuvent spécifier le comportement d'exécution d'une méthode transactionnelle.
Nous pouvons voir que la classe d'énumération org.springframework.transaction.annotation.propagation définit 6 valeurs d'énumération qui représentent le comportement de propagation:
Public Enum Propagation {requise (TransactionDefinition.Propagation_Required), supports (TransactionDefinition.Propagation_Supports), obligatoire (TransactionDefinition.Propagation_Mandatory), requillage_new (transactiondefinition.propagation_requires_new), Not_supported (transactiondefinition.propagation_not_supported), never (transactiondefinition.propagation_never), nested (transactiondefinition.propagation_nest); valeur int privée int; Propagation (int Value) {this.value = valeur; } public int value () {return this.value; }}Obligatoire: Si une transaction est actuellement présente, rejoignez la transaction; S'il n'y a actuellement aucune transaction, créez une nouvelle transaction. valeur par défaut.
Prise en charge: Si une transaction est actuellement présente, rejoignez la transaction; S'il n'y a actuellement aucune transaction, continuez à s'exécuter de manière non transactionnelle.
Obligatoire: si une transaction est actuellement présente, rejoignez la transaction; S'il n'y a actuellement aucune transaction, une exception est lancée. (Obligé de le mettre dans la transaction)
OBLESS_NEW: crée une nouvelle transaction, et si la transaction existe actuellement, la transaction actuelle sera suspendue. (Les journaux d'impression sont souvent utilisés. Même si le retour en arrière précédent est reculé, la transaction sera exécutée et que le message d'erreur sera enregistré)
Not_Supported: fonctionne de manière non transactionnelle. Si une transaction existe actuellement, la transaction actuelle sera suspendue.
Jamais: fonctionne de manière non transactionnelle, lance une exception si une transaction existe actuellement.
Nested: Si une transaction existe actuellement, une transaction est créée pour s'exécuter en tant que transaction imbriquée de la transaction actuelle; S'il n'y a pas de transaction actuellement, la valeur est équivalente à requise.
Spécifiez la méthode: défini en utilisant la propriété de propagation, par exemple:
@Transactional (propagation = propagation.requure)
Transaction et non de situation de retour
Ne reculez que si un RuntimeException non apporté se produit
L'exception lancée par Catch réussira lorsque les deux inserts
@Override @Transactional Public Void InsertAndInsert (personnel du personnel) {Staffdao.insert (personnel); essayez {int i = 1/0; } catch (exception e) {e.printStackTrace (); } standarddao.insert (personnel); }Ajouté à l'instruction Catch de la méthode de la couche de service: TransactionAspectSupport.CurrentTransactionStatus (). SetRollBackOnly (); Déclaration, le recul manuel n'insertera pas les données
@Override @Transactional public void insertandinsert (personnel du personnel) lève une exception {try {staffdao.insert (personnel); int i = 1/0; standarddao.insert (personnel); } catch (exception e) {TransactionAspectSupport.currentTransactionStatus (). SetRollBackOnly (); }}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.