Comment puis-je créer des haricots par programmation au Printemps de Démarrage?

J'ai une application qui a un certain nombre de paramètres de source de données figurant dans la demande.les propriétés. J'ai un @ConfigurationProperties classe qui se charge de ces paramètres. Maintenant, je veux prendre les valeurs de cette ConfigurationProperties classe et les utiliser pour créer la source de données haricots à la volée. J'ai essayé d'utiliser @PostConstruct et la mise en œuvre de BeanFactoryPostProcessor. Cependant, avec BeanFactoryPostProcessor, le traitement semble se produire au début de l'avant de mon ConfigurationProperties classe a été peuplée. Comment puis-je lire les propriétés et créer DataSource haricots à la volée avec Spring Boot?

Voici ce que mon application.propriétés ressemble:

ds.clients[0]=client1|jdbc:db2://server/client1
ds.clients[1]=client2,client3|jdbc:db2://server/client2
ds.clients[2]=client4|jdbc:db2://server/client4
ds.clients[3]=client5|jdbc:db2://server/client5

Et mon ConfigurationProperties classe:

@Component
@ConfigurationProperties(prefix = "ds")
public class DataSourceSettings {
    public static Map<String, String> CLIENT_DATASOURCES = new LinkedHashMap<>();

    private List<String> clients = new ArrayList<>();

    public List<String> getClients() {
        return clients;
    }

    public void setClients(List<String> clients) {
        this.clients = clients;
    }

    @PostConstruct
    public void configure() {
        for (String client : clients) {
            //extract client name
            String[] parts = client.split("\\|");
            String clientName = parts[0];
            String url = parts[1];
            //client to datasource mapping
            String dsName = url.substring(url.lastIndexOf("/") + 1);
            if (clientName.contains(",")) {
                //multiple clients with same datasource
                String[] clientList = clientName.split(",");
                for (String c : clientList) {
                    CLIENT_DATASOURCES.put(c, dsName);
                }
            } else {
                CLIENT_DATASOURCES.put(clientName, dsName);
            }
        }
    }

À la fin de cette @PostConstruct méthode, j'aimerais créer un BasicDataSource avec ces paramètres et l'ajouter à la ApplicationContext. Cependant, si j'essaie de le faire en œuvre BeanFactoryPostProcessor et la mise en œuvre de postProcessBeanFactory, le clients propriété est null, comme c'est le CLIENT_DATASOURCES que j'ai rempli avec @PostConstruct.

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    System.out.println("clients: " + CLIENT_DATASOURCES);
}

Quelle est la meilleure façon de créer des sources de données à la volée avec Spring Boot?

C'est une vieille question, donc il mérite un vieille réponse. Ce n'est pas spécifique à Spring Boot, mais en général au Printemps. Je pense qu'il détient toujours.

InformationsquelleAutor Matt Raible | 2014-08-06

Comment sur la création de vos haricots et demander de Démarrage d'injecter des valeurs en elle?

Quelque chose comme

