1. Was ist eine Java-Transaktion?
Das allgemeine Konzept ist, dass Transaktionen mit Datenbanken zusammenhängen. Eine Transaktion ist eine Abfolge von Vorgängen für den Zugriff auf die Datenbank. Das Datenbankanwendungssystem führt den Zugriff auf die Datenbank über Transaktionssätze durch. Die korrekte Ausführung von Transaktionen führt dazu, dass die Datenbank von einem Zustand in einen anderen übergeht.
Transaktionen müssen den von ISO/IEC festgelegten ACID-Grundsätzen entsprechen.
ACID ist die Abkürzung für Atomizität, Konsistenz, Isolation und Haltbarkeit. Transaktionen müssen den von ISO/IEC festgelegten ACID-Prinzipien entsprechen. ACID ist die Abkürzung für Atomizität, Konsistenz, Isolation und Haltbarkeit.
a. Atomizität
bedeutet, dass entweder alle Transaktionen ausgeführt werden oder keine. Wenn alle Untertransaktionen der Transaktion erfolgreich übermittelt wurden, werden alle Datenbankvorgänge übermittelt und der Datenbankstatus wird konvertiert. Wenn eine Untertransaktion fehlschlägt, werden die Datenbankvorgänge anderer Untertransaktionen zurückgesetzt, d. h. die Datenbank kehrt zu zurück der Zustand vor der Ausführung der Transaktion. Es findet kein Zustandsübergang statt.
b. Konsistenz
Die Ausführung einer Transaktion wandelt die Datenbank von einem korrekten Zustand in einen anderen korrekten Zustand um.
c. Isolation
Bevor die Transaktion korrekt festgeschrieben wird, dürfen Änderungen an den Daten durch die Transaktion keiner anderen Transaktion zur Verfügung gestellt werden, d. h. bevor die Transaktion korrekt festgeschrieben wird , seine möglichen Ergebnisse sollten bei keiner anderen Transaktion angezeigt werden.
d. Haltbarkeit
Nachdem eine Transaktion korrekt übermittelt wurde, werden ihre Ergebnisse dauerhaft in der Datenbank gespeichert. Auch wenn nach der Übermittlung der Transaktion weitere Fehler auftreten, werden die Verarbeitungsergebnisse der Transaktion gespeichert wird gespeichert.
Was ist eine Java-Transaktion, da das Konzept der Transaktion aus der Datenbank stammt? Was ist die Verbindung?
Wenn ein Java-Anwendungssystem eine Datenbank betreibt, wird diese tatsächlich über JDBC implementiert. Dann werden Hinzufügung, Änderung und Löschung alle indirekt über entsprechende Methoden implementiert, und die Steuerung von Transaktionen wird entsprechend auch auf den Java-Programmcode übertragen. Daher werden Datenbankoperationstransaktionen traditionell als Java-Transaktionen bezeichnet.
2. Warum Transaktionen benötigt werden
Ein einfacher Satz: Datenkonsistenz wahren.
3. Java-Transaktionstypen
Es gibt drei Arten von Java-Transaktionen: JDBC-Transaktionen, JTA-Transaktionen (Java Transaction API) und Containertransaktionen. Hier ist die einfachste Einführung. Abschließend stellen wir die Verwendung von JDBC-Transaktionen vor. Sie können die anderen beiden Typen selbst suchen und erlernen.
a. JDBC-Transaktion
JDBC-Transaktion wird durch das Verbindungsobjekt gesteuert. Die JDBC-Verbindungsschnittstelle (java.sql.Connection) bietet zwei Transaktionsmodi: automatische Übermittlung und manuelle Übermittlung. java.sql.Connection bietet die folgenden Methoden zur Steuerung von Transaktionen:
public void setAutoCommit(boolean) public boolean getAutoCommit() public void commit() public void rollback()
Bei Verwendung der JDBC-Transaktionsabgrenzung können Sie mehrere SQL-Anweisungen in einer einzigen Transaktion kombinieren. Ein Nachteil von JDBC-Transaktionen besteht darin, dass der Umfang der Transaktion auf eine Datenbankverbindung beschränkt ist. Eine JDBC-Transaktion kann nicht mehrere Datenbanken umfassen.
b. JTA (Java Transaction API)-Transaktion
JTA ist eine implementierte, protokollunabhängige API auf hoher Ebene. Anwendungen und Anwendungsserver können JTA verwenden, um auf Transaktionen zuzugreifen.
JTA ermöglicht Anwendungen die Durchführung verteilter Transaktionen – den Zugriff auf und die Aktualisierung von Daten auf zwei oder mehr Netzwerkcomputerressourcen, die über mehrere Datenbanken verteilt sein können. Die JTA-Unterstützung des JDBC-Treibers verbessert die Datenzugriffsmöglichkeiten erheblich.
Wenn Sie JTA zum Abgrenzen von Transaktionen verwenden möchten, benötigen Sie einen JDBC-Treiber, der die Schnittstellen javax.sql.XADataSource, javax.sql.XAConnection und javax.sql.XAResource implementiert.
Ein Treiber, der diese Schnittstellen implementiert, kann an JTA-Transaktionen teilnehmen. Ein XADataSource-Objekt ist eine Factory für XAConnection-Objekte. XAConnections sind JDBC-Verbindungen, die an JTA-Transaktionen teilnehmen, und Sie müssen die XADataSource mithilfe der Verwaltungstools des Anwendungsservers einrichten.
J2EE-Anwendungen verwenden JNDI, um Datenquellen abzufragen. Sobald die Anwendung das Datenquellenobjekt findet, ruft sie javax.sql.DataSource.getConnection() auf, um eine Verbindung zur Datenbank herzustellen.
XA-Verbindungen unterscheiden sich von Nicht-XA-Verbindungen. Es ist wichtig zu bedenken, dass XA-Verbindungen an JTA-Transaktionen beteiligt sind. Das bedeutet, dass XA-Verbindungen die Autocommit-Funktion von JDBC nicht unterstützen. Gleichzeitig dürfen Anwendungen nicht java.sql.Connection.commit() oder java.sql.Connection.rollback() für XA-Verbindungen aufrufen.
Stattdessen sollten Anwendungen UserTransaction.begin(), UserTransaction.commit() und serTransaction.rollback() verwenden.
c. Containertransaktionen
Containertransaktionen werden hauptsächlich von J2EE-Anwendungsservern bereitgestellt. Containertransaktionen werden größtenteils auf Basis von JTA durchgeführt, einer ziemlich komplexen API-Implementierung, die auf JNDI basiert. Im Vergleich zur Codierung zur Implementierung der JTA-Transaktionsverwaltung können wir dieselbe Funktion über den vom EJB-Container bereitgestellten Container-Transaktionsverwaltungsmechanismus (CMT) ausführen. Diese Funktion wird vom J2EE-Anwendungsserver bereitgestellt.
Dadurch können wir einfach angeben, welche Methode zur Transaktion hinzugefügt werden soll. Sobald der Container angegeben ist, ist er für Transaktionsverwaltungsaufgaben verantwortlich. Dies ist unsere Tiefbaulösung, denn auf diese Weise können wir Transaktionscode von der logischen Codierung ausschließen und gleichzeitig alle Schwierigkeiten dem J2EE-Container überlassen, ihn zu lösen.
使用EJB CMT的另外一个好处就是程序员无需关心JTA API的编码，不过，理论上我们必须使用EJB。
d、JDBC事务的使用
(1)步骤：
首先，设置事务的提交方式为非自动提交：conn.setAutoCommit(false);接下来，将需要添加事务的代码放入try，catch块中。
然后，在try块内添加事务的提交操作，表示操作无异常，提交事务：conn.commit();尤其不要忘记，在catch块内添加回滚事务，表示操作出现异常，撤销事务：conn.rollback();最后，设置事务提交方式为自动提交：conn.setAutoCommit(true);这样，通过简单的几步，我们就可以完成对事务处理的编写了。
(2)伪代码：
con = DriverManager.getConnection(url, user, password)；
String result = "";
String sql1 = "";
// LAST_INSERT_ID() 获取刚刚插入的自动递增的ID
String sql2 = "";
int flag;
try {
con.setAutoCommit(false);// 更改JDBC事务的默认提交方式
pstmt = con.prepareStatement(sql1);
flag = pstmt.executeUpdate();
if (flag > 0) {
pstmt = con.prepareStatement(sql2);
int i = pstmt.executeUpdate();
if (i > 0) {
con.commit();//提交JDBC事务
result = "add data success!!";
} else {
result = "add data fail!!";
}
} else {
result = "add data fail!!";
}
} catch (SQLException e) {
try {
con.rollback();//回滚JDBC事务
} catch (SQLException e1) {
// TODO Auto-generated catch block
result = "add data fail!! SQLException";
e1.printStackTrace();
}
result = "add data fail!! SQLException";
e.printStackTrace();
} finally {
try {
con.setAutoCommit(true); // 恢复JDBC事务的默认提交方式
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return result;4、三种事务差异
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。
3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用使用。
5、总结
事务控制是构建J2EE应用不可缺少的一部分，合理选择应用何种事务对整个应用系统来说至关重要。一般说来，在单个JDBC 连接连接的情况下可以选择JDBC事务，在跨多个连接或者数据库情况下，需要选择使用JTA事务，如果用到了EJB，则可以考虑使用EJB容器事务。
更多相关知识请关注java基础教程栏目
Das obige ist der detaillierte Inhalt vonTransaktionsverarbeitung in JAVA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
