Java ConnPerRouteBean类代码示例

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
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);
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public static b a(String str) {
    HttpParams basicHttpParams = new BasicHttpParams();
    HttpProtocolParams.setVersion(basicHttpParams, HttpVersion.HTTP_1_1);
    HttpProtocolParams.setUseExpectContinue(basicHttpParams, false);
    HttpConnectionParams.setStaleCheckingEnabled(basicHttpParams, false);
    HttpConnectionParams.setConnectionTimeout(basicHttpParams, 20000);
    HttpConnectionParams.setSoTimeout(basicHttpParams, 30000);
    HttpConnectionParams.setSocketBufferSize(basicHttpParams, 8192);
    HttpClientParams.setRedirecting(basicHttpParams, true);
    HttpClientParams.setAuthenticating(basicHttpParams, false);
    HttpProtocolParams.setUserAgent(basicHttpParams, str);
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    schemeRegistry.register(new Scheme(com.alipay.sdk.cons.b.a, SSLCertificateSocketFactory.getHttpSocketFactory(30000, null), WebSocket.DEFAULT_WSS_PORT));
    ClientConnectionManager threadSafeClientConnManager = new ThreadSafeClientConnManager(basicHttpParams, schemeRegistry);
    ConnManagerParams.setTimeout(basicHttpParams, 60000);
    ConnManagerParams.setMaxConnectionsPerRoute(basicHttpParams, new ConnPerRouteBean(10));
    ConnManagerParams.setMaxTotalConnections(basicHttpParams, 50);
    Security.setProperty("networkaddress.cache.ttl", "-1");
    HttpsURLConnection.setDefaultHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
    return new b(threadSafeClientConnManager, basicHttpParams);
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
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;
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
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;
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
/**
 * 微信自定义信任管理器X509TrustManager
 * @param httpclient
 * @return
 */
private static HttpClient initHttpClient(HttpClient httpclient) {
       try {
       	TrustManager[] tm = { new MyX509TrustManager() };
		// 取得SSL的SSLContext实例
		SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
		// 初始化SSLContext
		sslContext.init(null, tm, new java.security.SecureRandom());
		// 从上述SSLContext对象中得到SSLSocketFactory对象
		SocketFactory ssf = (SocketFactory) sslContext.getSocketFactory();	
           ClientConnectionManager ccm = new DefaultHttpClient().getConnectionManager();
           SchemeRegistry sr = ccm.getSchemeRegistry();
           sr.register(new Scheme("https", ssf, 8443));
           HttpParams params = new BasicHttpParams();
           params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
           params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
           params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
           HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
           params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000);
           params.setParameter(CoreConnectionPNames.SO_TIMEOUT, 5000);
           httpclient = new DefaultHttpClient(ccm, params);
       } catch (Exception ex) {
           Exceptions.printException(ex);
       }
       return httpclient;
   }
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
private static DefaultHttpClient getClient()
{
	if (client == null || !REUSE_CLIENT)
	{
		AQUtility.debug("creating http client");
		HttpParams httpParams = new BasicHttpParams();
		//httpParams.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
		HttpConnectionParams.setConnectionTimeout(httpParams, NET_TIMEOUT);
		HttpConnectionParams.setSoTimeout(httpParams, NET_TIMEOUT);
		//ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(NETWORK_POOL));
		ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(25));
		//Added this line to avoid issue at: http://stackoverflow.com/questions/5358014/android-httpclient-oom-on-4g-lte-htc-thunderbolt
		HttpConnectionParams.setSocketBufferSize(httpParams, 8192);
		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		registry.register(new Scheme("https", ssf == null ? SSLSocketFactory.getSocketFactory() : ssf, 443));
		ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, registry);
		client = new DefaultHttpClient(cm, httpParams);
	}
	return client;
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public static AndroidHttpClient newInstance(String paramString, Context paramContext)
{
  BasicHttpParams localBasicHttpParams = new BasicHttpParams();
  HttpConnectionParams.setStaleCheckingEnabled(localBasicHttpParams, false);
  HttpConnectionParams.setConnectionTimeout(localBasicHttpParams, 20000);
  HttpConnectionParams.setSoTimeout(localBasicHttpParams, 20000);
  HttpConnectionParams.setSocketBufferSize(localBasicHttpParams, 8192);
  HttpClientParams.setRedirecting(localBasicHttpParams, false);
  if (paramContext == null) {}
  for (SSLSessionCache localSSLSessionCache = null;; localSSLSessionCache = new SSLSessionCache(paramContext))
  {
    HttpProtocolParams.setUserAgent(localBasicHttpParams, paramString);
    SchemeRegistry localSchemeRegistry = new SchemeRegistry();
    localSchemeRegistry.register(new Scheme("http", ElegantPlainSocketFactory.getSocketFactory(), 80));
    localSchemeRegistry.register(new Scheme("https", getSocketFactory(localSSLSessionCache), 443));
    ConnManagerParamBean localConnManagerParamBean = new ConnManagerParamBean(localBasicHttpParams);
    localConnManagerParamBean.setConnectionsPerRoute(new ConnPerRouteBean(4));
    localConnManagerParamBean.setMaxTotalConnections(8);
    return new AndroidHttpClient(new ElegantThreadSafeConnManager(localBasicHttpParams, localSchemeRegistry), localBasicHttpParams);
  }
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public AsyncHttpClient(SchemeRegistry schemeregistry)
{
    a = 10;
    b = 10000;
    h = true;
    BasicHttpParams basichttpparams = new BasicHttpParams();
    ConnManagerParams.setTimeout(basichttpparams, b);
    ConnManagerParams.setMaxConnectionsPerRoute(basichttpparams, new ConnPerRouteBean(a));
    ConnManagerParams.setMaxTotalConnections(basichttpparams, 10);
    HttpConnectionParams.setSoTimeout(basichttpparams, b);
    HttpConnectionParams.setConnectionTimeout(basichttpparams, b);
    HttpConnectionParams.setTcpNoDelay(basichttpparams, true);
    HttpConnectionParams.setSocketBufferSize(basichttpparams, 8192);
    HttpProtocolParams.setVersion(basichttpparams, HttpVersion.HTTP_1_1);
    ThreadSafeClientConnManager threadsafeclientconnmanager = new ThreadSafeClientConnManager(basichttpparams, schemeregistry);
    e = getDefaultThreadPool();
    f = new WeakHashMap();
    g = new HashMap();
    d = new SyncBasicHttpContext(new BasicHttpContext());
    c = new DefaultHttpClient(threadsafeclientconnmanager, basichttpparams);
    c.addRequestInterceptor(new a(this));
    c.addResponseInterceptor(new b(this));
    c.addRequestInterceptor(new c(this), 0);
    c.setHttpRequestRetryHandler(new z(5, 1500));
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public RESTMusicService() {

        // Create and initialize default HTTP parameters
        HttpParams params = new BasicHttpParams();
        ConnManagerParams.setMaxTotalConnections(params, 20);
        ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(20));
        HttpConnectionParams.setConnectionTimeout(params, SOCKET_CONNECT_TIMEOUT);
        HttpConnectionParams.setSoTimeout(params, SOCKET_READ_TIMEOUT_DEFAULT);

        // 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);

        // Create and initialize scheme registry
        SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        schemeRegistry.register(new Scheme("https", createSSLSocketFactory(), 443));

        // Create an HttpClient with the ThreadSafeClientConnManager.
        // This connection manager must be used if more than one thread will
        // be using the HttpClient.
        connManager = new ThreadSafeClientConnManager(params, schemeRegistry);
        httpClient = new DefaultHttpClient(connManager, params);
    }
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public static HttpClient getClient(int httpPort, int httpsPort){
	SchemeRegistry schemeRegistry = new SchemeRegistry();
	// http scheme
	schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
	// https scheme
	schemeRegistry.register(new Scheme("https", new EasySSLSocketFactory(), 443));

	HttpParams params = new BasicHttpParams();
	params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
	params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
	params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
	HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

	ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
	return new DefaultHttpClient(cm,params);
	
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
public static HttpClient getTrustedClient(int httpPort, int httpsPort, File keystore, String keypass){
	SchemeRegistry schemeRegistry = new SchemeRegistry();
	// http scheme
	schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), httpPort));
	// https scheme
	schemeRegistry.register(new Scheme("https", new EasySSLSocketFactory(), httpsPort));

	HttpParams params = new BasicHttpParams();
	params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
	params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
	params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
	HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

	ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
	return new DispatchHttpClient(keystore, keypass);		
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
private ConnectionHelper() {
	HttpParams httpParams = new BasicHttpParams();
	ConnManagerParams.setMaxTotalConnections(httpParams,
			MAX_TOTAL_CONNECTIONS);
	ConnPerRouteBean connPerRoute = new ConnPerRouteBean(
			MAX_CONNECTIONS_PER_HOST);
	ConnManagerParams.setMaxConnectionsPerRoute(httpParams, connPerRoute);

	HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
	HttpProtocolParams.setUseExpectContinue(httpParams, false);
	SchemeRegistry reg = new SchemeRegistry();
	reg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(),
			80));
	reg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(),
			443));
	ThreadSafeClientConnManager connectionManager = new ThreadSafeClientConnManager(
			httpParams, reg);
	HttpConnectionParams.setConnectionTimeout(httpParams, CON_TIME_OUT_MS);
	HttpConnectionParams.setSoTimeout(httpParams, SO_TIME_OUT_MS);

	HttpClientParams.setCookiePolicy(httpParams,
			CookiePolicy.BROWSER_COMPATIBILITY);
	httpClient = new DefaultHttpClient(connectionManager, httpParams);
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
/**
 * prepare for the https connection
 * call this in the constructor of the class that does the connection if
 * it's used multiple times
 */
