Was ist der SpringBoot-Transaktionsverarbeitungsmechanismus?

1. Der Transaktionsmechanismus von Spring

Diese Technologien bieten APIs zum Öffnen von Transaktionen und zum Vervollständigen von Datenvorgängen Rollback der Daten, wenn ein Fehler auftritt.

Der Transaktionsmechanismus von Spring verwendet einen einheitlichen Mechanismus zur Abwicklung von Transaktionen mit unterschiedlichen Datenzugriffstechnologien. Der Transaktionsmechanismus von Spring bietet eine PlatformTransactionManager-Schnittstelle. Transaktionen mit unterschiedlichen Datenzugriffstechnologien verwenden unterschiedliche Schnittstellenimplementierungen:

Definieren Sie den Transaktionsmanager im Programm. Der Code lautet wie folgt folgt:

@Bean 
public PlatformTransactionManager transactionManager() { 
 JpaTransactionManager transactionManager = new JpaTransactionManager(); 
 transactionManager.setDataSource(dataSource()); 
 return transactionManager; 
}

2. Deklarative Transaktionen

Spring unterstützt deklarative Transaktionen, dh die Verwendung von Anmerkungen zur Auswahl der Methoden, die Transaktionen verwenden müssen , die die @Transactional-Annotation für die Methode verwendet, um anzugeben, dass die Methode Transaktionsunterstützung erfordert.

@Transactional 
public void saveSomething(Long id, String name) { 
 //数据库操作 
}

Was hier besondere Aufmerksamkeit erfordert, ist, dass diese @Transactional-Annotation aus dem Paket org.springframework.transaction.annotation stammt, nicht aus javax.transaction.

Spring stellt eine @EnableTransactionManagement-Annotation für die Konfigurationsklasse bereit, um deklarative Transaktionsunterstützung zu ermöglichen. Nach der Verwendung von @EnableTransactionManagement scannt der Spring-Container automatisch Methoden und Klassen, die mit @Transactional annotiert sind. Die Verwendung von @EnableTransactionManagement ist wie folgt:

@Configuration 
@EnableTransactionManagement 
public class AppConfig { 
 
}

3. Verwenden Sie @Transactional

@Transactional kann nicht nur auf Methoden annotiert werden, sondern auch auch Anmerkung zur Klasse. Wenn eine Klasse mit Anmerkungen versehen ist, bedeutet dies, dass alle öffentlichen Methoden dieser Klasse transaktionsfähig sind. Wenn die Annotation @Transactional sowohl auf Klassenebene als auch auf Methodenebene verwendet wird, überschreibt die auf Klassenebene verwendete Annotation die Annotation auf Methodenebene.

4. Transaktionsunterstützung von Spring Data JPA

Die Transaktionsunterstützung von Spring Data JPA ist für alle Standardmethoden aktiviert. Und die readOnly Das Attribut =true ist standardmäßig für Abfragetransaktionen aktiviert.

Dies ist aus dem Quellcode SimpleJpaRepository ersichtlich, der @Transactional (readOnly=true) auf Klassenebene definiert und das @Transactional-Attribut in Vorgängen im Zusammenhang mit Speichern und Löschen neu schreibt , das Attribut readOnly ist falsch und readOnly ist für die restlichen Abfragevorgänge immer noch falsch. 5. Transaktionsunterstützung von Spring Boot JDBC als Datenzugriffstechnologie, SpringBoot definiert für uns die Bean von PlatformTransactionManager, die DataSourceTransactionManager implementiert; für die Konfiguration siehe die Definition in der Klasse org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration:

@Bean 
@ConditionalOnMissingBean 
@ConditionalOnBean(DataSource.class) 
public PlatformTransactionManager transactionManager() { 
 return new DataSourceTransactionManager(this.dataSource); 
}

Wann Unter Verwendung von JPA als Datenzugriffstechnologie definiert Spring Boot eine Bean, die JpaTransactionManager von PlatformTransactionManager für uns implementiert. Weitere Informationen finden Sie in der Definition in der Klasse org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration.class:

