Es gibt drei Arten von Java -Transaktionen: JDBC -Transaktion, JTA -Transaktion (JAVA -Transaktions -API) und Containertransaktion. Gemeinsame Containertransaktionen wie Federtransaktionen. Containertransaktionen werden hauptsächlich von J2EE -Anwendungsservern bereitgestellt. Die meisten Containertransaktionen werden basierend auf JTA abgeschlossen. Dies ist eine JNDI-basierte, recht komplexe API-Implementierung. Daher werden in diesem Artikel die Containertransaktionen vorerst nicht erörtert. In diesem Artikel wird hauptsächlich zwei relativ grundlegende Transaktionen in der J2EE -Entwicklung vorgestellt: JDBC -Transaktion und JTA -Transaktion.
JDBC -Transaktionen
Alle Verhaltensweisen, einschließlich Transaktionen von JDBC, basieren auf einer Verbindung, und das Transaktionsmanagement wird über das Verbindungsobjekt in JDBC durchgeführt. In JDBC sind häufig verwendete transaktionsbezogene Methoden: setAutocommit, Commit, Rollback usw.
Hier ist ein einfacher JDBC -Transaktionscode:
public void jdbctransfer () {java.sql.connection conn = null; try {conn = conn = driverManager.getConnection ("jdbc: oracle: dünn: @host: 1521: sid", "username", "userpwd"); // Setzen Sie das automatische Leitfaden auf False, // Wenn auf true festgelegt wird, erkennt die Datenbank jede Datenaktualisierung als Transaktion und sendet automatisch Conn.SetAutoCommit (False). STMT = Conn.CreateStatement (); // Reduzieren Sie den Betrag in Konto A um 500 STMT.Execute ("/ aktualisieren Sie T_ACCOUNT SET -Betrag = Betrag - 500 wobei Account_id = 'a'"); // den Betrag in Konto B um 500 stmt.execute erhöhen ("/ update t_account set set seng = polex + 500 wobei Account_id = 'B'"); // Transaktion Conn.Commit () einreichen; // Transaktionsausschuss: Der zweistufige Betrieb der Übertragung ist gleichzeitig erfolgreich} catch (SQLEXception SQLE) {try {// Eine Ausnahme kommt auf, rollback () in dieser Transaktion conn.rollback (); // Transaktionsrollback: Der zweistufige Betrieb der Übertragung revoke STMT.CLOSE () vollständig; conn.close (); } catch (Ausnahme ignorieren) {} sqle.printstacktrace (); }}Der obige Code implementiert eine einfache Übertragungsfunktion, die den Übertragungsvorgang durch Transaktionen steuert, entweder übermittelt oder zurückrollt.
Vor- und Nachteile von JDBC -Transaktionen
JDBC bietet die grundlegendste Unterstützung für Datenbanktransaktionsvorgänge mit Java. Durch JDBC -Transaktionen können wir mehrere SQL -Anweisungen in dieselbe Transaktion einfügen, um deren Säureeigenschaften zu gewährleisten. Der Hauptvorteil von JDBC -Transaktionen besteht darin, dass die API relativ einfach ist, die grundlegendsten Transaktionsvorgänge implementieren und die Leistung relativ gut ist.
JDBC -Transaktionen haben jedoch eine Einschränkung: Eine JDBC -Transaktion kann nicht mehrere Datenbanken umfassen! ! ! Wenn daher mehrere Datenbankvorgänge oder verteilte Szenarien beteiligt sind, sind JDBC -Transaktionen zwar untrenn.
JTA -Transaktionen
Warum JTA benötigt wird
Normalerweise können JDBC -Transaktionen Probleme wie die Datenkonsistenz lösen. Angesichts der Tatsache, dass seine Verwendung relativ einfach ist, wissen viele Menschen nur, dass es JDBC -Transaktionen über Transaktionen in Java gibt oder dass einige Leute über Transaktionen in Frameworks (wie Hibernate, Frühling) über Transaktionen Bescheid wissen. Da JDBC jedoch keine verteilten Transaktionen implementieren kann, und es mehr verteilte Szenarien gibt, die heute verteilte Szenarien entstehen, entstehen JTA -Transaktionen. JTA -Transaktionen entstehen jedoch.
Wenn Sie nicht auf Szenarien stoßen, dass JDBC -Transaktionen bei der Arbeit nicht gelöst werden können, können Sie nur sagen, dass die Projekte, die Sie durchführen, immer noch zu klein sind. Nehmen Sie als Beispiel E-Commerce-Websites. Wir teilen im Allgemeinen eine E-Commerce-Website horizontal in Produktmodule, Bestellmodule, Einkaufswagenmodule, Nachrichtenmodule, Zahlungsmodule usw. auf. Dann stellen wir verschiedene Module für verschiedene Maschinen bereit, und jedes Modul kommuniziert über Remote-Service-Anrufe (RPCs) und andere Methoden. Bereitstellung von Diensten für die Außenwelt mit einem verteilten System.
Ein Zahlungsvorgang muss mit mehreren Modulen interagieren, jedes Modul wird in einer anderen Maschine bereitgestellt und die von jedem Modul betriebenen Datenbanken sind inkonsistent. Zu diesem Zeitpunkt kann JDBC nicht zur Verwaltung von Transaktionen verwendet werden. Schauen wir uns einen Code an:
/ ** Zahlungsauftragsverarbeitung **/ @Transactional (rollbackfor = exception.class) public void CompleteOrder () {OrderDao.Update (); // Dienst vor lokaler Aktualisierung des Bestellstatus -Accountservice.Update (); // Rufen Sie den Fund -Account -Dienst an, um dem Fondskonto PointService.Update () Punkte hinzuzufügen. // Rufen Sie den Punktesdienst an, um dem Punkteskonto -Konto -AccountingService.insert () Punkte hinzuzufügen. // Rufen Sie den Buchhaltungsdienst an, um das Buchhaltungssystem zu schreiben. // Rufen Sie den Händler -Benachrichtigungsdienst an, um die Benachrichtigung der Zahlungsergebnis an den Händler zu senden.}Der obige Code ist ein einfacher Zahlungsvorgang, bei dem fünf Dienste aufgerufen werden, die alle über RPC aufgerufen werden. Wie kann ich mit JDBC die Transaktionskonsistenz sicherstellen? Ich habe der Methode die @Transactional -Annotation hinzugefügt, aber aufgrund der Verwendung eines verteilten Dienstes kann die Transaktion die Wirkung von Säure nicht erreichen.
JTA -Transaktionen sind leistungsfähiger als JDBC -Transaktionen. Eine JTA -Transaktion kann mehrere Teilnehmer haben, während eine JDBC -Transaktion auf eine einzelne Datenbankverbindung beschränkt ist. Komponenten einer der folgenden Java -Plattformen können an einer JTA -Transaktion teilnehmen: JDBC Connection, JDO PersistenCemanager -Objekt, JMS Queue, JMS -Thema, Enterprise JavaBeans (EJB) und ein mit der Spezifikation von J2EE Connector -Architektur zusammengestelltes Ressourcenallocator.
Definition von JTA
Java Transaction API (JTA) ist eine Java Enterprise -Version der Anwendungsprogrammschnittstelle. In der Java -Umgebung können verteilte Transaktionen über mehrere XA -Ressourcen hinweg abgeschlossen werden.
JTA und sein Landsmann Java Transaktionsdienst (JTS; Java TransactionService) bieten verteilte Transaktionsdienste für die J2EE -Plattform an. JTA bietet jedoch nur eine Schnittstelle und bietet keine spezifische Implementierung. Stattdessen wird der J2EE -Serveranbieter gemäß der JTS -Spezifikation bereitgestellt. Es gibt mehrere gemeinsame JTA -Implementierungen:
1. JTA -Implementierung (JBoss) von J2EE Container bereitgestellt
2. Unabhängige JTA -Implementierungen: wie JOTM, Atomikos. Diese Implementierungen können in Umgebungen verwendet werden, in denen keine J2EE -Anwendungsserver verwendet werden, um verteilte Transaktionsgarantien bereitzustellen. Wie Tomcat-, Steg- und gewöhnliche Java -Anwendungen.
JTA bietet java.transaction.usertransaction, die die folgenden Methoden definiert.
Hier ist erwähnenswert, dass gewöhnliche JDBC -Operationen direkt in JTA -Operationen umgewandelt werden können, ohne die UserTransaction zu verwenden. JTA hat Anforderungen an DataSource, Verbindung und Ressource. Nur Klassen, die der XA -Spezifikation entsprechen und die relevanten Schnittstellen der XA -Spezifikation implementieren, können an JTA -Transaktionen teilnehmen. In Bezug auf die XA -Spezifikation finden Sie in der entsprechenden Einführung in einem anderen Artikel in meinem Artikel. Lassen Sie mich hier erwähnen, dass aktuelle Mainstream -Datenbanken die XA -Spezifikation unterstützen.
Um JTA -Transaktionen zu verwenden, benötigen Sie einen JDBC -Treiber, der die javax.sql.xadatasource, javax.sql.xaconnection und javax.sql.xaresource -Schnittstellen implementiert. Ein Treiber, der diese Schnittstellen implementiert, kann an JTA -Transaktionen teilnehmen. Ein Xadatasource -Objekt ist eine Fabrik eines Xaconnection -Objekts. Xaconnection ist eine JDBC -Verbindung, die an JTA -Transaktionen teilnimmt.
Um JTA -Transaktionen zu verwenden, müssen Sie XadataSource verwenden, um die Datenbankverbindung zu generieren, und die resultierende Verbindung ist eine XA -Verbindung.
Die Differenz zwischen XA Connection (javax.sql.xaconnection) und Nicht-XA-Verbindung (java.sql.connection) ist, dass XA an JTA-Transaktionen teilnehmen kann und automatische Commits nicht unterstützt.
Beispielcode:
public void jtatransfer () {javax.transaction.usertransaction tx = null; java.sql.connection conn = null; try {tx = (javax.transaction.usertransaction) context.lookup ("java: comp/userTransaction"); // JTA -Transaktionen erhalten, in diesem Fall wird der JBOSS -Container von javax.sql.datasource ds = (javax.sql.datasource) context.lookup ("java:/xaoracleds") verwaltet; // Erhalten Sie den Datenbankverbindungspool, es muss eine Datenbank und einen Treiber geben, der XA unterstützt, der tx.begin () unterstützt. conn = ds.getConnection (); // Setzen Sie das automatische Leitfaden auf False, // Wenn auf true festgelegt wird, erkennt die Datenbank jede Datenaktualisierung als Transaktion und sendet automatisch Conn.SetAutoCommit (False). STMT = Conn.CreateStatement (); // den Betrag in Konto a um 500 STMT.Execute ("/ aktualisieren t_account set seng = Betrag - 500 wobei Account_id = 'a'"); // den Betrag in Konto B um 500 stmt.execute erhöhen ("/ update t_account set set seng = polex + 500 wobei Account_id = 'B'"); // den Betrag in Konto B um 500 stmt.execute erhöhen ("/ update t_account set set seng = polex + 500 wobei Account_id = 'B'"); // den Betrag in Konto B um 500 stmt.execute erhöhen ("/ update t_account set set seng = polex + 500 wobei Account_id = 'B'"); // Transaktion tx.commit () begehen; // Transaktionsausschreibung: Der zweistufige Betrieb der Übertragung ist gleichzeitig erfolgreich} catch (SQLEXception SQLE) {try {// Eine Ausnahme tritt auf, rollback () in dieser Transaktion; // Transaktionsrollback: Der zweistufige Betrieb der Übertragung wird vollständig widerrufen .CLOSE (); conn.close (); } catch (Ausnahme ignorieren) {} sqle.printstacktrace (); }} Das obige Beispiel ist ein Übertragungsvorgang mit JTA -Transaktionen. Diese Operation ist relativ vom J2EE -Container abhängig und erfordert, dass die UserTransaction und die Verbindung über JNDI erhalten werden.
Standardverteilte Transaktionen
Eine verteilte Transaktion umfasst einen Transaktionsmanager und einen oder mehrere Ressourcenmanager. Ein Ressourcenmanager ist ein anhaltender Datenspeicher jeglicher Art. Der Transaktionsleiter übernimmt die Verantwortung für die Kommunikation zwischen allen Transaktionsteilnehmern.
Schauen Sie sich die obige Einführung in verteilte Transaktionen an. Ist es ähnlich wie bei der Transaktionsmanagement in 2PC? 2PC ist jedoch tatsächlich eine Implementierungsmethode für einen Transaktionsmanager, der der XA -Spezifikation zur Koordinierung mehrerer Ressourcenmanager entspricht. Ich hatte schon einmal mehrere Artikel auf 2PC und 3PC. In diesen Artikeln habe ich eingeführt, wie der Transaktionsmanager in verteilten Transaktionen den einheitlichen Commit oder Rollback mehrerer Transaktionen koordiniert. Ich werde auch den Inhalt im Zusammenhang mit verteilten Transaktionen ausführlich einführen, einschließlich, aber nicht beschränkt auf globale Transaktionen, DTP -Modelle, flexible Transaktionen usw.
Vor- und Nachteile von JTA
Der Vorteil von JTA besteht darin, dass es eine verteilte Transaktionslösung und strenge Säure bietet. Das Standard -JTA -Transaktionsmanagement wird jedoch in der täglichen Entwicklung nicht häufig verwendet, da es viele Mängel aufweist:
Implementierungskomplex
Normalerweise muss JTA UserTransaction von JNDI erhalten werden. Dies bedeutet, dass wir, wenn wir JTA verwenden, sowohl JTA als auch JNDI verwenden müssen.
JTA selbst ist eine sperrige API.
Normalerweise kann JTA nur in Anwendungsserverumgebungen verwendet werden, sodass die Verwendung von JTA die Wiederverwendbarkeit des Codes einschränkt.
Zusammenfassen
Es gibt drei Arten von Java -Transaktionen: JDBC -Transaktion, JTA -Transaktion (JAVA -Transaktions -API) und Containertransaktion. Unter ihnen ist die Verwendung von JDBCs Transaktionsbetriebsanwendungen relativ einfach und für den Umgang mit den gleichen Datenquellen geeignet. JTA -Transaktionen sind relativ komplex und können verwendet werden, um Transaktionen über mehrere Datenbanken hinweg zu verarbeiten. Sie sind eine Lösung für verteilte Transaktionen.
Lassen Sie mich hier kurz darüber sprechen. Obwohl JTA -Transaktionen eine Reihe von APIs sind, die von Java für verteilte Transaktionen bereitgestellt werden, haben verschiedene J2EE -Plattformen unterschiedliche Implementierungen und sind nicht sehr bequem zu verwenden. Daher wird diese verantwortungsbewusstere API in Projekten im Allgemeinen nicht verwendet. Zu den verteilten Transaktionslösungen, die üblicherweise in der Branche verwendet werden, gehören jetzt asynchrone Nachrichtensicherung, TCC, maximale Aufwandbenachrichtigung usw.
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.