Warum CMT Begehen am Ausgang der EJB-Methode, bei der transaction-Attribut ist "Erforderlich"?

ERFORDERLICH sein kann, böse

Ich persönlich mag es nicht die gewünschte Transaktion Attribut, und würde dringend davon abgeraten, seine Verwendung.

Träge Transaktionen anlegen (das ist, was ERFORDERLICH macht), führt nicht wirklich zu wissen, Wann und wo eine Transaktion tatsächlich gestartet werden, und wenn es zu Begehen. Das ist nicht eine gute Sache. Die Menschen sollten explizit design-Transaktions-Grenzen.

OBLIGATORISCH und UserTransaction Seelenverwandte sind

Ihrem Wunsch, eine UserTransaction ist sehr gut und hat Arbeit mit CMT-da ist kein Unterschied zwischen einer JTA-Transaktion gestartet wurde über die UserTransaction durch den mitgelieferten Behälter oder eine JTA-Transaktion gestartet, die für Sie durch den container.

Den Ansatz, den ich empfehlen würde, ist die Umstellung aller ERFORDERLICHEN Nutzung zu ZWINGEND. Mit VERBINDLICHEN der container wird nicht starten Transaktionen für Sie. Stattdessen wird es schützen Sie Ihr bean, indem sichergestellt wird es nicht aufgerufen werden, es sei denn, eine Transaktion ausgeführt wird. Dies ist eine erstaunliche und selten genutzter Funktion. OBLIGATORISCH ist der beste Freund eines jeden, der will zur Schaffung eines wirklich deterministischen Transaktions-app und auch durchzusetzen. Mit diesem setup Sie könnten fallen in der Liebe mit CMT.

In diesem Szenario Sie starten Sie die Transaktionen mit UserTransactions und dann den container ist wie Ihre große bodyguard treten die Menschen an den Straßenrand, es sei denn, Sie haben entsprechend begonnen, eine Transaktion, bevor Sie versuchen, aufrufen von code.

Überlegungen

• Einem Servlet oder einem BMT EJB kann ein UserTransaction.
• CMT Bohnen nicht verwenden können, eine UserTransaction, aber Sie können an einer Transaktion gestartet, indem eine UserTransaction (wie oben erwähnt, eine JTA-Transaktion ist eine JTA-Transaktion).
• BMT Bohnen nicht an eine bestehende Transaktion. Wenn Sie call a BMT-bean, während eine Transaktion ist bereits im Gange, der Abschluss der Transaktion wird ausgesetzt werden, indem die container vor Aufruf des BMT-Bohne, und wieder aufgenommen, nachdem die Methode abgeschlossen ist.
• @Resource UserTransaction erhalten Sie die Benutzer-Transaktion mittels Injektion
• java:comp/UserTransaction erhalten Sie die Benutzer-Transaktion, die über lookup -
• @TransactionAttribute(MANDATORY) verwendet, die auf Klassen-Ebene, beeinflussen die Methoden, die genaue Klasse (d.h. die fooClass.getDecaredMethods() Methoden). Methoden der super-Klassen und-Unterklassen, wird standardmäßig @TransactionAttribute(REQUIRED) es sei denn, diese Klassen sind explizit annotiert @TransactionAttribute(MANDATORY)
• Wenn Sie krank aufrufen userTransaction.begin() und userTransaction.commit() und dabei die zugehörige exception-handling, berücksichtigen @TransactionAttribute(REQUIRES_NEW). Ihre Transaktions-Grenzen werden weiterhin dokumentiert und explizit.
• RuntimeExceptions geworfen von einer Methode der CMT-bean wird der Transaktion verursacht werden, gekennzeichnet rollback, auch wenn Sie fangen und behandeln der Ausnahme in der aufrufenden code. Verwenden @ApplicationException deaktivieren Sie diese auf einer Fall-zu-Fall-basis für kundenspezifische runtime-exception-Klassen.

Verlieren Ihre Transaktion Kontext

Ein paar Dinge, die verursachen können Ihre in-progress-Transaktion zu beenden, auszusetzen oder anderweitig nicht weitergegeben an die aufgerufene bean.