@Bean 
@ConditionalOnMissingBean(PlatformTransactionManager.class) 
public PlatformTransactionManager transactionManager() { 
 return new JpaTransactionManager(); 
}

2. Unterstützung für Anmerkungstransaktionen automatisch aktivieren

Die speziell zum Konfigurieren von Transaktionen verwendete Klasse ist: org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration, diese Konfigurationsklasse hängt davon ab auf JpaBaseConfiguration und DataSourceTransactionManagerAutoConfiguration.

In der DataSourceTransactionManagerAutoConfiguration-Konfiguration ist auch die Unterstützung für deklarative Transaktionen aktiviert. Der Code lautet wie folgt:

@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class) 
@Configuration 
@EnableTransactionManagement 
protected static class TransactionManagementConfiguration { 
 
}

Also in Spring Boot, nein Sie müssen die Anzeige aktivieren und die Annotation @EnableTransactionManagement verwenden.

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: 
 driver-class-name: com.mysql.jdbc.Driver 
 url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8 
 username: root 
 password: password 
 
 jpa: 
 hibernate: 
 ddl-auto: update # 第一次简表create 后面用update 
 show-sql: true

3. Entitätsklasse-Mitarbeiter:

@Entity 
public class Staff { 
 @Id 
 @GeneratedValue 
 private Long id; 
 private String name; 
 private Integer age; 
 private String address; 
 
 public Staff() { 
 super(); 
 } 
 
 public Staff(Long id, String name, Integer age, String address) { 
 super(); 
 this.id = id; 
 this.name = name; 
 this.age = age; 
 this.address = address; 
 } 
 //省略get、set方法 
}

4. Mitarbeiter-Repository:

public interface StaffRepository extends JpaRepository<staff> { 
 
}</staff>

5. Service-Schnittstelle: # 🎜 🎜#

public interface StaffService { 
 public Staff saveStaffWithRollBack(Staff staff);//回滚 
 public Staff saveStaffWithoutRollBack(Staff staff);//不回滚 
}

6. Service-Implementierung:

@Service 
public class StaffServiceImpl implements StaffService { 
 
 @Autowired 
 StaffRepository staffRepository; //可以直接注入我们的RersonRepository的Bean。 
 
 @Override 
 //使用@Transactional注解的rollbackFor属性，指定特定异常时，数据回滚。 
 @Transactional(rollbackFor = {IllegalArgumentException.class}) 
 public Staff saveStaffWithRollBack(Staff staff) { 
 Staff s = staffRepository.save(staff); 
 if (staff.getName().equals("张三")) { 
  throw new IllegalArgumentException("张三已经存在了，rollback"); 
 } 
 return s; 
 } 
 
 @Override 
 public Staff saveStaffWithoutRollBack(Staff staff) { 
 Staff s = staffRepository.save(staff); 
 if (staff.getName().equals("张三")) { 
  throw new IllegalArgumentException("张三已经存在了，数据不回滚"); 
 } 
 return s; 
 } 
}

7.Controller:

@RestController 
@RequestMapping("/staff") 
public class StaffController { 
 @Autowired 
 StaffService staffService; 
 
 //测试回滚情况 
 @RequestMapping("/rollback") 
 public Staff rollback(Staff staff) { 
 return staffService.saveStaffWithRollBack(staff); 
 } 
 
 //测试不回滚情况 
 @RequestMapping("/notrollback") 
 public Staff noRollBack(Staff staff) { 
 return staffService.saveStaffWithoutRollBack(staff); 
 } 
}

8. Test ausführen:

(1) Rollback: http://localhost:5000/staff/rollback?name=张三&age=18

Konsole:

#🎜🎜 #

Datenbank:

(2) Kein Rollback: http://localhost :5000/staff /notrollback?name=张三&age=18

Konsole:

# 🎜🎜##🎜 🎜#Datenbank:

Das obige ist der detaillierte Inhalt vonWas ist der SpringBoot-Transaktionsverarbeitungsmechanismus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!