public HttpUtils(int connTimeout, String userAgent) { HttpParams params = new BasicHttpParams(); ConnManagerParams.setTimeout(params, connTimeout); HttpConnectionParams.setSoTimeout(params, connTimeout); HttpConnectionParams.setConnectionTimeout(params, connTimeout); if (TextUtils.isEmpty(userAgent)) { userAgent = OtherUtils.getUserAgent(null); } HttpProtocolParams.setUserAgent(params, userAgent); ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10)); ConnManagerParams.setMaxTotalConnections(params, 10); HttpConnectionParams.setTcpNoDelay(params, true); HttpConnectionParams.setSocketBufferSize(params, 1024 * 8); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443)); httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params); httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES)); httpClient.addRequestInterceptor( new HttpRequestInterceptor() { @Override public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.HttpException, IOException { if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) { httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP); } } }); httpClient.addResponseInterceptor( new HttpResponseInterceptor() { @Override public void process(HttpResponse response, HttpContext httpContext) throws org.apache.http.HttpException, IOException { final HttpEntity entity = response.getEntity(); if (entity == null) { return; } final Header encoding = entity.getContentEncoding(); if (encoding != null) { for (HeaderElement element : encoding.getElements()) { if (element.getName().equalsIgnoreCase("gzip")) { response.setEntity(new GZipDecompressingEntity(response.getEntity())); return; } } } } }); }
private HttpClient getHttpClient() { if (null == customerHttpClient) { HttpParams params = new BasicHttpParams(); // 设置一些基本参数 HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); HttpProtocolParams.setUseExpectContinue(params, true); HttpProtocolParams.setUserAgent(params, "Linux; Android 2.2.1;zh-CN; itkt_Android"); // HttpClientParams.setRedirecting(params, true); // HttpClientParams.setCookiePolicy(params, CookiePolicy.BROWSER_COMPATIBILITY); // 设置最大连接数 ConnManagerParams.setMaxTotalConnections(params, MAX_TOTAL_CONNECTIONS); // 设置获取连接的最大等待时间 ConnManagerParams.setTimeout(params, WAIT_TIMEOUT); // 设置每个路由最大连接数 ConnPerRouteBean connPerRoute = new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS); ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute); // 设置连接超时时间 HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIMEOUT); // 设置读取超时时间 HttpConnectionParams.setSoTimeout(params, READ_TIMEOUT); try { KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); SchemeRegistry schReg = new SchemeRegistry(); schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); // 使用线程安全的连接管理来创建HttpClient ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg); customerHttpClient = new DefaultHttpClient(conMgr, params); customerHttpClient.getParams().setParameter("http.protocol.content-charset", HTTP.UTF_8); } catch (Exception e) { e.printStackTrace(); } } return customerHttpClient; }
public void testCloseExpiredConnections() throws Exception { HttpParams mgrpar = defaultParams.copy(); ConnManagerParams.setMaxTotalConnections(mgrpar, 1); SingleClientConnManager mgr = createSCCM(mgrpar, null); final HttpHost target = getServerHttp(); final HttpRoute route = new HttpRoute(target, null, false); ManagedClientConnection conn = mgr.getConnection(route, null); conn.open(route, httpContext, defaultParams); mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); mgr.closeExpiredConnections(); conn = mgr.getConnection(route, null); assertTrue(conn.isOpen()); mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); Thread.sleep(150); mgr.closeExpiredConnections(); conn = mgr.getConnection(route, null); assertFalse(conn.isOpen()); mgr.shutdown(); }
protected DefaultHttpClient getHttpClient() { if (httpClient == null) { HttpParams httpParams = new BasicHttpParams(); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8); HttpProtocolParams.setUseExpectContinue( httpParams, false); // some webservers have problems if this is set to true ConnManagerParams.setMaxTotalConnections(httpParams, MAX_TOTAL_CONNECTIONS); HttpConnectionParams.setConnectionTimeout(httpParams, CONNECTION_TIMEOUT); HttpConnectionParams.setSoTimeout(httpParams, SOCKET_TIMEOUT); // httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY, new // HttpHost("192.168.16.180", 8888, "http")); httpParams.setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.RFC_2109); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpClient = new DefaultHttpClient(connectionManager, httpParams); } return httpClient; }
private DefaultHttpClient getNewHttpClient() { DefaultHttpClient client = null; try { KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); trustStore.load(null, null); SSLSocketFactory sf = new TrustedSSLSocketFactory(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 100); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); SchemeRegistry registry = new SchemeRegistry(); registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); registry.register(new Scheme("https", sf, 443)); ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry); client = new DefaultHttpClient(ccm, params); } catch (Exception e) { client = new DefaultHttpClient(); } client = applyTimeout(client); return client; }
/** Creates a new AsyncHttpClient. */ public AsyncHttpClient() { BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, socketTimeout); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections)); ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS); HttpConnectionParams.setSoTimeout(httpParams, socketTimeout); HttpConnectionParams.setTcpNoDelay(httpParams, true); HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent( httpParams, String.format("android-async-http/%s (http://loopj.com/android-async-http)", VERSION)); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpContext = new SyncBasicHttpContext(new BasicHttpContext()); httpClient = new DefaultHttpClient(cm, httpParams); httpClient.addRequestInterceptor( new HttpRequestInterceptor() { public void process(HttpRequest request, HttpContext context) { if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) { request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP); } for (String header : clientHeaderMap.keySet()) { request.addHeader(header, clientHeaderMap.get(header)); } } }); httpClient.addResponseInterceptor( new HttpResponseInterceptor() { public void process(HttpResponse response, HttpContext context) { final HttpEntity entity = response.getEntity(); final Header encoding = entity.getContentEncoding(); if (encoding != null) { for (HeaderElement element : encoding.getElements()) { if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) { response.setEntity(new InflatingEntity(response.getEntity())); break; } } } } }); httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_MAX_RETRIES)); threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool(); requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>(); clientHeaderMap = new HashMap<String, String>(); }
public Http(Context context) { BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, socketTimeout); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections)); ConnManagerParams.setMaxTotalConnections(httpParams, 10); HttpConnectionParams.setSoTimeout(httpParams, socketTimeout); HttpConnectionParams.setConnectionTimeout(httpParams, socketTimeout); HttpConnectionParams.setTcpNoDelay(httpParams, true); HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpContext = new SyncBasicHttpContext(new BasicHttpContext()); httpClient = new DefaultHttpClient(cm, httpParams); httpClient.addRequestInterceptor( new HttpRequestInterceptor() { public void process(HttpRequest request, HttpContext context) { if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) { request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP); } for (String header : clientHeaderMap.keySet()) { request.addHeader(header, clientHeaderMap.get(header)); } } }); httpClient.addResponseInterceptor( new HttpResponseInterceptor() { public void process(HttpResponse response, HttpContext context) { final HttpEntity entity = response.getEntity(); if (entity == null) { return; } final Header encoding = entity.getContentEncoding(); if (encoding != null) { for (HeaderElement element : encoding.getElements()) { if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) { response.setEntity(new InflatingEntity(response.getEntity())); break; } } } } }); clientHeaderMap = new HashMap<String, String>(); }
private static DefaultHttpClient clientFactory() { SchemeRegistry sr = new SchemeRegistry(); sr.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); BasicHttpParams params = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(params, CONN_TIMEOUT); HttpConnectionParams.setSoTimeout(params, CONN_TIMEOUT); ConnManagerParams.setMaxTotalConnections(params, MAX_TOTAL_CONN); ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(MAX_CONN_PER_ROUTE)); ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(params, sr); DefaultHttpClient client = new DefaultHttpClient(mgr, params); return client; }
private static void setupHttpClient() { BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, CONNECTION_TIMEOUT); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(MAX_CONNECTIONS)); ConnManagerParams.setMaxTotalConnections(httpParams, MAX_CONNECTIONS); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent(httpParams, HTTP_USER_AGENT); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); // schemeRegistry.register(new Scheme("https", new // EasySSLProtocolSocketFactory(), 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8); httpClient = new DefaultHttpClient(cm, httpParams); }
/** initialize HttpParams , initialize settings such as total connextions,timeout ... */ private BasicHttpParams createHttpParams() { BasicHttpParams params = new BasicHttpParams(); ConnManagerParams.setTimeout(params, config.getConnectTimeout()); ConnManagerParams.setMaxConnectionsPerRoute( params, new ConnPerRouteBean(DEFAULT_MAX_CONN_PER_ROUT)); ConnManagerParams.setMaxTotalConnections(params, DEFAULT_MAX_CONN_TOTAL); HttpConnectionParams.setTcpNoDelay(params, TCP_NO_DELAY); HttpConnectionParams.setConnectionTimeout(params, config.getConnectTimeout()); HttpConnectionParams.setSoTimeout(params, config.getSocketTimeout()); HttpConnectionParams.setSocketBufferSize(params, config.getSocketBufferSize()); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent(params, config.getUserAgent()); // settingOthers(params); return params; }
public static HttpClient getThreadSafeClient() { HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 100); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpConnectionParams.setConnectionTimeout(params, REGISTRATION_TIMEOUT); HttpConnectionParams.setSoTimeout(params, REGISTRATION_TIMEOUT); ConnManagerParams.setTimeout(params, REGISTRATION_TIMEOUT); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ClientConnectionManager mgr = new ThreadSafeClientConnManager(params, schemeRegistry); HttpClient client = new DefaultHttpClient(mgr, params); return client; }
/** Tests that SCM can still connect to the same host after a connection was aborted. */ public void testOpenAfterAbort() throws Exception { HttpParams mgrpar = defaultParams.copy(); ConnManagerParams.setMaxTotalConnections(mgrpar, 1); SingleClientConnManager mgr = createSCCM(mgrpar, null); final HttpHost target = getServerHttp(); final HttpRoute route = new HttpRoute(target, null, false); ManagedClientConnection conn = mgr.getConnection(route, null); assertTrue(conn instanceof AbstractClientConnAdapter); ((AbstractClientConnAdapter) conn).abortConnection(); conn = mgr.getConnection(route, null); assertFalse("connection should have been closed", conn.isOpen()); conn.open(route, httpContext, defaultParams); mgr.releaseConnection(conn, -1, null); mgr.shutdown(); }
public void testAlreadyLeased() throws Exception { HttpParams mgrpar = defaultParams.copy(); ConnManagerParams.setMaxTotalConnections(mgrpar, 1); SingleClientConnManager mgr = createSCCM(mgrpar, null); final HttpHost target = getServerHttp(); final HttpRoute route = new HttpRoute(target, null, false); ManagedClientConnection conn = mgr.getConnection(route, null); mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); mgr.getConnection(route, null); try { mgr.getConnection(route, null); fail("IllegalStateException should have been thrown"); } catch (IllegalStateException ex) { mgr.shutdown(); } }
public static HttpClient newInstance() { HttpParams params = new BasicHttpParams(); // 不自动处理重定向请求 params.setParameter(ClientPNames.HANDLE_REDIRECTS, false); HttpConnectionParams.setStaleCheckingEnabled(params, true); HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT); HttpConnectionParams.setSoTimeout(params, SOCKET_OPERATION_TIMEOUT); HttpConnectionParams.setSocketBufferSize(params, SOCKET_BUFFER_SIZE); HttpConnectionParams.setTcpNoDelay(params, true); ConnManagerParams.setMaxTotalConnections(params, 50); ConnPerRouteBean connPerRoute = new ConnPerRouteBean(); connPerRoute.setDefaultMaxPerRoute(4); ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); SSLSocketFactory socketFactory = SSLSocketFactory.getSocketFactory(); socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); schemeRegistry.register(new Scheme("https", socketFactory, 443)); ClientConnectionManager manager = new ThreadSafeClientConnManager(params, schemeRegistry); return new DefaultHttpClient(manager, params); }
protected void setupHttpClient() { LOG.info("setting up http client"); BasicHttpParams httpParams = new BasicHttpParams(); HttpConnectionParams.setSoTimeout(httpParams, 70 * 1000); HttpConnectionParams.setConnectionTimeout(httpParams, 10 * 1000); ConnManagerParams.setMaxTotalConnections(httpParams, 200); ConnPerRoute connPerRoute = new ConnPerRouteBean(400); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, connPerRoute); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); // ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, // HttpClientWithKeystore.getSchemeRegistry()); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setContentCharset(httpParams, "utf-8"); mHttpClient = new HttpClientWithKeystore(cm, httpParams); mHttpClient.getParams().setParameter("http.useragent", mConfig.getApplicationName()); mHttpClient.getParams().setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false); mHttpClient.setReuseStrategy(new NoConnectionReuseStrategy()); }
public void init() { if (inited) { return; } // init thread pool executor = new NimTaskExecutor( "NIM_HTTP_TASK_EXECUTOR", new NimTaskExecutor.Config(1, 3, 10 * 1000, true)); // init HttpClient supporting multi thread access HttpParams httpParams = new BasicHttpParams(); // 设置最大连接数 ConnManagerParams.setMaxTotalConnections(httpParams, MAX_CONNECTIONS); // 设置获取连接的最大等待时间 ConnManagerParams.setTimeout(httpParams, WAIT_TIMEOUT); // 设置每个路由最大连接数 ConnManagerParams.setMaxConnectionsPerRoute( httpParams, new ConnPerRouteBean(MAX_ROUTE_CONNECTIONS)); // 设置连接超时时间 HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT); // 设置读取超时时间 HttpConnectionParams.setSoTimeout(httpParams, READ_TIMEOUT); SchemeRegistry registry = new SchemeRegistry(); registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); SSLSocketFactory.getSocketFactory().setHostnameVerifier(new AllowAllHostnameVerifier()); connManager = new ThreadSafeClientConnManager(httpParams, registry); client = new DefaultHttpClient(connManager, httpParams); uiHandler = new Handler(DemoCache.getContext().getMainLooper()); inited = true; }
public Publisher() { HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 200); ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20); connPerRoute.setDefaultMaxPerRoute(50); ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); httpClient = new DefaultHttpClient(cm, params); httpClient.setKeepAliveStrategy( new ConnectionKeepAliveStrategy() { public long getKeepAliveDuration(HttpResponse response, HttpContext context) { HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE)); while (it.hasNext()) { HeaderElement he = it.nextElement(); String param = he.getName(); String value = he.getValue(); if (value != null && param.equalsIgnoreCase("timeout")) { try { return Long.parseLong(value) * 1000; } catch (NumberFormatException ignore) { } } } // default keepalive is 60 seconds. This is higher than usual // since the number of hubs it should be talking to should be // small return 30 * 1000; } }); }
private void initHttpClient() { try { // Create and initialize HTTP parameters HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 10); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); // Create and initialize scheme registry SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 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("https", sf, 443)); // Create an HttpClient with the ThreadSafeClientConnManager. ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); mClient = new DefaultHttpClient(cm, params); } catch (Exception e) { mClient = new DefaultHttpClient(); } }
private synchronized HttpClient initHttpClient(final BOSHClientConfig config) { // Create and initialize HTTP parameters HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 100); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setUseExpectContinue(params, false); if (config != null && config.getProxyHost() != null && config.getProxyPort() != 0) { HttpHost proxy = new HttpHost(config.getProxyHost(), config.getProxyPort()); params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy); } // Create and initialize scheme registry SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); SSLSocketFactory sslFactory = SSLSocketFactory.getSocketFactory(); sslFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); schemeRegistry.register(new Scheme("https", sslFactory, 443)); // Create an HttpClient with the ThreadSafeClientConnManager. // This connection manager must be used if more than one thread will // be using the HttpClient. ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); return new DefaultHttpClient(cm, params); }
/** * Geeft een (Thread-safe) instantie van de httpclient * * @return instantie van httpclient */ public static HttpClient getClient() { // Er mag maar ייn instantie van de thread-safe httpclient zijn, dus we maken er ook maar ייn if (SyncClient.httpclient == null) { // Bron van onderstaande: // http://svn.apache.org/repos/asf/httpcomponents/httpclient/branches/4.0.x/httpclient/src/examples/org/apache/http/examples/client/ClientMultiThreadedExecution.java // Create and initialize HTTP parameters HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, 100); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); // Create and initialize scheme registry SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); // Create an HttpClient with the ThreadSafeClientConnManager. // This connection manager must be used if more than one thread will // be using the HttpClient. ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); SyncClient.httpclient = new DefaultHttpClient(cm, params); } return SyncClient.httpclient; }
/** Tests releasing with time limits. */ public void testReleaseConnectionWithTimeLimits() throws Exception { HttpParams mgrpar = defaultParams.copy(); ConnManagerParams.setMaxTotalConnections(mgrpar, 1); SingleClientConnManager mgr = createSCCM(mgrpar, null); final HttpHost target = getServerHttp(); final HttpRoute route = new HttpRoute(target, null, false); final int rsplen = 8; final String uri = "/random/" + rsplen; HttpRequest request = new BasicHttpRequest("GET", uri, HttpVersion.HTTP_1_1); ManagedClientConnection conn = mgr.getConnection(route, null); conn.open(route, httpContext, defaultParams); // a new context is created for each testcase, no need to reset HttpResponse response = Helper.execute( request, conn, target, httpExecutor, httpProcessor, defaultParams, httpContext); assertEquals( "wrong status in first response", HttpStatus.SC_OK, response.getStatusLine().getStatusCode()); byte[] data = EntityUtils.toByteArray(response.getEntity()); assertEquals("wrong length of first response entity", rsplen, data.length); // ignore data, but it must be read // release connection without marking for re-use // expect the next connection obtained to be closed mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); conn = mgr.getConnection(route, null); assertFalse("connection should have been closed", conn.isOpen()); // repeat the communication, no need to prepare the request again conn.open(route, httpContext, defaultParams); httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); response = httpExecutor.execute(request, conn, httpContext); httpExecutor.postProcess(response, httpProcessor, httpContext); assertEquals( "wrong status in second response", HttpStatus.SC_OK, response.getStatusLine().getStatusCode()); data = EntityUtils.toByteArray(response.getEntity()); assertEquals("wrong length of second response entity", rsplen, data.length); // ignore data, but it must be read // release connection after marking it for re-use // expect the next connection obtained to be open conn.markReusable(); mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); conn = mgr.getConnection(route, null); assertTrue("connection should have been open", conn.isOpen()); // repeat the communication, no need to prepare the request again httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); response = httpExecutor.execute(request, conn, httpContext); httpExecutor.postProcess(response, httpProcessor, httpContext); assertEquals( "wrong status in third response", HttpStatus.SC_OK, response.getStatusLine().getStatusCode()); data = EntityUtils.toByteArray(response.getEntity()); assertEquals("wrong length of third response entity", rsplen, data.length); // ignore data, but it must be read conn.markReusable(); mgr.releaseConnection(conn, 100, TimeUnit.MILLISECONDS); Thread.sleep(150); conn = mgr.getConnection(route, null); assertTrue("connection should have been closed", !conn.isOpen()); // repeat the communication, no need to prepare the request again conn.open(route, httpContext, defaultParams); httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); response = httpExecutor.execute(request, conn, httpContext); httpExecutor.postProcess(response, httpProcessor, httpContext); assertEquals( "wrong status in third response", HttpStatus.SC_OK, response.getStatusLine().getStatusCode()); data = EntityUtils.toByteArray(response.getEntity()); assertEquals("wrong length of fourth response entity", rsplen, data.length); // ignore data, but it must be read mgr.shutdown(); }
/** * Creates a handler with the specified input URL, max thread count, and message backlog support. * * @param inputUrl - the URL provided by Loggly for sending log messages to * @param maxThreads - the max number of concurrent background threads that are allowed to send * data to Loggly * @param backlog - the max number of log messages that can be queued up (anything beyond will be * thrown away) */ public LogglyHandler(String inputUrl, int maxThreads, int backlog) { this.inputUrl = inputUrl; pool = new ThreadPoolExecutor( maxThreads, maxThreads, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(backlog), new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, "Loggly Thread"); thread.setDaemon(true); return thread; } }, new ThreadPoolExecutor.DiscardOldestPolicy()); pool.allowCoreThreadTimeOut(true); retryQueue = new LinkedBlockingQueue<LogglySample>(backlog); Thread retryThread = new Thread( new Runnable() { @Override public void run() { while (allowRetry) { // drain the retry requests LogglySample sample = null; while ((sample = retryQueue.poll()) != null) { if (sample.retryCount > 10) { // todo: capture statistics about the failure (exception and/or status code) // and then report on it in some sort of thoughtful way to standard err } else { pool.submit(sample); } } // retry every 10 seconds try { Thread.sleep(10000); } catch (InterruptedException e) { System.err.println("Retry sleep was interrupted, giving up on retry thread"); return; } } } }, "Loggly Retry Thread"); retryThread.setDaemon(true); retryThread.start(); HttpParams params = new BasicHttpParams(); ConnManagerParams.setMaxTotalConnections(params, maxThreads); ConnPerRouteBean connPerRoute = new ConnPerRouteBean(maxThreads); ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute); // set 15 second timeouts, since Loggly should return quickly params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 15000); params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 15000); SchemeRegistry registry = new SchemeRegistry(); try { registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); } catch (Exception e) { throw new RuntimeException("Could not register SSL socket factor for Loggly", e); } ThreadSafeClientConnManager connManager = new ThreadSafeClientConnManager(params, registry); httpClient = new DefaultHttpClient(connManager, params); // because the threads a daemon threads, we want to give them a chance // to finish up before we totally shut down Runtime.getRuntime() .addShutdownHook( new Thread( new Runnable() { @Override public void run() { close(); } })); }
private static void httpInit() { try { HttpParams params = new BasicHttpParams(); params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, Integer.valueOf(30000)); params.setParameter(CoreConnectionPNames.SO_TIMEOUT, Integer.valueOf(50000)); // 设置20秒socket超时 params.setLongParameter(ConnManagerPNames.TIMEOUT, 30000); params.setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false); params.setParameter( CoreConnectionPNames.SOCKET_BUFFER_SIZE, Integer.valueOf(8192 * 3)); // 默认是8192 byte socket buffers ConnManagerParams.setMaxTotalConnections(params, 200); ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20); HttpHost localhost = new HttpHost(INFO.HOST_IP, INFO.HOST_PORT); connPerRoute.setMaxForRoute(new HttpRoute(localhost), 50); ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute); //////////////////// KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); trustStore.load(null, null); SSLSocketFactory sf = new SSLSocketFactoryEx(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); //////////////////////////////////// SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", sf, 443)); ClientConnectionManager clientManager = new ThreadSafeClientConnManager(params, schemeRegistry); defaultHttpClient = new DefaultHttpClient(clientManager, params); defaultHttpClient.setKeepAliveStrategy( new DefaultConnectionKeepAliveStrategy() { public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive = super.getKeepAliveDuration(response, context); if (keepAlive == -1) { keepAlive = 5000; } return keepAlive; } }); defaultHttpClient.addRequestInterceptor(preemptiveAuth, 0); defaultHttpClient.setHttpRequestRetryHandler( new HttpRequestRetryHandler() { public boolean retryRequest( IOException exception, int executionCount, HttpContext context) { // INFO.Log("NETWORKTEST>><<",exception.toString()+"##"+executionCount); if (executionCount >= 2) { return false; } if (exception instanceof NoHttpResponseException) { // 服务停掉则重新尝试连接 // INFO.Log("NETWORKTEST>><<","port:"+INFO.HOST_PORT); return true; } if (exception instanceof UnknownHostException) { INFO.HOST_PORT = 8080; // INFO.Log("NETWORKTEST>><<","port:"+INFO.HOST_PORT); return true; } if (exception instanceof UnknownServiceException) { INFO.HOST_PORT = 8080; // INFO.Log("NETWORKTEST>><<","Service:"+INFO.HOST_PORT); return true; } if (exception instanceof SocketException) { // INFO.Log("NETWORKTEST>><<","SocketException"); return true; } if (exception instanceof SSLHandshakeException) { return false; } HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST); boolean idempotent = !(request instanceof HttpEntityEnclosingRequest); if (idempotent) { return true; } return false; } }); } catch (Exception ex) { ex.printStackTrace(); } // ssl // FileInputStream instream = new FileInputStream(new File("my.keystore")); // InputStream instream = appContext.getResources().openRawResource(R.drawable.adcd); //读证书 // try { // KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); // //KeyStore.getDefaultType() android为 BKS // trustStore.load(instream, "nopassword".toCharArray()); // SSLSocketFactory socketFactory = new SSLSocketFactory(trustStore); // Scheme sch = new Scheme("https", socketFactory, 443); //443端口 // defaultHttpClient.getConnectionManager().getSchemeRegistry().register(sch); // }catch(Exception e){ // e.printStackTrace(); // }finally { // try { // instream.close(); // } catch (IOException e) { // e.printStackTrace(); // } // } }
/** * Creates a new fetcher for fetching HTTP objects. Not really suitable for production use. Use of * an HTTP proxy for security is also necessary for production deployment. * * @param maxObjSize Maximum size, in bytes, of the object we will fetch, 0 if no limit.. * @param connectionTimeoutMs timeout, in milliseconds, for connecting to hosts. * @param readTimeoutMs timeout, in millseconds, for unresponsive connections * @param basicHttpFetcherProxy The http proxy to use. */ public BasicHttpFetcher( int maxObjSize, int connectionTimeoutMs, int readTimeoutMs, String basicHttpFetcherProxy) { // Create and initialize HTTP parameters setMaxObjectSizeBytes(maxObjSize); setSlowResponseWarning(DEFAULT_SLOW_RESPONSE_WARNING); HttpParams params = new BasicHttpParams(); ConnManagerParams.setTimeout(params, connectionTimeoutMs); // These are probably overkill for most sites. ConnManagerParams.setMaxTotalConnections(params, 1152); ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(256)); HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent(params, "Apache Shindig"); HttpProtocolParams.setContentCharset(params, "UTF-8"); HttpConnectionParams.setConnectionTimeout(params, connectionTimeoutMs); HttpConnectionParams.setSoTimeout(params, readTimeoutMs); HttpConnectionParams.setStaleCheckingEnabled(params, true); HttpClientParams.setRedirecting(params, true); HttpClientParams.setAuthenticating(params, false); // Create and initialize scheme registry SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); // UCSF. Change to allow self signed registered certs /** * try { SSLContext sslContext = SSLContext.getInstance("SSL"); // set up a TrustManager that * trusts everything sslContext.init(null, new TrustManager[] { new X509TrustManager() { public * X509Certificate[] getAcceptedIssuers() { System.out.println("getAcceptedIssuers * ============="); return null; } * * <p>public void checkClientTrusted(X509Certificate[] certs, String authType) { * System.out.println("checkClientTrusted ============="); } * * <p>public void checkServerTrusted(X509Certificate[] certs, String authType) { * System.out.println("checkServerTrusted ============="); } } }, new SecureRandom()); * SSLSocketFactory sf = new SSLSocketFactory(sslContext); * sf.setHostnameVerifier((X509HostnameVerifier)org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); * schemeRegistry.register(new Scheme("https", sf, 443)); } catch (Exception e) { throw new * RuntimeException(e); } */ schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); // end UCSF ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); DefaultHttpClient client = new DefaultHttpClient(cm, params); // Set proxy if set via guice. if (!StringUtils.isEmpty(basicHttpFetcherProxy)) { String[] splits = basicHttpFetcherProxy.split(":"); ConnRouteParams.setDefaultProxy( client.getParams(), new HttpHost(splits[0], Integer.parseInt(splits[1]), "http")); } // try resending the request once client.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(1, true)); // Add hooks for gzip/deflate client.addRequestInterceptor( new HttpRequestInterceptor() { public void process(final org.apache.http.HttpRequest request, final HttpContext context) throws HttpException, IOException { if (!request.containsHeader("Accept-Encoding")) { request.addHeader("Accept-Encoding", "gzip, deflate"); } } }); client.addResponseInterceptor( new HttpResponseInterceptor() { public void process( final org.apache.http.HttpResponse response, final HttpContext context) throws HttpException, IOException { HttpEntity entity = response.getEntity(); if (entity != null) { Header ceheader = entity.getContentEncoding(); if (ceheader != null) { for (HeaderElement codec : ceheader.getElements()) { String codecname = codec.getName(); if ("gzip".equalsIgnoreCase(codecname)) { response.setEntity(new GzipDecompressingEntity(response.getEntity())); return; } else if ("deflate".equals(codecname)) { response.setEntity(new DeflateDecompressingEntity(response.getEntity())); return; } } } } } }); client.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler()); // Disable automatic storage and sending of cookies (see SHINDIG-1382) client.removeRequestInterceptorByClass(RequestAddCookies.class); client.removeResponseInterceptorByClass(ResponseProcessCookies.class); // Use Java's built-in proxy logic in case no proxy set via guice. if (StringUtils.isEmpty(basicHttpFetcherProxy)) { ProxySelectorRoutePlanner routePlanner = new ProxySelectorRoutePlanner( client.getConnectionManager().getSchemeRegistry(), ProxySelector.getDefault()); client.setRoutePlanner(routePlanner); } FETCHER = client; }
/** * {@inheritDoc} <br> * <br> * The default implementation does all of this and more, including using a connection pool and * killing connections after a timeout to use less battery power on mobile devices. It's unlikely * that you'll want to change this behavior. */ @Override public synchronized HttpClient getHttpClient() { if (client == null) { // Set up default connection params. There are two routes to // Dropbox - api server and content server. HttpParams connParams = new BasicHttpParams(); ConnManagerParams.setMaxConnectionsPerRoute( connParams, new ConnPerRoute() { @Override public int getMaxForRoute(HttpRoute route) { return 10; } }); ConnManagerParams.setMaxTotalConnections(connParams, 20); // Set up scheme registry. SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); DBClientConnManager cm = new DBClientConnManager(connParams, schemeRegistry); try { SSLContext sslContext = SSLContext.getInstance("SSL"); sslContext.init( null, new TrustManager[] { new X509TrustManager() { public X509Certificate[] getAcceptedIssuers() { System.out.println("getAcceptedIssuers ============="); return null; } public void checkClientTrusted(X509Certificate[] certs, String authType) { System.out.println("checkClientTrusted ============="); } public void checkServerTrusted(X509Certificate[] certs, String authType) { System.out.println("checkServerTrusted ============="); } } }, new SecureRandom()); SSLSocketFactory sf = new SSLSocketFactory(sslContext); Scheme httpsScheme = new Scheme("https", 443, sf); schemeRegistry.register(httpsScheme); } catch (Exception e) { e.printStackTrace(); } schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); // Set up client params. HttpParams httpParams = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(httpParams, DEFAULT_TIMEOUT_MILLIS); HttpConnectionParams.setSoTimeout(httpParams, DEFAULT_TIMEOUT_MILLIS); HttpConnectionParams.setSocketBufferSize(httpParams, 8192); HttpProtocolParams.setUserAgent( httpParams, "OfficialDropboxJavaSDK/" + DropboxAPI.SDK_VERSION); DefaultHttpClient c = new DefaultHttpClient(cm, httpParams) { @Override protected ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy() { return new DBKeepAliveStrategy(); } @Override protected ConnectionReuseStrategy createConnectionReuseStrategy() { return new DBConnectionReuseStrategy(); } }; c.addRequestInterceptor( new HttpRequestInterceptor() { @Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { if (!request.containsHeader("Accept-Encoding")) { request.addHeader("Accept-Encoding", "gzip"); } } }); c.addResponseInterceptor( new HttpResponseInterceptor() { @Override public void process(final HttpResponse response, final HttpContext context) throws HttpException, IOException { HttpEntity entity = response.getEntity(); if (entity != null) { Header ceheader = entity.getContentEncoding(); if (ceheader != null) { HeaderElement[] codecs = ceheader.getElements(); for (HeaderElement codec : codecs) { if (codec.getName().equalsIgnoreCase("gzip")) { response.setEntity(new GzipDecompressingEntity(response.getEntity())); return; } } } } } }); client = c; } return client; }
/** * Creates a new AsyncHttpClient and set timeout. * * @param timeout 超时时间 */ public AsyncHttpClient(int timeout) { this.socketTimeout = timeout; BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, socketTimeout); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(maxConnections)); ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS); HttpConnectionParams.setSoTimeout(httpParams, socketTimeout); HttpConnectionParams.setTcpNoDelay(httpParams, true); HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent( httpParams, String.format("android-async-http/%s (http://loopj.com/android-async-http)", VERSION)); SchemeRegistry schemeRegistry = new SchemeRegistry(); SSLSocketFactory sf = null; try { KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); trustStore.load(null, null); sf = new MySSLSocketFactory(trustStore); } catch (Exception e) { e.printStackTrace(); } sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", sf, 443)); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpContext = new SyncBasicHttpContext(new BasicHttpContext()); httpClient = new DefaultHttpClient(cm, httpParams); httpClient.addRequestInterceptor( new HttpRequestInterceptor() { public void process(HttpRequest request, HttpContext context) { if (!request.containsHeader(HEADER_ACCEPT_ENCODING)) { request.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP); } for (String header : clientHeaderMap.keySet()) { request.addHeader(header, clientHeaderMap.get(header)); } } }); httpClient.addResponseInterceptor( new HttpResponseInterceptor() { public void process(HttpResponse response, HttpContext context) { final HttpEntity entity = response.getEntity(); final Header encoding = entity.getContentEncoding(); if (encoding != null) { for (HeaderElement element : encoding.getElements()) { if (element.getName().equalsIgnoreCase(ENCODING_GZIP)) { response.setEntity(new InflatingEntity(response.getEntity())); break; } } } } }); httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_MAX_RETRIES)); /* HttpHost proxy = NetworkUtils.getHttpHostProxy(); if (proxy!=null) { // set proxy httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy); } */ threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool(); requestMap = new WeakHashMap<Context, List<WeakReference<Future<?>>>>(); clientHeaderMap = new HashMap<String, String>(); }
public AsyncHttpClient() { HttpParams basicHttpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(basicHttpParams, (long) socketTimeout); ConnManagerParams.setMaxConnectionsPerRoute( basicHttpParams, new ConnPerRouteBean(maxConnections)); ConnManagerParams.setMaxTotalConnections(basicHttpParams, DEFAULT_MAX_CONNECTIONS); HttpConnectionParams.setSoTimeout(basicHttpParams, socketTimeout); HttpConnectionParams.setConnectionTimeout(basicHttpParams, socketTimeout); HttpConnectionParams.setTcpNoDelay(basicHttpParams, true); HttpConnectionParams.setSocketBufferSize(basicHttpParams, DEFAULT_SOCKET_BUFFER_SIZE); HttpProtocolParams.setVersion(basicHttpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent( basicHttpParams, String.format( "android-async-http/%s (http://loopj.com/android-async-http)", new Object[] {VERSION})); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register( new Scheme(MediaService.DEFAULT_MEDIA_DELIVERY, PlainSocketFactory.getSocketFactory(), 80)); schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); ClientConnectionManager threadSafeClientConnManager = new ThreadSafeClientConnManager(basicHttpParams, schemeRegistry); this.httpContext = new SyncBasicHttpContext(new BasicHttpContext()); this.httpClient = new DefaultHttpClient(threadSafeClientConnManager, basicHttpParams); this.httpClient.addRequestInterceptor( new HttpRequestInterceptor() { public void process(HttpRequest httpRequest, HttpContext httpContext) { if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) { httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP); } Iterator it = AsyncHttpClient.this.clientHeaderMap.keySet().iterator(); while (it.hasNext()) { String str = (String) it.next(); httpRequest.addHeader(str, (String) AsyncHttpClient.this.clientHeaderMap.get(str)); } } }); this.httpClient.addResponseInterceptor( new HttpResponseInterceptor() { public void process(HttpResponse httpResponse, HttpContext httpContext) { HttpEntity entity = httpResponse.getEntity(); if (entity != null) { Header contentEncoding = entity.getContentEncoding(); if (contentEncoding != null) { HeaderElement[] elements = contentEncoding.getElements(); int length = elements.length; int i = 0; while (i < length) { if (elements[i].getName().equalsIgnoreCase(ENCODING_GZIP)) { httpResponse.setEntity(new InflatingEntity(httpResponse.getEntity())); return; } else { i++; } } } } } }); this.httpClient.setHttpRequestRetryHandler(new RetryHandler(5)); this.threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool(); this.requestMap = new WeakHashMap(); this.clientHeaderMap = new HashMap(); }