Java PoolingClientConnectionManager.setMaxTotal方法代码示例

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * 每次返回一个新的HttpClient实例
 * @author nan.li
 * @return
 */
public static DefaultHttpClient getHttpClient()
{
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
    schemeRegistry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
    
    PoolingClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry);
    cm.setMaxTotal(500);
    cm.setDefaultMaxPerRoute(200);
    
    HttpParams params = new BasicHttpParams();
    params.setParameter("http.connection.timeout", Integer.valueOf(CON_TIMEOUT));
    params.setParameter("http.socket.timeout", Integer.valueOf(SO_TIMEOUT));
    params.setParameter("http.useragent", UA_WINDOW7_CHROME);
    
    DefaultHttpClient client = new DefaultHttpClient(cm, params);
    return client;
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * Creates an HttpClient with a Pooling Client connection manager.
 *
 * @param maxConnections the max number of connections
 * @param connectionTimeoutInMs the connection timeout in ms.
 * @param socketTimeoutInMs the socket timeout in ms.
 * @return an HttpClient with a Pooling Client connection manager.
 */
public static HttpClient pooledConnectionHttpClient(int maxConnections, int connectionTimeoutInMs, int socketTimeoutInMs) {

    PoolingClientConnectionManager cm = new PoolingClientConnectionManager();
    cm.setDefaultMaxPerRoute(maxConnections);
    cm.setMaxTotal(maxConnections);

    HttpClient httpClient = new DefaultHttpClient(cm);
    HttpParams params = httpClient.getParams();
    HttpConnectionParams.setConnectionTimeout(params, connectionTimeoutInMs);
    HttpConnectionParams.setSoTimeout(params, socketTimeoutInMs);

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Created Pooled HTTP Client. Max Connections per route=" + maxConnections +
                ", Max Connections=" + maxConnections + ", Connection Timeout in ms=" + connectionTimeoutInMs + ", Socket Timeout in ms=" + socketTimeoutInMs);
    }

    return httpClient;
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * Constructor.
 * @param ssl True if SSL connections are desired. False otherwise.
 */
