Besoin de modifier dynamiquement la base de données Nom de l'url de la source de données (base de données multi-tenant)

Voici comment résoudre ce problème: Vous pouvez créer 2 sources de données distinctes. Créez des qualificatifs pour eux et injectez tous les deux dans votre contrôleur. Ensuite, dans la logique d'écriture du point final, qui sélectionnerait l'une des sources pour enregistrer les informations.

Voici comment ajouter une source de données supplémentaire à votre projet:

https: // medium.com/@joeclever/using-multiple-datasources-with-spring-boot-and-spring-data-6430b00c02e7

Je pense que c'est une bonne idée d'utiliser Wildfly dans cette situation. Chez Wildfly, vous pouvez modifier la base de données connectée à l'aide des paramètres.

Ma solution: entrez la description du lien ici

et merci de créer votre propre classe PersistenceConfiguration lorsque vous choisissez la base de données 3 commentaires

Oui, nous pouvons le faire en utilisant un espace réservé. Définissez -DdbName1 = VOTRE_DB_NAME dans les variables d'environnement. Par exemple:

spring.datasource.url=jdbc:sqlserver://test-datbase:1433;${dbName1}
spring.datasource.username=userName
spring.datasource.password=Password
spring.datasource.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver

avec l'aide du lien ci-dessous, je peux définir ma source de données multiple au démarrage du serveur

https://fizzylogic.nl/2016/01/24/make-your-spring-boot-application-multi-tenant -aware-in-2-steps /

mais je veux supprimer l'annotation de configuration comme ci-dessous et définir mon locataire en utilisant la méthode ci-dessous, mais à travers cela, je ne suis pas en mesure de me connecter à la base de données.

public class MultitenantConfiguration {
  @Bean
@ConfigurationProperties(
        prefix = "spring.datasource"
)
public DataSource dataSource(ArrayList<String> names) {


    Map<Object,Object> resolvedDataSources = new HashMap<>();

    for(String  dbName: names) {

        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create(this.getClass().getClassLoader());
        dataSourceBuilder.driverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver")
                .url("jdbc:sqlserver://abc.server;databaseName="+dbName+"")
                .username("userName")
                .password("Password");


        resolvedDataSources.put(dbName, dataSourceBuilder.build());
    }



    MultitenantDataSource dataSource = new MultitenantDataSource();
    dataSource.setDefaultTargetDataSource(defaultDataSource());
    dataSource.setTargetDataSources(resolvedDataSources);
    dataSource.afterPropertiesSet();


    return dataSource;
}

/**
 * Creates the default data source for the application
 * @return
 */
private DataSource defaultDataSource() {
    DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create(this.getClass().getClassLoader())
            .driverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver")
            .url("jdbc:abc.server;databaseName=test")
            .username("UserName")
            .password("Password");

    return dataSourceBuilder.build();
}
  }

J'ai fait un projet dans lequel je peux créer plusieurs dataSources avec vos changesSets spécifiques, donc si vous avez besoin d'ajouter une autre dataSource, cela changerait simplement votre application.yml, plus besoin de changer le code. Mais si vous ne l'utilisez pas, retirez simplement la liquibase qui fonctionne aussi!

Sur chaque hit pour votre contrôleur, vous devez obtenir un en-tête X-TenantId, qui changera votre ThreadLocal, qui à son tour change la source de données en fonction du locataire

Code complet: https://github.com/dijalmasilva/spring-boot-multitenancy-datasource-liquibase

@Configuration
@ConditionalOnProperty(prefix = "spring.liquibase", name = "enabled", matchIfMissing = true)
@EnableConfigurationProperties(LiquibaseProperties.class)
@AllArgsConstructor
public class LiquibaseConfiguration {

    private LiquibaseProperties properties;
    private DataSourceProperties dataSourceProperties;

    @Bean
    @DependsOn("tenantRoutingDataSource")
    public MultiTenantDataSourceSpringLiquibase liquibaseMultiTenancy(Map<Object, Object> dataSources,
                                                                      @Qualifier("taskExecutor") TaskExecutor taskExecutor) {
        // to run changeSets of the liquibase asynchronous
        MultiTenantDataSourceSpringLiquibase liquibase = new MultiTenantDataSourceSpringLiquibase(taskExecutor);
        dataSources.forEach((tenant, dataSource) -> liquibase.addDataSource((String) tenant, (DataSource) dataSource));
        dataSourceProperties.getDataSources().forEach(dbProperty -> {
            if (dbProperty.getLiquibase() != null) {
                liquibase.addLiquibaseProperties(dbProperty.getTenantId(), dbProperty.getLiquibase());
            }
        });

        liquibase.setContexts(properties.getContexts());
        liquibase.setChangeLog(properties.getChangeLog());
        liquibase.setDefaultSchema(properties.getDefaultSchema());
        liquibase.setDropFirst(properties.isDropFirst());
        liquibase.setShouldRun(properties.isEnabled());
        return liquibase;
    }

}

public class TenantFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        final String X_TENANT_ID = "X-TenantID";

        final HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        final String tenantId = httpServletRequest.getHeader(X_TENANT_ID);

        if (tenantId == null) {
            final HttpServletResponse response = (HttpServletResponse) servletResponse;
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            response.setContentType(MediaType.APPLICATION_JSON_VALUE);
            response.getWriter().write("{\"error\": \"No tenant header supplied\"}");
            response.getWriter().flush();
            TenantContext.clear();
            return;
        }

        TenantContext.setCurrentTenant(tenantId);
        filterChain.doFilter(servletRequest, servletResponse);
    }
}