Changement de schéma de base de données en cours d'exécution basée sur l'utilisateur connecté

Hypothèses

Parce que je n'ai pas la réputation encore à poster un commentaire ci-dessous votre question, ma réponse est basée sur les éléments suivants assumtions:

• Le schéma actuel d'utiliser le nom de l'utilisateur actuel, est accessible par un Printemps JSR 330 Fournisseur comme private javax.inject.Provider<User> user; String schema = user.get().getSchema();. C'est, idéalement, d'un ThreadLocal proxy.

• De construire un DataSource qui est entièrement configuré de façon dont vous avez besoin, il exige les mêmes propriétés. Chaque fois. La seule chose qui est différente, c'est le nom du schéma. (Il serait facilement possible d'obtenir d'autres paramètres, mais ce serait trop pour cette réponse)

• Chaque schéma est déjà mis en place avec la nécessaire DDL, donc il n'est pas nécessaire d'hibernation pour créer des tableaux ou quelque chose d'autre

• Chaque schéma de base de données semble tout à fait la même à l'exception de son nom

• Vous avez besoin de réutiliser une source de données à chaque fois que l'utilisateur correspondant fait une demande à votre application. Mais vous ne voulez pas avoir à chaque source de données de chaque utilisateur de façon permanente dans la mémoire.

Ma solution à l'idée

Utiliser une combinaison de ThreadLocal proxys pour obtenir le nom du schéma et un Singleton-source de données qui se comporte de façon différente sur demande de l'utilisateur. Cette solution est inspirée par votre indice de AbstractRoutingDataSource, Meherzad observations et des expériences.

Une dynamique DataSource

Je suggère de faciliter la AbstractDataSource de Printemps et le mettre en œuvre comme le AbstractRoutingDataSource. Au lieu de statique Mapapproche, nous utilisons un Goyave Cache pour obtenir un facile d'utiliser le cache.

public class UserSchemaAwareRoutingDataSource extends AbstractDataSource {
private @Inject javax.inject.Provider<User> user;
private @Inject Environment env;
private LoadingCache<String, DataSource> dataSources = createCache();
@Override
public Connection getConnection() throws SQLException {
return determineTargetDataSource().getConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return determineTargetDataSource().getConnection(username, password);
}
private DataSource determineTargetDataSource() {
String schema = user.get().getSchema();
return dataSources.get(schema);
}
private LoadingCache<String, DataSource> createCache() {
return CacheBuilder.newBuilder()
.maximumSize(100)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(
new CacheLoader<String, DataSource>() {
public DataSource load(String key) throws AnyException {
return buildDataSourceForSchema(key);
}
});
}
private DataSource buildDataSourceForSchema(String schema) {
//e.g. of property: "jdbc:postgresql://localhost:5432/mydatabase?currentSchema="
String url = env.getRequiredProperty("spring.datasource.url") + schema;
return DataSourceBuilder.create()
.driverClassName(env.getRequiredProperty("spring.datasource.driverClassName"))
[...]
.url(url)
.build();
}
}

Maintenant, vous avez une `source de données qui agit différent pour chaque utilisateur. Une fois une source de données est créée, elle va être mis en cache pendant 10 minutes. C'est tout.

D'en faire la demande au courant de notre dynamique de la source de données

La place pour intégrer notre nouvelle source de données est la source de données singleton connu pour le printemps contexte et utilisés dans tous les haricots par exemple, l'EntityManagerFactory

Nous avons besoin d'un équivalent à ceci:

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

mais il doit être plus dynamique, plus qu'un simple bien fondé DataSourceBuilder:

@Primary
@Bean(name = "dataSource")
public UserSchemaAwareRoutingDataSource dataSource() {
return new UserSchemaAwareRoutingDataSource();
}

Conclusion

Nous avons un transparent et dynamique de la source de données qui utilise la bonne source de données à chaque fois.

Questions ouvertes

• Quoi faire, quand aucun utilisateur n'est connecté? Il n'y a pas de base de données accès autorisé?
• Qui met en place les régimes?

Avertissement

Je n'ai pas testé ce code!

EDIT:
Pour mettre en œuvre un Provider<CustomUserDetails> avec le Printemps, vous avez besoin de définir ce que prototype. Vous pouvez utiliser les Ressorts de soutien de la JSR 330 et le Printemps Securitys SecurityContextHolder:

@Bean @Scope("prototype")
public CustomUserDetails customUserDetails() {
return return (CustomUserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
}

Vous n'avez pas besoin d'un RequestInterceptor, le UserProvider ou le contrôleur de code pour mettre à jour l'utilisateur plus.

Cela vous aide?

EDIT2
Juste pour mémoire: ne faites PAS référence à la CustomUserDetails bean directement. Puisque c'est un prototype, le Printemps va essayer de créer un proxy pour la classe CustomUserDetails, ce qui n'est pas une bonne idée dans notre cas. Utilisez donc Providers pour accéder à ce bean. Ou faire une interface.