Frühlingstransaktions-Rollback

1. Aufgetretene Probleme

Wenn wir mehrere Datenbankspeichervorgänge in einer Methode durchführen, tritt im mittleren Datenbankvorgang ein Fehler auf. Der Pseudocode lautet wie folgt:

public method() {
    Dao1.save(Person1);
    Dao1.save(Person2);

    Dao1.save(Person2);//假如这句发生了错误，前面的两个对象会被保存到数据库中
    Dao1.save(Person2);
}

　　期待的情况：发生错误之前的所有数据库保存操作都回滚，即不保存
　　正常情况：前面的数据库操作会被执行，而发生数据库操作错误开始及之后的所有的数据保存操作都将失败。这样子应该都不是我们要的结果吧。
　　当遇到这种情况，我们就可以使用Spring的事务解决这个问题。
2、异常的一些基本知识
1) 异常的架构
　　异常的继承结构：Throwable为基类，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception。Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。

2) Fehlerausnahme

Fehler weist darauf hin, dass während des Fehlers ein sehr schwerwiegender und nicht behebbarer Fehler aufgetreten ist Beim Ausführen des Programms kann die Anwendung in diesem Fall nur gestoppt werden, da beispielsweise ein Fehler in der virtuellen JAVA-Maschine auftritt. Fehler ist eine ungeprüfte Ausnahme. Der Compiler prüft nicht, ob der Fehler behandelt wurde, und es besteht keine Notwendigkeit, Ausnahmen vom Typ Fehler im Programm abzufangen. Unter normalen Umständen sollten in Programmen keine Ausnahmen vom Typ Fehler ausgelöst werden.

3) RuntimeException

Ausnahme umfasst RuntimeException und andere Nicht-RuntimeException-Ausnahmen.
RuntimeException ist eine ungeprüfte Ausnahme, was bedeutet, dass der Compiler nicht prüft, ob das Programm RuntimeException verarbeitet. Es besteht keine Notwendigkeit, Ausnahmen vom Typ RuntimException im Programm abzufangen, und es besteht keine Notwendigkeit, die RuntimeException-Klasse in zu deklarieren Methodenkörper. Wenn eine RuntimeException auftritt, bedeutet dies, dass im Programm ein Programmierfehler aufgetreten ist. Daher sollte der Fehler gefunden und das Programm geändert werden, anstatt die RuntimeException abzufangen.

4) Geprüfte Ausnahme

Geprüfte Ausnahme, die auch die am häufigsten verwendete Ausnahme in der Programmierung ist. Alle Ausnahmen, die von Exception erben und keine RuntimeException sind, sind geprüfte Ausnahmen im Bild oben und ClassNotFoundException. Die JAVA-Sprache schreibt vor, dass die geprüfte Ausnahme verarbeitet werden muss und entweder eine geprüfte Ausnahme im Methodenkörper deklariert oder eine Catch-Anweisung verwendet, um die geprüfte Ausnahme zur Verarbeitung zu erfassen.

3. Beispiel

Die hier verwendete Transaktionskonfiguration lautet wie folgt:

<!-- Jpa 事务配置 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    
    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

In der Spring-Konfigurationsdatei, wenn das defaultAutoCommit der Datenquelle auf True gesetzt ist , dann die Methode Wenn Sie die Ausnahme selbst abfangen, wird die Transaktion nicht zurückgesetzt. Wenn Sie die Ausnahme nicht selbst abfangen, wird die Transaktion beispielsweise zurückgesetzt in der Konfigurationsdatei

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> 

<property name="xxx" value="xxx"/> 

<property name="xxx" value="xxx"/>

 ....
 <property name="defaultAutoCommit" value="true" /> 

</bean>

Vielleicht stellen Sie fest, dass Sie diesen Parameter nicht konfiguriert haben. Wird er nicht automatisch übermittelt? Die Antwort lautet „Nein“. Ich verwende com.alibaba.druid.pool.DruidDataSource Datenbankverbindungspool. Der Standardwert „DefaultAutoCommit“ ist „true“, was in Ordnung ist.

Dann gibt es jetzt zwei Situationen

Situation 1: Wenn die Ausnahme wird nicht manuell im Programm abgefangen

@Transactional(rollbackOn = { Exception.class })  
public void test() throws Exception {  
     doDbStuff1();  
     doDbStuff2();//假如这个操作数据库的方法会抛出异常，现在方法doDbStuff1()对数据库的操作   会回滚。  }

Situation 2: Wenn wir die Ausnahme selbst im Programm abfangen

@Transactional(rollbackOn = { Exception.class })  
public void test() {  
     try {  
        doDbStuff1();  
        doDbStuff2();//假如这个操作数据库的方法会抛出异常，现在方法doDbStuff1()对数据库的操作  不会回滚。  
     } catch (Exception e) {  
           e.printStackTrace();     
     }  
}

Was ist nun, wenn wir die Ausnahme manuell abfangen müssen und dies auch wollen um ein Rollback durchführen zu können, wenn die Ausnahme ausgelöst wird?

Schreiben Sie es einfach so, um die Transaktion manuell rückgängig zu machen:

@Transactional(rollbackOn = { Exception.class })  
public void test() {  
     try {  
        doDbStuff1();  
        doDbStuff2();  
     } catch (Exception e) {  
          e.printStackTrace();     
          TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//就是这一句了，加上之后，如果doDbStuff2()抛了异常,                                                                                       //doDbStuff1()是会回滚的  
     }  
}