使用两个交易，一个似乎工作，但另一个没有。 为什么？

Question

I'm working with two transactions on spring which has reference to two entitymanagers and hence two datasources, while using @Transactional("transaction1") it works fine but @Transactional("transaction2") throws out an error saying no active transactions found. following is the piece of code:

    @Bean(name = "transaction1")
        public PlatformTransactionManager transactionManager() {
            JpaTransactionManager transactionManager = new JpaTransactionManager();
            transactionManager.setEntityManagerFactory(entityManagerFactoryBean2()
                    .getObject());
            return transactionManager;
        }

    @Bean(name = "transaction2")
        public PlatformTransactionManager sermaTransactionManager() {

            JpaTransactionManager transactionManager = new JpaTransactionManager();
            transactionManager
                    .setEntityManagerFactory(entityManagerFactoryBean1()
                            .getObject());

            return transactionManager;
        }

respective entitymanagers:

    @Bean(name = "entitymanager1")
        public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean1() {

            LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
            entityManagerFactoryBean.setDataSource(dataSource1());
            entityManagerFactoryBean
                    .setPackagesToScan(new String[] { this.environment
                            .getProperty("db.packagesToScan") });
            entityManagerFactoryBean
                    .setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
            entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter());

            Map<String, Object> jpaProperties = new HashMap<String, Object>();
            jpaProperties.put("eclipselink.weaving", "false");
            jpaProperties.put("eclipselink.logging.level", "INFO");
            jpaProperties.put("eclipselink.logging.parameters", "true");
            entityManagerFactoryBean.setJpaPropertyMap(jpaProperties);

            return entityManagerFactoryBean;
        }

    @Bean(name = "entitymanager2")
        public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean2() {

            LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
            entityManagerFactoryBean.setDataSource(dataSource2());
            entityManagerFactoryBean
                    .setPackagesToScan(new String[] { this.environment
                            .getProperty("db.packagesToScan") });
            entityManagerFactoryBean
                    .setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
            entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter());

            Map<String, Object> jpaProperties = new HashMap<String, Object>();
            jpaProperties.put("eclipselink.weaving", "false");
            jpaProperties.put("eclipselink.logging.parameters", "true");
            jpaProperties.put("eclipselink.logging.level", "INFO");
            entityManagerFactoryBean.setJpaPropertyMap(jpaProperties);

            return entityManagerFactoryBean;
        }

respective datasources:

@Bean("datasource1")
public DriverManagerDataSource dataSource1() {

        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource                        .setDriverClassName(this.environment.getProperty("db.driver"));
        dataSource.setUrl(this.environment.getProperty("db.url"));
        dataSource.setUsername(this.environment
                .getProperty("db.username.abc"));
        dataSource.setPassword(this.environment
                .getProperty("db.password.abc"));

        return dataSource;
    }
@Bean("datasource2")
public DriverManagerDataSource dataSource2() {

        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource
                .setDriverClassName(this.environment.getProperty("db.driver"));
        dataSource.setUrl(this.environment.getProperty("db.url"));
        dataSource.setUsername(this.environment.getProperty("db.username"));
        dataSource.setPassword(this.environment.getProperty("db.password"));

        return dataSource;
    }

My genericDaoImpl has the following to link respective entitymanagers:

@PersistenceContext(unitName = "entitymanager1")
    private EntityManager em1;

    @PersistenceContext(unitName = "entitymanager2")
    private EntityManager em2;

when i do @Transactional("transaction1") it works fine, but when i do @Transactional("transaction2") it says no active transactions. and when i dont mention the qualifier for the transactions, error says two transactions found (transaction1, transaction2). any help would be great.

Answer 1

There is an issue with the config:

The problem is that when the beans are initialized like this:

transactionManager.setEntityManagerFactory(entityManagerFactoryBean2().getObject());

The call to entityManagerFactoryBean2() will create a new entity manager factory, and then the @Bean annotation will trigger the creation of another entity manager factory, with the same config.

When you inject the entity manager factory with @Autowired in a bean, you are injecting the instance created with @Bean, and not the instance passed to the transaction manager.

One warning concerning the config:

The config above allows to do transactions in two separate datasources, but it's not possible with this config to do transactions that span the two databases. For example:

@Service
public class PlanesService {

    @PersistenceContext(unitName = "entityManagerFactory1")
    private EntityManager em1;

    @PersistenceContext(unitName = "entityManagerFactory2")
    private EntityManager em2;


    @Transactional("transactionManager1")
    public Plane savePlanes() {
        F14 f14 = new F14("F14","f14");
        F16 f16 = new F16("F16","f16");

        em1.persist(f14);
        em2.persist(f16);

        return f14;
    }
}

This code will only persist f14, because the only entity manager that has an ongoing transaction is em1 (due to @Transactional("transactionManager1") ). The call to em2.persist() will be ignored (em2 can still do reads though).

If you want to do transactions that include both databases you need a JTA transaction manager.

An example of a working config:

This an example of a configuration that fixes the above injection issues:

@Configuration
public class DataSourcesConfig {

    @Bean(name = "datasource1")
    public DriverManagerDataSource dataSource1() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        ...
        return dataSource;
    }

    @Bean(name = "datasource2")
    public DriverManagerDataSource dataSource2() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        ...
        return dataSource;
    }
}

@Configuration
public class EntityManagerFactoriesConfiguration {

    @Autowired
    @Qualifier("datasource1")
    private DataSource dataSource1;

    @Autowired
    @Qualifier("datasource2")
    private DataSource dataSource2;


    @Bean(name = "entityManagerFactory1")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactoryBean.setDataSource(dataSource1);
        entityManagerFactoryBean.setPackagesToScan(new String[] { "your.package.here" });
        entityManagerFactoryBean.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

        Map<String, Object> jpaProperties = new HashMap<String, Object>();
        ...
        entityManagerFactoryBean.setJpaPropertyMap(jpaProperties);

        return entityManagerFactoryBean;
    }

    @Bean(name = "entityManagerFactory2")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean2() {

        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactoryBean.setDataSource(dataSource2);
        entityManagerFactoryBean.setPackagesToScan(new String[] { "your.package.here" });
        entityManagerFactoryBean.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

        Map<String, Object> jpaProperties = new HashMap<String, Object>();

        entityManagerFactoryBean.setJpaPropertyMap(jpaProperties);
        ...
        return entityManagerFactoryBean;
    }
}     


@Configuration
@EnableTransactionManagement
public class TransactionManagersConfig {

    @Autowired
    @Qualifier("entityManagerFactory1")
    EntityManagerFactory entityManagerFactory1;

    @Autowired
    @Qualifier("entityManagerFactory2")
    EntityManagerFactory entityManagerFactory2;

    @Autowired
    @Qualifier("datasource1")
    private DataSource dataSource1;

    @Autowired
    @Qualifier("datasource2")
    private DataSource dataSource2;

    @Bean(name = "transactionManager1")
    public PlatformTransactionManager transactionManager1() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory1);
        transactionManager.setDataSource(dataSource1);
        return transactionManager;
    }

    @Bean(name = "transactionManager2")
    public PlatformTransactionManager transactionManager2() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory2);
        transactionManager.setDataSource(dataSource2);
        return transactionManager;
    }
}

By splitting the config in several @Configuration classes and autowiring them, we ensure that it's always the same beans being used (singletons).

Notice the @EnableTransactionManagement annotation, that enables @Transactional.