public HttpClientFactory(boolean ssl) {
    // create the logger
    logger = Logger.getLogger(HttpClientFactory.class);
    
    if (ssl) {
        sslConnectionsManager = new PoolingClientConnectionManager(getSchemeRegistry());
        sslConnectionsManager.setMaxTotal(Constants.MAX_CONNS);
        sslConnectionsManager.setDefaultMaxPerRoute(Constants.MAX_CONNS_PER_ROUTE);
    } else {
        connectionsManager = new PoolingClientConnectionManager();
        connectionsManager.setMaxTotal(Constants.MAX_CONNS);
        connectionsManager.setDefaultMaxPerRoute(Constants.MAX_CONNS_PER_ROUTE);
    } // if else
    
    logger.info("Setting max total connections (" + Constants.MAX_CONNS + ")");
    logger.info("Setting default max connections per route (" + Constants.MAX_CONNS_PER_ROUTE + ")");
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
public UpdateShardHandler(ConfigSolr cfg) {
  
  clientConnectionManager = new PoolingClientConnectionManager(SchemeRegistryFactory.createSystemDefault());
  if (cfg != null ) {
    clientConnectionManager.setMaxTotal(cfg.getMaxUpdateConnections());
    clientConnectionManager.setDefaultMaxPerRoute(cfg.getMaxUpdateConnectionsPerHost());
  }
  
  
  ModifiableSolrParams params = new ModifiableSolrParams();
  if (cfg != null) {
    params.set(HttpClientUtil.PROP_SO_TIMEOUT,
        cfg.getDistributedSocketTimeout());
    params.set(HttpClientUtil.PROP_CONNECTION_TIMEOUT,
        cfg.getDistributedConnectionTimeout());
  }
  // in the update case, we want to do retries, and to use
  // the default Solr retry handler that createClient will 
  // give us
  params.set(HttpClientUtil.PROP_USE_RETRY, true);
  log.info("Creating UpdateShardHandler HTTP client with params: {}", params);
  client = HttpClientUtil.createClient(params, clientConnectionManager);
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
private void init(String host, int port, String userName, String password) {
    this.host = host;
    this.port = port;
    this.userName = userName;
    this.password = password;
    this.baseUrl = SCHEME_HTTP + host + ":" + port + KYLIN_API_PATH;

    final HttpParams httpParams = new BasicHttpParams();
    HttpConnectionParams.setSoTimeout(httpParams, httpSocketTimeoutMs);
    HttpConnectionParams.setConnectionTimeout(httpParams, httpConnectionTimeoutMs);

    final PoolingClientConnectionManager cm = new PoolingClientConnectionManager();
    KylinConfig config = KylinConfig.getInstanceFromEnv();
    cm.setDefaultMaxPerRoute(config.getRestClientDefaultMaxPerRoute());
    cm.setMaxTotal(config.getRestClientMaxTotal());

    client = new DefaultHttpClient(cm, httpParams);

    if (userName != null && password != null) {
        CredentialsProvider provider = new BasicCredentialsProvider();
        UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(userName, password);
        provider.setCredentials(AuthScope.ANY, credentials);
        client.setCredentialsProvider(provider);
    }
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * create a proxy client
 * 
 * @return either a client or null if none is configured
 * @throws KeyManagementException
 * @throws NumberFormatException
 *           if that port could not be parsed.
 * @throws NoSuchAlgorithmException
 */
private static HttpClient createProxyClient(PlayProfile profile)
		throws KeyManagementException, NoSuchAlgorithmException {
	if (profile.getProxyAddress() == null) {
		return null;
	}

	PoolingClientConnectionManager connManager = new PoolingClientConnectionManager(
			SchemeRegistryFactory.createDefault());
	connManager.setMaxTotal(100);
	connManager.setDefaultMaxPerRoute(30);

	DefaultHttpClient client = new DefaultHttpClient(connManager);
	client.getConnectionManager().getSchemeRegistry()
			.register(Utils.getMockedScheme());
	HttpHost proxy = new HttpHost(profile.getProxyAddress(),
			profile.getProxyPort());
	client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
	if (profile.getProxyUser() != null && profile.getProxyPassword() != null) {
		client.getCredentialsProvider().setCredentials(
				new AuthScope(proxy),
				new UsernamePasswordCredentials(profile.getProxyUser(), profile
						.getProxyPassword()));
	}
	return client;
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
@Inject
public SparqlPersistance(@Named("r2r.fusekiUrl") String sparqlQuery, SparqlPostClient sparqlClient) throws Exception {
	this.sparqlQuery = new SparqlQueryClient(sparqlQuery + "/query");
	this.sparqlClient = sparqlClient;
	
	// putting this here for now 
	HttpParams params = new BasicHttpParams();		
	HttpConnectionParams.setConnectionTimeout(params, 10000);
	HttpConnectionParams.setSoTimeout(params, 40000);
	PoolingClientConnectionManager cm = new PoolingClientConnectionManager();
	cm.setDefaultMaxPerRoute(20);
	cm.setMaxTotal(200);
	HttpOp.setDefaultHttpClient(new DefaultHttpClient(cm, params));

	// make sure we have the latest model
	// for some reason we need to do post to capture the prefixes
	sparqlClient.post(R2ROntology.createR2ROntModel());
	sparqlClient.update("CREATE GRAPH <" + R2R_DERIVED_GRAPH + ">");
	// by loading these now, we make sure that we do not collide with calls to upsertAffiliation
	knownAffiliations = loadAffiliations();
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
	SchemeRegistry schemeRegistry = new SchemeRegistry();
	schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
	schemeRegistry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
	taobaoHttpManager = new PoolingClientConnectionManager(schemeRegistry);
	taobaoHttpManager.setMaxTotal(taobaoMaxConnection);
	taobaoHttpManager.setDefaultMaxPerRoute(taobaoMaxConnection); // 每条通道最大并发连接数
	log.info("Feedback http connection pool has start up..., max total is:" + taobaoMaxConnection);
	
	
	verifyReceiptDataHttpManager = new PoolingClientConnectionManager(schemeRegistry);;
	verifyReceiptDataHttpManager.setMaxTotal(verifyReceiptMaxConnection);
	verifyReceiptDataHttpManager.setDefaultMaxPerRoute(verifyReceiptMaxConnection);
	log.info("Feedback http connection pool has start up..., max total is:" + verifyReceiptDataHttpManager);
	
	commonHttpManager = new PoolingClientConnectionManager(schemeRegistry);;
	commonHttpManager.setMaxTotal(commonMaxConnection);
	commonHttpManager.setDefaultMaxPerRoute(commonMaxConnection);
	
	
	log.info("Feedback http connection pool has start up..., max total is:" + commonHttpManager);
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
public DefaultHttpClientImpl() {
	cm = new PoolingClientConnectionManager();
	cm.setMaxTotal(100);
	cm.setDefaultMaxPerRoute(100);
	client = new SystemDefaultHttpClient() {

		@Override
		protected ClientConnectionManager createClientConnectionManager() {
			return cm;
		}

	};
	client.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000);
	client.getParams().setParameter(CoreConnectionPNames.TCP_NODELAY, true);
	client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 30000);
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
public DefaultWmsHttpClientFactory() {
	final PoolingClientConnectionManager cm = new PoolingClientConnectionManager();
	cm.setMaxTotal(100);
	cm.setDefaultMaxPerRoute(100);
	client = new SystemDefaultHttpClient() {

		@Override
		protected ClientConnectionManager createClientConnectionManager() {
			return cm;
		}

	};
	client.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000);
	client.getParams().setParameter(CoreConnectionPNames.TCP_NODELAY, true);
	client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 30000);
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * Creates an authenticated JIRA client with custom HttpClient.
 *
 * @param httpClient Custom HttpClient to be used
 * @param uri Base URI of the JIRA server
 * @param creds Credentials to authenticate with
 * @throws JiraException 
 */
public JiraClient(HttpClient httpClient, String uri, ICredentials creds) throws JiraException {
    if (httpClient == null) {
        PoolingClientConnectionManager connManager = new PoolingClientConnectionManager();
        connManager.setDefaultMaxPerRoute(20);
        connManager.setMaxTotal(40);
        httpClient = new DefaultHttpClient(connManager);
    }

    restclient = new RestClient(httpClient, creds, URI.create(uri));

    if (creds != null) {
        username = creds.getLogonName();
        //intialize connection if required
        creds.initialize(restclient);
    }
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
public ClientConnectionManager configureConnectionManager(
		HttpParams params) throws ArangoDb4JException {
	if (conman == null) {
		SchemeRegistry schemeRegistry = new SchemeRegistry();
		schemeRegistry.register(configureScheme());

		PoolingClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry);
		cm.setMaxTotal(maxConnections);
		cm.setDefaultMaxPerRoute(maxConnections);
		conman = cm;
	}

	if (cleanupIdleConnections) {
		IdleConnectionMonitor.monitor(conman);
	}
	return conman;
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
private Set<SolrClient> createSolrClients(Map<String, String> indexConnectionParams) throws MalformedURLException {
    String solrMode = getSolrMode(indexConnectionParams);
    if (solrMode.equals("cloud")) {
        String indexZkHost = indexConnectionParams.get(SolrConnectionParams.ZOOKEEPER);
        String collectionName = indexConnectionParams.get(SolrConnectionParams.COLLECTION);
        CloudSolrClient solrServer = new CloudSolrClient.Builder().withZkHost(indexZkHost).build();
        int zkSessionTimeout = HBaseIndexerConfiguration.getSessionTimeout(getConf());
        solrServer.setZkClientTimeout(zkSessionTimeout);
        solrServer.setZkConnectTimeout(zkSessionTimeout);
        solrServer.setDefaultCollection(collectionName);
        return Collections.singleton((SolrClient)solrServer);
    } else if (solrMode.equals("classic")) {
        PoolingClientConnectionManager connectionManager = new PoolingClientConnectionManager();
        connectionManager.setDefaultMaxPerRoute(getSolrMaxConnectionsPerRoute(indexConnectionParams));
        connectionManager.setMaxTotal(getSolrMaxConnectionsTotal(indexConnectionParams));

        HttpClient httpClient = new DefaultHttpClient(connectionManager);
        return new HashSet<SolrClient>(createHttpSolrClients(indexConnectionParams, httpClient));
    } else {
        throw new RuntimeException("Only 'cloud' and 'classic' are valid values for solr.mode, but got " + solrMode);
    }

}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
@Override
protected ClientConnectionManager createClientConnectionManager() {
    PoolingClientConnectionManager connmgr = new PoolingClientConnectionManager(
            SchemeRegistryFactory.createSystemDefault());
    String s = System.getProperty("http.keepAlive");
    if ("true".equalsIgnoreCase(s)) {
        s = System.getProperty("http.maxConnections", "5");
        int max = Integer.parseInt(s);
        connmgr.setDefaultMaxPerRoute(max);
        connmgr.setMaxTotal(2 * max);
    }
    return connmgr;
}
 

import org.apache.http.impl.conn.PoolingClientConnectionManager; //导入方法依赖的package包/类
/**
 * Creates a BeyondJ manager wrapper for the specified URL, username, password and URL encoding.
 *
 * @param url      the full URL of the BeyondJ manager instance to use
 * @param username the username to use when authenticating with BeyondJ manager
 * @param password the password to use when authenticating with BeyondJ manager
 * @param charset  the URL encoding charset to use when communicating with BeyondJ manager
 * @param verbose  if the build is in verbose mode (quiet mode otherwise)
 * @since 2.2
 */
public DeploymentManager(URL url, String username, String password, String charset, boolean verbose) {
    this.url = url;
    this.username = username;
    this.password = password;
    this.charset = charset;
    this.verbose = verbose;

    PoolingClientConnectionManager poolingClientConnectionManager = new PoolingClientConnectionManager();
    poolingClientConnectionManager.setMaxTotal(5);
    this.httpClient = new DefaultHttpClient(poolingClientConnectionManager);

    if (StringUtils.isNotEmpty(username)) {
        Credentials creds = new UsernamePasswordCredentials(username, password);

        String host = url.getHost();
        int port = url.getPort() > -1 ? url.getPort() : AuthScope.ANY_PORT;
        httpClient.getCredentialsProvider().setCredentials(new AuthScope(host, port), creds);

        AuthCache authCache = new BasicAuthCache();
        BasicScheme basicAuth = new BasicScheme();
        HttpHost targetHost = new HttpHost(url.getHost(), url.getPort(), url.getProtocol());
        authCache.put(targetHost, basicAuth);

        localContext = new BasicHttpContext();
        localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
    }
}