Java Code Examples for org.apache.http.params.HttpConnectionParams#setStaleCheckingEnabled()

private HttpParams createHttpParams() {
    HttpParams params = new BasicHttpParams();
    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
    HttpProtocolParams.setContentCharset(params, "UTF-8");
    HttpProtocolParams.setUseExpectContinue(params, false);
    ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(3));
    ConnManagerParams.setMaxTotalConnections(params, 3);
    ConnManagerParams.setTimeout(params, 1000);
    HttpConnectionParams.setConnectionTimeout(params, 30000);
    HttpConnectionParams.setSoTimeout(params, 30000);
    HttpConnectionParams.setStaleCheckingEnabled(params, false);
    HttpConnectionParams.setTcpNoDelay(params, true);
    HttpConnectionParams.setSocketBufferSize(params, 8192);
    HttpClientParams.setRedirecting(params, false);
    return params;
}
 

public static HttpClient get() {
    HttpParams httpParams = new BasicHttpParams();
    ConnManagerParams.setTimeout(httpParams, 3000);
    ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(30));
    ConnManagerParams.setMaxTotalConnections(httpParams, 30);
    HttpClientParams.setRedirecting(httpParams, true);
    HttpProtocolParams.setUseExpectContinue(httpParams, true);
    HttpConnectionParams.setStaleCheckingEnabled(httpParams, false);
    HttpConnectionParams.setSoTimeout(httpParams, 2000);
    HttpConnectionParams.setConnectionTimeout(httpParams, 2000);
    HttpConnectionParams.setTcpNoDelay(httpParams, true);
    HttpConnectionParams.setSocketBufferSize(httpParams, 8192);
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme(IDataSource.SCHEME_HTTP_TAG, PlainSocketFactory.getSocketFactory(), 80));
    try {
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        trustStore.load(null, null);
        SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
        sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        schemeRegistry.register(new Scheme(IDataSource.SCHEME_HTTPS_TAG, sf, 443));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return new DefaultHttpClient(new ThreadSafeClientConnManager(httpParams, schemeRegistry), httpParams);
}
 

private static HttpParams createHttpParams() {
	final HttpParams params = new BasicHttpParams();
	// 设置是否启用旧连接检查，默认是开启的。关闭这个旧连接检查可以提高一点点性能，但是增加了I/O错误的风险（当服务端关闭连接时）。
	// 开启这个选项则在每次使用老的连接之前都会检查连接是否可用，这个耗时大概在15-30ms之间
	HttpConnectionParams.setStaleCheckingEnabled(params, false);
	HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);// 设置链接超时时间
	HttpConnectionParams.setSoTimeout(params, TIMEOUT);// 设置socket超时时间
	HttpConnectionParams.setSocketBufferSize(params, SOCKET_BUFFER_SIZE);// 设置缓存大小
	HttpConnectionParams.setTcpNoDelay(params, true);// 是否不使用延迟发送(true为不延迟)
	HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); // 设置协议版本
	HttpProtocolParams.setUseExpectContinue(params, true);// 设置异常处理机制
	HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);// 设置编码
	HttpClientParams.setRedirecting(params, false);// 设置是否采用重定向

	ConnManagerParams.setTimeout(params, TIMEOUT);// 设置超时
	ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(MAX_CONNECTIONS));// 多线程最大连接数
	ConnManagerParams.setMaxTotalConnections(params, 10); // 多线程总连接数
	return params;
}
 

public HttpClient createHttpClient(ClientConfiguration clientconfiguration)
{
    BasicHttpParams basichttpparams = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(basichttpparams, clientconfiguration.getConnectionTimeout());
    HttpConnectionParams.setSoTimeout(basichttpparams, clientconfiguration.getSocketTimeout());
    HttpConnectionParams.setStaleCheckingEnabled(basichttpparams, true);
    HttpConnectionParams.setTcpNoDelay(basichttpparams, true);
    int i = clientconfiguration.getSocketBufferSizeHints()[0];
    int j = clientconfiguration.getSocketBufferSizeHints()[1];
    if (i > 0 || j > 0)
    {
        HttpConnectionParams.setSocketBufferSize(basichttpparams, Math.max(i, j));
    }
    SchemeRegistry schemeregistry = new SchemeRegistry();
    schemeregistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    if (clientconfiguration.getProtocol() == Protocol.HTTPS)
    {
        schemeregistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
    }
    return new DefaultHttpClient(new SingleClientConnManager(basichttpparams, schemeregistry), basichttpparams);
}
 

