Eingehende Analyse von Spring-Transaktionen (mit Beispielen)

Dieser Artikel bietet Ihnen eine ausführliche Analyse der Spring-Transaktionen (mit Beispielen). Freunde in Not können sich darauf beziehen.

Ich glaube, dass jeder das Spring-Transaktionsmanagement häufig nutzt, aber es beschränkt sich möglicherweise nur auf eine @Transactional-Anmerkung oder die Konfiguration transaktionsbezogener Dinge in XML. In jedem Fall kann eine tägliche ausreichend sein, damit wir sie verwenden können. Aber als Programmierer sollten Sie mehr über die Details von Spring-Transaktionen erfahren, sei es für ein Vorstellungsgespräch oder um den von Ihnen geschriebenen Code besser kontrollieren zu können.

Hier werde ich ein paar Fragen stellen, um zu sehen, ob Sie sie sofort beantworten können:

• Wenn verschachtelte Aufrufe Methoden enthalten, die Transaktionen enthalten, im Frühjahr Transaktionsmanagement, zu welchem ​​Wissenspunkt gehört das?

• Das von uns verwendete Framework kann Hibernate/JPA oder Mybatis sein. Wie wir alle wissen, erfordert die unterste Ebene ein session/connection-Objekt, das uns bei der Ausführung von Operationen hilft. Um die Integrität der Transaktion sicherzustellen, müssen wir dasselbe -Objekt für mehrere Gruppen von Datenbankoperationen verwenden, und wir wissen, dass die von Spring IOC verwalteten Objekte standardmäßig alle session/connectionEinzelfälle sind . Warum verursacht dies keine Thread-Sicherheitsprobleme, wenn wir es verwenden? Was genau macht Spring intern?

• Wie nennt man das BPP?

• Was sind die wichtigen Schnittstellen für das Spring-Transaktionsmanagement?

1. Grundkenntnisse, die zum Lesen dieses Artikels erforderlich sind

Meine Klassenkameraden, die diesen Artikel lesen

Standard, mit denen jeder vertraut ist Frühling Verfügen über ein gewisses Verständnis für betriebswirtschaftliches Wissen. (ps: Wenn Sie den jeweiligen Artikel nicht kennen, lesen Sie ihn und kommen Sie hierher zurück)

Wir alle wissen, dass Spring-Transaktionen eine der Best Practices von Spring AOP sind, also sprechen wir über die Grundkenntnisse von AOP (einfache Konfiguration, Verwendung) muss zuerst bekannt sein. Wenn Sie AOP umfassender verstehen möchten, können Sie diesen Artikel lesen: Wichtige Wissenspunkte von AOP (Terminologieeinführung, umfassende Verwendung). Wenn wir über AOP sprechen, müssen wir über das zugrunde liegende Prinzip von AOP sprechen: das dynamische Proxy-Entwurfsmuster. Zu diesem Zeitpunkt verfügen Sie bereits über ein grundlegendes Verständnis von AOP. So können wir XML/Annotationen verwenden, um das Spring-Transaktionsmanagement zu konfigurieren.

Was Sie beim IOC-Lernen wissen können, ist der Lebenszyklus von Beans in Spring (der zu BPP-Objekten führt) und die von IOC verwalteten Objekte sind standardmäßig Singletons: Singleton-Entwurfsmuster, wenn es ein Singleton-Objekt gibt.

State“ (mit Mitgliedsvariablen), so viele Threads, die auf dieses Singleton-Objekt zugreifen, können zu Thread-Unsicherheit führen. Was ist Thread-Sicherheit? , Es gibt viele Möglichkeiten, die Thread-Sicherheit zu lösen, aber eine davon ist: Lassen Sie jeden Thread seine eigene Variable haben: ThreadLocal

Wenn Sie nicht viel über die oben genannten Wissenspunkte wissen, ist es Es wird empfohlen, auf das blaue Symbol „Einsteigen“ zu klicken und einige Wörter zu lernen.

