Comment utiliser correctement TransactionManager autonome dans une application Web?

Question

Je voudrais écrire ma prochaine webapp Java en utilisant l'un des micro-cadres. Par exemple. Spark ou Jooby. Le problème est que les deux ne supportent pas JTA, donc j'ai besoin d'utiliser une des bibliothèques tierces. J'ai googlé pour les implémentations JTA open-source et en ai trouvé deux: Atomikos et Bitronix. Il semble que ce dernier projet soit légèrement abandonné alors j'ai décidé d'aller avec Atomikos. Malheureusement, la documentation est rare, donc je ne trouve pas de réponses à mes questions.

Voici le cas d'utilisation. Supposons que nous ayons deux classes DAO quelles méthodes doivent être exécutées sous transaction unique:

class SomeService { 

    // both injected by Guice 
    private FooDao fooDao; 
    private BarDao barDao; 

    public void someMethod() { 
     // both methods should be executed in a single transaction 
     fooDao.insert(new Foo()); 
     barDao.insert(new Bar()); 
    } 
} 

Je n'ai jamais utilisé javax.transaction API directement/manuellement avant (vous savez les transactions déclaratives sont très simples avec le printemps), donc je suis un peu confus. JTA fournit deux abstractions générales (UserTransaction et TransactionManager) et ils ont tous les deux des méthodes pour gérer la transaction JDBC. Autant que je comprenne TransactionManager exploite des objets UserTransaction en utilisant des variables ThreadLocal. Par conséquent UserTransaction doit être confiné au thread et TransactionManager supposé être thread-safe. Ai-je raison?

Donc il y a plusieurs approches possibles:

1. Je peux injecter TransactionManager dans mon service (via Guice) et l'utiliser directement.
2. Je peux partager TransactionManager via une variable statique publique.
3. Je peux créer un fournisseur/une fabrique UserTransaction (via Guice) et en obtenir des objets.

Quelle est la bonne/meilleure pratique? Une autre question si quelqu'un connaissant Atomikos est qu'il fournit deux implémentations de gestionnaire de transactions (peut-être même plus): J2eeTransactionManager et UserTransactionManager. Encore une fois, la documentation est trop rare, donc je ne vois aucune différence sauf JNDI. Je suppose que UserTransactionManager devrait être suffisant pour mes besoins, mais les états de description qui suit

J2eeTransactionManager

Une mise en œuvre de TransactionManager qui devrait être utilisé par des applications J2EE .

.. sans aucune explication.

ps. Désolé mon anglais n'est pas bien je le sais.

Answer 1

Ок, puisque personne ne m'a répondu, après avoir creusé dans le code source, je pense que je suis prêt à répondre à ma propre question:

1. Les deux Atomikos et Bitronix TMs mis en œuvre comme singletons [1], [2]
2. Atomikos et Bitronix TM sont compatibles avec les threads. En particulier, Atomikos utilise la synchronisation intrinsèque et Bitronix ne partage pas l'état entre les threads.
3. Les deux Atomikos et Bitronix TM implémenter les deux interfaces (oops) TransactionManager et UserTransaction de façon à ce que, fondamentalement, peu importe celle que vous utiliserez. Même si vous regardez la classe Atomikos UserTransactionImp, vous verrez qu'elle instancie et utilise en interne l'implémentation correspondante de TransactionManager.

Ainsi, il est possible d'avoir une seule instance TM-per-webapp, que vous pouvez partager comme vous le souhaitez. Depuis Atomikos TM supposed to be instantiated il est préférable de le partager via l'injection de dépendance. Bitronix TM peut être utilisé par public static method comme n'importe quel autre singleton.

De plus, vous pouvez gérer les transactions via JNDI. Vous pouvez trouver un exemple dans le code source Java Persistence avec Hibernate.