public PlatformTransactionManager annotationDrivenTransactionManager() { JtaTransactionManager jtaTransactionManager = new JtaTransactionManager(); jtaTransactionManager.setTransactionManager(this.applicationContext.getBean(TransactionManagerImpl.class)); jtaTransactionManager.setUserTransaction(this.applicationContext.getBean(UserCompensableImpl.class)); SpringContextRegistry springContextRegistry = SpringContextRegistry.getInstance(); springContextRegistry.setApplicationContext(this.applicationContext); springContextRegistry.setBeanFactory(this.beanFactory); springContextRegistry.setTransactionManager(jtaTransactionManager); return springContextRegistry.getTransactionManager(); }
@Test public void serializable() throws Exception { UserTransaction ut1 = mock(UserTransaction.class); UserTransaction ut2 = mock(UserTransaction.class); TransactionManager tm = mock(TransactionManager.class); JtaTransactionManager jtam = new JtaTransactionManager(); jtam.setUserTransaction(ut1); jtam.setTransactionManager(tm); jtam.setRollbackOnCommitFailure(true); jtam.afterPropertiesSet(); SimpleNamingContextBuilder jndiEnv = SimpleNamingContextBuilder .emptyActivatedContextBuilder(); jndiEnv.bind(JtaTransactionManager.DEFAULT_USER_TRANSACTION_NAME, ut2); JtaTransactionManager serializedJtatm = (JtaTransactionManager) SerializationTestUtils .serializeAndDeserialize(jtam); // should do client-side lookup assertNotNull("Logger must survive serialization", serializedJtatm.logger); assertTrue("UserTransaction looked up on client", serializedJtatm .getUserTransaction() == ut2); assertNull("TransactionManager didn't survive", serializedJtatm .getTransactionManager()); assertEquals(true, serializedJtatm.isRollbackOnCommitFailure()); }
/** * This implementation returns a JtaTransactionObject instance for the * JTA UserTransaction. * <p>The UserTransaction object will either be looked up freshly for the * current transaction, or the cached one looked up at startup will be used. * The latter is the default: Most application servers use a shared singleton * UserTransaction that can be cached. Turn off the "cacheUserTransaction" * flag to enforce a fresh lookup for every transaction. * @see #setCacheUserTransaction */ @Override protected Object doGetTransaction() { UserTransaction ut = getUserTransaction(); if (ut == null) { throw new CannotCreateTransactionException("No JTA UserTransaction available - " + "programmatic PlatformTransactionManager.getTransaction usage not supported"); } if (!this.cacheUserTransaction) { ut = lookupUserTransaction( this.userTransactionName != null ? this.userTransactionName : DEFAULT_USER_TRANSACTION_NAME); } return doGetJtaTransaction(ut); }
if (jtaTm.getTransactionManager() == null) { throw new IllegalArgumentException( "Can only apply JtaTransactionManager which has a TransactionManager reference set"); new ConfigurableJtaPlatform(jtaTm.getTransactionManager(), jtaTm.getUserTransaction(), jtaTm.getTransactionSynchronizationRegistry()));
protected JtaTransactionManager newJtaTransactionManager(UserTransaction ut) { return new JtaTransactionManager(ut); }
@Bean public JtaTransactionManager transactionManager() { BitronixTransactionManager bitronixTransactionManager = jtaTransactionManager(); JtaTransactionManager transactionManager = new JtaTransactionManager(); transactionManager.setTransactionManager(bitronixTransactionManager); transactionManager.setUserTransaction(bitronixTransactionManager); transactionManager.setAllowCustomIsolationLevels(true); return transactionManager; }
JtaTransactionManager ptm = new JtaTransactionManager(); ptm.setUserTransactionName("jndi-ut"); ptm.setTransactionManagerName("jndi-tm"); ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate(); jndiTemplate.addObject("jndi-ut", ut); jndiTemplate.addObject("jndi-tm", tm); ptm.setJndiTemplate(jndiTemplate); ptm.afterPropertiesSet(); assertEquals(ut, ptm.getUserTransaction()); assertEquals(tm, ptm.getTransactionManager());
@Override protected TransactionManager locateTransactionManager() { return this.transactionManager.getTransactionManager(); }
JtaTransactionManager ptm = new JtaTransactionManager(); ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate(); if (defaultUt) { ptm.setJndiTemplate(jndiTemplate); ptm.afterPropertiesSet(); assertEquals(tm, ptm.getTransactionManager()); assertNull(ptm.getTransactionManager()); assertEquals(ut, ptm.getUserTransaction()); assertTrue(ptm.getUserTransaction() instanceof UserTransactionAdapter); UserTransactionAdapter uta = (UserTransactionAdapter) ptm.getUserTransaction(); assertEquals(tm, uta.getTransactionManager());
/** * Factory method that creates a {@link PlatformTransactionManager}. * * @return {@link PlatformTransactionManager} the created PlatformTransactionManager. */ public PlatformTransactionManager create() { JtaTransactionManager transactionManager; if (isBound(JBOSS_USER_TRANSACTION)) { transactionManager = new JtaTransactionManager(); transactionManager.setUserTransactionName(JBOSS_USER_TRANSACTION); transactionManager.setTransactionManagerName(JBOSS_TRANSACTION_MANANGER); transactionManager.setTransactionSynchronizationRegistryName(JBOSS_TRANSACTION_SYNC_REG); } else if (isBound(OSGI_TRANSACTION_MANAGER)) { transactionManager = new JtaTransactionManager((TransactionManager)lookupInJndi(OSGI_TRANSACTION_MANAGER)); } else if (isBound(JtaTransactionManager.DEFAULT_USER_TRANSACTION_NAME)) { transactionManager = new JtaTransactionManager(); transactionManager.setUserTransactionName(JtaTransactionManager.DEFAULT_USER_TRANSACTION_NAME); } else { throw CommonCamelMessages.MESSAGES.couldNotCreateAJtaTransactionManagerAsNoTransactionManagerWasFoundJBOSSUSERTRANSACTION( JBOSS_USER_TRANSACTION, OSGI_TRANSACTION_MANAGER, JtaTransactionManager.DEFAULT_USER_TRANSACTION_NAME); } // Initialize the transaction manager. transactionManager.afterPropertiesSet(); return transactionManager; }
given(ut2.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE); JtaTransactionManager ptm = new JtaTransactionManager(); ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut)); ptm.setCacheUserTransaction(false); ptm.afterPropertiesSet(); assertEquals(ut, ptm.getUserTransaction()); assertEquals(JtaTransactionManager.SYNCHRONIZATION_ALWAYS, ptm.getTransactionSynchronization()); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut2)); tt.execute(new TransactionCallbackWithoutResult() { @Override
dsToUse.afterPropertiesSet(); JtaTransactionManager ptm = new JtaTransactionManager(userTransaction); ptm.setAllowCustomIsolationLevels(true);
else if (getTransactionManager() != null) { Transaction transaction = getTransactionManager().getTransaction(); if (transaction == null) { throw new IllegalStateException("No JTA Transaction available"); "cannot register Spring after-completion callbacks with outer JTA transaction - " + "processing Spring after-completion callbacks with outcome status 'unknown'"); invokeAfterCompletion(synchronizations, TransactionSynchronization.STATUS_UNKNOWN);
if (this.jtaTransactionManager.getTransactionManager() != null && this.jtaTransactionManager.getUserTransaction() != null) { return bean; } else if (this.transactionManager == null) { this.beanList.add(bean); } else { this.jtaTransactionManager.setTransactionManager(this.transactionManager);
@Test public void jtaTransactionManagerWithRollbackAndCommit() throws Exception { UserTransaction ut = mock(UserTransaction.class); given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE); JtaTransactionManager ptm = newJtaTransactionManager(ut); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); TransactionStatus status = ptm.getTransaction(new DefaultTransactionDefinition()); assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); // first: rollback ptm.rollback(status); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); try { // second: commit attempt ptm.commit(status); fail("Should have thrown IllegalTransactionStateException"); } catch (IllegalTransactionStateException ex) { // expected } verify(ut).begin(); verify(ut).rollback(); }
if (jtaTm.getTransactionManager() == null) { throw new IllegalArgumentException( "Can only apply JtaTransactionManager which has a TransactionManager reference set"); new ConfigurableJtaPlatform(jtaTm.getTransactionManager(), jtaTm.getUserTransaction()));
tm.setFailEarlyOnGlobalRollbackOnly(true); TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition()); boolean outerTransactionBoundaryReached = false; try { tm.commit(ts); tm.rollback(ts);
@Override public void afterPropertiesSet() throws TransactionSystemException { super.afterPropertiesSet(); loadWebLogicTransactionClasses(); }
@Override protected UserTransaction locateUserTransaction() { return this.transactionManager.getUserTransaction(); }
@Test public void jtaTransactionManagerWithPropagationSupportsAndSynchronizationNever() throws Exception { UserTransaction ut = mock(UserTransaction.class); given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION); JtaTransactionManager ptm = newJtaTransactionManager(ut); TransactionTemplate tt = new TransactionTemplate(ptm); ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); ptm.afterPropertiesSet(); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); tt.execute(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); status.setRollbackOnly(); } }); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); }