static { HostConfiguration hostConfiguration = new HostConfiguration(); HttpConnectionManagerParams params = new HttpConnectionManagerParams(); params.setConnectionTimeout(3000); params.setMaxTotalConnections(2000); params.setStaleCheckingEnabled(true); params.setTcpNoDelay(true); params.setSoTimeout(10000); params.setMaxConnectionsPerHost(hostConfiguration, 1000); HttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager(); connectionManager.setParams(params); httpClient = new HttpClient(connectionManager); httpClient.setHostConfiguration(hostConfiguration); }
/** Factory method used by producers and consumers to create a new {@link HttpClient} instance */ public static HttpClient createHttpClient() { HttpClientParams clientParams = new HttpClientParams(); HttpConnectionManagerParams managerParams = new HttpConnectionManagerParams(); managerParams.setConnectionTimeout(1000); // 设置连接超时时间 managerParams.setDefaultMaxConnectionsPerHost(2); managerParams.setSoTimeout(1000); // 设置读取数据超时时间 HttpConnectionManager httpConnectionManager = new MultiThreadedHttpConnectionManager(); httpConnectionManager.setParams(managerParams); HttpClient answer = new HttpClient(clientParams); answer.setHttpConnectionManager(httpConnectionManager); return answer; }
public static HttpClient getClient() { int connectionTimeout = 3000; int pageTimeout = 7000; HttpConnectionManager connectionManager = new SimpleHttpConnectionManager(); HttpConnectionManagerParams connectionParams = connectionManager.getParams(); connectionParams.setConnectionTimeout(connectionTimeout); connectionParams.setSoTimeout(pageTimeout); HttpClient httpClient = null; if (connectionManager != null) { httpClient = new HttpClient(connectionManager); } return httpClient; }
public HostConfiguration getHostConfiguration(String location) throws IOException { if (_log.isDebugEnabled()) { _log.debug("Location is " + location); } HostConfiguration hostConfiguration = new HostConfiguration(); hostConfiguration.setHost(new URI(location, false)); if (isProxyHost(hostConfiguration.getHost())) { hostConfiguration.setProxy(_PROXY_HOST, _PROXY_PORT); } HttpConnectionManager httpConnectionManager = _httpClient.getHttpConnectionManager(); HttpConnectionManagerParams httpConnectionManagerParams = httpConnectionManager.getParams(); int defaultMaxConnectionsPerHost = httpConnectionManagerParams.getMaxConnectionsPerHost(hostConfiguration); int maxConnectionsPerHost = GetterUtil.getInteger( PropsUtil.get( HttpImpl.class.getName() + ".max.connections.per.host", new Filter(hostConfiguration.getHost()))); if ((maxConnectionsPerHost > 0) && (maxConnectionsPerHost != defaultMaxConnectionsPerHost)) { httpConnectionManagerParams.setMaxConnectionsPerHost( hostConfiguration, maxConnectionsPerHost); } int timeout = GetterUtil.getInteger( PropsUtil.get( HttpImpl.class.getName() + ".timeout", new Filter(hostConfiguration.getHost()))); if (timeout > 0) { HostParams hostParams = hostConfiguration.getParams(); hostParams.setIntParameter(HttpConnectionParams.CONNECTION_TIMEOUT, timeout); hostParams.setIntParameter(HttpConnectionParams.SO_TIMEOUT, timeout); } return hostConfiguration; }
static { HttpConnectionManagerParams params = loadHttpConfFromFile(); connectionManager = new MultiThreadedHttpConnectionManager(); connectionManager.setParams(params); client = new HttpClient(connectionManager); }
/* */ static /* */ { /* 39 */ HttpConnectionManagerParams params = loadHttpConfFromFile(); /* */ /* 41 */ connectionManager = new MultiThreadedHttpConnectionManager(); /* */ /* 43 */ connectionManager.setParams(params); client = new HttpClient(connectionManager); /* */ }
/** 私有的构造方法 */ private HttpProtocolHandler() { // 创建一个线程安全的HTTP连接池 connectionManager = new MultiThreadedHttpConnectionManager(); connectionManager.getParams().setDefaultMaxConnectionsPerHost(defaultMaxConnPerHost); connectionManager.getParams().setMaxTotalConnections(defaultMaxTotalConn); IdleConnectionTimeoutThread ict = new IdleConnectionTimeoutThread(); ict.addConnectionManager(connectionManager); ict.setConnectionTimeout(defaultIdleConnTimeout); ict.start(); }
/* (non-Javadoc) * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet() */ public void afterPropertiesSet() throws Exception { final HttpConnectionManager httpConnectionManager = httpClient.getHttpConnectionManager(); final HttpConnectionManagerParams params = httpConnectionManager.getParams(); params.setConnectionTimeout(connectionTimeout); params.setSoTimeout(readTimeout); params.setParameter( HttpMethodParams.RETRY_HANDLER, new HttpMethodRetryHandler() { public boolean retryMethod( final HttpMethod method, final IOException exception, int executionCount) { if (executionCount >= timesToRetry) { // Do not retry if over max retry count return false; } if (exception instanceof NoHttpResponseException) { // Retry if the server dropped connection on us return true; } if (exception instanceof SocketException) { // Retry if the server reset connection on us return true; } if (exception instanceof SocketTimeoutException) { // Retry if the read timed out return true; } if (!method.isRequestSent()) { // Retry if the request has not been sent fully or // if it's OK to retry methods that have been sent return true; } // otherwise do not retry return false; } }); }
/** * Creates a new connection to the server. * * @param builder The HttpFileSystemConfigBuilder. * @param scheme The protocol. * @param hostname The hostname. * @param port The port number. * @param username The username. * @param password The password * @param fileSystemOptions The file system options. * @return a new HttpClient connection. * @throws FileSystemException if an error occurs. * @since 2.0 */ public static HttpClient createConnection( HttpFileSystemConfigBuilder builder, String scheme, String hostname, int port, String username, String password, FileSystemOptions fileSystemOptions) throws FileSystemException { HttpClient client; try { HttpConnectionManager mgr = new MultiThreadedHttpConnectionManager(); HttpConnectionManagerParams connectionMgrParams = mgr.getParams(); client = new HttpClient(mgr); final HostConfiguration config = new HostConfiguration(); config.setHost(hostname, port, scheme); if (fileSystemOptions != null) { String proxyHost = builder.getProxyHost(fileSystemOptions); int proxyPort = builder.getProxyPort(fileSystemOptions); if (proxyHost != null && proxyHost.length() > 0 && proxyPort > 0) { config.setProxy(proxyHost, proxyPort); } UserAuthenticator proxyAuth = builder.getProxyAuthenticator(fileSystemOptions); if (proxyAuth != null) { UserAuthenticationData authData = UserAuthenticatorUtils.authenticate( proxyAuth, new UserAuthenticationData.Type[] { UserAuthenticationData.USERNAME, UserAuthenticationData.PASSWORD }); if (authData != null) { final UsernamePasswordCredentials proxyCreds = new UsernamePasswordCredentials( UserAuthenticatorUtils.toString( UserAuthenticatorUtils.getData( authData, UserAuthenticationData.USERNAME, null)), UserAuthenticatorUtils.toString( UserAuthenticatorUtils.getData( authData, UserAuthenticationData.PASSWORD, null))); AuthScope scope = new AuthScope(proxyHost, AuthScope.ANY_PORT); client.getState().setProxyCredentials(scope, proxyCreds); } if (builder.isPreemptiveAuth(fileSystemOptions)) { HttpClientParams httpClientParams = new HttpClientParams(); httpClientParams.setAuthenticationPreemptive(true); client.setParams(httpClientParams); } } Cookie[] cookies = builder.getCookies(fileSystemOptions); if (cookies != null) { client.getState().addCookies(cookies); } } /** * ConnectionManager set methodsmust be called after the host & port and proxy host & port are * set in the HostConfiguration. They are all used as part of the key when * HttpConnectionManagerParams tries to locate the host configuration. */ connectionMgrParams.setMaxConnectionsPerHost( config, builder.getMaxConnectionsPerHost(fileSystemOptions)); connectionMgrParams.setMaxTotalConnections(builder.getMaxTotalConnections(fileSystemOptions)); client.setHostConfiguration(config); if (username != null) { final UsernamePasswordCredentials creds = new UsernamePasswordCredentials(username, password); AuthScope scope = new AuthScope(hostname, AuthScope.ANY_PORT); client.getState().setCredentials(scope, creds); } client.executeMethod(new HeadMethod()); } catch (final Exception exc) { throw new FileSystemException( "vfs.provider.http/connect.error", new Object[] {hostname}, exc); } return client; }
private String send(HttpMethod method, boolean sslExceptionIgnore) throws HttpNetAgentException { String responseBody = null; HttpClient hc = null; try { this.hashCode(); String reqLog = ">> " + (method instanceof PostMethod ? "POST" : "GET") + " [" + method.getURI() + "]"; if (method instanceof PostMethod) { NameValuePair[] params = ((PostMethod) method).getParameters(); for (int i = 0; i < params.length; i++) { NameValuePair param = params[i]; reqLog += "\n" + (param.getName() + "=" + param.getValue()); } } reqLog += ", hscd[" + this.hashCode() + "], sslExcIgnore[" + sslExceptionIgnore + "], hs[" + this.hashCode() + "]"; logger.info(reqLog); logger.info(getHttpInfoDumy(method)); HttpConnectionManager httpConnMgr = new SimpleHttpConnectionManager(); HttpConnectionManagerParams httpConnMgrParams = new HttpConnectionManagerParams(); // Connection Timeout 설정 httpConnMgrParams.setConnectionTimeout(netTimeoutConn); // Socket Timeout 설정 httpConnMgrParams.setSoTimeout(netTimeoutSock); httpConnMgr.setParams(httpConnMgrParams); hc = new HttpClient(httpConnMgr); /* if (sslExceptionIgnore){ try { Protocol.registerProtocol("https", new Protocol("https", new EasySSLProtocolSocketFactory(), 443)); } catch (GeneralSecurityException e) { e.printStackTrace(); } } */ int status = hc.executeMethod(method); if (200 == status) { responseBody = method.getResponseBodyAsString(); logger.info("<< responseBody [" + responseBody + "], hs[" + this.hashCode() + "]"); if (responseBody == null) responseBody = ""; } else { logger.error( "<< http status Not Success [" + status + "], hs[" + this.hashCode() + "]," + getHttpInfoDumy(method)); throw new HttpNetAgentException( HttpNetAgentException.HTTP_HAEDER_NOT_SUCCESS, "Http Status[" + status + "]"); } } catch (HttpException e) { logger.error( "<< HttpException msg [" + e.getMessage() + "], hs[" + this.hashCode() + "]," + getHttpInfoDumy(method), e); throw new HttpNetAgentException(HttpNetAgentException.HTTP_NET_ERROR, e.getMessage()); } catch (IOException e) { logger.error( "<< IOException msg [" + e.getMessage() + "], hs[" + this.hashCode() + "]," + getHttpInfoDumy(method), e); throw new HttpNetAgentException(HttpNetAgentException.HTTP_NET_ERROR, e.getMessage()); } return responseBody; }
public HttpClient getHttpClient() { HttpConnectionManagerParams params = new HttpConnectionManagerParams(); HttpConnectionManager manager = new MultiThreadedHttpConnectionManager(); manager.setParams(params); return new HttpClient(manager); }