Examples with PlatformTransactionManager org.springframework.transaction.PlatformTransactionManager used on opensource projects

Example 1 with PlatformTransactionManager

use of org.springframework.transaction.PlatformTransactionManager in project cucumber-jvm by cucumber.

the class SpringFactoryTest method shouldGiveUsNewInstancesOfGlueScopeClassesForEachScenario.

@Test
public void shouldGiveUsNewInstancesOfGlueScopeClassesForEachScenario() {
    final ObjectFactory factory = new SpringFactory();
    factory.addClass(BellyStepdefs.class);
    factory.addClass(AutowiresPlatformTransactionManager.class);
    // Scenario 1
    factory.start();
    final PlatformTransactionManager o1 = factory.getInstance(AutowiresPlatformTransactionManager.class).getTransactionManager();
    factory.stop();
    // Scenario 2
    factory.start();
    final PlatformTransactionManager o2 = factory.getInstance(AutowiresPlatformTransactionManager.class).getTransactionManager();
    factory.stop();
    assertNotNull(o1);
    assertNotNull(o2);
    assertNotSame(o1, o2);
}

Example 2 with PlatformTransactionManager

use of org.springframework.transaction.PlatformTransactionManager in project spring-framework by spring-projects.

the class TestContextTransactionUtils method retrieveTransactionManager.

/**
	 * Retrieve the {@linkplain PlatformTransactionManager transaction manager}
	 * to use for the supplied {@linkplain TestContext test context}.
	 * <p>The following algorithm is used to retrieve the transaction manager
	 * from the {@link org.springframework.context.ApplicationContext ApplicationContext}
	 * of the supplied test context:
	 * <ol>
	 * <li>Look up the transaction manager by type and explicit name, if the supplied
	 * {@code name} is non-empty, throwing a {@link BeansException} if the named
	 * transaction manager does not exist.
	 * <li>Attempt to look up the single transaction manager by type.
	 * <li>Attempt to look up the <em>primary</em> transaction manager by type.
	 * <li>Attempt to look up the transaction manager via a
	 * {@link TransactionManagementConfigurer}, if present.
	 * <li>Attempt to look up the transaction manager by type and the
	 * {@linkplain #DEFAULT_TRANSACTION_MANAGER_NAME default transaction manager
	 * name}.
	 * @param testContext the test context for which the transaction manager
	 * should be retrieved; never {@code null}
	 * @param name the name of the transaction manager to retrieve; may be
	 * {@code null} or <em>empty</em>
	 * @return the transaction manager to use, or {@code null} if not found
	 * @throws BeansException if an error occurs while retrieving an explicitly
	 * named transaction manager
	 * @throws IllegalStateException if more than one TransactionManagementConfigurer
	 * exists in the ApplicationContext
	 */
public static PlatformTransactionManager retrieveTransactionManager(TestContext testContext, String name) {
    Assert.notNull(testContext, "TestContext must not be null");
    BeanFactory bf = testContext.getApplicationContext().getAutowireCapableBeanFactory();
    try {
        // look up by type and explicit name
        if (StringUtils.hasText(name)) {
            return bf.getBean(name, PlatformTransactionManager.class);
        }
    } catch (BeansException ex) {
        logger.error(String.format("Failed to retrieve transaction manager named '%s' for test context %s", name, testContext), ex);
        throw ex;
    }
    try {
        if (bf instanceof ListableBeanFactory) {
            ListableBeanFactory lbf = (ListableBeanFactory) bf;
            // look up single bean by type
            Map<String, PlatformTransactionManager> txMgrs = BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf, PlatformTransactionManager.class);
            if (txMgrs.size() == 1) {
                return txMgrs.values().iterator().next();
            }
            try {
                // look up single bean by type, with support for 'primary' beans
                return bf.getBean(PlatformTransactionManager.class);
            } catch (BeansException ex) {
                logBeansException(testContext, ex, PlatformTransactionManager.class);
            }
            // look up single TransactionManagementConfigurer
            Map<String, TransactionManagementConfigurer> configurers = BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf, TransactionManagementConfigurer.class);
            Assert.state(configurers.size() <= 1, "Only one TransactionManagementConfigurer may exist in the ApplicationContext");
            if (configurers.size() == 1) {
                return configurers.values().iterator().next().annotationDrivenTransactionManager();
            }
        }
        // look up by type and default name
        return bf.getBean(DEFAULT_TRANSACTION_MANAGER_NAME, PlatformTransactionManager.class);
    } catch (BeansException ex) {
        logBeansException(testContext, ex, PlatformTransactionManager.class);
        return null;
    }
}

Example 3 with PlatformTransactionManager

use of org.springframework.transaction.PlatformTransactionManager in project spring-framework by spring-projects.

the class TransactionAspectSupport method determineQualifiedTransactionManager.

private PlatformTransactionManager determineQualifiedTransactionManager(String qualifier) {
    PlatformTransactionManager txManager = this.transactionManagerCache.get(qualifier);
    if (txManager == null) {
        txManager = BeanFactoryAnnotationUtils.qualifiedBeanOfType(this.beanFactory, PlatformTransactionManager.class, qualifier);
        this.transactionManagerCache.putIfAbsent(qualifier, txManager);
    }
    return txManager;
}

Example 4 with PlatformTransactionManager

use of org.springframework.transaction.PlatformTransactionManager in project spring-boot by spring-projects.

the class TransactionAutoConfigurationTests method singleTransactionManager.

@Test
public void singleTransactionManager() {
    load(DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class);
    PlatformTransactionManager transactionManager = this.context.getBean(PlatformTransactionManager.class);
    TransactionTemplate transactionTemplate = this.context.getBean(TransactionTemplate.class);
    assertThat(transactionTemplate.getTransactionManager()).isSameAs(transactionManager);
}

Example 5 with PlatformTransactionManager

use of org.springframework.transaction.PlatformTransactionManager in project grails-core by grails.

the class ChainedTransactionManagerTests method shouldRollbackAllTransactionManagers.

@Test
public void shouldRollbackAllTransactionManagers() throws Exception {
    PlatformTransactionManager first = createNonFailingTransactionManager("first");
    PlatformTransactionManager second = createNonFailingTransactionManager("second");
    setupTransactionManagers(first, second);
    createAndRollbackTransaction();
    assertThat(first, wasRolledback());
    assertThat(second, wasRolledback());
}