Printemps: à l'Aide du générateur de modèle pour créer un bean

- Je utiliser ektorp pour se connecter à CouchDB.

La façon de construire un ektorp HttpClient instance est d'utiliser le générateur de modèle:

HttpClient httpClient = new StdHttpClient.Builder()
                                .host("mychouchdbhost")
                                .port(4455)
                                .build();

Je suis relativement nouveau pour le Printemps. Merci de me conseiller sur comment puis-je configurer un HttpClient dans mon contexte de la créer via le Builder.

Une façon de le faire est avec @Configuration. Sont les autres options?

InformationsquelleAutor artemb | 2010-07-13

Vous pouvez essayer de mettre en œuvre FactoryBean interface:

public class HttpFactoryBean implements FactoryBean<HttpClient>{

private String host;
private int port;


public HttpClient getObject() throws Exception {
    return new StdHttpClient.Builder()
                            .host(host)
                            .port(port)
                            .build();
}

public Class<? extends HttpClient> getObjectType() {
    return StdHttpClient.class;
}

public boolean isSingleton() {
    return true;
}

public void setHost(String host) {
    this.host = host;
}

public void setPort(int port) {
    this.port = port;
}}

Et ajouter à la config suivante bean définition:

<beans ..."> 
   <bean name="myHttpClient" class="HttpFactoryBean">
       <property name="port" value="8080"/>
       <property name="host" value="localhost"/>
   </bean>
</beans>

Ensuite, vous pouvez injecter cette fève à l'autre, des haricots, il sera résolue de la StdHttpClient instance.

InformationsquelleAutor wax

Une fois, j'ai tombé sur le même problème, quand j'étais en développement flexy-piscine (un réactif de pool de connexions de dimensionnement de l'utilité), j'ai donc écrit un article avec à la fois basé sur Java et xml exemple.

Fondamentalement, en commençant par les constructeurs suivants:

public final class Configuration<T extends DataSource> extends ConfigurationProperties<T, Metrics, PoolAdapter<T>> {
public static final long DEFAULT_METRIC_LOG_REPORTER_PERIOD = 5;
public static class Builder<T extends DataSource> {
private final String uniqueName;
private final T targetDataSource;
private final PoolAdapterBuilder<T> poolAdapterBuilder;
private final MetricsBuilder metricsBuilder;
private boolean jmxEnabled = true;
private long metricLogReporterPeriod = DEFAULT_METRIC_LOG_REPORTER_PERIOD;
public Builder(String uniqueName, T targetDataSource, MetricsBuilder metricsBuilder, PoolAdapterBuilder<T> poolAdapterBuilder) {
this.uniqueName = uniqueName;
this.targetDataSource = targetDataSource;
this.metricsBuilder = metricsBuilder;
this.poolAdapterBuilder = poolAdapterBuilder;
}
public Builder setJmxEnabled(boolean enableJmx) {
this.jmxEnabled = enableJmx;
return this;
}
public Builder setMetricLogReporterPeriod(long metricLogReporterPeriod) {
this.metricLogReporterPeriod = metricLogReporterPeriod;
return this;
}
public Configuration<T> build() {
Configuration<T> configuration = new Configuration<T>(uniqueName, targetDataSource);
configuration.setJmxEnabled(jmxEnabled);
configuration.setMetricLogReporterPeriod(metricLogReporterPeriod);
configuration.metrics = metricsBuilder.build(configuration);
configuration.poolAdapter = poolAdapterBuilder.build(configuration);
return configuration;
}
}
private final T targetDataSource;
private Metrics metrics;
private PoolAdapter poolAdapter;
private Configuration(String uniqueName, T targetDataSource) {
super(uniqueName);
this.targetDataSource = targetDataSource;
}
public T getTargetDataSource() {
return targetDataSource;
}
public Metrics getMetrics() {
return metrics;
}
public PoolAdapter<T> getPoolAdapter() {
return poolAdapter;
}
}

À l'aide de la Java de la configuration est très simple:

@org.springframework.context.annotation.Configuration
public class FlexyDataSourceConfiguration {
@Bean
public Configuration configuration() {
return new Configuration.Builder(
UUID.randomUUID().toString(),
poolingDataSource,
CodahaleMetrics.BUILDER,
BitronixPoolAdapter.BUILDER
).build();
}
}

Mais vous pouvez aussi utiliser de configuration XML ainsi:

<bean id="configurationBuilder" class="com.vladmihalcea.flexypool.config.Configuration$Builder">
<constructor-arg value="uniqueId"/>
<constructor-arg ref="poolingDataSource"/>
<constructor-arg value="#{ T(com.vladmihalcea.flexypool.metric.codahale.CodahaleMetrics).BUILDER }"/>
<constructor-arg value="#{ T(com.vladmihalcea.flexypool.adaptor.BitronixPoolAdapter).BUILDER }"/>
</bean>
<bean id="configuration" factory-bean="configurationBuilder" factory-method="build"/>

Lire votre article. J'ai aimé cette façon et a trouvé qu'il est unique. Pourriez-vous m'aider à comprendre la construction des deux dernières constructor-arg ? J'ai été incapable de trouver une aide sur le GÉNÉRATEUR de construire être utilisé, il.
C'est un Générateur de prendre d'autres Constructeurs pour résoudre des dépendances.
Oh... le "CONSTRUCTEUR" est la propriété de "CodahaleMetrics" et "BitronixPoolAdapter" si ne me trompe pas.
Oui. Le CONSTRUCTEUR est un défaut singleton Générateur que vous pouvez utiliser comme une dépendance.
Cool. Merci pour la clarification. 🙂
Pouvez-vous développer votre exemple? Il ne montre pas comment appeler setJmxEnabled ou setMetricLogReporterPeriod sur les configs, et utilise uniquement le constructeur constructeur
Vous pouvez saisir le dépôt GitHub et de les voir en action.
J'ai téléchargé le dépôt GitHub et fouillé tout le xml des fichiers de configuration pour des exemples d'appel de setJmxEnabled et setMetricLogReporterPeriod et ne trouve rien.
Voici un exemple. C'est la norme Printemps config.

InformationsquelleAutor Vlad Mihalcea

3

Veuillez vérifier Printemps interface factorybean et FactoryMethod de la documentation.

InformationsquelleAutor Script Runner

Bien que non explicite pour ton cas, il est possible d'étendre un constructeur, si elle expose les propriétés via le standard bean modèle set méthodes. c'est à dire si nous prenons le org.apache.httpcomponents:httpclient HttpClientBuilder comme exemple, nous avons pu disposer des éléments suivants:

public class HttpClientFactoryBean
extends HttpClientBuilder
implements InitializingBean,
FactoryBean<HttpClient> {
private HttpClient value;
@Override
public void afterPropertiesSet() throws Exception {
this.value = build();
}
@Override
public HttpClient getObject() throws Exception {
return value;
}
@Override
public Class<?> getObjectType() {
return HttpClient.class;
}
@Override
public boolean isSingleton() {
return true;
}
}

Maintenant, toute méthode exposée par HttpClientBuilder est accessible à votre usine bean. Une configuration telle que la suivante est maintenant possible:

<beans id="httpClient" class="com.drunkendev.factory.HttpClientFactoryBean">
<beans name="defaultCredentialsProvider" ref="credentialsProvider"/>
<beans name="targetAuthenticationStrategy">
<util:constant static-field="org.apache.http.impl.client.TargetAuthenticationStrategy.INSTANCE"/>
</beans>
</beans>

InformationsquelleAutor Brett Ryan

Vous devez vous connecter pour publier un commentaire.