1. Mécanisme de transaction de Spring
Toutes les technologies d'accès aux données ont des mécanismes de traitement des transactions, qui fournissent des API pour activer les transactions, commettre des transactions pour terminer les opérations de données ou le rétablissement des données lorsqu'une erreur se produit.
Le mécanisme de transaction de Spring utilise un mécanisme unifié pour gérer les transactions de différentes technologies d'accès aux données. Le mécanisme de transaction de Spring fournit une interface PlatformTransactionManager, et les transactions de différentes technologies d'accès aux données sont implémentées à l'aide de différentes interfaces:
Le code pour définir un gestionnaire de transactions dans un programme est le suivant:
@Bean Public PlatformTransactionManager TransactionManager () {jpatransactionManager TransactionManager = new JPatransactionManager (); TransactionManager.SetDataSource (DataSource ()); return TransactionManager; }2. Transactions déclaratives
Spring prend en charge les transactions déclaratives, c'est-à-dire en utilisant des annotations pour sélectionner la méthode qui doit utiliser les transactions. Il utilise @Transactional Annotation pour indiquer sur la méthode selon laquelle la méthode nécessite la prise en charge de la transaction.
@Transactional public void SaveSomething (Long ID, nom de chaîne) {// Fonctionnement de la base de données}Il est important de noter ici que cette annotation @transactionnelle provient du package org.springframework.transaction.annotation, pas javax.transaction.
Spring fournit une annotation @EnableTransactionManagement pour activer la prise en charge de la transaction déclarative sur les classes de configuration. Après avoir utilisé @EnableTransactionManagement, le conteneur de ressort scannera automatiquement les méthodes et les classes annotées @Transactional. @EnableTransactionManagement est utilisé comme suit:
@Configuration @EnableTransActionManagement Classe publique AppConfig {}3. Utilisez @Transactional au niveau de la classe
@Transactional peut non seulement annoter sur les méthodes, mais aussi sur les classes. Lors de l'anotation sur une classe, cela signifie que toutes les méthodes publiques de cette classe sont activées par la transaction. Si le niveau de classe et le niveau de méthode utilisent une annotation @transactionnelle au niveau de la classe, l'annotation au niveau de la méthode sera surchargée à l'aide du niveau de classe.
4. Prise en charge des transactions pour les données de printemps JPA
Spring Data JPA permet la prise en charge des transactions pour toutes les méthodes par défaut, et la propriété ReadOnly = True est activée par défaut pour les transactions de requête.
Cela peut être vu à partir du code source SimpleJParepository que SimpleJParePository définit @Transactional (readonly = true) au niveau de la classe, tandis que la propriété @Transactional est réécrite dans les opérations liées à la sauvegarde et à la suppression. À l'heure actuelle, la propriété ReadOnly est fausse et les autres opérations de requête Readonly sont toujours fausses.
5. Prise en charge des transactions de Spring Boot
1. Gestionnaire de transaction configuré automatiquement
Lorsque vous utilisez JDBC comme technologie d'accès aux données, Springboot définit le bean de PlatformTransactionManager pour nous. Voir la définition dans l'org.springframework.boot.autoconfigure.jdbc.datasourcetransactionManageraToConfiguration Classe:
@Bean @conditionalonMissingBean @ConditionalonBean (DataSource.class) Public PlatformTransactionManager TransactionManager () {return new DataSourceTransactionManager (this.datasource); }Lorsque vous utilisez JPA comme technologie d'accès aux données, Spring Boot définit un bean pour la mise en œuvre de PlatformTransactionManager de JPatransactionManager; Voir la définition dans le org.springframework.boot.autoconfigure.orm.jpa.jpabaseConfiguration.class Class:
@Bean @conditionalonMissingBean (PlatformTransactionManager.class) Public PlatformTransactionManager TransactionManager () {return new JPatransactionManager (); } 2. Activer automatiquement la prise en charge des transactions d'annotation
Spring Boot est spécialement utilisé pour configurer les transactions comme org.springframework.boot.autoconfigure.transaction.transactionAutoConfiguration. Cette classe de configuration dépend de JpabaseConfiguration et de DataSourcetransactionManageraToConfiguration.
La prise en charge des transactions déclaratives est également activée dans la configuration de DataSourceTransactionManageraToConfiguration, le code est le suivant:
@ConditionalonMissingBean (AbstractTransactionManagementConfiguration.class) @configuration @enableTransactionManagement Class statique ProactionManagementConfiguration {}Ainsi, dans Spring Boot, il n'est pas nécessaire d'afficher @EnableTransactionManagement Annotation activé.
6. Exemple (Springboot)
1.pom.xml:
<dependency> <proupId> org.springframework.boot </proupId> <ArtifActid> printemp-boot-starter-web </ artifactid> </pedigency> <dependency> <proupId> org.springframework.boot </proupId> <ptetifactid> Spring-Boot-starter-data-jpa </letifactid> </ dépendance> <GroupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-data-rest </retifactid> </dependency> <dependency> <proupId> mysql </proupId> <Ertifactid> MySQL-Connector-Java </ artifactid> <ccope> runtime </scope> </Dedency>
2.Application.yml:
Serveur: Port: 5000 Spring: DataSource: Driver-Class-Name: com.mysql.jdbc.driver URL: jdbc: mysql: // localhost: 3306 / test? useunicode = true & worforcy Pour mettre à jour Show-SQL: True
3. Personnel des cours d'entité:
@Entity public class personnel {@id @GeneratedValue Private Long ID; nom de chaîne privé; Âge entier privé; adresse de chaîne privée; Public () {Super (); } Personnel public (ID long, nom de chaîne, âge entier, adresse de chaîne) {super (); this.id = id; this.name = name; this.age = âge; this.address = adresse; } // omettre les méthodes Get and Set}4. Référentiel du personnel:
Interface publique StaffRepository étend JParepository <personnel, long> {}5. Interface de service:
Interface publique Staffservice {Public SavestAffWithrollback (personnel du personnel); // Rollingback Staff public SavestAffWithoutrollback (personnel du personnel); // Ne pas Rollback}6. Implémentation du service:
@Service Public Class StaffServiceImplt implémente StaffService {@Autowired StaffRepository StaffRepository; // Vous pouvez injecter directement le haricot de notre rersonRopository. @Override // Utilisez l'attribut RollbackFor de @Transactional Annotation Pour spécifier une exception spécifique, les données seront annulées. @Transactional (rollbackfor = {illégalArgumentException.class}) Public SavestAffWithRollback (personnel du personnel) {Staff S = standRepository.save (personnel); if (stand.GetName (). Equals ("Zhang San")) {Throw New illégalArgumentException ("Zhang San existe déjà, Rollback"); } return s; } @Override Public Public SavestAffWithoutrollback (personnel du personnel) {Staff S = StaffRepository.save (personnel); if (staff.GetName (). equals ("Zhang san")) {lancer un nouveau IllégalArgumentException ("Zhang San existe déjà, les données ne reviennent pas"); } return s; }}7. Contrôleur:
@RestController @RequestMapping ("/ Staff") Classe publique Staff-Controller {@Autowired Staffservice Staffservice; // Testez la situation de Rollback @RequestMapping ("/ Rollback") Rollback du personnel public (personnel du personnel) {return StaffService.SavestAffWithRollback (personnel); } // Testez la situation de Rollback @RequestMapping ("/ Notrollback") Personnel public Norollback (Personnel du personnel) {Retour StaffService.SavestAffWithoutrollback (personnel); }}8. Exécutez le test:
(1) Rollback: http: // localhost: 5000 / personnel / rollback? Name = zhang san & age = 18
Console:
base de données:
(2) Pas de Rollback: http: // localhost: 5000 / personnel / notrollback? Name = zhang san & age = 18
Console:
base de données:
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.