35

Ich verwende ektorp, um eine Verbindung zu CouchDB herzustellen.Spring: Builder-Muster verwenden, um eine Bean zu erstellen

Die Art und Weise eine EKTORP HttpClient Instanz zu bauen builder Muster verwenden:

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

ich Frühling relativ neu bin. Bitte beraten Sie mich, wie ich ein HttpClient in meinem Kontext konfigurieren kann, um es über die Builder zu erstellen.

Eine Möglichkeit, dies zu tun ist mit . Gibt es noch andere Optionen?

Antwort

42

Sie können versuchen, FactoryBean Schnittstelle zu implementieren:

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; 
}} 

Und in der Config folgenden Bean Definition:

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

Dann können Sie injizieren diese Bohnen in einer anderen Bohnen, wird es als StdHttpClient gelöst werden Beispiel.

3

Bitte Spring FactoryBean und FactoryMethod Dokumentation überprüfen.

1

Während nicht explizit für Ihren Fall; Es ist möglich, einen Builder zu erweitern, wenn er Eigenschaften über standardmäßige Bean-Pattern-Methoden (set) verfügbar macht. das heißt, wenn wir die org.apache.httpcomponents:httpclientHttpClientBuilder als Beispiel nehmen wir folgende Voraussetzungen erfüllt sein könnten:

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; 
    } 

} 

Jetzt jede Methode von HttpClientBuilder ausgesetzt ist Ihre Fabrik Bohne zugänglich. Eine Konfiguration wie die folgende ist jetzt möglich:

<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> 
5

ich einmal auf dem gleichen Problem gestolpert, als ich flexy-pool (a reactive connection pool sizing utility) entwickle, so schrieb ich an article sowohl mit einem Java-basierten und ein XML-basiertes Beispiel.

Grundsätzlich aus den folgenden Builder starten:

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; 
    } 
} 

die Java-basierte Konfiguration zu verwenden ist straight-forward:

@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(); 
    } 
} 

Sie können aber auch als auch XML-basierte Konfiguration verwenden:

+0

Lesen Sie Ihren Artikel. Ich mochte diesen Weg und fand ihn einzigartig. Könnten Sie mir helfen, das Konstrukt der letzten beiden Konstruktor-Arg zu verstehen? Ich konnte keine Hilfe finden, weil das BUILDER-Konstrukt dort verwendet wurde. – rajneesh2k10

+1

Es ist ein Builder, der andere Builders verwendet, um einige Abhängigkeiten aufzulösen. –

+0

Oh ... Also der "BUILDER" ist die Eigenschaft von "CodohaleMetrics" und "BitronixPoolAdapter" wenn nicht falsch. – rajneesh2k10

Verwandte Themen