1. Wenn MyBatis allein verwendet wird, verwenden Sie SQLSession, um Transaktionen zu verarbeiten:
öffentliche Klasse myBatistxtest {private statische SQLSessionFactory SQLSessionFactory; privater statischer Leser -Leser; @BeForeClass public static void setupBeForeClass () löst Ausnahme aus {try {reader = ressourcen.getResourceAsReader ("configuration.xml"); SQLSessionFactory = new SQLSessionFactoryBuilder (). Build (Reader); } endlich {if (reader! = null) {reader.close (); }}} @Test public voidUstUlertxtest () {SQLSession Session = SQLSessionFactory.OpenSession (false); // Öffnen Sie die Sitzung und die Transaktion startet versuchen {iUSerMapper mapper = session.getMapper (iUserMapper.Class); User user = neuer user (9, "test transaction"); int betroffeneCount = mapper.updateuser (Benutzer); // Die Commit -Anweisung wurde aufgrund des nachfolgenden Ausnahme -Benutzer -Benutzers = neuer Benutzer (10, "kontinuierlich") nicht ausgeführt. INT betroffeneCount2 = mapper.updateuser (user2); // Die Commit -Anweisung int i = 2/0 wird aufgrund der nachfolgenden Ausnahme nicht ausgeführt. // Die Laufzeitausnahme wird Session.commit () ausgelöst; // Senden Sie die Sitzung, dh das Transaktionsausschuss} endlich {Session.close (); // Schließen Sie die Sitzung und veröffentlichen Ressourcen}}}
2. Verwenden Sie nach der Integration in die Spring das Transaktionsmanagement von Spring:
Einer der Hauptgründe für die Verwendung von MyBatis-Spring ist, dass MyBatis es ermöglicht, am Transaktionsmanagement von Spring teilzunehmen. Anstatt einen neuen spezifischen Transaktionsmanager für MyBatis zu erstellen, verwendet MyBatis-Spring den im Frühjahr vorhandenen DataSourcetRansactionManager.
Sobald der DataSourcetransactionManager konfiguriert ist, können Sie Transaktionen in Feder so konfigurieren, wie Sie es normalerweise tun. @Transactional Annotation und AOP -Stilkonfiguration werden unterstützt. Während der Transaktionsverarbeitung wird ein separates SQLSession -Objekt erstellt und verwendet. Wenn die Transaktion abgeschlossen ist, wird diese Sitzung auf die entsprechende Weise festgelegt oder zurückgerollt.
Sobald die Transaktion erstellt wurde, verwaltet MyBatis-Spring transparent Transaktionen. In Ihrem DAO- oder Service -Kurs sind keinen zusätzlichen Code erforderlich.
1. Standardkonfiguration
Um die Transaktionsverarbeitung von Spring zu aktivieren, erstellen Sie einfach ein DataSourcetRansActionManager -Objekt in der XML -Konfigurationsdatei von Spring:
<bean id = "transactionManager"> <Eigenschaft name = "dataSource" ref = "dataSource"/> </bean>
Die angegebene DataSource kann im Allgemeinen jede JDBC -Datenquelle sein, die Sie Spring verwenden. Dies schließt den Verbindungspool und die Datenquelle ein, die durch JNDI -Lookup erhalten wurde.
Beachten Sie, dass die für den Transaktionsmanager angegebene DataSource dieselbe Datenquelle wie die zum Erstellen der SQLSessionFactoryBean sein muss, andernfalls funktioniert der Transaktionsmanager nicht.
2. Transaktionen für Containerverwaltung
Wenn Sie einen JEE-Container verwenden und möchten, dass Spring an Transaktionen zur Containerverwaltung teilnimmt, sollte die Feder mit JTatransactionManager oder der Container-Specified Subclass konfiguriert werden. Der bequemste Weg, dies zu tun, besteht darin, den Transaktionsnamenspace von Spring zu verwenden:
<tx: jta-transaktionsmanager/>
In dieser Konfiguration entspricht MyBatis mit anderen Spring -Transaktionsressourcen, die durch Container -Management -Transaktionen konfiguriert sind. Die Spring verwendet automatisch alle vorhandenen Containertransaktionen und fügt eine SQLSession an sie an. Wenn die Transaktion nicht gestartet wird oder wenn die Transaktion erforderlich ist, ermöglicht die Feder einen neuen Container, Transaktionen zu verwalten.
Beachten Sie, dass Sie SQLSessionFactoryBean so konfigurieren müssen, dass Sie die Transaktionen mithilfe von Containern und nicht mit der Transaktionsmanagement von Spring verwalten möchten, um die grundlegende MyBatis ManagedTransactionFactory anstelle eines anderen Spring -Transaktionsmanagers zu verwenden:
<bean id = "
3. Programmiertransaktionsmanagement
MyBatis 'SQLSession bietet eine bestimmte Methode zur Behandlung programmatischer Transaktionen. Bei der Verwendung von MyBatis-Spring wird die Bean jedoch unter Verwendung von Feder verwaltet SQLSession oder Mapper injiziert. Das bedeutet, dass Feder normalerweise Transaktionen abwickelt. Sie können die Methoden von SQLSession.Commit (), SQLSession.rollback () oder SQLSession.close () auf den Spring-Managed SQLSession aufrufen. Wenn Sie dies tun, wird eine nicht unterstützte OperationException geworfen. Beachten Sie, dass diese Methoden bei der Verwendung injizierter Mapper nicht zugegriffen werden können. Unabhängig davon, ob die Verbindung auf automatisch eingestellt ist oder nicht, wird die Ausführung der SQLSession -Datenmethode oder eines Aufrufs der Mapper -Methode außerhalb der Spring -Transaktion automatisch begangen. Hier ist ein Beispiel für eine Programmiertransaktion:
DefaultTransactionDefinition def = new DefaultTransactionDefinition (); Def.SetPropagationBehavior (TransactionDefinition.Propagation_Required); TransactionStatus status = txManager.Gettransaction (DEF); Versuchen Sie {UsMapper.insertuser (Benutzer); } catch (myException ex) {throw ex; } TxManager.Commit (Status);4.@Transactional -Methode:
Erstellen Sie die Beans-da-tx.xml-Datei unter dem ClassPath und fügen Sie Transaktionskonfiguration basierend auf Beans-da.xml (Serie V) hinzu:
<!-- Transaction Manager--> <bean id="txManager" > <property name="dataSource" ref="dataSource" /> </bean> <!-- Transaction annotation driver, classes and methods marked @Transactional will be transactional--> <tx:annotation-driven transaction-manager="txManager" /> <bean id="userService" />
Servicekategorie:
@Service ("UserService") public class UserService {@autowired iUSerMapper Mapper; public int batchUpdateuserswhenException () {// Nicht-Transaktions-Benutzer = neuer Benutzer (9, "vor Ausnahme"); int betroffeneCount = mapper.updateuser (Benutzer); // Ausführung erfolgreicher Benutzer user2 = neuer Benutzer (10, "nach Ausnahme"); int i = 1/0; // Runtime -Ausnahme int AffectCount2 = mapPer.Updateuser (user2); // nicht ausgeführt if (betroffene } return 0; } @Transactional public int txUpdateuersWenException () {// Transactional user user = new user (9, "vor Ausnahme"); int betroffeneCount = mapper.updateuser (Benutzer); // Rollback aufgrund der nachfolgenden Ausnahme -Benutzer user2 = neuer Benutzer (10, "nach Ausnahme"); int i = 1/0; // eine Laufzeitausnahme und den Transaktionsrollback Int betroffeneCount2 = mappper.updateuser (user2) auswerfen; // nicht ausgeführt if (betroffene } return 0; }}In der Testklasse:
@Runwith (SpringJunit4ClASSRunner.class) @ContextConfiguration (SOPITATIONS = {"CLASSPATH: Beans-da-tx.xml"}) public class SpringIneInteGerTeTxtest {@Resource UserService UserService; @Test public void updateSerExceptionTest () {UserService.batchupdateuserswhenException (); } @Test public void txUpdateuersExceptionTest () {UserService.txUpDateuersWhenException (); }}
5. TransactionTemplate -Methode
Fügen Sie in beans-da-tx.xml hinzu:
<bean id = "txtemplate"> <constructor-arg type = "org.springframework.transaction.PlatformTransactionManager" Ref = "TransactionManager" /> < /bean>
Treten Sie der UserService -Klasse bei:
@Autowired (fordert = false) TransactionTemplate Txtemplate; public int txUpdateuserswhenExceptionviatxtemplate () {int retval = txtemplate.execute (neuer transactioncallback <GanzEger> () {@Override public Integer doIntransaction (TransactionStatus -Status) {// Transaktionsbetrieb Benutzer user = neuer Benutzer (9, "Vorher"). Nachfolgende Ausnahme user2 = neuer Benutzer (10, "nach Ausnahme"); return returnval; }In die SpringIneIntegrateTxtest -Klasse hinzufügen:
@Test public void updateSerswhenExceptionViatxtemPlateTest () {UserService.txUpdateuserswhenExceptionViatxtemplate (); //}HINWEIS: Ohne Werfen kann keine Ausnahme oder RunTimeException fangen:
@Transactional public int txUpdateuserswhenExceptionAndCatch () {// Transaktionsoperation, aber das periphere Rahmen kann die Ausnahme nicht erfassen und nicht einreichen, wenn die Ausführung korrekt ist. try {user user = new user (9, "vor Ausnahme"); int betroffeneCount = mapper.updateuser (Benutzer); // Ausführung war ein erfolgreicher Benutzer von Benutzer2 = neuer Benutzer (10, "nach Ausnahme"); int i = 1/0; // Runtime -Ausnahme int AffectCount2 = mapPer.Updateuser (user2); // nicht ausgeführt if (betroffene }} catch (Ausnahme e) {// Alle Ausnahmen werden gefangen, ohne E. printstacktrace () zu werfen; } return 0; }