private static HttpParams createHttpParams() {
	final HttpParams params = new BasicHttpParams();
	// 设置是否启用旧连接检查，默认是开启的。关闭这个旧连接检查可以提高一点点性能，但是增加了I/O错误的风险（当服务端关闭连接时）。
	// 开启这个选项则在每次使用老的连接之前都会检查连接是否可用，这个耗时大概在15-30ms之间
	HttpConnectionParams.setStaleCheckingEnabled(params, false);
	HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);// 设置链接超时时间
	HttpConnectionParams.setSoTimeout(params, TIMEOUT);// 设置socket超时时间
	HttpConnectionParams.setSocketBufferSize(params, SOCKET_BUFFER_SIZE);// 设置缓存大小
	HttpConnectionParams.setTcpNoDelay(params, true);// 是否不使用延迟发送(true为不延迟)
	HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); // 设置协议版本
	HttpProtocolParams.setUseExpectContinue(params, true);// 设置异常处理机制
	HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);// 设置编码
	HttpClientParams.setRedirecting(params, false);// 设置是否采用重定向

	ConnManagerParams.setTimeout(params, TIMEOUT);// 设置超时
	ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(MAX_CONNECTIONS));// 多线程最大连接数
	ConnManagerParams.setMaxTotalConnections(params, 10); // 多线程总连接数
	return params;
}
 

private static final HttpParams createHttpParams() {
    final HttpParams params = new BasicHttpParams();
    HttpProtocolParams.setUseExpectContinue(params, false);
    HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
    ConnManagerParams.setTimeout(params, NetworkHelper.SOCKET_TIMEOUT_MS);
    HttpConnectionParams.setConnectionTimeout(params,
            NetworkHelper.CONNECTION_TIMEOUT_MS);
    HttpConnectionParams.setSoTimeout(params,
            NetworkHelper.SOCKET_TIMEOUT_MS);

    ConnManagerParams.setMaxConnectionsPerRoute(params,
            new ConnPerRouteBean(NetworkHelper.MAX_TOTAL_CONNECTIONS));
    ConnManagerParams.setMaxTotalConnections(params,
            NetworkHelper.MAX_TOTAL_CONNECTIONS);

    HttpConnectionParams.setStaleCheckingEnabled(params, false);
    HttpConnectionParams.setTcpNoDelay(params, true);
    HttpConnectionParams.setSocketBufferSize(params,
            NetworkHelper.SOCKET_BUFFER_SIZE);
    HttpClientParams.setRedirecting(params, false);
    HttpProtocolParams.setUserAgent(params, "FanFou for Android/"
            + AppContext.appVersionName);
    return params;
}
 

/**
 * Replicates default connection and protocol parameters used within
 * {@link ApacheHttpTransport#newDefaultHttpClient()} with one exception:
 *
 * Stale checking is enabled.
 */
HttpParams newDefaultHttpParams() {
  HttpParams params = new BasicHttpParams();
  HttpConnectionParams.setStaleCheckingEnabled(params, true);
  HttpConnectionParams.setSocketBufferSize(params, 8192);
  ConnManagerParams.setMaxTotalConnections(params, 200);
  ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(200));
  return params;
}
 