private void setup() {
    SchemeRegistry schemeRegistry = new SchemeRegistry();

    // http scheme
    schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    // https scheme
    schemeRegistry.register(new Scheme("https", new EasySSLSocketFactory(), 443));

    params = new BasicHttpParams();
    params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 1);
    params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(1));
    params.setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
    HttpProtocolParams.setContentCharset(params, "utf8");

    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    // set the user credentials for our site "example.com"
    credentialsProvider.setCredentials(new AuthScope("example.com", AuthScope.ANY_PORT),
            new UsernamePasswordCredentials("UserNameHere", "UserPasswordHere"));
    clientConnectionManager = new ThreadSafeClientConnManager(params, schemeRegistry);

    context = new BasicHttpContext();
    context.setAttribute("http.auth.credentials-provider", credentialsProvider);
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
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;
}
 

import org.apache.http.conn.params.ConnPerRouteBean; //导入依赖的package包/类
/**
 * build parameters for REST call
 * @return
 */

private HttpParams buildParameters(){
	HttpParams params = new BasicHttpParams();			
	params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
	params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
	//params.setParameter(ClientPNames.HANDLE_REDIRECTS, new Boolean(false));
	params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
				
	HttpProtocolParams.setUseExpectContinue(params, false);
	HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
	
	HttpConnectionParams.setConnectionTimeout(params, getConnectionTimeoutDuration());
	HttpConnectionParams.setSoTimeout(params, getSocketTimeoutDuration());		
	return params;
}