Java HttpAsyncClientBuilder.build方法代碼示例

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private CloseableHttpAsyncClient createHttpClient() {
    //default timeouts are all infinite
    RequestConfig.Builder requestConfigBuilder = RequestConfig.custom()
            .setConnectTimeout(DEFAULT_CONNECT_TIMEOUT_MILLIS)
            .setSocketTimeout(DEFAULT_SOCKET_TIMEOUT_MILLIS)
            .setConnectionRequestTimeout(DEFAULT_CONNECTION_REQUEST_TIMEOUT_MILLIS);
    if (requestConfigCallback != null) {
        requestConfigBuilder = requestConfigCallback.customizeRequestConfig(requestConfigBuilder);
    }

    HttpAsyncClientBuilder httpClientBuilder = HttpAsyncClientBuilder.create().setDefaultRequestConfig(requestConfigBuilder.build())
            //default settings for connection pooling may be too constraining
            .setMaxConnPerRoute(DEFAULT_MAX_CONN_PER_ROUTE).setMaxConnTotal(DEFAULT_MAX_CONN_TOTAL);
    if (httpClientConfigCallback != null) {
        httpClientBuilder = httpClientConfigCallback.customizeHttpClient(httpClientBuilder);
    }
    return httpClientBuilder.build();
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private CloseableHttpAsyncClient createCloseableHttpAsyncClient() throws Exception {
        HttpAsyncClientBuilder builder = HttpAsyncClientBuilder.create();
        builder.useSystemProperties();
        builder.setSSLContext(SSLContext.getDefault());
        builder.setConnectionReuseStrategy(DefaultConnectionReuseStrategy.INSTANCE);
        builder.setMaxConnPerRoute(2);
        builder.setMaxConnTotal(2);
        builder.setDefaultRequestConfig(RequestConfig
            .custom()
            .setConnectionRequestTimeout(1000)
            .setConnectTimeout(2000)
            .setSocketTimeout(2000)
        .build()
        );
//        builder.setHttpProcessor()
        CloseableHttpAsyncClient hc = builder.build();
        hc.start();
        return hc;
    }
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private void open() {
   if (open) {
      // Ignore
      return;
   }

   final HttpAsyncClientBuilder builder = HttpAsyncClients.custom()
         .setMaxConnPerRoute(1000)
         .setMaxConnTotal(1000)
         .setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
         .setThreadFactory(threadFactory);
   if (credentialsProvider != null) {
      builder.setDefaultCredentialsProvider(credentialsProvider);
   }

   httpclient = builder.build();
   httpclient.start();
   this.open = true;
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private CloseableHttpAsyncClient getAsyncProxyHttpClient(URI proxyUri) {
  LOG.info("Creating async proxy http client");
  PoolingNHttpClientConnectionManager cm = getAsyncConnectionManager();
  HttpHost proxy = new HttpHost(proxyUri.getHost(), proxyUri.getPort());
  
  HttpAsyncClientBuilder clientBuilder = HttpAsyncClients.custom();
  if (cm != null) {
    clientBuilder = clientBuilder.setConnectionManager(cm);
  }

  if (proxy != null) {
    clientBuilder = clientBuilder.setProxy(proxy);
  }
  clientBuilder = setRedirects(clientBuilder);
  return clientBuilder.build();
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private QueryExecutor(String userAgent, ObjectMapper mapper, HttpHost proxy)
{
    checkNotNull(userAgent, "userAgent is null");
    checkNotNull(mapper, "mapper is null");

    this.userAgent = userAgent;
    this.mapper = mapper;

    HttpClientBuilder builder = HttpClients.custom();
    HttpAsyncClientBuilder asyncBuilder = HttpAsyncClients.custom();

    if (proxy != null) {
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
        builder.setRoutePlanner(routePlanner);
        asyncBuilder.setRoutePlanner(routePlanner);
    }

    this.httpClient = asyncBuilder.build();
    this.httpClient.start();
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
/**
 * Creates asynchronous Apache HTTP client.
 *
 * @param settings
 *         settings to use to create client.
 * @param conf
 *         configuration related to async connection.
 * @return Instance of {@link CloseableHttpAsyncClient}.
 */
private CloseableHttpAsyncClient createClient(HttpSettings settings, ApacheHttpClientConfiguration conf) {
    IOReactorConfig ioReactor = IOReactorConfig.custom().setIoThreadCount(conf.getMaxThreadCount()).build();
    HttpAsyncClientBuilder httpClientBuilder = HttpAsyncClients.custom()
            .useSystemProperties()
                    // allow POST redirects
            .setRedirectStrategy(new LaxRedirectStrategy()).setMaxConnTotal(conf.getMaxTotalConnectionCount()).setMaxConnPerRoute(conf.getMaxRouteConnectionCount()).setDefaultIOReactorConfig(ioReactor)
            .setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy()).setDefaultRequestConfig(createDefaultRequestConfig(settings));
    if (settings.getProxyUrl() != null) {
        DefaultProxyRoutePlanner routePlanner = createProxyRoutePlanner(settings, httpClientBuilder);
        httpClientBuilder.setRoutePlanner(routePlanner);
    }
    CloseableHttpAsyncClient httpClient = httpClientBuilder.build();
    httpClient.start();
    return httpClient;
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
public ApacheHttpAsyncClient(HttpAsyncClientBuilder builder, Config config, SharedResourcesBroker<GobblinScopeTypes> broker) {
  super (broker, HttpUtils.createApacheHttpClientLimiterKey(config));
  config = config.withFallback(FALLBACK);

  RequestConfig requestConfig = RequestConfig.copy(RequestConfig.DEFAULT)
      .setSocketTimeout(config.getInt(REQUEST_TIME_OUT_MS_KEY))
      .setConnectTimeout(config.getInt(CONNECTION_TIME_OUT_MS_KEY))
      .setConnectionRequestTimeout(config.getInt(CONNECTION_TIME_OUT_MS_KEY))
      .build();

  try {
    builder.disableCookieManagement().useSystemProperties().setDefaultRequestConfig(requestConfig);
    builder.setConnectionManager(getNHttpConnManager(config));
    client = builder.build();
    client.start();
  } catch (IOException e) {
    throw new RuntimeException("ApacheHttpAsyncClient cannot be initialized");
  }
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
private CloseableHttpAsyncClient createHttpClient() {

        final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
        requestConfigBuilder.setConnectionRequestTimeout(TIMEOUT_CONNECTION_REQUEST);
        requestConfigBuilder.setConnectTimeout(TIMEOUT_CONNECT);
        requestConfigBuilder.setSocketTimeout(TIMEOUT_SOCKET);

        if (this.mProxyHost != null) {
            requestConfigBuilder.setProxy(this.mProxyHost);
        }

        final HttpAsyncClientBuilder clientBuilder = HttpAsyncClients.custom();

        final RequestConfig requestConfig = requestConfigBuilder.build();
        clientBuilder.setDefaultRequestConfig(requestConfig);

        if (this.mProxyHost != null && !StringUtils.isEmpty(this.mProxyUsername)) {
            final AuthScope authScope = new AuthScope(this.mProxyHost);
            final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            final Credentials credentials = new UsernamePasswordCredentials(this.mProxyUsername, this.mProxyPassword);
            credentialsProvider.setCredentials(authScope, credentials);
            clientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        }

        return clientBuilder.build();
    }
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
public static CloseableHttpAsyncClient createSSLClient(HttpHost proxy) {
    TrustStrategy acceptingTrustStrategy = new TrustStrategy() {

        @Override
        public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
            return true;
        }
    };

    try {
        SSLContext sslContext = SSLContexts.custom()
                .loadTrustMaterial(null, acceptingTrustStrategy)
                .build();

        HttpAsyncClientBuilder client = HttpAsyncClients.custom()
                .setDefaultCookieStore(new BasicCookieStore())
                .setSSLContext(sslContext)
                .setSSLHostnameVerifier(SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        if (proxy !=null) {
            client.setProxy(proxy);
        }

        return client.build();
    } catch (Exception e) {
        System.out.println("Could not create SSLContext");
        return null;
    }

}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
public CloseableHttpAsyncClient createHttpAsyncClient(
        ClientConfiguration config, PoolingNHttpClientConnectionManager cm) {
    HttpAsyncClientBuilder httpClientBuilder = HttpAsyncClients.custom();
    httpClientBuilder.setConnectionManager(cm);
    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(config.getConnectionTimeoutInMillisecond())
            .setSocketTimeout(config.getSocketTimeoutInMillisecond()).build();
    httpClientBuilder.setDefaultRequestConfig(requestConfig);
    httpClientBuilder.setUserAgent(config.getUserAgent());
    httpClientBuilder.disableCookieManagement();
    String proxyHost = config.getProxyHost();
    int proxyPort = config.getProxyPort();
    if (proxyHost != null) {
        if (proxyPort <= 0) {
            throw new ClientException("The proxy port is invalid. Please check your configuration.");
        }
        HttpHost proxy = new HttpHost(proxyHost, proxyPort);
        httpClientBuilder.setProxy(proxy);
        String proxyUsername = config.getProxyUsername();
        String proxyPassword = config.getProxyPassword();
        if (proxyUsername != null && proxyPassword != null) {
            String proxyDomain = config.getProxyDomain();
            String proxyWorkstation = config.getProxyWorkstation();
            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(
                    new AuthScope(proxyHost, proxyPort), new NTCredentials(
                            proxyUsername, proxyPassword, proxyWorkstation,
                            proxyDomain));
            httpClientBuilder.setDefaultCredentialsProvider(credsProvider);
        }
    }
    return httpClientBuilder.build();
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
/**
 * Create Olingo2 Application with custom HTTP client builder.
 *
 * @param serviceUri Service Application base URI.
 * @param builder custom HTTP client builder.
 */
public Olingo2AppImpl(String serviceUri, HttpAsyncClientBuilder builder) {
    setServiceUri(serviceUri);

    if (builder == null) {
        this.client = HttpAsyncClients.createDefault();
    } else {
        this.client = builder.build();
    }
    this.client.start();
    this.contentType = ContentType.create("application/json", Consts.UTF_8);
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
@Override
public void open() {
    if (open) {
        // Ignore
        return;
    }
    final HttpAsyncClientBuilder builder = HttpAsyncClients.custom()
            .setThreadFactory(threadFactory);
    if (credentialsProvider != null) {
        builder.setDefaultCredentialsProvider(credentialsProvider);
    }
    httpclient = builder.build();
    httpclient.start();
    this.open = true;
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
/**
 * Builds the RestClient.
 * 
 * @return
 */
public RestClient build() {
	AsyncRestClient client = new AsyncRestClient();
	client.setUriPrefix(uriPrefix);
	
	HttpAsyncClientBuilder builder = HttpAsyncClients.custom();
	if (requestConfig != null) {
		builder.setDefaultRequestConfig(requestConfig);
	}
	if (userAgentName != null) {
		builder.setUserAgent(userAgentName);
	}
	if (sslContext != null) {
		builder.setSSLContext(sslContext);
	}
	if (connectionReuseStrategy != null) {
		builder.setConnectionReuseStrategy(connectionReuseStrategy);
	}
	if (defaultHeaders != null) {
		builder.setDefaultHeaders(Arrays.asList(defaultHeaders));
	}
	
	CloseableHttpAsyncClient httpClient = builder.build();
	httpClient.start();
	
	client.setHttpClient(httpClient, false);
	client.setSerDe(serDe);
	
	return client;
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
/**
 * Create asynchronous http client based on connection manager.
 *
 * @param connectionManager Asynchronous http client connection manager.
 * @return Asynchronous http client based on connection manager.
 */
protected CloseableHttpAsyncClient createHttpAsyncClient(NHttpClientConnectionManager connectionManager) {
    HttpAsyncClientBuilder builder = HttpAsyncClients.custom().setConnectionManager(connectionManager);

    int socketBufferSizeInBytes = this.config.getSocketBufferSizeInBytes();
    if (socketBufferSizeInBytes > 0) {
        builder.setDefaultConnectionConfig(
                ConnectionConfig.custom().setBufferSize(socketBufferSizeInBytes).build());
    }
    return builder.build();
}
 

import org.apache.http.impl.nio.client.HttpAsyncClientBuilder; //導入方法依賴的package包/類
/**
 * Factory method for Apache HttpAsyncClient
 * 
 * @return
 */
protected CloseableHttpAsyncClient createHttpAsyncClient() {

    log.info("Creating HttpAsyncClient");
    HttpAsyncClientBuilder clientBuilder = HttpAsyncClients.custom();
    
    clientBuilder.setSSLStrategy(createSSLIOSessionStrategy());
    
    /*
     * defaultMaxPerRoute and maxTotal will be overridden by connection manager
     * if it is set.
     */
    ConnectionSettings connSettings = createConnectionSettings();
    clientBuilder.setConnectionManagerShared(connSettings.shared);
    clientBuilder.setMaxConnPerRoute(connSettings.defaultMaxPerRoute);
    clientBuilder.setMaxConnTotal(connSettings.maxTotal);
    
    NHttpClientConnectionManager connectionManager = createConnectionManager();
    if(connectionManager != null){
        log.info("Connection manager is set");
        clientBuilder.setConnectionManager(connectionManager);
    }
    
    HttpHost proxy = detectHttpProxy();
    if (proxy != null) {

        clientBuilder.setProxy(proxy);

        CredentialsProvider credsProvider = createDefaultCredentialsProvider(
                proxy.getHostName(), proxy.getPort());
        if (credsProvider != null) {
            clientBuilder.setDefaultCredentialsProvider(credsProvider);
        }
    }
    String userAgent = getUserAgent();
    log.debug("User-Agent: {}", userAgent);
    clientBuilder.setUserAgent(userAgent);
    clientBuilder.setDefaultRequestConfig(createDefaultRequestConfig());
    return clientBuilder.build();
}