Esempio n. 1
0
public class HttpUtils {

  public static final HttpGetCache sHttpGetCache = new HttpGetCache();

  private final DefaultHttpClient httpClient;
  private final HttpContext httpContext = new BasicHttpContext();
  private HttpRedirectHandler httpRedirectHandler;

  public HttpUtils() {
    this(HttpUtils.DEFAULT_CONN_TIMEOUT);
  }

  public HttpUtils(int connTimeout) {
    HttpParams params = new BasicHttpParams();

    ConnManagerParams.setTimeout(params, connTimeout);
    HttpConnectionParams.setSoTimeout(params, connTimeout);
    HttpConnectionParams.setConnectionTimeout(params, connTimeout);

    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", SimpleSSLSocketFactory.getSocketFactory(), 443));

    httpClient =
        new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);
    try {
      if (ComParams.userAgent != null) {
        configUserAgent(ComParams.userAgent);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));

    httpClient.addRequestInterceptor(
        new HttpRequestInterceptor() {
          @Override
          public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext)
              throws 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 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;
                }
              }
            }
          }
        });
  }

  // ************************************ default settings & fields ****************************

  private String defaultResponseTextCharset = HTTP.UTF_8;

  private long currentRequestExpiry = HttpGetCache.getDefaultExpiryTime();

  private static final int DEFAULT_CONN_TIMEOUT = 1000 * 15; // 15s

  private static final int DEFAULT_RETRY_TIMES = 5;

  private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";
  private static final String ENCODING_GZIP = "gzip";

  private static final ThreadFactory sThreadFactory =
      new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
          Thread thread = new Thread(r, "HttpUtils #" + mCount.getAndIncrement());
          thread.setPriority(Thread.NORM_PRIORITY - 1);
          return thread;
        }
      };

  private static int threadPoolSize = 3;
  private static Executor executor = Executors.newFixedThreadPool(threadPoolSize, sThreadFactory);

  public HttpClient getHttpClient() {
    return this.httpClient;
  }

  // ***************************************** config *******************************************

  public HttpUtils configDefaultResponseTextCharset(String charSet) {
    if (!TextUtils.isEmpty(charSet)) {
      this.defaultResponseTextCharset = charSet;
    }
    return this;
  }

  public HttpUtils configHttpGetCacheSize(int httpGetCacheSize) {
    // sHttpGetCache.setCacheSize(httpGetCacheSize);
    return this;
  }

  public HttpUtils configHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) {
    this.httpRedirectHandler = httpRedirectHandler;
    return this;
  }

  public HttpUtils configDefaultHttpGetCacheExpiry(long defaultExpiry) {
    HttpGetCache.setDefaultExpiryTime(defaultExpiry);
    currentRequestExpiry = HttpGetCache.getDefaultExpiryTime();
    return this;
  }

  public HttpUtils configCurrentHttpGetCacheExpiry(long currRequestExpiry) {
    this.currentRequestExpiry = currRequestExpiry;
    return this;
  }

  public HttpUtils configCookieStore(CookieStore cookieStore) {
    httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
    return this;
  }

  public HttpUtils configUserAgent(String userAgent) {
    HttpProtocolParams.setUserAgent(this.httpClient.getParams(), userAgent);
    return this;
  }

  public HttpUtils configTimeout(int timeout) {
    final HttpParams httpParams = this.httpClient.getParams();
    ConnManagerParams.setTimeout(httpParams, timeout);
    HttpConnectionParams.setSoTimeout(httpParams, timeout);
    HttpConnectionParams.setConnectionTimeout(httpParams, timeout);
    return this;
  }

  public HttpUtils configRegisterScheme(Scheme scheme) {
    this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);
    return this;
  }

  public HttpUtils configSSLSocketFactory(SSLSocketFactory sslSocketFactory) {
    Scheme scheme = new Scheme("https", sslSocketFactory, 443);
    this.httpClient.getConnectionManager().getSchemeRegistry().register(scheme);
    return this;
  }

  public HttpUtils configRequestRetryCount(int count) {
    this.httpClient.setHttpRequestRetryHandler(new RetryHandler(count));
    return this;
  }

  public HttpUtils configRequestThreadPoolSize(int threadPoolSize) {
    if (threadPoolSize > 0 && threadPoolSize != HttpUtils.threadPoolSize) {
      HttpUtils.threadPoolSize = threadPoolSize;
      HttpUtils.executor = Executors.newFixedThreadPool(threadPoolSize, sThreadFactory);
    }
    return this;
  }

  // ***************************************** send request
  // *******************************************

  public <T> HttpHandler<T> send(
      HttpRequest.HttpMethod method, String url, RequestCallBack<T> callBack) {
    return send(method, url, null, callBack);
  }

  public <T> HttpHandler<T> send(
      HttpRequest.HttpMethod method,
      String url,
      RequestParams params,
      RequestCallBack<T> callBack) {
    return send(method, url, params, null, callBack);
  }

  public <T> HttpHandler<T> send(
      HttpRequest.HttpMethod method,
      String url,
      RequestParams params,
      String contentType,
      RequestCallBack<T> callBack) {
    if (url == null) throw new IllegalArgumentException("url may not be null");
    HttpRequest request = new HttpRequest(method, url);
    return sendRequest(request, params, contentType, callBack);
  }

  public ResponseStream sendSync(HttpRequest.HttpMethod method, String url) throws HttpException {
    return sendSync(method, url, null);
  }

  public ResponseStream sendSync(HttpRequest.HttpMethod method, String url, RequestParams params)
      throws HttpException {
    return sendSync(method, url, params, null);
  }

  public ResponseStream sendSync(
      HttpRequest.HttpMethod method, String url, RequestParams params, String contentType)
      throws HttpException {
    if (url == null) throw new IllegalArgumentException("url may not be null");
    HttpRequest request = new HttpRequest(method, url);
    return sendSyncRequest(request, params, contentType);
  }

  // ***************************************** download *******************************************

  public HttpHandler<File> download(String url, String target, RequestCallBack<File> callback) {
    return download(HttpRequest.HttpMethod.GET, url, target, null, false, false, callback);
  }

  public HttpHandler<File> download(
      String url, String target, boolean autoResume, RequestCallBack<File> callback) {
    return download(HttpRequest.HttpMethod.GET, url, target, null, autoResume, false, callback);
  }

  public HttpHandler<File> download(
      String url,
      String target,
      boolean autoResume,
      boolean autoRename,
      RequestCallBack<File> callback) {
    return download(
        HttpRequest.HttpMethod.GET, url, target, null, autoResume, autoRename, callback);
  }

  public HttpHandler<File> download(
      String url, String target, RequestParams params, RequestCallBack<File> callback) {
    return download(HttpRequest.HttpMethod.GET, url, target, params, false, false, callback);
  }

  public HttpHandler<File> download(
      String url,
      String target,
      RequestParams params,
      boolean autoResume,
      RequestCallBack<File> callback) {
    return download(HttpRequest.HttpMethod.GET, url, target, params, autoResume, false, callback);
  }

  public HttpHandler<File> download(
      String url,
      String target,
      RequestParams params,
      boolean autoResume,
      boolean autoRename,
      RequestCallBack<File> callback) {
    return download(
        HttpRequest.HttpMethod.GET, url, target, params, autoResume, autoRename, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method, String url, String target, RequestCallBack<File> callback) {
    return download(method, url, target, null, false, false, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method,
      String url,
      String target,
      boolean autoResume,
      RequestCallBack<File> callback) {
    return download(method, url, target, null, autoResume, false, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method,
      String url,
      String target,
      boolean autoResume,
      boolean autoRename,
      RequestCallBack<File> callback) {
    return download(method, url, target, null, autoResume, autoRename, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method,
      String url,
      String target,
      RequestParams params,
      RequestCallBack<File> callback) {
    return download(method, url, target, params, false, false, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method,
      String url,
      String target,
      RequestParams params,
      boolean autoResume,
      RequestCallBack<File> callback) {
    return download(method, url, target, params, autoResume, false, callback);
  }

  public HttpHandler<File> download(
      HttpRequest.HttpMethod method,
      String url,
      String target,
      RequestParams params,
      boolean autoResume,
      boolean autoRename,
      RequestCallBack<File> callback) {

    if (url == null) throw new IllegalArgumentException("url may not be null");
    if (target == null) throw new IllegalArgumentException("target may not be null");

    HttpRequest request = new HttpRequest(method, url);

    HttpHandler<File> handler =
        new HttpHandler<File>(httpClient, httpContext, defaultResponseTextCharset, callback);

    handler.setExpiry(currentRequestExpiry);
    handler.setHttpRedirectHandler(httpRedirectHandler);
    request.setRequestParams(params, handler);

    handler.executeOnExecutor(executor, request, target, autoResume, autoRename);
    return handler;
  }

  // //////////////////////////////////////////////////////////////////////////////////////////////
  private <T> HttpHandler<T> sendRequest(
      HttpRequest request, RequestParams params, String contentType, RequestCallBack<T> callBack) {
    if (contentType != null) {
      request.setHeader("Content-Type", contentType);
    }

    HttpHandler<T> handler =
        new HttpHandler<T>(httpClient, httpContext, defaultResponseTextCharset, callBack);

    handler.setExpiry(currentRequestExpiry);
    handler.setHttpRedirectHandler(httpRedirectHandler);
    request.setRequestParams(params, handler);

    handler.executeOnExecutor(executor, request);
    return handler;
  }

  private ResponseStream sendSyncRequest(
      HttpRequest request, RequestParams params, String contentType) throws HttpException {
    if (contentType != null) {
      request.setHeader("Content-Type", contentType);
    }

    SyncHttpHandler handler =
        new SyncHttpHandler(httpClient, httpContext, defaultResponseTextCharset);

    handler.setExpiry(currentRequestExpiry);
    handler.setHttpRedirectHandler(httpRedirectHandler);
    request.setRequestParams(params);
    try {
      return handler.sendRequest(request);
    } catch (com.fortune.util.HttpException e) {
      e.printStackTrace();
    }
    return null;
  }
}
Esempio n. 2
0
 public HttpUtils configDefaultHttpGetCacheExpiry(long defaultExpiry) {
   HttpGetCache.setDefaultExpiryTime(defaultExpiry);
   currentRequestExpiry = HttpGetCache.getDefaultExpiryTime();
   return this;
 }