Java SSLContexts.createSystemDefault方法代码示例

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
protected void initBase() {
       SSLContext sslContext = SSLContexts.createSystemDefault();
       SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
               sslContext,
               SSLConnectionSocketFactory.STRICT_HOSTNAME_VERIFIER);

       httpRequestConfig = RequestConfig.custom()
               .setSocketTimeout(TIMEOUT)
               .setConnectTimeout(TIMEOUT)
               .setCookieSpec(CookieSpecs.BEST_MATCH)
               .build();

       cookieStore = new BasicCookieStore();

       httpClient = HttpClientBuilder.create()
           .setSSLSocketFactory(sslsf)
           .setDefaultCookieStore(cookieStore)
           .setDefaultRequestConfig(httpRequestConfig)
               .build();


	localContext = HttpClientContext.create();

}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
protected void initBase() {
        //Initiate SSLSocketFactory. "java.lang.IllegalArgumentException: Item may not be null" error fixed.
        SSLContext sslContext = SSLContexts.createSystemDefault();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslContext,
                SSLConnectionSocketFactory.STRICT_HOSTNAME_VERIFIER);

		httpClient = HttpClientBuilder.create()
            .setSSLSocketFactory(sslsf)
                .build();

//		httpRequestConfig = RequestConfig.custom()
//		        .setSocketTimeout(TIMEOUT)
//		        .setConnectTimeout(TIMEOUT)
//		        .build();
		
		localContext = new BasicHttpContext();
	}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
