Java HttpConnectionManagerParams.setDefaultMaxConnectionsPerHost方法代碼示例

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
protected HttpClient constructHttpClient()
{
    MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
    HttpClient httpClient = new HttpClient(connectionManager);
    HttpClientParams params = httpClient.getParams();
    params.setBooleanParameter(HttpConnectionParams.TCP_NODELAY, true);
    params.setBooleanParameter(HttpConnectionParams.STALE_CONNECTION_CHECK, true);
    if (socketTimeout != null) 
    {
        params.setSoTimeout(socketTimeout);
    }
    HttpConnectionManagerParams connectionManagerParams = httpClient.getHttpConnectionManager().getParams();
    connectionManagerParams.setMaxTotalConnections(maxTotalConnections);
    connectionManagerParams.setDefaultMaxConnectionsPerHost(maxHostConnections);
    connectionManagerParams.setConnectionTimeout(connectionTimeout);

    return httpClient;
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * 
 * @throws Exception .
 */
private void init() throws Exception {
    httpClientManager = new MultiThreadedHttpConnectionManager();
  
    HttpConnectionManagerParams params = httpClientManager.getParams();
    params.setStaleCheckingEnabled(true);
    params.setMaxTotalConnections(1000);
    params.setDefaultMaxConnectionsPerHost(500);
    params.setConnectionTimeout(2000);
    params.setSoTimeout(3000);
 
    /** 設置從連接池中獲取連接超時。*/
    HttpClientParams clientParams  = new HttpClientParams();
    clientParams.setConnectionManagerTimeout(1000);
    httpClient = new HttpClient(clientParams, httpClientManager);
    
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
public HttpClient(int maxConPerHost, int conTimeOutMs, int soTimeOutMs, int maxSize) {
    connectionManager = new MultiThreadedHttpConnectionManager();
    HttpConnectionManagerParams params = connectionManager.getParams();
    params.setDefaultMaxConnectionsPerHost(maxConPerHost);
    params.setConnectionTimeout(conTimeOutMs);
    params.setSoTimeout(soTimeOutMs);

    HttpClientParams clientParams = new HttpClientParams();
    // 忽略cookie 避免 Cookie rejected 警告
    clientParams.setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
    client = new org.apache.commons.httpclient.HttpClient(clientParams, connectionManager);
    Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
    Protocol.registerProtocol("https", myhttps);
    this.maxSize = maxSize;
    // 支持proxy
    if (proxyHost != null && !proxyHost.equals("")) {
        client.getHostConfiguration().setProxy(proxyHost, proxyPort);
        client.getParams().setAuthenticationPreemptive(true);
        if (proxyAuthUser != null && !proxyAuthUser.equals("")) {
            client.getState().setProxyCredentials(AuthScope.ANY,
                    new UsernamePasswordCredentials(proxyAuthUser, proxyAuthPassword));
            log("Proxy AuthUser: " + proxyAuthUser);
            log("Proxy AuthPassword: " + proxyAuthPassword);
        }
    }
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
public HttpClient(int maxConPerHost, int conTimeOutMs, int soTimeOutMs,
			int maxSize) {
		
//		MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
		SimpleHttpConnectionManager connectionManager = new SimpleHttpConnectionManager(true);
		HttpConnectionManagerParams params = connectionManager.getParams();
		params.setDefaultMaxConnectionsPerHost(maxConPerHost);
		params.setConnectionTimeout(conTimeOutMs);
		params.setSoTimeout(soTimeOutMs);

		HttpClientParams clientParams = new HttpClientParams();
		clientParams.setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
		client = new org.apache.commons.httpclient.HttpClient(clientParams,
				connectionManager);
		Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
		Protocol.registerProtocol("https", myhttps);
	}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Load proxy configuration when proxy config has changed
 */
private void loadProxyConfig(){
	connectionManager = new MultiThreadedHttpConnectionManager();
	HttpConnectionManagerParams params = new HttpConnectionManagerParams();

	params.setSoTimeout(proxyConfig.getSoTimeout());
	params.setConnectionTimeout(proxyConfig.getConnectionTimeout());
	params.setMaxTotalConnections(proxyConfig.getMaxTotalConnections());
	params.setDefaultMaxConnectionsPerHost(proxyConfig
			.getDefaultMaxConnectionsPerHost());

	connectionManager.setParams(params);
	httpClient = new HttpClient(connectionManager);
	
	configureCallbacks();
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Define client configuration
 * @param httpClient instance to configure
 */
private static void setConfiguration(final HttpClient httpClient) {
    final HttpConnectionManagerParams httpParams = httpClient.getHttpConnectionManager().getParams();
    // define connect timeout:
    httpParams.setConnectionTimeout(NetworkSettings.DEFAULT_CONNECT_TIMEOUT);
    // define read timeout:
    httpParams.setSoTimeout(NetworkSettings.DEFAULT_SOCKET_READ_TIMEOUT);

    // define connection parameters:
    httpParams.setMaxTotalConnections(NetworkSettings.DEFAULT_MAX_TOTAL_CONNECTIONS);
    httpParams.setDefaultMaxConnectionsPerHost(NetworkSettings.DEFAULT_MAX_HOST_CONNECTIONS);

    // set content-encoding to UTF-8 instead of default ISO-8859
    final HttpClientParams httpClientParams = httpClient.getParams();
    // define timeout value for allocation of connections from the pool
    httpClientParams.setConnectionManagerTimeout(NetworkSettings.DEFAULT_CONNECT_TIMEOUT);
    // encoding to UTF-8
    httpClientParams.setParameter(HttpClientParams.HTTP_CONTENT_CHARSET, "UTF-8");
    // avoid retries (3 by default):
    httpClientParams.setParameter(HttpMethodParams.RETRY_HANDLER, _httpNoRetryHandler);
    
    // Customize the user agent:
    httpClientParams.setParameter(HttpMethodParams.USER_AGENT, System.getProperty(NetworkSettings.PROPERTY_USER_AGENT));
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Init the parameter settings for the http client
 */
private HttpConnectionManagerParams connectionParams() {
    HttpConnectionManagerParams params = new HttpConnectionManagerParams();
    params.setDefaultMaxConnectionsPerHost(readMaxHostConnectionSetting());
    params.setMaxTotalConnections(readMaxTotalConnectionSetting());
    return params;

}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
public Stubs(ConfigurationContext ctx, String bbUrl) throws AxisFault
{
	this.ctx = ctx;
	this.bbUrl = bbUrl;

	/*
	 * Must use deprecated class of setting up security because the SOAP
	 * response doesn't include a security header. Using the deprecated
	 * OutflowConfiguration class we can specify that the security
	 * header is only for the outgoing SOAP message.
	 */
	ofc = new OutflowConfiguration();
	ofc.setActionItems("UsernameToken Timestamp");
	ofc.setUser("session");
	ofc.setPasswordType("PasswordText");

	final MultiThreadedHttpConnectionManager conMan = new MultiThreadedHttpConnectionManager();
	final HttpConnectionManagerParams params = new HttpConnectionManagerParams();
	params.setMaxTotalConnections(1000);
	params.setDefaultMaxConnectionsPerHost(100);
	params.setSoTimeout(60000);
	params.setConnectionTimeout(30000);
	conMan.setParams(params);

	httpClient = new HttpClient(conMan);
	final HttpClientParams clientParams = httpClient.getParams();
	clientParams.setAuthenticationPreemptive(false);
	clientParams.setCookiePolicy(CookiePolicy.BROWSER_COMPATIBILITY);
	ctx.setProperty(HTTPConstants.CACHED_HTTP_CLIENT, httpClient);

	contextWebservice = new ContextWSStub(ctx, PathUtils.filePath(bbUrl, "webapps/ws/services/Context.WS"));
	initStub(contextWebservice);
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Builds an HTTP client with the given settings. Settings are NOT reset to their default values after a client has
 * been created.
 * 
 * @return the created client.
 */
public HttpClient buildClient() {
    if (httpsProtocolSocketFactory != null) {
        Protocol.registerProtocol("https", new Protocol("https", httpsProtocolSocketFactory, 443));
    }

    HttpClientParams clientParams = new HttpClientParams();
    clientParams.setAuthenticationPreemptive(isPreemptiveAuthentication());
    clientParams.setContentCharset(getContentCharSet());
    clientParams.setParameter(HttpClientParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(
            connectionRetryAttempts, false));

    HttpConnectionManagerParams connMgrParams = new HttpConnectionManagerParams();
    connMgrParams.setConnectionTimeout(getConnectionTimeout());
    connMgrParams.setDefaultMaxConnectionsPerHost(getMaxConnectionsPerHost());
    connMgrParams.setMaxTotalConnections(getMaxTotalConnections());
    connMgrParams.setReceiveBufferSize(getReceiveBufferSize());
    connMgrParams.setSendBufferSize(getSendBufferSize());
    connMgrParams.setTcpNoDelay(isTcpNoDelay());

    MultiThreadedHttpConnectionManager connMgr = new MultiThreadedHttpConnectionManager();
    connMgr.setParams(connMgrParams);

    HttpClient httpClient = new HttpClient(clientParams, connMgr);

    if (proxyHost != null) {
        HostConfiguration hostConfig = new HostConfiguration();
        hostConfig.setProxy(proxyHost, proxyPort);
        httpClient.setHostConfiguration(hostConfig);

        if (proxyUsername != null) {
            AuthScope proxyAuthScope = new AuthScope(proxyHost, proxyPort);
            UsernamePasswordCredentials proxyCredentials = new UsernamePasswordCredentials(proxyUsername,
                    proxyPassword);
            httpClient.getState().setProxyCredentials(proxyAuthScope, proxyCredentials);
        }
    }

    return httpClient;
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
private void initialize(Cluster cluster, boolean sslEnabled) {
  this.cluster = cluster;
  this.sslEnabled = sslEnabled;
  MultiThreadedHttpConnectionManager manager =
    new MultiThreadedHttpConnectionManager();
  HttpConnectionManagerParams managerParams = manager.getParams();
  managerParams.setConnectionTimeout(2000); // 2 s
  managerParams.setDefaultMaxConnectionsPerHost(10);
  managerParams.setMaxTotalConnections(100);
  extraHeaders = new ConcurrentHashMap<String, String>();
  this.httpClient = new HttpClient(manager);
  HttpClientParams clientParams = httpClient.getParams();
  clientParams.setVersion(HttpVersion.HTTP_1_1);

}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
public HttpClient(int maxConPerHost, int conTimeOutMs, int soTimeOutMs,
		int maxSize) {
	connectionManager = new MultiThreadedHttpConnectionManager();
	HttpConnectionManagerParams params = connectionManager.getParams();
	params.setDefaultMaxConnectionsPerHost(maxConPerHost);
	params.setConnectionTimeout(conTimeOutMs);
	params.setSoTimeout(soTimeOutMs);

	HttpClientParams clientParams = new HttpClientParams();
	// 忽略cookie 避免 Cookie rejected 警告
	clientParams.setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
	client = new org.apache.commons.httpclient.HttpClient(clientParams,
			connectionManager);
	Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
	Protocol.registerProtocol("https", myhttps);
	this.maxSize = maxSize;
	// 支持proxy
	if (proxyHost != null && !proxyHost.equals("")) {
		client.getHostConfiguration().setProxy(proxyHost, proxyPort);
		client.getParams().setAuthenticationPreemptive(true);
		if (proxyAuthUser != null && !proxyAuthUser.equals("")) {
			client.getState().setProxyCredentials(
					AuthScope.ANY,
					new UsernamePasswordCredentials(proxyAuthUser,
							proxyAuthPassword));
			log("Proxy AuthUser: " + proxyAuthUser);
			log("Proxy AuthPassword: " + proxyAuthPassword);
		}
	}
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Constructor
 * @param cluster the cluster definition
 */
public Client(Cluster cluster) {
  this.cluster = cluster;
  MultiThreadedHttpConnectionManager manager = 
    new MultiThreadedHttpConnectionManager();
  HttpConnectionManagerParams managerParams = manager.getParams();
  managerParams.setConnectionTimeout(2000); // 2 s
  managerParams.setDefaultMaxConnectionsPerHost(10);
  managerParams.setMaxTotalConnections(100);
  extraHeaders = new ConcurrentHashMap<String, String>();
  this.httpClient = new HttpClient(manager);
  HttpClientParams clientParams = httpClient.getParams();
  clientParams.setVersion(HttpVersion.HTTP_1_1);
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Creates an instance of MultiThreadedHttpConnectionManager using HttpClient 3.x APIs
 *
 * @param properties Properties to configure MultiThreadedHttpConnectionManager
 * @return An instance of properly configured MultiThreadedHttpConnectionManager
 */
private HttpConnectionManager createConnectionManager(Properties properties) {
    HttpConnectionManagerParams params = new HttpConnectionManagerParams();
    if (properties == null || properties.isEmpty()) {
        throw new IllegalArgumentException("Parameters required to initialize HttpClient instances " +
                "associated with OAuth token validation service stub are not provided");
    }
    String maxConnectionsPerHostParam = properties.getProperty("MaxConnectionsPerHost");
    if (maxConnectionsPerHostParam == null || maxConnectionsPerHostParam.isEmpty()) {
        if (log.isDebugEnabled()) {
            log.debug("MaxConnectionsPerHost parameter is not explicitly defined. Therefore, the default, " +
                    "which is 2, will be used");
        }
    } else {
        params.setDefaultMaxConnectionsPerHost(Integer.parseInt(maxConnectionsPerHostParam));
    }

    String maxTotalConnectionsParam = properties.getProperty("MaxTotalConnections");
    if (maxTotalConnectionsParam == null || maxTotalConnectionsParam.isEmpty()) {
        if (log.isDebugEnabled()) {
            log.debug("MaxTotalConnections parameter is not explicitly defined. Therefore, the default, " +
                    "which is 10, will be used");
        }
    } else {
        params.setMaxTotalConnections(Integer.parseInt(maxTotalConnectionsParam));
    }
    HttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
    connectionManager.setParams(params);
    return connectionManager;
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
public static HttpClient createHttpClient() {
	HttpClient result = null;
	try {

		result = new HttpClient();
		// 使用多緒HttpClient
		MultiThreadedHttpConnectionManager httpConnectionManager = new MultiThreadedHttpConnectionManager();
		HttpConnectionManagerParams managerParams = httpConnectionManager
				.getParams();
		managerParams.setDefaultMaxConnectionsPerHost(100);
		managerParams.setMaxTotalConnections(200);
		// 連線超時
		managerParams.setConnectionTimeout(5 * 1000);
		// 讀取超時
		managerParams.setSoTimeout(5 * 1000);
		//
		result.setHttpConnectionManager(httpConnectionManager);
		//
		HttpClientParams params = result.getParams();
		// http.protocol.content-charset
		params.setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
		// 失敗 retry 3 次
		params.setParameter(HttpMethodParams.RETRY_HANDLER,
				new DefaultHttpMethodRetryHandler(3, false));

	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return result;
}
 

import org.apache.commons.httpclient.params.HttpConnectionManagerParams; //導入方法依賴的package包/類
/**
 * Constructor
 * @param cluster the cluster definition
 */
public Client(Cluster cluster) {
  this.cluster = cluster;
  MultiThreadedHttpConnectionManager manager = 
    new MultiThreadedHttpConnectionManager();
  HttpConnectionManagerParams managerParams = manager.getParams();
  managerParams.setConnectionTimeout(2000); // 2 s
  managerParams.setDefaultMaxConnectionsPerHost(10);
  managerParams.setMaxTotalConnections(100);
  this.httpClient = new HttpClient(manager);
  HttpClientParams clientParams = httpClient.getParams();
  clientParams.setVersion(HttpVersion.HTTP_1_1);
}