• BMT Bohnen stop-transaction propagation. Wenn eine Transaktion im Gange ruft eine BMT-bean, dass die Transaktion ausgesetzt wird, bevor der BMT-bean aufgerufen wird, und wird fortgesetzt, nachdem die bean zurück. BMT-Bohnen, kann der Ursprung der Transaktionen kann aber nicht die Teilnahme an bestehenden Transaktionen. Wenn die Vermehrung ist auf mysteriöse Weise fehlschlägt, stellen Sie sicher, es gibt keine ungewollten Anrufe zu BMT Bohnen in der Mitte der Transaktion.
• Verwenden Sie nicht alles andere als ein container geliefert UserTransaction oder container geliefert Methoden wie SessionContext.setRollbackOnly, um Transaktionen zu verwalten. Die Verwendung von "resource-manager bestimmte Transaktion Abgrenzung API" wie JPA EntityTransaction oder java.sql.Connection.commit() wird umgehen, Transaktions-management.
• Nicht starten Sie Ihre eigenen threads. Transaction propagation geschieht auf einer pro-thread-basis. Es gibt keine standard-APIs in Java EE mit Unterstützung der Transaktion, die sich über mehrere threads. Wenn Sie verlassen den thread entweder starten Sie Ihren eigenen thread oder mit @Asynchronous Sie Ihre bestehenden Transaktion hinter sich.

NClark, sollten Sie den folgenden code lief ich auf GlassFish 3.1.1. Ich hoffe, es wird in irgendeiner Weise helfen 🙂

@Stateless
@TransactionManagement(TransactionManagementType.BEAN)
public class ReusingTransaction {

   //It's BMT - we can't control Tx through context - must use...
   @Resource
   SessionContext sctx;

   //... the UserTransaction instead.
   @Resource
   UserTransaction utx;

   //This CMT EJB will reuse BMT started transaction
   @EJB
   AnotherBean reuseTx;

   public void testMethod() throws Exception {
      //Begin Tx and check it's status - compare value with:
      //http://java.sun.com/javaee/6/docs/api/constant-values.html#javax.transaction.Status.STATUS_ACTIVE
      utx.begin();
      System.out.println("####testMethod#### Tx status: " + utx.getStatus());

      //Our BMT started a Tx - now invoke CMT and reuse this Tx
      //Notice: AnotherBean has MANDATORY Tx attribute, so if no Tx would
      //exist, the AnotherBean couldn't be even invoked.
      reuseTx.testIt();

      //Check if the CMT AnotherBean affected Tx we started. 
      System.out.println("####testMethod#### Tx status: " + utx.getStatus());

      //Just to prevent exceptions.
      utx.rollback();
   }

   //Implicitly CMT - must reuse the Tx
   @Stateless
   @TransactionAttribute(TransactionAttributeType.MANDATORY)
   public static class AnotherBean {

      //It's CMT, so Tx control is made through it's context.
      @Resource
      SessionContext sctx;

      //Can inject it, but cannot use it - will throw an Exception.
      @Resource
      UserTransaction utx;

      public void testIt() throws Exception {

         //Give a sign that rollback must be made.
         sctx.setRollbackOnly();
         System.out.println("####testIt#### Tx status: " + getTxStatus());
      }
   }

   //Small hack to get the status of current thread JTA Tx
   //http://java.sun.com/javaee/6/docs/api/javax/transaction/TransactionSynchronizationRegistry.html
   private static int getTxStatus() throws Exception {
      InitialContext ctx = new InitialContext();
      TransactionSynchronizationRegistry tsr = (TransactionSynchronizationRegistry)
                               ctx.lookup("java:comp/TransactionSynchronizationRegistry");

      return tsr.getTransactionStatus();
   }
}

Dieser EJB aufgerufen werden können, d.h. von Singleton EJB mit @Startup sofort zu sehen wie Ihr DA reagieren wird.

Auf Glassfish 3.1.1, Sie kommen mit dem folgenden Ergebnis:

INFO: ####testMethod#### Tx status: 0

INFO: ####testIt#### Tx status: 1

INFO: ####testMethod#### Tx status: 1

Prost!