Zwei Beispiele für unzuverlässige Intuition

2.1 Das erste Beispiel

Ein Freund hat mich vorhin nach einem Beispiel gefragt:

Eine Ausnahme wird auf der Service-Ebene ausgelöst und auf der Controller-Ebene erfasst. Wenn es eine Ausnahme im Service gibt, wird die Transaktion dann zurückgesetzt?

// Service方法
    
@Transactional
public Employee addEmployee() throws Exception {

    Employee employee = new Employee("3y", 23);
    employeeRepository.save(employee);
    // 假设这里出了Exception
    int i = 1 / 0;

    return employee;
}

// Controller调用
@RequestMapping("/add")
public Employee addEmployee() {
    Employee employee = null;
    try {
        employee = employeeService.addEmployee();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return employee;

}

Meine

erste Reaktion: Es wird nicht zurückgesetzt.

• Das dachte ich damals: Weil die Serviceschicht eine Ausnahme ausgelöst hat und diese vom Controller abgefangen wurde. Ob ein Rollback durchgeführt wird oder nicht, sollte durch die Logik im Catch-Code-Block des Controllers bestimmt werden. Wenn der Catch-Code-Block nicht zurückgesetzt wird, sollte er nicht zurückgesetzt werden.

Aber nach dem Testen sagte mein Freund, dass es rückgängig gemacht werden kann. (Pappapa schlägt ins Gesicht)

Nach dem Betrachten des Dokuments stellt sich heraus, dass das Dokument Anweisungen enthält:

Standardmäßig aktivierte Ausnahmen führen nicht dazu, dass der Transaktionsinterceptor die Transaktion für ein Rollback markiert, während Instanzen von RuntimeException und seinen Unterklassen dies tun

Schlussfolgerung: Wenn es sich um eine Ausnahme zur Kompilierungszeit handelt, wird sie nicht automatisch zurückgesetzt

Wenn es sich um eine Laufzeitausnahme handelt, wird sie automatisch zurückgesetzt!

2.2 Das zweite Beispiel

Das zweite Beispiel stammt aus dem Zhihu@LiuShu-Artikel, die entsprechende URL wird am Ende des Artikels angegeben

Wie Sie wissen, können Methoden, die von

-Anmerkungen umgeben sind, von Spring-Transaktionen verwaltet werden. Wenn ich eine Methode ohne Transaktion unter der aktuellen Klasse @Transactional verwende, um eine Methode mit einer Transaktion aufzurufen, dann haben wir das Was passiert mit diesem Anruf? Wird es ein Geschäft geben?

Beschreiben Sie es im Code:

// 没有事务的方法去调用有事务的方法
public Employee addEmployee2Controller() throws Exception {

    return this.addEmployee();
}

@Transactional
public Employee addEmployee() throws Exception {

    employeeRepository.deleteAll();
    Employee employee = new Employee("3y", 23);

    // 模拟异常
    int i = 1 / 0;

    return employee;
}

Mein erster Instinkt ist: Dies hängt mit dem Ausbreitungsmechanismus von Spring-Transaktionen zusammen.

Eigentlich hat das nichts mit dem Spring-Transaktionsweitergabemechanismus zu tun

Lassen Sie es mich unten beschreiben:

• Spring-Transaktionsmanagement verwendet AOP, und die unterste Ebene des AOP Dynamic Proxy wird verwendet. Wenn wir also die Annotation

  für eine Klasse oder Methode markieren, wird ein @Transactional Proxy-Objekt generiert.

Lass es mich mit Bildern erklären:

显然地，我们拿到的是代理(Proxy)对象，调用addEmployee2Controller()方法，而addEmployee2Controller()方法的逻辑是target.addEmployee()，调用回原始对象(target)的addEmployee()。所以这次的调用压根就没有事务存在，更谈不上说Spring事务传播机制了。

Eingehende Analyse von Spring-Transaktionen (mit Beispielen)：

测试结果：压根就Eingehende Analyse von Spring-Transaktionen (mit Beispielen)

2.2.1再延伸一下

从上面的测试我们可以发现：如果是在本类中没有事务的方法来调用标注注解@Transactional方法，最后的结论是没有事务的。那如果我将这个标注注解的方法移到别的Service对象上，有没有事务？

@Service
public class TestService {

    @Autowired
    private EmployeeRepository employeeRepository;
    
    @Transactional
    public Employee addEmployee() throws Exception {

        employeeRepository.deleteAll();

        Employee employee = new Employee("3y", 23);

        // 模拟异常
        int i = 1 / 0;

        return employee;
    }

}


@Service
public class EmployeeService {

    @Autowired
    private TestService testService;
    // 没有事务的方法去调用别的类有事务的方法
    public Employee addEmployee2Controller() throws Exception {
        return testService.addEmployee();
    }
}

测试结果：

因为我们用的是代理对象(Proxy)去调用addEmployee()方法，那就当然有事务了。

看完这两个例子，有没有觉得3y的直觉是真的水！

三、Spring事务传播机制

如果嵌套调用含有事务的方法，在Spring事务管理中，这属于哪个知识点？

在当前含有事务方法内部调用其他的方法(无论该方法是否含有事务)，这就属于Spring事务传播机制的知识点范畴了。

Spring事务基于Spring AOP，Spring AOP底层用的动态代理，动态代理有两种方式：

• 基于接口代理(JDK代理)

• 基于接口代理，凡是类的方法非public修饰，或者用了static关键字修饰，那这些方法都不能被Spring AOP增强

• 基于CGLib代理(子类代理)

• 基于子类代理，凡是类的方法使用了private、static、final修饰，那这些方法都不能被Spring AOP增强

至于为啥以上的情况不能增强，用你们的脑瓜子想一下就知道了。

值得说明的是：那些不能被Spring AOP增强的方法并不是不能在事务环境下工作了。只要它们被外层的事务方法调用了，由于Spring事务管理的传播级别，内部方法也可以工作在外部方法所启动的事务上下文中。

至于Spring事务传播机制的几个级别，我在这里就不贴出来了。这里只是再次解释“啥情况才是属于Spring事务传播机制的范畴”。

四、多线程问题

我们使用的框架可能是Hibernate/JPA或者是Mybatis，都知道的底层是需要一个session/connection对象来帮我们执行操作的。要保证事务的完整性，我们需要多组数据库操作要使用同一个session/connection对象，而我们又知道Spring IOC所管理的对象默认都是单例的，这为啥我们在使用的时候不会引发线程安全问题呢？内部Spring到底干了什么？

回想一下当年我们学Mybaits的时候，是怎么编写Session工具类？

没错，用的就是ThreadLocal，同样地，Spring也是用的ThreadLocal。

以下内容来源《精通 Spring4.x》

我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态的“状态性对象”采用ThreadLocal封装，让它们也成为线程安全的“状态性对象”，因此，有状态的Bean就能够以singleton的方式在多线程中工作。

我们可以试着点一下进去TransactionSynchronizationManager中看一下：

5. Was ist BPP?

Der vollständige Name von BBP lautet: BeanPostProcessor, allgemein bekannt als Objekt-Postprozessor

• Einfach ausgedrückt können unsere Objekte über BeanPostProcessor verarbeitet werden „Verarbeitung“.

Frühlingsbohnenmanagement (oder Bohnenlebenszyklus) ist ebenfalls ein Wissenspunkt, der oft getestet wird, und ich werde ihn neu organisieren in der Herbstrekrutierung Hier sind die Schritte, weil sie wichtiger sind, also werde ich sie hier posten:

1. ResouceLoader lädt die Konfigurationsinformationen

2. BeanDefintionReader analysiert die Konfigurationsinformationen und generiert eine nach der anderen BeanDefintion

3. BeanDefintion wird von BeanDefintionRegistry verwaltet

4. BeanFactoryPostProcessor verarbeitet die Konfigurationsinformationen (d. h , Verarbeitung von Konfigurationsinformationen, im Allgemeinen über PropertyPlaceholderConfigurer Zu implementieren)

5. Bean instanziieren

6. Wenn die Bean配置/实现instantiationAwareBean, rufen Sie die entsprechende Methode auf

7. Verwenden Sie BeanWarpper, um die Attributkonfiguration (Abhängigkeit) zwischen Objekten abzuschließen

8. Wenn die Bean配置/实现了Aware-Schnittstelle vorhanden ist, rufen Sie die entsprechende Methode auf

9. Wenn das Bean mit der before-Methode von BeanPostProcessor konfiguriert ist, dann rufen Sie

10. auf. Wenn das Bean mit init-method konfiguriert ist oder InstantiationBean implementiert, dann rufen Sie auf die entsprechende Methode

11. Wenn die Bean mit der After-Methode von BeanPostProcessor konfiguriert ist, rufen Sie

12. auf, um das Objekt in die HashMap

    einzufügen

13. Wenn schließlich die Methode destroy oder DisposibleBean konfiguriert ist, wird der Zerstörungsvorgang ausgeführt

Es gibt auch Bilder über BPP:

5.1 Warum speziell über BPP sprechen?

Die unterste Ebene der Spring AOP-Programmierung verwendet dynamische Proxy-Technologie, und beim Aufruf muss das Proxy-Objekt verwendet werden. Wie macht der Frühling das?

Ich muss nur ein BPP schreiben. In der postProcessBeforeInitialization- oder postProcessAfterInitialization-Methode beurteile ich das Objekt, um zu sehen, ob es eine Aspektlogik einbinden muss Dieses Proxy-Objekt zurückgeben und dann dieses Proxy-Objekt zurückgeben, dann ist das, was schließlich in den Container eingefügt wird, natürlich das Proxy-Objekt.

Spring stellt BeanPostProcessor zur Verfügung, mit dem wir die benötigten Objekte „verarbeiten “ können!

6. Verstehen Sie mehrere wichtige Schnittstellen von Spring-Transaktionen

Spring-Transaktionen können in zwei Typen unterteilt werden:

• Programmatische Transaktionen (durch Code) Zur Implementierung Transaktionen)