public ConnectionManager() {
    loggedIn = false;
    SSLContext sslContext = SSLContexts.createSystemDefault();
    LayeredConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext);

    PoolingHttpClientConnectionManager pcm = new PoolingHttpClientConnectionManager();
    pcm.setMaxTotal(100);
    pcm.setDefaultMaxPerRoute(50);

    HttpCompressionRequestInterceptor requestInterceptor = new HttpCompressionRequestInterceptor();
    HttpCompressionResponseInterceptor responseInterceptor = new HttpCompressionResponseInterceptor();

    httpClient = HttpClients.custom()
            .setConnectionManager(pcm)
            .setSSLSocketFactory(sslSocketFactory)
            .addInterceptorFirst(requestInterceptor)
            .addInterceptorFirst(responseInterceptor)
            .build();
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
private SSLConnectionSocketFactory createSslSocketFactory(Configuration configuration) {
    X509HostnameVerifier verifier;
    if (configuration.isApiSslCnCheck()) {
        verifier = SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER;
    } else {
        verifier = SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
    }

    // Remove SSLv2Hello and SSLv3 from the allowed ciphers list
    // Java 7u75 disabled them anyway, so usually the MyTimetable server will not support these protocols
    SSLContext sslContext = SSLContexts.createSystemDefault();
    Set<String> enabledProtocols = new HashSet<String>();
    for (String s : sslContext.getDefaultSSLParameters().getProtocols()) {
        if (s.equals("SSLv3") || s.equals("SSLv2Hello")) {
            continue;
        }
        enabledProtocols.add(s);
    }

    return new SSLConnectionSocketFactory(sslContext,
            enabledProtocols.toArray(new String[enabledProtocols.size()]), null, verifier);
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
private SSLConnectionSocketFactory getLenientSslSocketFactory()
{
    SSLContext sslContext = SSLContexts.createSystemDefault();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
            sslContext,
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    return sslsf;
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
private HttpClient createHttpClient(ConnectionConfig config) {
  RequestConfig requestConfig = RequestConfig.custom()
      .setConnectTimeout(config.getConnectionTimeoutMs())
      .setSocketTimeout(config.getSocketTimeoutMs())
      .build();

  RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();
  registryBuilder.register("http", new PlainConnectionSocketFactory());

  if (config.isHttpsEnabled()) {
    SSLContext sslContext = SSLContexts.createSystemDefault();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslContext,
        SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    registryBuilder.register("https", sslsf);
  }
  connectionManager = new PoolingHttpClientConnectionManager(registryBuilder.build());
  connectionManager.setDefaultMaxPerRoute(config.getMaxConnection());
  connectionManager.setMaxTotal(config.getMaxConnection());

  HttpClient httpClient = HttpClients.custom()
      .setConnectionManager(connectionManager)
      .setDefaultRequestConfig(requestConfig)
      .setRetryHandler(new DefaultHttpRequestRetryHandler(3, false))
      .build();
  return httpClient;
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
/**
 * Builds the HTTP client to connect to the server.
 * 
 * @param trustSelfSigned <tt>true</tt> if the client should accept
 *            self-signed certificates
 * @return a new client instance
 */
private CloseableHttpClient buildClient(boolean trustSelfSigned) {
	try {
		// if required, define custom SSL context allowing self-signed certs
		SSLContext sslContext = !trustSelfSigned ? SSLContexts.createSystemDefault()
			: SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build();

		// set timeouts for the HTTP client
		int globalTimeout = readFromProperty("bdTimeout", 100000);
		int connectTimeout = readFromProperty("bdConnectTimeout", globalTimeout);
		int connectionRequestTimeout = readFromProperty("bdConnectionRequestTimeout", globalTimeout);
		int socketTimeout = readFromProperty("bdSocketTimeout", globalTimeout);
		RequestConfig requestConfig = RequestConfig.copy(RequestConfig.DEFAULT).setConnectTimeout(connectTimeout)
			.setSocketTimeout(socketTimeout).setConnectionRequestTimeout(connectionRequestTimeout).build();

		// configure caching
		CacheConfig cacheConfig = CacheConfig.copy(CacheConfig.DEFAULT).setSharedCache(false).setMaxCacheEntries(1000)
			.setMaxObjectSize(2 * 1024 * 1024).build();

		// configure connection pooling
		PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(RegistryBuilder
			.<ConnectionSocketFactory> create().register("http", PlainConnectionSocketFactory.getSocketFactory())
			.register("https", new SSLConnectionSocketFactory(sslContext)).build());
		int connectionLimit = readFromProperty("bdMaxConnections", 40);
		// there's only one server to connect to, so max per route matters
		connManager.setMaxTotal(connectionLimit);
		connManager.setDefaultMaxPerRoute(connectionLimit);

		// create the HTTP client
		return CachingHttpClientBuilder.create().setCacheConfig(cacheConfig).setDefaultRequestConfig(requestConfig)
			.setConnectionManager(connManager).build();
	} catch (GeneralSecurityException e) {
		throw new InternalConfigurationException("Failed to set up SSL context", e);
	}
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
public static InputStream executePostWithForm(String targetURL, List<Property> properties)
		throws ClientProtocolException, IOException {
	// Create SSL Client
	SSLContext sslcontext = SSLContexts.createSystemDefault();
	SSLConnectionSocketFactory sslConnectionSocketFactory = 
		new SSLConnectionSocketFactory(
				sslcontext,
				new String[] { "TLSv1", "SSLv3" },
				null,
				SSLConnectionSocketFactory.getDefaultHostnameVerifier());		
	Registry<ConnectionSocketFactory> socketFactoryRegistry = 
		RegistryBuilder.<ConnectionSocketFactory>create()
			.register("http", PlainConnectionSocketFactory.INSTANCE)
			.register("https", sslConnectionSocketFactory)
			.build();
	PoolingHttpClientConnectionManager cm = 
		new PoolingHttpClientConnectionManager(socketFactoryRegistry);		
	CloseableHttpClient httpClient = HttpClients.custom()
		.setSSLSocketFactory(sslConnectionSocketFactory)
		.setConnectionManager(cm)
		.build();

	MultipartEntityBuilder builder = MultipartEntityBuilder.create();
	for (Property p : properties)
		builder.addTextBody(p.key, p.value, ContentType.TEXT_PLAIN);
	HttpPost uploadFile = new HttpPost(targetURL);
	uploadFile.setEntity(builder.build());

	// Send POST
	CloseableHttpResponse response = httpClient.execute(uploadFile);
	
	int status = response.getStatusLine().getStatusCode();
	if ((status == HttpURLConnection.HTTP_MOVED_TEMP
			|| status == HttpURLConnection.HTTP_MOVED_PERM
			|| status == HttpURLConnection.HTTP_SEE_OTHER)) {
		System.out.println("Got status " + status);

		// Get redirect url from "location" header field
		String newURL = response.getFirstHeader("Location").getValue();
		System.out.println("Redirect to URL: " + newURL);

		// Send the new POST
		uploadFile = new HttpPost(newURL);
		uploadFile.setEntity(builder.build());
		response = httpClient.execute(uploadFile);
	}

	// Get response
	return response.getEntity().getContent();
}
 

import org.apache.http.conn.ssl.SSLContexts; //导入方法依赖的package包/类
private HttpClient createHttpClient(FDSClientConfiguration config) {
  RequestConfig requestConfig = RequestConfig.custom()
      .setConnectTimeout(config.getConnectionTimeoutMs())
      .setSocketTimeout(config.getSocketTimeoutMs())
      .build();

  RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();
  registryBuilder.register("http", new ConnectionInfoRecorderSocketFactory(
      new PlainConnectionSocketFactory()));

  if (config.isHttpsEnabled()) {
    SSLContext sslContext = SSLContexts.createSystemDefault();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslContext,
        SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    registryBuilder.register("https", new ConnectionInfoRecorderSocketFactory(sslsf));
  }
  ipBlackList = new TimeBasedIpAddressBlackList(config.getIpAddressNegativeDurationMillsec());
  connectionManager = new PoolingHttpClientConnectionManager(registryBuilder.build(),
      null,
      null,
      new RoundRobinDNSResolver(new InternalSiteBlackListDNSResolver(ipBlackList,
          this.dnsResolver == null ?
              SystemDefaultDnsResolver.INSTANCE : this.dnsResolver)),
      config.getHTTPKeepAliveTimeoutMS(), TimeUnit.MILLISECONDS);
  connectionManager.setDefaultMaxPerRoute(config.getMaxConnection());
  connectionManager.setMaxTotal(config.getMaxConnection());

  FDSBlackListEnabledHostChecker fdsBlackListEnabledHostChecker = new FDSBlackListEnabledHostChecker();
  retryHandler = new InternalIpBlackListRetryHandler(config.getRetryCount(),
      ipBlackList, fdsBlackListEnabledHostChecker);
  HttpClient httpClient = HttpClients.custom()
      .setRetryHandler(retryHandler)
      .setServiceUnavailableRetryStrategy(new ServiceUnavailableDNSBlackListStrategy(
          config.getRetryCount(),
          config.getRetryIntervalMilliSec(),
          ipBlackList,
          fdsBlackListEnabledHostChecker))
      .setConnectionManager(connectionManager)
      .setDefaultRequestConfig(requestConfig)
      .build();
  return httpClient;
}