Transactions faciles avec Spring JDBC?

Je travaille sur une application Java qui utilise les classes Spring IoC et JDBC Template. J’ai une classe DAO qui a 4 méthodes: m1 () à m4 (). m1 effectue plusieurs insertions et mises à jour sur la table t1, m2 sur la table t2, m3 sur t3, etc.

Les méthodes DAO sont utilisées comme suit:

while(true) { //process & generate data dao.m1(data1); dao.m2(data2); dao.m3(data3); dao.m4(data4); //sleep }

Je veux que les opérations de firebase database sous les 4 appels de méthode consécutifs soient atomiques, que toutes les 4 tables soient mises à jour avec succès ou qu’aucune ne le soit. Donc, s’il y a une erreur lors de l’exécution d’opérations dans m3 (), je souhaite annuler toutes les modifications (mises à jour et insertions) effectuées en m2 & m1.

Alors, le spring vous permet-il de le faire de la manière suivante?

 while (true) { //process & generate data transaction = TransactionManager.createNewTransaction(); transaction.start() try { dao.m1(data1); dao.m2(data2); dao.m3(data3); dao.m4(data4); } catch(DbUpdateException e) { transaction.rollBack(); } transaction.end(); // sleep

}

ou y a-t-il de meilleures façons de le faire?

Pour être complet, la solution programmatique serait:

 private TransactionTemplate transactionTemplate; public setTransactionManager(PlatformTransactionManager transactionManager) { this.transactionTemplate = new TransactionTemplate(transactionManager); } ... while (true) { transactionTemplate.execute(new TransactionCallbackWithoutResult() { protected void doInTransactionWithoutResult(TransactionStatus status) { try { dao.m1(data1); dao.m2(data2); dao.m3(data3); dao.m4(data4); } catch(DbUpdateException e) { status.setRollbackOnly(); } } }); }

Yes Spring vous permet de contrôler par programme les transactions .

Personnellement, je préfère les transactions déclaratives utilisant des annotations, comme suit:

 public void runBatchJob() { while (true) { // generate work doWork(unitOfWork); } } @Transactional private void doWork(UnitOfWork work) { dao.m1(data1); dao.m2(data2); dao.m3(data3); dao.m4(data4); }

où les fonctions DAO sont définies:

 @Transactional public void m1(Data data) { ... }

Cela nécessite dans votre applicationContext.xml :

Les transactions déclaratives peuvent être déclarées comme nécessitant une transaction, nécessitant une nouvelle transaction, des transactions de support, etc. Une annulation a lieu lorsqu’un bloc annoté avec @Transactional lève une RuntimeException .

Oui, vous pouvez mettre ces appels dans une méthode et spécifier vos transactions de manière déclarative .

Vous n’avez pas besoin d’append ce code – Spring peut le faire pour vous.

Spring peut gérer tout cela pour vous en utilisant @Transactional comme expliqué ou en XML si vous préférez.

L’importation à obtenir est le type de propagation de transaction que vous voulez, qui dépend de votre application.

Par défaut, une transaction sera lancée s’il n’en existe pas et réutilisera une transaction existante si elle a déjà été démarrée. C’est le comportement que vous voulez si vous voulez que les 4 DAO soient atomiques.

Placez @Transactional sur une classe qui gérera les méthodes DAO appelées (MyService) – tout élément situé en dessous de cette couche fera désormais partie de cette limite de transaction.

c’est à dire:

 @Transactional public void m1(Data data) { ... } @Transactional public void m2(Data data) { ... }

Faire cela dans le code est complètement inutile.

Voir ici pour plus d’informations