public StreamClientImpl(StreamClientConfigurationImpl configuration) throws InitializationException {
    this.configuration = configuration;

    HttpProtocolParams.setContentCharset(globalParams, getConfiguration().getContentCharset());
    HttpProtocolParams.setUseExpectContinue(globalParams, false);

    // These are some safety settings, we should never run into these timeouts as we
    // do our own expiration checking
    HttpConnectionParams.setConnectionTimeout(globalParams, (getConfiguration().getTimeoutSeconds()+5) * 1000);
    HttpConnectionParams.setSoTimeout(globalParams, (getConfiguration().getTimeoutSeconds()+5) * 1000);

    HttpConnectionParams.setStaleCheckingEnabled(globalParams, getConfiguration().getStaleCheckingEnabled());
    if (getConfiguration().getSocketBufferSize() != -1)
        HttpConnectionParams.setSocketBufferSize(globalParams, getConfiguration().getSocketBufferSize());

    // Only register 80, not 443 and SSL
    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

    clientConnectionManager = new PoolingClientConnectionManager(registry);
    clientConnectionManager.setMaxTotal(getConfiguration().getMaxTotalConnections());
    clientConnectionManager.setDefaultMaxPerRoute(getConfiguration().getMaxTotalPerRoute());

    httpClient = new DefaultHttpClient(clientConnectionManager, globalParams);
    if (getConfiguration().getRequestRetryCount() != -1) {
        httpClient.setHttpRequestRetryHandler(
            new DefaultHttpRequestRetryHandler(getConfiguration().getRequestRetryCount(), false)
        );
    }
}
 

public StreamClientImpl(StreamClientConfigurationImpl configuration) throws InitializationException {
    this.configuration = configuration;

    HttpProtocolParams.setContentCharset(globalParams, getConfiguration().getContentCharset());
    HttpProtocolParams.setUseExpectContinue(globalParams, false);

    // These are some safety settings, we should never run into these timeouts as we
    // do our own expiration checking
    HttpConnectionParams.setConnectionTimeout(globalParams, (getConfiguration().getTimeoutSeconds()+5) * 1000);
    HttpConnectionParams.setSoTimeout(globalParams, (getConfiguration().getTimeoutSeconds()+5) * 1000);

    HttpConnectionParams.setStaleCheckingEnabled(globalParams, getConfiguration().getStaleCheckingEnabled());
    if (getConfiguration().getSocketBufferSize() != -1)
        HttpConnectionParams.setSocketBufferSize(globalParams, getConfiguration().getSocketBufferSize());

    // Only register 80, not 443 and SSL
    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

    clientConnectionManager = new PoolingClientConnectionManager(registry);
    clientConnectionManager.setMaxTotal(getConfiguration().getMaxTotalConnections());
    clientConnectionManager.setDefaultMaxPerRoute(getConfiguration().getMaxTotalPerRoute());

    httpClient = new DefaultHttpClient(clientConnectionManager, globalParams);
    if (getConfiguration().getRequestRetryCount() != -1) {
        httpClient.setHttpRequestRetryHandler(
            new DefaultHttpRequestRetryHandler(getConfiguration().getRequestRetryCount(), false)
        );
    }
}
 

/** Returns a new instance of the default HTTP parameters we use. */
static HttpParams newDefaultHttpParams() {
  HttpParams params = new BasicHttpParams();
  // Turn off stale checking. Our connections break all the time anyway,
  // and it's not worth it to pay the penalty of checking every time.
  HttpConnectionParams.setStaleCheckingEnabled(params, false);
  HttpConnectionParams.setSocketBufferSize(params, 8192);
  ConnManagerParams.setMaxTotalConnections(params, 200);
  ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(20));
  return params;
}
 

/**
 * Create a new HttpClient with reasonable defaults (which you can update).
 * 
 * @param userAgent
 *            to report in your HTTP requests
 * @param context
 *            to use for caching SSL sessions (may be null for no caching)
 * @return AndroidHttpClient for you to use for all your requests.
 */
