Java TransactionSynchronizationRegistry类代码示例

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
@Test
@DisplayName( "Connection outside the scope of a transaction test" )
public void connectionOutsideTransactionTest() throws SQLException {
    TransactionManager txManager = com.arjuna.ats.jta.TransactionManager.transactionManager();
    TransactionSynchronizationRegistry txSyncRegistry = new com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionSynchronizationRegistryImple();

    AgroalDataSourceConfigurationSupplier configurationSupplier = new AgroalDataSourceConfigurationSupplier()
            .connectionPoolConfiguration( cp -> cp
                    .transactionIntegration( new NarayanaTransactionIntegration( txManager, txSyncRegistry ) )
            );

    try ( AgroalDataSource dataSource = AgroalDataSource.from( configurationSupplier ) ) {
        Connection connection = dataSource.getConnection();
        logger.info( format( "Got connection {0}", connection ) );
        connection.close();
        assertTrue( connection.isClosed() );
    }
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
@Test
@DisplayName( "Basic rollback test" )
public void basicRollbackTest() throws SQLException {
    TransactionManager txManager = com.arjuna.ats.jta.TransactionManager.transactionManager();
    TransactionSynchronizationRegistry txSyncRegistry = new com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionSynchronizationRegistryImple();

    AgroalDataSourceConfigurationSupplier configurationSupplier = new AgroalDataSourceConfigurationSupplier()
            .connectionPoolConfiguration( cp -> cp
                    .transactionIntegration( new NarayanaTransactionIntegration( txManager, txSyncRegistry ) )
            );

    try ( AgroalDataSource dataSource = AgroalDataSource.from( configurationSupplier ) ) {
        txManager.begin();

        Connection connection = dataSource.getConnection();
        logger.info( format( "Got connection {0}", connection ) );

        txManager.rollback();

        assertTrue( connection.isClosed() );
    } catch ( NotSupportedException | SystemException e ) {
        fail( "Exception: " + e.getMessage() );
    }
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
@Test
@DisplayName( "Multiple close test" )
public void multipleCloseTest() throws SQLException {
    TransactionManager txManager = com.arjuna.ats.jta.TransactionManager.transactionManager();
    TransactionSynchronizationRegistry txSyncRegistry = new com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionSynchronizationRegistryImple();

    AgroalDataSourceConfigurationSupplier configurationSupplier = new AgroalDataSourceConfigurationSupplier()
            .connectionPoolConfiguration( cp -> cp
                    .transactionIntegration( new NarayanaTransactionIntegration( txManager, txSyncRegistry ) )
            );

    try ( AgroalDataSource dataSource = AgroalDataSource.from( configurationSupplier ) ) {

        // there is a call to connection#close in the try-with-resources block and another on the callback from the transaction#commit()
        try ( Connection connection = dataSource.getConnection() ) {
            logger.info( format( "Got connection {0}", connection ) );
            try {
                txManager.begin();
                txManager.commit();
            } catch ( NotSupportedException | SystemException | RollbackException | HeuristicMixedException | HeuristicRollbackException e ) {
                fail( "Exception: " + e.getMessage() );
            }
        }  
    }
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
@Test
public void testSetJtaTransactionManager() throws Exception {
	DataSource ds = mock(DataSource.class);
	TransactionManager tm = mock(TransactionManager.class);
	UserTransaction ut = mock(UserTransaction.class);
	TransactionSynchronizationRegistry tsr = mock(TransactionSynchronizationRegistry.class);
	JtaTransactionManager jtm = new JtaTransactionManager();
	jtm.setTransactionManager(tm);
	jtm.setUserTransaction(ut);
	jtm.setTransactionSynchronizationRegistry(tsr);
	LocalSessionFactoryBuilder lsfb = new LocalSessionFactoryBuilder(ds);
	lsfb.setJtaTransactionManager(jtm);
	Object jtaPlatform = lsfb.getProperties().get(AvailableSettings.JTA_PLATFORM);
	assertNotNull(jtaPlatform);
	assertSame(tm, jtaPlatform.getClass().getMethod("retrieveTransactionManager").invoke(jtaPlatform));
	assertSame(ut, jtaPlatform.getClass().getMethod("retrieveUserTransaction").invoke(jtaPlatform));
	assertTrue(lsfb.getProperties().get(AvailableSettings.TRANSACTION_STRATEGY) instanceof CMTTransactionFactory);
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
/**
 * Constructor
 * @param tm The transaction manager
 * @param tsr The transaction synchronization registry
 * @param utr The user transaction registry
 * @param terminator The XA terminator
 * @param rr The recovery registry
 */
public TransactionIntegrationImpl(TransactionManager tm,
                                  TransactionSynchronizationRegistry tsr,
                                  org.jboss.tm.usertx.UserTransactionRegistry utr,
                                  org.jboss.tm.JBossXATerminator terminator,
                                  org.jboss.tm.XAResourceRecoveryRegistry rr)
{
   if (tm instanceof org.jboss.tm.TransactionTimeoutConfiguration)
   {
      this.tm = new TransactionManagerDelegator(tm);
   }
   else
   {
      this.tm = tm;
   }
   this.tsr = tsr;
   this.utr = new UserTransactionRegistryImpl(utr);
   this.terminator = terminator;
   this.rr = rr;
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
/**
 * Constructor
 * @param wm The WorkManager
 * @param tsr The TransactionSynchronizationRegistry
 * @param terminator The XATerminator
 * @param validatorFactory the ValidatorFactory
 */
public BootstrapContextImpl(WorkManager wm,
                            TransactionSynchronizationRegistry tsr,
                            XATerminator terminator,
                            ValidatorFactory validatorFactory)
{
   this.workManager = wm;
   this.transactionSynchronizationRegistry = tsr;
   this.xaTerminator = terminator;
   this.supportedContexts = new HashSet<Class>(3);
   this.validatorFactory = validatorFactory;
   this.supportedContexts.add(HintsContext.class);
   this.supportedContexts.add(SecurityContext.class);
   this.supportedContexts.add(TransactionContext.class);

   this.timers = null;
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
private void checkBuiltInResourceTypes(final ResourceReference reference, final String jndi) {
    final Class<?> resourceType = reference.getResourceType();
    if ("java:comp/BeanManager".equals(jndi) && resourceType != BeanManager.class) {
        throw new DefinitionException(
                "Resource " + reference.getJndiName() + " in " + reference.getOwnerClass() + " can't be cast to a BeanManager");
    } else if ("java:comp/TransactionSynchronizationRegistry".equals(jndi) && resourceType != TransactionSynchronizationRegistry.class) {
        throw new DefinitionException(
                "Resource " + reference.getJndiName() + " in " + reference.getOwnerClass() + " can't be cast to a TransactionSynchronizationRegistry");
    } else if ("java:comp/TransactionManager".equals(jndi) && resourceType != TransactionManager.class) {
        throw new DefinitionException(
                "Resource " + reference.getJndiName() + " in " + reference.getOwnerClass() + " can't be cast to a TransactionManager");
    } else if ("java:comp/ValidatorFactory".equals(jndi) && resourceType != ValidatorFactory.class) {
        throw new DefinitionException(
                "Resource " + reference.getJndiName() + " in " + reference.getOwnerClass() + " can't be cast to a ValidatorFactory");
    } else if ("java:comp/Validator".equals(jndi) && resourceType != Validator.class) {
        throw new DefinitionException(
                "Resource " + reference.getJndiName() + " in " + reference.getOwnerClass() + " can't be cast to a Validator");
    }
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public SetValuedCmr(final EntityBean source, final String sourceProperty, final Class<Bean> relatedType, final String relatedProperty) {
    if (source == null) {
        throw new NullPointerException("source is null");
    }
    if (relatedType == null) {
        throw new NullPointerException("relatedType is null");
    }

    this.source = source;
    this.sourceProperty = sourceProperty;
    this.relatedProperty = relatedProperty;

    this.relatedInfo = Cmp2Util.getBeanContext(relatedType);

    transactionRegistry = SystemInstance.get().getComponent(TransactionSynchronizationRegistry.class);
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public CmrSet(final EntityBean source, final String sourceProperty, final BeanContext relatedInfo, final String relatedProperty, final Collection<Bean> relatedBeans) {
    this.source = source;
    this.sourceProperty = sourceProperty;
    this.relatedInfo = relatedInfo;
    this.relatedProperty = relatedProperty;
    this.relatedBeans = relatedBeans;

    relatedLocal = relatedInfo.getLocalInterface();
    final TransactionSynchronizationRegistry transactionRegistry = SystemInstance.get().getComponent(TransactionSynchronizationRegistry.class);
    try {
        transactionRegistry.registerInterposedSynchronization(new Synchronization() {
            public void beforeCompletion() {
            }

            public void afterCompletion(final int i) {
                mutable = false;
            }
        });
    } catch (final IllegalStateException ignored) {
        // no tx so not mutable
        mutable = false;
    }
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public void setUp() throws Exception {
    super.setUp();


    // setup tx mgr
    transactionManager = new GeronimoTransactionManager();
    SystemInstance.get().setComponent(TransactionSynchronizationRegistry.class, transactionManager);

    // setup naming
    MockInitialContextFactory.install(Collections.singletonMap("java:comp/TransactionSynchronizationRegistry", transactionManager));
    assertSame(transactionManager, new InitialContext().lookup("java:comp/TransactionSynchronizationRegistry"));

    // Put tx mgr into SystemInstance so OpenJPA can find it
    SystemInstance.get().setComponent(TransactionManager.class, transactionManager);

    // init databases
    jtaDs = createJtaDataSource(transactionManager);
    nonJtaDs = createNonJtaDataSource();
    initializeDatabase(jtaDs);
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public void testMultiThreaded() throws Exception {
    final TransactionSynchronizationRegistry reg = TransactionManagerServices.getTransactionSynchronizationRegistry();

    btm.begin();
    reg.putResource("1", "one");
    assertEquals("one", reg.getResource("1"));
    btm.commit();

    Thread t = new Thread() {
        public void run() {
            try {
                btm.begin();
                reg.putResource("1", "one");
                assertEquals("one", reg.getResource("1"));
                btm.commit();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };

    t.start();
    t.join();
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public void testRegistrySynchronizations() throws Exception {
    TransactionSynchronizationRegistry reg = TransactionManagerServices.getTransactionSynchronizationRegistry();

    CoutingSynchronization normalSync = new CoutingSynchronization();
    CoutingSynchronization interposedSync = new CoutingSynchronization();

    btm.begin();

    reg.registerInterposedSynchronization(interposedSync);
    btm.getCurrentTransaction().registerSynchronization(normalSync);

    btm.commit();

    assertTrue(normalSync.getBeforeTimestamp() < interposedSync.getBeforeTimestamp());
    assertTrue(interposedSync.getBeforeTimestamp() < normalSync.getAfterTimestamp());
    assertTrue(interposedSync.getAfterTimestamp() < normalSync.getAfterTimestamp());
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
public void init() throws Exception {
    List<String> clazzes = new ArrayList<>();
    clazzes.add(TransactionManager.class.getName());
    clazzes.add(TransactionSynchronizationRegistry.class.getName());
    clazzes.add(UserTransaction.class.getName());
    clazzes.add(RecoverableTransactionManager.class.getName());
    if (useSpring) {
        clazzes.add(PLATFORM_TRANSACTION_MANAGER_CLASS);
    }
    String[] ifar = clazzes.toArray(new String[clazzes.size()]);
    serviceRegistration = bundleContext.registerService(ifar, transactionManager, null);
    wrapperRegistration = bundleContext.registerService(org.ops4j.pax.transx.tm.TransactionManager.class,
            new TransactionManagerWrapper(transactionManager), null);
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
/**
 * Look up the JTA 1.1 TransactionSynchronizationRegistry in JNDI via the configured name.
 * <p>Can be overridden in subclasses to provide a different TransactionManager object.
 * @param registryName the JNDI name of the
 * TransactionSynchronizationRegistry
 * @return the TransactionSynchronizationRegistry object
 * @throws TransactionSystemException if the JNDI lookup failed
 * @see #setJndiTemplate
 * @see #setTransactionSynchronizationRegistryName
 */
protected TransactionSynchronizationRegistry lookupTransactionSynchronizationRegistry(String registryName) throws TransactionSystemException {
	try {
		if (logger.isDebugEnabled()) {
			logger.debug("Retrieving JTA TransactionSynchronizationRegistry from JNDI location [" + registryName + "]");
		}
		return getJndiTemplate().lookup(registryName, TransactionSynchronizationRegistry.class);
	}
	catch (NamingException ex) {
		throw new TransactionSystemException(
				"JTA TransactionSynchronizationRegistry is not available at JNDI location [" + registryName + "]", ex);
	}
}
 

import javax.transaction.TransactionSynchronizationRegistry; //导入依赖的package包/类
/**
 * Find the JTA 1.1 TransactionSynchronizationRegistry through autodetection:
 * checking whether the UserTransaction object or TransactionManager object
 * implements it, and checking Java EE 5's standard JNDI location.
 * <p>The default implementation simply returns {@code null}.
 * @param ut the JTA UserTransaction object
 * @param tm the JTA TransactionManager object
 * @return the JTA TransactionSynchronizationRegistry handle to use,
 * or {@code null} if none found
 * @throws TransactionSystemException in case of errors
 */
protected TransactionSynchronizationRegistry findTransactionSynchronizationRegistry(UserTransaction ut, TransactionManager tm)
		throws TransactionSystemException {

	if (this.userTransactionObtainedFromJndi) {
		// UserTransaction has already been obtained from JNDI, so the
		// TransactionSynchronizationRegistry probably sits there as well.
		String jndiName = DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME;
		try {
			TransactionSynchronizationRegistry tsr = getJndiTemplate().lookup(jndiName, TransactionSynchronizationRegistry.class);
			if (logger.isDebugEnabled()) {
				logger.debug("JTA TransactionSynchronizationRegistry found at default JNDI location [" + jndiName + "]");
			}
			return tsr;
		}
		catch (NamingException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug(
						"No JTA TransactionSynchronizationRegistry found at default JNDI location [" + jndiName + "]", ex);
			}
		}
	}
	// Check whether the UserTransaction or TransactionManager implements it...
	if (ut instanceof TransactionSynchronizationRegistry) {
		return (TransactionSynchronizationRegistry) ut;
	}
	if (tm instanceof TransactionSynchronizationRegistry) {
		return (TransactionSynchronizationRegistry) tm;
	}
	// OK, so no JTA 1.1 TransactionSynchronizationRegistry is available...
	return null;
}