• Deklarative Transaktionen (um Transaktionen durch Konfiguration zu implementieren)

Programmatische Transaktionen sind in Spring relativ einfach zu implementieren, da deklarative Transaktionen a kapseln Bei vielen Dingen (im Allgemeinen verwenden wir sie einfach, aber alles darin ist sehr komplex) ist es viel schwieriger, deklarative Transaktionen zu implementieren.

In programmatischen Transaktionen gibt es die folgenden wichtigen Schnittstellen:

• Transaktionsdefinition: Definiert Spring-kompatible Transaktionsattribute (z. B. Isolationsstufe der Transaktion, Transaktion). Weitergabe, Transaktions-Timeout, schreibgeschützter Status)

• TransactionStatus: Stellt den spezifischen Laufstatus der Transaktion dar (erhält Informationen zum Ausführungsstatus der Transaktion, auch Sie können dies verwenden Schnittstelle zum indirekten Rollback von Transaktionen und anderen Vorgängen)

• PlatformTransactionManager: Transaktionsmanagerschnittstelle (definiert eine Reihe von Verhaltensweisen, und die spezifische Implementierung wird an verschiedene Persistenz-Frameworks übergeben zur Vervollständigung ---AnalogieJDBC)

In deklarativen Transaktionen gibt es zusätzlich zu den Schnittstellen TransactionStatus und PlatformTransactionManager Mehrere wichtige Schnittstellen:

• TransactionProxyFactoryBean: Proxy-Objekt generieren

• TransactionInterceptor: Objektabfang implementieren

• TransactionAttrubute: Transaktionskonfigurationsdaten

Das obige ist der detaillierte Inhalt vonEingehende Analyse von Spring-Transaktionen (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!