public static AndroidHttpClient newInstance(String userAgent,
		Context context) {
	HttpParams params = new BasicHttpParams();

	// Turn off stale checking. Our connections break all the time anyway,
	// and it's not worth it to pay the penalty of checking every time.
	HttpConnectionParams.setStaleCheckingEnabled(params, false);

	HttpConnectionParams.setConnectionTimeout(params,
			SOCKET_OPERATION_TIMEOUT);
	HttpConnectionParams.setSoTimeout(params, SOCKET_OPERATION_TIMEOUT);
	HttpConnectionParams.setSocketBufferSize(params, 8192);

	// Don't handle redirects -- return them to the caller. Our code
	// often wants to re-POST after a redirect, which we must do ourselves.
	HttpClientParams.setRedirecting(params, false);

	// Use a session cache for SSL sockets
	// SSLSessionCache sessionCache = context == null ? null : new
	// SSLSessionCache(context);

	// Set the specified user agent and register standard protocols.
	HttpProtocolParams.setUserAgent(params, userAgent);
	SchemeRegistry schemeRegistry = new SchemeRegistry();
	schemeRegistry.register(new Scheme("http", PlainSocketFactory
			.getSocketFactory(), 80));
	// schemeRegistry.register(new Scheme("https",
	// SSLCertificateSocketFactory.getHttpSocketFactory(
	// SOCKET_OPERATION_TIMEOUT, sessionCache), 443));

	ClientConnectionManager manager = new ThreadSafeClientConnManager(
			params, schemeRegistry);

	// We use a factory method to modify superclass initialization
	// parameters without the funny call-a-static-method dance.
	return new AndroidHttpClient(manager, params);
}
 

/**
 * Initialize the connection.
 */
synchronized void freeze() {
    if (frozen) {
        return;
    }
    if (userAgent == null) {
        setDefaultUserAgent();
    }
    serviceMap = new HashMap<String, ServiceEndpoint>();
    if (log.isDebugEnabled()) {
        StringBuilder buf = new StringBuilder();
        buf.append("Creating MwsConnection {");
        buf.append("applicationName:");
        buf.append(applicationName);
        buf.append(",applicationVersion:");
        buf.append(applicationVersion);
        buf.append(",awsAccessKeyId:");
        buf.append(awsAccessKeyId);
        buf.append(",uri:");
        buf.append(endpoint.toString());
        buf.append(",userAgent:");
        buf.append(userAgent);
        buf.append(",connectionTimeout:");
        buf.append(connectionTimeout);
        if (proxyHost != null && proxyPort != 0) {
            buf.append(",proxyUsername:");
            buf.append(proxyUsername);
            buf.append(",proxyHost:");
            buf.append(proxyHost);
            buf.append(",proxyPort:");
            buf.append(proxyPort);
        }
        buf.append("}");
        log.debug(buf);
    }

    BasicHttpParams httpParams = new BasicHttpParams();
    httpParams.setParameter(CoreProtocolPNames.USER_AGENT, userAgent);
    HttpConnectionParams
            .setConnectionTimeout(httpParams, connectionTimeout);
    HttpConnectionParams.setSoTimeout(httpParams, socketTimeout);
    HttpConnectionParams.setStaleCheckingEnabled(httpParams, true);
    HttpConnectionParams.setTcpNoDelay(httpParams, true);

    connectionManager = getConnectionManager();
    httpClient = new DefaultHttpClient(connectionManager, httpParams);
    httpContext = new BasicHttpContext();
    if (proxyHost != null && proxyPort != 0) {
        String scheme = MwsUtl.usesHttps(endpoint) ? "https" : "http";
        HttpHost hostConfiguration = new HttpHost(proxyHost, proxyPort, scheme);
        httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, hostConfiguration);

        if (proxyUsername != null && proxyPassword != null) {
            Credentials credentials = new UsernamePasswordCredentials(proxyUsername, proxyPassword);
            CredentialsProvider cprovider = new BasicCredentialsProvider();
            cprovider.setCredentials(new AuthScope(proxyHost, proxyPort), credentials);
            httpContext.setAttribute(ClientContext.CREDS_PROVIDER, cprovider);
        }
    }
    headers = Collections.unmodifiableMap(headers);
    frozen = true;
}
 

