1. Lorsque MyBatis est utilisé seul, utilisez SQLSession pour gérer les transactions:
classe publique MyBatistxTest {private statique sqlSessionFactory SqlSessionFactory; lecteur de lecteur statique privé; @BeForeclass public static void setupBeForClass () lève une exception {try {Reader = Resources.getResourCeasReader ("Configuration.xml"); sqlSessionFactory = new SqlSessionFactoryBuilder (). Build (lecteur); } enfin {if (reader! = null) {reader.close (); }}} @Test public void updateUsertXTest () {SqlSession Session = SqlSessionFactory.OpenSession (false); // Ouvrez la session et la transaction commence à essayer {iusermapper masper = session.getMapper (iusermapper.class); Utilisateur utilisateur = nouvel utilisateur (9, "transaction de test"); int affectCount = mapper.updateUser (utilisateur); // L'instruction Commit n'a pas été exécutée en raison de l'utilisateur d'exception ultérieur utilisateur = nouvel utilisateur (10, "Test Transaction en continu"); int affectCount2 = mapper.updateUser (user2); // L'instruction de validation int i = 2/0 n'est pas exécutée en raison de l'exception ultérieure; // L'exception d'exécution est déclenchée session.Commit (); // Soumettez la session, c'est-à-dire que la transaction valide} enfin {session.close (); // ferme la session et la libération de ressources}}}
2. Après avoir intégré à Spring, utilisez la gestion des transactions de Spring:
L'une des principales raisons de l'utilisation de MyBatis-Spring est qu'elle permet à MyBatis de participer à la gestion des transactions de Spring. Plutôt que de créer un nouveau gestionnaire de transactions spécifique pour MyBatis, MyBatis-Spring utilise le DataSourceTransactionManager qui existe au printemps.
Une fois que DataSourceTransactionManager est configuré, vous pouvez configurer les transactions à Spring comme vous le faites normalement. @Transactional Annotation et AOP Style Configuration sont pris en charge. Pendant le traitement des transactions, un objet SQLSession séparé sera créé et utilisé. Une fois la transaction terminée, cette session sera engagée ou annulée de la manière appropriée.
Une fois la transaction créée, MyBatis-Spring gérera de manière transparente les transactions. Il n'y a pas besoin de code supplémentaire dans votre classe DAO ou service.
1. Configuration standard
Pour activer le traitement des transactions de Spring, créez simplement un objet DataSourceTransactionManager dans le fichier de configuration XML de Spring:
<bean id = "TransactionManager"> <propriété name = "dataSource" ref = "dataSource" /> </bant>
La source de données spécifiée peut généralement être n'importe quelle source de données JDBC que vous utilisez Spring. Cela comprend le pool de connexions et la source de données obtenue via la recherche JNDI.
Notez que la source de données spécifiée pour le gestionnaire de transactions doit être la même source de données que celle utilisée pour créer le SQLSessionFactoryBean, sinon le gestionnaire de transactions ne fonctionnera pas.
2. Transactions de gestion des conteneurs
Si vous utilisez un conteneur JEE et que vous souhaitez que Spring participe aux transactions de gestion des conteneurs, Spring doit être configuré à l'aide de JTatransActionManager ou de sa sous-classe spécifiée par le conteneur. La façon la plus pratique de le faire est d'utiliser l'espace de noms de transaction de Spring:
<TX: JTA-Transaction-Manager />
Dans cette configuration, MyBatis sera le même que les autres ressources de transaction Spring configurées par les transactions de gestion des conteneurs. Spring utilisera automatiquement toutes les transactions de conteneurs existantes, en la fixant une SQLSession. Si la transaction n'est pas démarrée ou si la transaction est requise, Spring permettra à un nouveau conteneur de gérer les transactions.
Notez que si vous souhaitez gérer les transactions à l'aide de conteneurs et non de la gestion des transactions de Spring, vous devez configurer SQLSessionFactoryBean pour utiliser le MyBatis ManagedTransactionFactory de base au lieu de tout autre gestionnaire de transactions Spring:
<bean id = "sqlSessionFactory"> <propriété name = "dataSource" ref = "dataSource" /> <propriété name = "TransactionFactoryClass"> <value> org.apache.ibatis.transaction.managed.managedTransactionFactory "/> </ / Property> </ank
3. Gestion des transactions de programmation
SQLSession de MyBatis fournit une méthode spécifiée pour gérer les transactions programmatiques. Mais lorsque vous utilisez MyBatis-Spring, le haricot sera injecté à l'aide de SQLSession ou de mappeur géré par le ressort. Cela signifie que Spring gère généralement les transactions. Vous ne pouvez pas appeler le SQLSession.Commit (), SqlSession.Rollback (), ou SqlSession.Close () Méthodes sur SQLSession gérée par le printemps. Si vous faites cela, une conception non soutenue de l'Opération sera lancée. Notez que ces méthodes ne sont pas accessibles lors de l'utilisation de mappeurs injectés. Que la connexion soit définie sur AutoCommit ou non, l'exécution de la méthode des données SQLSession ou de tout appel à la méthode Mapper en dehors de la transaction Spring sera automatiquement engagée. Voici un exemple de transaction de programmation:
DefaultTransactionDefinition Def = new defaultTransactionDefinition (); def.setPropagationBeHavior (transactionDefinition.Propagation_Required); TransactionStatus Status = txManager.getTransaction (DEF); essayez {userMapper.Inserser (utilisateur); } catch (myException ex) {throw ex; } txManager.Commit (statut);4. @ Méthode transactionnelle:
Créez un fichier beans-da-tx.xml sous le chemin de classe et ajoutez une configuration de transaction basée sur beans-da.xml (série V):
<! - Transaction Manager -> <bean id = "txManager"> <propriété name = "dataSource" ref = "dataSource" /> </Ean> <! - Transaction annotation, classes et méthodes marqué @Transactional sera transactionnel -> <tx: annotation-drive transaction-manager = "txmanager" /> <ean id = "userson"
Catégorie de service:
@Service ("userService") classe publique UserService {@autowired iusemapper mappeur; public int batchupDateUsersWenexception () {// Utilisateur utilisateur non transactionnel = nouveau utilisateur (9, "avant exception"); int affectCount = mapper.updateUser (utilisateur); // exécution de l'utilisateur réussi User2 = nouvel utilisateur (10, "après exception"); int i = 1/0; // lance l'exception de runtime int affecteCount2 = mapper.updateUser (user2); // non exécuté if (affecteCount == 1 && affecteCount2 == 1) {return 1; } return 0; } @Transactional public int txupDateUsersWhenexception () {// transactionnel utilisateur utilisateur = new utilisateur (9, "avant exception"); int affectCount = mapper.updateUser (utilisateur); // Rollback en raison de l'exception ultérieure utilisateur utilisateur2 = nouvel utilisateur (10, "après exception"); int i = 1/0; // lance une exception d'exécution et le rollback de transaction int affecteCount2 = mappper.updateUser (user2); // non exécuté if (affecteCount == 1 && affecteCount2 == 1) {return 1; } return 0; }}Dans la classe de test:
@Runwith (springjunit4classrunner.class) @contextconfiguration (locations = {"classpath: beans-da-tx.xml"}) public class SpringIntegratetXTest {@Resource Userservice Userservice; @Test public void updateUsersExceptionTest () {userService.batchupDateusersWenexception (); } @Test public void txupDateUsersExceptionStest () {userService.txupDateusersWenexception (); }}
5. Méthode TransactionTemplate
Ajouter les haricots-da-px.xml:
<bean id = "txtemplate"> <constructor-arg type = "org.springframework.transaction.platformTransactionManager" ref = "TransactionManager" /> </bant>
Rejoignez la classe UserService:
@Autowired (required = false) transactionTemplate txTemplate; public int txupDateUsersWenexceptionViatXTemplate () {int retval = txtemplate.execute (new TransactionCallback <Integer> () {@Override public Integer doIntransaction (TransactionStatus Status) {// opération de transaction utilisateur utilisateur = nouvel utilisateur (9, "avant l'exception" Utilisateur User2 = NOUVEAU UTILISATION (après exception "); int i = 1/0; retour returnVal; }Ajouter à la classe SpringIntegrateTxTest:
@Test public void UpdateUsersWenexceptionViatXTemplatest () {userService.txupDateUsersWenexceptionViatXTemplate (); //}Remarque: Impossible de capturer l'exception ou RuntimeException sans lancer:
@Transactional public int txupDateUsersWhenexceptionAndCatch () {// Opération transactionnelle, mais le cadre périphérique ne peut pas attraper l'exception et le soumettre si l'exécution est correcte. essayez {utilisateur utilisateur = nouvel utilisateur (9, "avant exception"); int affectCount = mapper.updateUser (utilisateur); // L'exécution a été un utilisateur utilisateur réussi2 = nouvel utilisateur (10, "après exception"); int i = 1/0; // lance l'exception de runtime int affecteCount2 = mapper.updateUser (user2); // non exécuté if (affecteCount == 1 && affecteCount2 == 1) {return 1; }} catch (exception e) {// Toutes les exceptions sont capturées sans lancer e.printStackTrace (); } return 0; }