Dieser Artikel untersucht hauptsächlich den relevanten Inhalt des Transaktionsmechanismus von Spring wie folgt.
In der Regel gibt es zwei Transaktionsstrategien: globale Transaktionen und lokale Transaktionen. Globale Transaktionen können mehrere Transaktionsressourcen (d. H. Datenquellen, typischerweise Datenbanken und Nachrichtenwarteschlangen) umfassen und in der Regel die Verwaltung von J2EE -Anwendungsservern erfordern, für die der JTA -Support des Servers ganz unten erforderlich ist. Lokale Transaktionen beziehen sich auf die Persistenz -Technologie, die von der zugrunde liegenden Schicht angewendet wird. Wenn die zugrunde liegende Ebene direkt JDBC verwendet, muss das Verbindungsobjekt verwendet werden, um die Transaktion zu betreiben. Wenn Hibernate Persistence -Technologie verwendet wird, müssen Sie das Sitzungsobjekt verwenden, um die Transaktion durchzuführen.
Im Allgemeinen ist der Programmierungsprozess unter Verwendung von JTA -Transaktionen, JDBC -Transaktionen und Hibernate -Transaktionen ungefähr wie folgt.
Wie aus der obigen Abbildung ersichtlich ist, muss der Programmcode unter Verwendung der herkömmlichen Transaktionsprogrammierung mit der API spezifischer Transaktionsrichtlinien gekoppelt werden. Wenn die Anwendung eine Strategie wechseln muss, bedeutet dies, dass der Code stark geändert werden muss. Wenn Sie jedoch Federtransaktionen verwenden, wird es kein Problem geben.
Sring liefert keine Transaktionsunterstützung, sondern ist nur für die Verpackung der zugrunde liegenden Transaktionen verantwortlich und bietet auf der Federebene eine einheitliche Programmierapi in die Außenwelt. Der Kern der Spring -Transaktion ist die PlatformTransactionManager -Schnittstelle.
PlatformTransactionManager stellt eine Transaktionsschnittstelle dar, die unabhängig vom spezifischen Typ ist und jede Transaktion darstellt, einschließlich JDBC -Transaktionen, Winterschlaftransaktionen und sogar JTA -Transaktionen.
Der Springa -Transaktionsmechanismus ist ein typisches politisches Modell. PlatformTransactionManager repräsentiert die Transaktionsverwaltungsschnittstelle, weiß jedoch nicht, wie Transaktionen verwaltet werden. Es erfordert nur das Transaktionsmanagement, drei Methoden bereitzustellen: Start der Transaktion getTransaction(), commit() und rollback() Die spezifische Implementierung bleibt jedoch seiner Implementierungsklasse abgeschlossen. Programmierer müssen den Transaktionstyp in der Konfigurationsdatei nur gemäß dem verwendeten Transaktionstyp konfigurieren. Die zugrunde liegende Feder verwendet automatisch die spezifische Transaktions -Implementierungsklasse, um Transaktionsvorgänge durchzuführen. Für Programmierer müssen sie sich überhaupt nicht um den zugrunde liegenden Prozess kümmern, sondern nur für die PlatformTransactionManager -Schnittstelle programmieren. Die PlatformTransactionManager -Schnittstelle bietet die folgenden Methoden: getTransaction(..), commit(); rollback(); Dies sind alle Transaktionsvorgänge, die nicht mit der Plattform zusammenhängen.
Das vollständige Schreiben von getTransaction() ist TransactionStatus getTransaction(TransactionDefinition definiton)
Diese Methode wird verwendet, um ein Transaktionsobjekt zurückzugeben, und die Parameter -Transaktionsdefinition kann verschiedene Attribute für das Transaktionsobjekt angeben. Normalerweise kann es die Isolationsattribute der Transaktion, der Ausbreitungsattribute, der Zeitüberschreitung und des Lesens dieser Attribute angeben.
Für die spezifische Transaktionsverwaltung von Spring muss der PlatformTransactionManager in der Konfigurationsdatei konfiguriert werden. Das Folgende ist die Federkonfiguration, die verschiedenen Transaktionsarten entspricht.
Die Konfiguration des lokalen Transaktionsmanagers der JDBC -Datenquelle lautet wie folgt:
<!-Definieren Sie die Datenquellenbean, verwenden Sie die C3P0-Datenquelle, um sie zu implementieren und die erforderlichen Informationen der Datenquelle zu injizieren-> <bean id = "dataSource" -Method = "Schließen" P: DriverClass = "com.mysql.jdbc.driver" p: jdbcurl = "jdbc: mysql:///locl." P: maxpoolsize = "40" P: minpoolsize = "2" P: initialpoolsize = "2" P: maxidletime = "30" /> <!-Konfigurieren Sie den lokalen Datenmanager für JDBC-Datenquelle, verwenden Sie die DataSourcetRansactionManager-Klasse von DataSourcetRansaction-> <bean id = "transactionManager"
Die Konfiguration des JTA Global Transaction Managers für die Containerverwaltung ist wie folgt:
<bean id="dataSource" p:jndiName="jdbc/jpetstore" /><!-- Using the JtaTransactionManager class, this class implements the PlatformTransactionManager interface-><!-- Using JTA global transactions, Spring containers can obtain transactional resources from the Java EE server by themselves without dependency injection--><bean id="transactionManager" />
Für JTA Global Transactions müssen Sie nur die Implementierungsklasse des Transaktionsmanagers angeben. Der Spring Container erhält die Datenquelle von dem J2EE -Server selbst ohne explizite Einspritzung in den Transaktionsmanager.
Die auf der Hibernate Persistence -Technologie basierende lokale Transaktionskonfiguration ist wie folgt.
<!-Definieren Sie die Datenquellenbean, verwenden Sie die C3P0-Datenquelle, um sie zu implementieren und die erforderlichen Informationen der Datenquelle zu injizieren-> <bean id = "dataSource" -Method = "Schließen" P: DriverClass = "com.mysql.jdbc.driver" p: jdbcurl = "jdbc: mysql:///locl." P: maxpoolsize = "40" P: minpoolsize = "2" P: initialpoolsize = "2" p: maxidletime = "30" /> <!-Definieren Sie die Sitzung von Hibernate. InnotatedClasses wird verwendet, um alle persistenten Klassen aufzulisten-> <Eigenschaft name = "AnnotatedClasses"> <list> <!-Folgendes wird verwendet, um alle PO-Klassen aufzulisten. Hibernate-> <prop key = "hibernate.dialect"> org.hibernate.dialect Der lokale Datenmanager von Hibernate Die HibernatetransactionManager-Klasse-> <!-Diese Klasse ist eine spezifische Implementierung der PlatformTransactionManager-Schnittstelle für Hibernate-> <!-Konfigurieren von hibernatetransactionManager erfordert SessionFactory-> <bean id = "transactionManager" p: sessions-ref = "SessionFactory" / /> / /> / /> / /> / /> / /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> " />" /> ".
Wenn Spring -Transaktionen die Hibernate -Richtlinie anwenden, sind im Allgemeinen drei Punkte erforderlich, um: Datenquelle, SessionFactory und Transaction Manager zu konfigurieren.
Wenn die zugrunde liegende Ebene die Hibernate Persistence Layer -Technologie und die Transaktion JTA Global Transaction verwendet, lautet die Konfiguration wie folgt:
<!-Konfigurieren Sie JTA-Datenquelle-> <bean id = "dataSource" p: jndiname = "jdbc /jpetstore" /> <!-Hibernate SessionFactory Definieren. SessionFactory muss sich auf die Datenquelle verlassen und DataSource injizieren-> <bean id = "sessionfactory" p: dataSource-ref = "dataSource"> <!-AnnotatedClasses werden verwendet, um alle persistenten Klassen aufzulisten. </list> </property> <!-Definieren Sie die SessionFactory-Eigenschaft von Hibernate-> <Property name = "hibernateProperties"> <props> <!-den Verbindungsdialekt von hibernate-> <prop key = "hibernate.dialect"> org. Hibernate-Mapping-Tabellen-> <Prop Key = "hibernate.hbm2ddl.auto"> update </prop> </props> </property> </bean> <!
Im Vergleich zur vorherigen Hibernate-basierten Spring-Transaktion wird die Datenquelle durch eine JNDI-Datenquelle ersetzt und den Transaktionsmanager durch einen JTatRansactionManager ersetzen.
Für JTA Global Transactions, da die Unterstützung des zugrunde liegenden Anwendungsservers erforderlich ist, können möglicherweise Unterschiede in den Details zwischen JTA Global Transactions von verschiedenen Anwendungsservern vorliegen. Wenn Sie den globalen Transaktionsmanager tatsächlich konfigurieren, müssen Sie daher möglicherweise Unterklassen von JtatransactionManager wie OC4JjTatransactionManager verwenden, das von Oracels Javaee Application Server bereitgestellt wurde, weblogicjtatransactionManager von Oracle für Weblogic, WebSphereuowtransactionManager, die von Ibmphere für Webphere usw. zur Verfügung gestellt wurde, usw.
Aus der Federkonfiguration verschiedener Transaktionstypen oben ist ersichtlich, dass die Anwendung bei einer Anwendung die Spring -Transaktions -Verwaltung nicht mit der spezifischen Transaktions -API gekoppelt werden muss. Die Anwendung muss nur an die PlatormTransactionManager -Schnittstelle programmiert werden. Der ApplicationContext wählt die entsprechende Transaktionsrichtlinie -Implementierungsklasse (d. H. Die Implementierungsklasse des PlatormtransactionManagers) basierend auf der Konfigurationsdatei aus.
Im Detail, wie die Programmierung der Transaktionskontrolle im Frühjahr durchführt, gibt es normalerweise zwei Möglichkeiten.
Programmiertransaktionsmanagement: Es wird die drei von PlatormTransactionManager bereitgestellten drei abstrakten Methoden zur Steuerung des Transaktionsflusss im Code direkt verwendet. Sie können auch eine Bohne mit PlatormtransactionManager im Federbehälter erhalten. Diese Bohne ist immer eine Instanz der spezifischen Implementierungsklasse des PlatormtransactionManagers. Die spezifische Implementierungsklasse wird vom ApplicationContext gemäß dem Richtlinienmuster ausgewählt. Programmierer müssen sich nicht darum kümmern, sie müssen nur interface orientiert programmieren.
Deklarativer Transaktionsmanagement: Diese Methode erfordert nicht, dass der Transaktionskontrollprozess in den Code geschrieben wird, sondern verwendet AOP, um die Transaktionseinbindung vollständig über Konfigurationsdateien abzuschließen. Das heißt, XML -Konfigurationsdateien können Transaktionsagenten für Geschäftskomponenten konfigurieren, und Transaktionsagenten bieten Transaktionskontrolle für Geschäftskomponenten. Jetzt ist diese Methode die beste, mit dem niedrigsten Quellcode -Eindringen.
Bei Verwendung deklarativer Transaktionen müssen Sie nur eine Konfigurationsdatei schreiben und die Typen von Komponenten konfigurieren, die eine Transaktionsregelung erfordern. Die Geschäftskomponenten werden im Rahmen des AOP -Mechanismus in die Transaktionskontrolle eingewebt, und Programmierer müssen keinen Transaktionsmanagementcode schreiben und können sich auf die Entwicklung von Geschäftskomponenten konzentrieren. Daher wird im Allgemeinen ein deklaratives Transaktionsmanagement empfohlen.
Die XML -Schema -Methode von Spring bietet eine Concise Transaktionskonfigurationsstrategie. Es konfiguriert eine Transaktionsverbesserungsverarbeitung über den Namespace <tx:advice> , wobei verschiedene Attribute der Transaktion angegeben werden können (z. B. Isolations-Attribute, Ausbreitungszuordnungen, Zeitüberschreitungen, nur schreibgeschützte Attribute usw.), und dann kann die Transaktionsverbesserung an das Einstiegspunkt des AOP (d. H. Die Ausführungsmethode der Bean-Methode der Bean-Methode des Ausführungsverfahrens. Hier finden Sie ein einfaches Beispiel: Konfigurieren einer NewsDaOImpl -Bean für Datenoperationen, unter Verwendung der C3P0 -Datenquelle, dem JDBC -Transaktionsmanager von Spring und der Festlegung von Eigenschaften für Transaktionen in <TX: Ratschläge.
Die vollständige Federkonfiguration lautet wie folgt:
<? xmlns: p = "http://www.springframework.org/schema/p" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.spingrameWramework XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springFramework.org/schema/tx/sping-tx- Bean, verwenden Sie die C3P0-Datenquelle, um sie zu implementieren, und injizieren Sie die erforderlichen Informationen der Datenquelle-> <bean id = "dataSource" Destroy-Methode = "Close" p: driverClass = "com.mysql.jdbc.driver" p: jdbcurl = "jdbc: mySQL: ///. //. //. //. ///. //. ///LOWS- //FRIVE/test/test? p: user = "root" p: passwart = "" P: maxpoolsize = "40" P: minpoolsize = "2" P: initialpoolsize = "2" p: maxidletime = "30" /> <!-Konfigurieren Sie den lokalen Datenmanager von JDBC Data Source, verwenden die DataSourcetransactaRce-DataSources-DataSources-DataSources-class-> <Bean id = "-Bean id =". /> <!-Konfigurieren Sie eine Business Logic Bean-> <bean id = "newsdao" p: ds-ref = "dataSource" /> <!-Konfigurieren Sie die Verarbeitung der Transaktionsverbesserung, Geben Sie Transaktionsmanager an-> <tx: Beratung ID = "TxAdvice" Transaction-Manager = "transactionManager"> <!-verwendet, um mit dem zu konfigurierten Detaildetails zu konfigurieren. sind nur schreibgeschützt-> <tx: method name = "get*" schreibgeschützt = "true" /> <! Ausführung aller Methoden in allen Impl-End-Klassen unter dem Impl-Paket-> <AOP: Pointcut Expression = "Ausführung (*com.dao.impl.*Impl. <!-Konfigurieren Sie einen weiteren Einstiegspunkt, um die Ausführung aller Methoden in der Klasse zu entsprechen.
Im NewsDaoImpl -Code soll doppelte Daten in die Tabelle eingefügt werden.
Paket com.dao.impl; import javax.sql.dataSource; import org.springframework.jdbc.core.jdbctemplate; com.dao.newsdao; Public Class NewsdaoImpl implements Newsdao {private datas tatas uw; public void setdds (datasource) {thsource ds; void Insert (String -Titel, String -Inhalt) {// Verwendung von C3P0 Datenpool jdbctemplate jt = new Jdbctemplate (ds); Der erste Datensatz kann eingefügt werden // Wenn die Transaktionskontrolle hinzugefügt wird, wird der erste Datensatz nicht eingefügt}}Hier ist die Testmethode.
public static void test3 () {applicationContext ctx = new classPathXmlApplicationContext ("beans4jdbc.xml"); // Holen Sie sich den Transaktionsagenten Bean Newsdao dao = (NewsDao) ctx.getbean ("NewsDao", NewsDao.Class); Dao.insert ("Kernidee der Java -Programmierung", "Leichtes Java ee -Entwicklung"); System.out.println ("Ausführung abgeschlossen"); }Durch die Ausführung der Testmethode wird festgestellt, dass eine Ausnahme (aufgrund doppelter Daten) ausgelöst wird und aufgrund der Transaktionskontrolle keine Dateninsertion in der Datenbank vorliegt.
Wie Sie im obigen Beispiel sehen können, wird normalerweise in der XML -Schema -Konfiguration eine AOP -Konfiguration für eine gewöhnliche Bohne durchgeführt, und eine Beratungsverstärkung wird integriert. Die Beratungsverbesserung ist mit einem Transaktionsmanager konfiguriert, der auf der Datenquelle beruht.
Für <AOP: Advisor> erfolgt die Bindung von Ratschlägen und Einstiegspunkten vom Bean -Postprozessor am Ende des Frühlings (z.
Darüber hinaus können Sie im <TX: Ratschläge> Konfigurationsverbesserung auch angeben, dass bei der Aufnahme einer bestimmten Ausnahme Rollback und erzwingen, nicht Rollback, dh Rollback-for = "xxxexception", no-rollback-for = "xxxxexception" ".
Zusätzlich zur Verwendung von XML -Schema -Methoden können Sie der Methode auch direkt @Transaction -Annotation hinzufügen, um diese Methode transaktionsübergreifende Eigenschaften zu erstellen. In @Transaction können verschiedene Eigenschaften für Transaktionen konfiguriert werden (wie Isolationseigenschaften, Ausbreitungseigenschaften, Zeitüberschreitungen, schreibgeschützte Eigenschaften usw.). Darüber hinaus ist es erforderlich, der XML-Konfiguration eine <tx: Annotation-transportierte Konfiguration hinzuzufügen, wodurch die Feder den Transaktionsagenten gemäß der Annotation konfiguriert, sodass die Eigenschaftskonfiguration der Transaktion und die AOP-Schneidungskonfiguration in nur einem Schritt (direkt über die Annotationskonfiguration auf dem Method-Name) vervollständigt werden kann.
<tx: Annotationsgetriebene Transaktionsmanager = "TransactionManager" />
NewsdaoImpl.
@Transactional (Propagation = Propagation.Required, Isolation = Isolation.Default, Timeout = 5) @Overridepublic void Insert (String -Titel, String -Inhalt) {Das obige ist der gesamte Inhalt dieses Artikels über den Beispielcode des Transaktionsmechanismus von Spring's Transaction Mechanismus, und ich hoffe, dass dies für alle hilfreich sein wird. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!