1. Quelle Transaktionsmechanismus
Alle Datenzugriffstechnologien verfügen über Transaktionsverarbeitungsmechanismen, die APIs bereitstellen, um Transaktionen zu ermöglichen, Transaktionen zu begehen, um Datenvorgänge zu vervollständigen oder Daten zurückzugewinnen, wenn ein Fehler auftritt.
Der Transaktionsmechanismus von Spring verwendet einen einheitlichen Mechanismus, um Transaktionen verschiedener Datenzugriffstechnologien zu verarbeiten. Der Transaktionsmechanismus von Spring bietet eine PlattformTransactionManager -Schnittstelle, und Transaktionen verschiedener Datenzugriffstechnologien werden mithilfe verschiedener Schnittstellen implementiert:
Der Code zum Definieren eines Transaktionsmanagers in einem Programm lautet wie folgt:
@Bean Public PlatformTransactionManager transactionManager () {jpatransactionManager transactionManager = new jpatransactionManager (); TransactionManager.SetDataSource (DataSource ()); Transaktionsmanager zurückgeben; }2. Deklarative Transaktionen
Spring unterstützt deklarative Transaktionen, dh anhand von Anmerkungen zur Auswahl der Methode, die Transaktionen verwenden muss. Es verwendet @transactional Annotation, um auf der Methode anzugeben, dass die Methode Transaktionsunterstützung erfordert.
@Transactional public void speichert (Long ID, String -Name) {// Datenbankoperation}Es ist wichtig zu beachten, dass diese @Transactional -Annotation vom org.springframework.transaction.Annotation -Paket, nicht javax.transaction, stammt.
Spring bietet eine @EnableTransactionManagement -Annotation, mit der deklarative Transaktionsunterstützung für Konfigurationsklassen ermöglicht werden kann. Nach der Verwendung @EnabletransactionManagement scannt der Federcontainer automatisch die Methoden und Klassen, die @Transactional kommentiert sind. @EnabletransactionManagement wird wie folgt verwendet:
@Configuration @enabletransactionManagement Public Class AppConfig {}3. Verwenden Sie @Transactional auf Klassenebene
@Transactional kann nicht nur mit Methoden, sondern auch den Klassen kommentieren. Bei der Annotation einer Klasse bedeutet dies, dass alle öffentlichen Methoden dieser Klasse transaktionsaktiviert sind. Wenn die Klassenstufe und Methodenebene @Transactional Annotation auf Klassenebene verwenden, wird die Annotation der Methodenebene mithilfe der Klassenebene überladen.
4. Transaktionsunterstützung für Springdaten JPA
Spring Data JPA ermöglicht die Transaktionsunterstützung für alle Standardmethoden, und die Readonly = True -Eigenschaft ist standardmäßig für Abfragetransaktionen aktiviert.
Dies ist aus dem Quellcode SimpleJParePository zu erkennen, dass SimpleJParePository @Transactional (readonly = true) auf Klassenebene definiert, während die @Transactional -Eigenschaft in Operationen, die sich auf Speichern und Löschen beziehen, umgeschrieben wird. Zu diesem Zeitpunkt ist die Readonly -Eigenschaft falsch und die anderen Abfrageoperationen readonly immer noch falsch.
5. Transaktionsunterstützung von Spring Boot
1. automatisch konfiguriertes Transaktionsmanager
Bei der Verwendung von JDBC als Datenzugriffstechnologie definiert Springboot die Bean von PlatformTransactionManager für uns. Siehe die Definition in org.springframework.boot.autoconfigure.jdbc.datasourcetransactionManAGerAnoConfiguration -Klasse:
@Bean @ConditionalonmissingBean @Conditionalonbean (dataSource.class) publicTransactionManager TransactionManager () {Neue DataSourcetransactionManager zurückgeben (this.dataSource); }Bei der Verwendung von JPA als Datenzugriffstechnologie definiert Spring Boot eine Bean für die PlatformTransactionManager -Implementierung von JpatransactionManager. Siehe die Definition in der org.springframework.boot.autoconfigure.orm.jpa.jpabaseConfiguration.Class -Klasse:
@Bean @ConditionalonmissingBean (PlatformTransactionManager.Class) publicTransactionManager TransactionManager () {return New JpatransactionManager (); } 2. Aktivieren Sie automatisch Unterstützung für Annotationstransaktionen
Spring Boot wird speziell verwendet, um Transaktionen als org.springframework.boot.autoconfigure.transaction.transactionAutoconfiguration zu konfigurieren. Diese Konfigurationsklasse hängt von JPABaseConfiguration und DataSourcetransactionManAgerAnauconfiguration ab.
Die Unterstützung für deklarative Transaktionen ist auch in der Konfiguration von DataSourcetRANSACTMANAGERAUTOCON -Festungskonfiguration aktiviert. Der Code lautet wie folgt:
@ConditionalonmissingBean (AbstractTransactionManagementConfiguration.Class) @Configuration @enableTransactionManagement Protected Static Class TransactionManagementConfiguration {}Im Spring -Boot müssen also nicht die aktivierte @EnableTransactionManagement -Annotation angezeigt werden.
6. Beispiel (Springboot)
1.Pom.xml:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-rest</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency>
2.Application.yml:
Server: Port: 5000 Spring: DataSource: Treiberklassenname: com.mysql.jdbc.driver URL: JDBC: MySQL: // localhost: 3306/test? useUnicode = true & charakterität Update show-SQL: True
3. Mitarbeiter der Entitätsklasse:
@Entity public Class Staff {@ID @GeneratedValue Private Long ID; privater Zeichenfolge Name; privates Ganzzahlalter; private String -Adresse; public staff () {super (); } öffentliche Mitarbeiter (Long ID, String -Name, ganzzahliger Alter, String -Adresse) {Super (); this.id = id; this.name = name; this.age = Alter; this.address = Adresse; } // Die Methoden GET und SET} weglassen4. Das Repository des Personals:
public interface stafRepository erweitert Jarepository <Staff, Long> {}5. Serviceschnittstelle:
öffentliche Schnittstelle Staffservice {öffentliche Mitarbeiter SavestAffWithrollback (Mitarbeiter); // Rollingback Public Staff SavestAffwitHoutrollback (Mitarbeiter); // nicht rollback}6. Service -Implementierung:
@Service Public Class StaffserviceImpl implementiert Staffservice {@autowired StaffRepository StaffRepository; // Sie können die Bohne unseres RersonRepository direkt injizieren. @Override // Verwenden Sie das Attribut von @Transactional Annotation, um eine bestimmte Ausnahme anzugeben. Die Daten werden zurückgerollt. @Transactional (Rollbackfor = {illegalArgumentException.class}) öffentliche Mitarbeiter SavestAffWithrollback (Staff) {Staff S = StaffRepository.save (Staff); if (staff.getName (). Equals ("Zhang san")) {Neue IllegalArgumentException ("Zhang San bereits existiert, Rollback"); } return s; } @Override öffentliche Mitarbeiter SavestAffWitHoutrollback (Staff) {Staff S = StaffRepository.save (Staff); if (staff.getName (). Equals ("Zhang san")) {Wirf neu illegalArgumentException ("Zhang san existiert bereits, Daten rollen nicht zurück"); } return s; }}7.Kontroller:
@RestController @RequestMapping ("/Staff") öffentlicher Klasse StaffController {@autowired Staffservice Staffservice; // Testen Sie die Rollback -Situation @RequestMapping ("/rollback") öffentlicher Mitarbeiter Rollback (Mitarbeiter) {Return staffservice.savestaffWithrollback (Staff); } // Testen Sie die Rollback -Situation @RequestMapping ("/notrollback") öffentliche Mitarbeiter Norollback (Mitarbeiter) {Return staffservice.savestaffwithoutrollback (Staff); }}8. Führen Sie den Test aus:
(1) Rollback: http: // localhost: 5000/Staff/Rollback? Name = Zhang San & Age = 18
Konsole:
Datenbank:
(2) Kein Rollback: http: // localhost: 5000/Staff/Notrollback? Name = Zhang San & Age = 18
Konsole:
Datenbank:
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.