private void settingOthers(BasicHttpParams params) {
    HttpConnectionParams.setLinger(params, DEFAULT_KEEP_LIVE);
    HttpConnectionParams.setStaleCheckingEnabled(params, false);
    HttpProtocolParams.setUseExpectContinue(params, false);
}
 

public StreamClientImpl(StreamClientConfigurationImpl configuration) throws InitializationException {
    this.configuration = configuration;

    ConnManagerParams.setMaxTotalConnections(globalParams, getConfiguration().getMaxTotalConnections());
    HttpConnectionParams.setConnectionTimeout(globalParams,
            getConfiguration().getConnectionTimeoutSeconds() * 1000);
    HttpConnectionParams.setSoTimeout(globalParams, getConfiguration().getDataReadTimeoutSeconds() * 1000);
    HttpProtocolParams.setContentCharset(globalParams, getConfiguration().getContentCharset());
    if (getConfiguration().getSocketBufferSize() != -1) {

        // Android configuration will set this to 8192 as its httpclient is based
        // on a random pre 4.0.1 snapshot whose BasicHttpParams do not set a default value for socket buffer size.
        // This will also avoid OOM on the HTC Thunderbolt where default size is 2Mb (!):
        // http://stackoverflow.com/questions/5358014/android-httpclient-oom-on-4g-lte-htc-thunderbolt

        HttpConnectionParams.setSocketBufferSize(globalParams, getConfiguration().getSocketBufferSize());
    }
    HttpConnectionParams.setStaleCheckingEnabled(globalParams, getConfiguration().getStaleCheckingEnabled());

    // This is a pretty stupid API... https://issues.apache.org/jira/browse/HTTPCLIENT-805
    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); // The 80 here is... useless
    clientConnectionManager = new ThreadSafeClientConnManager(globalParams, registry);
    httpClient = new DefaultHttpClient(clientConnectionManager, globalParams);
    if (getConfiguration().getRequestRetryCount() != -1) {
        httpClient.setHttpRequestRetryHandler(
                new DefaultHttpRequestRetryHandler(getConfiguration().getRequestRetryCount(), false));
    }

    /*
     * // TODO: Ugh! And it turns out that by default it doesn't even use persistent connections properly!
     * 
     * @Override
     * protected ConnectionReuseStrategy createConnectionReuseStrategy() {
     * return new NoConnectionReuseStrategy();
     * }
     * 
     * @Override
     * protected ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy() {
     * return new ConnectionKeepAliveStrategy() {
     * public long getKeepAliveDuration(HttpResponse httpResponse, HttpContext httpContext) {
     * return 0;
     * }
     * };
     * }
     * httpClient.removeRequestInterceptorByClass(RequestConnControl.class);
     */
}
 

static DefaultHttpClient createClient(String userAgent,
		boolean acceptAllSslCertificates) {

	HttpParams params = new BasicHttpParams();
	HttpConnectionParams.setStaleCheckingEnabled(params, false);
	HttpConnectionParams.setConnectionTimeout(params, 20 * 1000);

	// to make connection pool more fault tolerant
	ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRoute() {
		public int getMaxForRoute(HttpRoute route) {
			return 10;
		}
	});

	HttpConnectionParams.setSoTimeout(params, 20 * 1000);

	HttpConnectionParams.setSocketBufferSize(params, 8192);

	HttpClientParams.setRedirecting(params, false);

	HttpProtocolParams.setUserAgent(params, userAgent);

	SSLSocketFactory sslSocketFactory = null;

	if (acceptAllSslCertificates) {
		try {
			sslSocketFactory = new AcceptAllSocketFactory();
		} catch (Exception e) {
			// omitted
		}
	}

	if (sslSocketFactory == null) {
		sslSocketFactory = SSLSocketFactory.getSocketFactory();
	}

	SchemeRegistry schemeRegistry = new SchemeRegistry();
	schemeRegistry.register(new Scheme("http", PlainSocketFactory
			.getSocketFactory(), 80));
	schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));

	ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(
			params, schemeRegistry);

	final DefaultHttpClient client = new DefaultHttpClient(manager, params);

	return client;
}