Question

我在三个不同的数据源中使用数据源路由进行了项目spring-boot。

这是我的配置：

@Configuration
@EnableCaching
public class CachingConfiguration extends CachingConfigurerSupport {

    @Override
    public KeyGenerator keyGenerator() {
        return new EnvironmentAwareCacheKeyGenerator();
    }

}

-

public class DatabaseContextHolder {

    private static final ThreadLocal<DatabaseEnvironment> CONTEXT =
        new ThreadLocal<>();

    public static void set(DatabaseEnvironment databaseEnvironment) {
        CONTEXT.set(databaseEnvironment);
    }

    public static DatabaseEnvironment getEnvironment() {
        return CONTEXT.get();
    }

    public static void clear() {
        CONTEXT.remove();
    }

}

-

@Configuration
@EnableJpaRepositories(basePackageClasses = UsuarioRepository.class, 
                       entityManagerFactoryRef = "customerEntityManager", 
                       transactionManagerRef = "customerTransactionManager")
@EnableTransactionManagement
public class DatasourceConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "spring.ciclocairu.datasource")
    public DataSource ciclocairuDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.palmas.datasource")
    public DataSource palmasDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.megabike.datasource")
    public DataSource megabikeDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DataSource customerDataSource() {
        DataSourceRouter router = new DataSourceRouter();

        final HashMap<Object, Object> map = new HashMap<>(3);
        map.put(DatabaseEnvironment.CICLOCAIRU, ciclocairuDataSource());
        map.put(DatabaseEnvironment.PALMAS, palmasDataSource());
        map.put(DatabaseEnvironment.MEGABIKE, megabikeDataSource());
        router.setTargetDataSources(map);
        return router;
    }

    @Autowired(required = false)
    private PersistenceUnitManager persistenceUnitManager;

    @Bean
    @Primary
    @ConfigurationProperties("spring.jpa")
    public JpaProperties customerJpaProperties() {
        return new JpaProperties();
    }

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean customerEntityManager(
        final JpaProperties customerJpaProperties) {

        EntityManagerFactoryBuilder builder =
            createEntityManagerFactoryBuilder(customerJpaProperties);

        return builder.dataSource(customerDataSource()).packages(Users.class)
            .persistenceUnit("customerEntityManager").build();
    }

    @Bean
    @Primary
    public JpaTransactionManager customerTransactionManager(
        @Qualifier("customerEntityManager") final EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }

    private JpaVendorAdapter createJpaVendorAdapter(
            JpaProperties jpaProperties) {
            AbstractJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
            adapter.setShowSql(jpaProperties.isShowSql());
            adapter.setDatabase(jpaProperties.getDatabase());
            adapter.setDatabasePlatform(jpaProperties.getDatabasePlatform());
            //adapter.setGenerateDdl(jpaProperties.isGenerateDdl());
            return adapter;
        }

    private EntityManagerFactoryBuilder createEntityManagerFactoryBuilder(
            JpaProperties customerJpaProperties) {
            JpaVendorAdapter jpaVendorAdapter =
                createJpaVendorAdapter(customerJpaProperties);
            return new EntityManagerFactoryBuilder(jpaVendorAdapter,
                customerJpaProperties.getProperties(), this.persistenceUnitManager);
        }







}

-

public class DataSourceRouter extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {

        if(DatabaseContextHolder.getEnvironment() == null)
            DatabaseContextHolder.set(DatabaseEnvironment.CICLOCAIRU);

        return DatabaseContextHolder.getEnvironment();
    }
}

-

public class EnvironmentAwareCacheKeyGenerator implements KeyGenerator {

    @Override
    public Object generate(Object target, Method method, Object... params) {

        String key = DatabaseContextHolder.getEnvironment().name() + "-" + (
            method == null ? "" : method.getName() + "-") + StringUtils
            .collectionToDelimitedString(Arrays.asList(params), "-");

        return key;
    }

}

我使用设置数据源 DatabaseContextHolder.set（DatabaseEnvironment.CICLOCAIRU）;

解决问题：

例如，不同数据源中的两个用户：1和2

如果一个用户使用数据源1，并发送请求，使用数据源2的其他用户，您的下一个请求，而不是数据源2，而是数据源1。我认为此ThreadLocal<DatabaseEnvironment> CONTEXT = new ThreadLocal<>();是请求的独占，但是事实并非如此。

很抱歉，如果不清楚。

实际上，我需要DataSurceRouter对于每个请求都是互斥的，并且一个请求不能相互干扰。

我认为DatasourceRouter是错误的，还是我的代码不好？

Answer 1

该问题可能是由于服务器线程池引起的：您具有给定数量的线程，并且每个请求都在其中滚动。

服务器回收线程时，线程局部变量的值已从上一个周期开始设置，因此您需要在每次请求后刷新该值，以使线程保持干净状态。

多重数据源的多重访问中的数据源路由器问题

1 个答案: