Ejemplo n.º 1
0
  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();
  }
Ejemplo n.º 4
0
  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;
  }
Ejemplo n.º 6
0
  /** 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>();
  }
Ejemplo n.º 7
0
  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;
  }
Ejemplo n.º 9
0
 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;
 }
Ejemplo n.º 11
0
  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);
  }
Ejemplo n.º 15
0
  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());
  }
Ejemplo n.º 16
0
  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;
  }
Ejemplo n.º 17
0
  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;
          }
        });
  }
Ejemplo n.º 18
0
  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);
  }
Ejemplo n.º 20
0
  /**
   * 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();
  }
Ejemplo n.º 22
0
  /**
   * 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();
                  }
                }));
  }
Ejemplo n.º 23
0
  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();
    //			}
    //		}

  }
Ejemplo n.º 24
0
  /**
   * 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;
  }
Ejemplo n.º 26
0
  /**
   * 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();
 }