@Bean
@ConfigurationProperties("ds.client1")
public DataSource dataSource() {
    DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties("ds.client2")
public DataSource dataSource() {
    DataSourceBuilder.create().build();
}

Puis, un paramètre dans le ds.client1 espace de noms appartient à la première source de données (c'est à dire ds.client1.password est la source de données de mot de passe pour que DataSource).

Mais peut-être que vous ne savez pas combien de sources de données que vous aurez? Cela devient plus compliqué, surtout si vous avez besoin d'injecter ces dynamiques de sources de données dans d'autres objets. Si vous avez seulement besoin de recherche par nom, vous pouvez vous inscrire vous-même comme des singletons. Voici un exemple qui fonctionne

@ConfigurationProperties(prefix = "ds")
public class DataSourceSettings implements BeanFactoryAware {
private List<String> clients = new ArrayList<>();
private BeanFactory beanFactory;
public List<String> getClients() {
return clients;
}
public void setClients(List<String> clients) {
this.clients = clients;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@PostConstruct
public void configure() {
Map<String, String> clientDataSources = new HashMap<String, String>();
for (String client : clients) {
//extract client name
String[] parts = client.split("\\|");
String clientName = parts[0];
String url = parts[1];
//client to datasource mapping
String dsName = url.substring(url.lastIndexOf("/") + 1);
if (clientName.contains(",")) {
//multiple clients with same datasource
String[] clientList = clientName.split(",");
for (String c : clientList) {
clientDataSources.put(c, url);
}
}
else {
clientDataSources.put(clientName, url);
}
}
Assert.state(beanFactory instanceof ConfigurableBeanFactory, "wrong bean factory type");
ConfigurableBeanFactory configurableBeanFactory = (ConfigurableBeanFactory) beanFactory;
for (Map.Entry<String, String> entry : clientDataSources.entrySet()) {
DataSource dataSource = createDataSource(entry.getValue());
configurableBeanFactory.registerSingleton(entry.getKey(), dataSource);
}
}
private DataSource createDataSource(String url) {
return DataSourceBuilder.create().url(url).build();
}
}

Noter que ces grains sont seulement disponible par bean recherche de nom. Laissez-moi savoir si cela fonctionne pour vous.

Je ne pense pas que la première option ne fonctionnera parce que ne sais pas combien de sources de données que je vais avoir.
Bien, permettez-moi de vous donner quelques idées sur le deuxième cas, alors.
Je devine que ces sources de données sont liés à d'autres objets (c'est à dire que vous devez fil dans d'autres haricots)?
Les sources de données que je veux créer dynamiquement ne sont pas liés à d'autres objets. Ils sont référencés par SQL dans Apache Camel. Par exemple: sql:select * from table where id=# classées par nom?dataSource=myDS
bon, j'ai mis à jour ma réponse. Laissez-moi savoir comment ça se passe
Merci Stéphane - qui a fonctionné! Je n'ai besoin d'ajouter une vérification pour voir si la fève est déjà enregistré (pour les tests unitaires). Aussi, j'ai changé de List<String> des clients à une Liste<ClientDataSource> pour se débarrasser de certains de la chaîne d'analyse. Cheers!

InformationsquelleAutor Stephane Nicoll

J'ai créé un exemple de projet sur github afin de démontrer votre cas d'utilisation.

https://github.com/lhotari/dynamic-datasources

J'ai mis en place un ImportBeanDefinitionRegistrar à ajouter les haricots. Vous pouvez obtenir une prise de la configuration par la mise en œuvre de EnvironmentAware. Il pourrait y avoir d'autres façons d'atteindre votre objectif, mais c'est la façon que j'ai utilisé dans GspAutoConfiguration pour enregistrer les haricots dynamicly. GspAutoConfiguration fait Graal GSP disponible au Printemps les applications de Démarrage.

Voici la configuration par défaut de la classe dans la dynamique de la source de données de l'échantillon:
https://github.com/lhotari/dynamic-datasources/blob/master/src/main/groovy/sample/DynamicDataSourcesConfiguration.java

package sample;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.beans.FatalBeanException;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.bind.PropertiesConfigurationFactory;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;
import org.springframework.validation.BindException;
@Configuration
public class DynamicDataSourcesConfiguration implements ImportBeanDefinitionRegistrar, EnvironmentAware {
private ConfigurableEnvironment environment;
private static Map<String, Object> defaultDsProperties = new HashMap<String, Object>() {
{
put("suppressClose", true);
put("username", "sa");
put("password", "");
put("driverClassName", "org.h2.Driver");
}
};
@Override
public void setEnvironment(Environment environment) {
this.environment = (ConfigurableEnvironment)environment;
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
DataSourceSettings settings = resolveSettings();
for (Entry<String, String> entry : settings.clientDataSources().entrySet()) {
createDsBean(registry, entry.getKey(), entry.getValue());
}
}
private void createDsBean(BeanDefinitionRegistry registry, String beanName, String jdbcUrl) {
GenericBeanDefinition beanDefinition = createBeanDefinition(SingleConnectionDataSource.class);
beanDefinition.getPropertyValues().addPropertyValues(defaultDsProperties).addPropertyValue("url", jdbcUrl);
registry.registerBeanDefinition(beanName, beanDefinition);
}
private GenericBeanDefinition createBeanDefinition(Class<?> beanClass) {
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(beanClass);
beanDefinition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_NO);
return beanDefinition;
}
private DataSourceSettings resolveSettings() {
DataSourceSettings settings = new DataSourceSettings();
PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(settings);
factory.setTargetName("ds");
factory.setPropertySources(environment.getPropertySources());
factory.setConversionService(environment.getConversionService());
try {
factory.bindPropertiesToTarget();
}
catch (BindException ex) {
throw new FatalBeanException("Could not bind DataSourceSettings properties", ex);
}
return settings;
}
}

C'est de cette façon que j'avais penser aussi.. usines...

InformationsquelleAutor Lari Hotari

Vous devez vous connecter pour publier un commentaire.