Java 类org.apache.http.impl.client.AbstractHttpClient 实例源码

/** 执行网络访问 */
private static HttpResult execute(String url, HttpRequestBase requestBase) {
    boolean isHttps = url.startsWith("https://");//判断是否需要采用https
    AbstractHttpClient httpClient = HttpClientFactory.create(isHttps);
    HttpContext httpContext = new SyncBasicHttpContext(new BasicHttpContext());
    HttpRequestRetryHandler retryHandler = httpClient.getHttpRequestRetryHandler();//获取重试机制
    int retryCount = 0;
    boolean retry = true;
    while (retry) {
        try {
            HttpResponse response = httpClient.execute(requestBase, httpContext);//访问网络
            if (response != null) {
                return new HttpResult(response, httpClient, requestBase);
            }
        } catch (Exception e) {
            IOException ioException = new IOException(e.getMessage());
            retry = retryHandler.retryRequest(ioException, ++retryCount, httpContext);//把错误异常交给重试机制，以判断是否需要采取从事
        }
    }
    return null;
}

private static AbstractHttpClient createHTTPClient() {
    AbstractHttpClient client = new DefaultHttpClient();
    String proxyHost = System.getProperty("https.proxyHost", "");
    if (!proxyHost.isEmpty()) {
        int proxyPort = Integer.parseInt(System.getProperty("https.proxyPort", "-1"));
        log.info("Using proxy " + proxyHost + ":" + proxyPort);
        HttpParams params = client.getParams();
        HttpHost proxy = new HttpHost(proxyHost, proxyPort);
        params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);

        String proxyUser = System.getProperty(JMeter.HTTP_PROXY_USER, JMeterUtils.getProperty(JMeter.HTTP_PROXY_USER));
        if (proxyUser != null) {
            log.info("Using authenticated proxy with username: " + proxyUser);
            String proxyPass = System.getProperty(JMeter.HTTP_PROXY_PASS, JMeterUtils.getProperty(JMeter.HTTP_PROXY_PASS));

            String localHost;
            try {
                localHost = InetAddress.getLocalHost().getCanonicalHostName();
            } catch (Throwable e) {
                log.error("Failed to get local host name, defaulting to 'localhost'", e);
                localHost = "localhost";
            }

            AuthScope authscope = new AuthScope(proxyHost, proxyPort);
            String proxyDomain = JMeterUtils.getPropDefault("http.proxyDomain", "");
            NTCredentials credentials = new NTCredentials(proxyUser, proxyPass, localHost, proxyDomain);
            client.getCredentialsProvider().setCredentials(authscope, credentials);
        }
    }
    return client;
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;

    //断点续传处理
    if (this.responseHandler instanceof BreakpointHttpResponseHandler) {
        BreakpointHttpResponseHandler breakpointHandler = (BreakpointHttpResponseHandler)this.responseHandler;
        File tempFile = breakpointHandler.getTempFile();
        if (tempFile.exists()) {
            long previousFileSize = tempFile.length();
            Log.e(tag, "previousFileSized: " + previousFileSize);
            this.request.setHeader("RANGE", "bytes=" + previousFileSize + "-");
        }
    }
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;

    //断点续传处理
    if (this.responseHandler instanceof BreakpointHttpResponseHandler) {
        BreakpointHttpResponseHandler breakpointHandler = (BreakpointHttpResponseHandler)this.responseHandler;
        File tempFile = breakpointHandler.getTempFile();
        if (tempFile.exists()) {
            long previousFileSize = tempFile.length();
            Log.e(tag, "previousFileSized: " + previousFileSize);
            this.request.setHeader("RANGE", "bytes=" + previousFileSize + "-");
        }
    }
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;

    //断点续传处理
    if (this.responseHandler instanceof BreakpointHttpResponseHandler) {
        BreakpointHttpResponseHandler breakpointHandler = (BreakpointHttpResponseHandler)this.responseHandler;
        File tempFile = breakpointHandler.getTempFile();
        if (tempFile.exists()) {
            long previousFileSize = tempFile.length();
            Log.e(tag, "previousFileSized: " + previousFileSize);
            this.request.setHeader("RANGE", "bytes=" + previousFileSize + "-");
        }
    }
}

/** 执行网络访问 */
private static HttpResult execute(String url, HttpRequestBase requestBase) {
    boolean isHttps = url.startsWith("https://");//判断是否需要采用https
    AbstractHttpClient httpClient = HttpClientFactory.create(isHttps);
    HttpContext httpContext = new SyncBasicHttpContext(new BasicHttpContext());
    HttpRequestRetryHandler retryHandler = httpClient.getHttpRequestRetryHandler();//获取重试机制
    int retryCount = 0;
    boolean retry = true;
    while (retry) {
        try {
            HttpResponse response = httpClient.execute(requestBase, httpContext);//访问网络
            if (response != null) {
                return new HttpResult(response, httpClient, requestBase);
            }
        } catch (Exception e) {
            IOException ioException = new IOException(e.getMessage());
            retry = retryHandler.retryRequest(ioException, ++retryCount, httpContext);//把错误异常交给重试机制，以判断是否需要采取从事
            LogUtils.e(e);
        }
    }
    return null;
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
     this.client = client;
     this.context = context;
     this.request = request;
     this.responseHandler = responseHandler;

     //断点续传处理
     if(this.responseHandler instanceof BreakpointHttpResponseHandler){
        BreakpointHttpResponseHandler breakpointHandler = (BreakpointHttpResponseHandler)this.responseHandler;
        File tempFile = breakpointHandler.getTempFile();
        if (tempFile.exists()) {
    long previousFileSize = tempFile.length();
    Log.e(tag, "previousFileSized: " + previousFileSize);
    this.request.setHeader("RANGE", "bytes=" + previousFileSize + "-");
}
     }
 }

/**
 * This method is used to capture Location headers after HttpClient redirect handling.
 */
private void setupClient(final AbstractHttpClient client) {
    this.client.addResponseInterceptor(new HttpResponseInterceptor() {
        @Override
        public void process(final HttpResponse response, final HttpContext context)
                throws HttpException, IOException {
            Header header = response.getFirstHeader("Location");
            if (header!=null) {
                String location = header.getValue();

                /*
                 * Append the base name to the Location header
                 */
                if (location.startsWith("/")) {
                    String baseUrl = context.getAttribute(ExecutionContext.HTTP_TARGET_HOST).toString();
                    location = baseUrl + location;
                }
                context.setAttribute("Location", location);
            }
        }
    });
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, ResponseHandlerInterface responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;

    //断点续传处理
    if (this.responseHandler instanceof BreakpointHttpResponseHandler) {
        BreakpointHttpResponseHandler breakpointHandler = (BreakpointHttpResponseHandler)this.responseHandler;
        File tempFile = breakpointHandler.getTempFile();
        if (tempFile.exists()) {
            long previousFileSize = tempFile.length();
            Log.e(tag, "previousFileSized: " + previousFileSize);
            this.request.setHeader("RANGE", "bytes=" + previousFileSize + "-");
        }
    }
}

/**
 * Configure credentials and auth scheme on client if an authorization is 
 * available for url
 * @param client {@link HttpClient}
 * @param url URL to test 
 * @param credentialsProvider {@link CredentialsProvider}
 * @param localHost host running JMeter
 */
public void setupCredentials(HttpClient client, URL url,
        CredentialsProvider credentialsProvider, String localHost) {
    Authorization auth = getAuthForURL(url);
    if (auth != null) {
        String username = auth.getUser();
        String realm = auth.getRealm();
        String domain = auth.getDomain();
        if (log.isDebugEnabled()){
            log.debug(username + " > D="+domain+" R="+realm + " M="+auth.getMechanism());
        }
        if (Mechanism.KERBEROS.equals(auth.getMechanism())) {
            ((AbstractHttpClient) client).getAuthSchemes().register(
                    AuthSchemes.SPNEGO,
                    new FixedSPNegoSchemeFactory(isStripPort(url)));
            credentialsProvider.setCredentials(new AuthScope(null, -1, null), USE_JAAS_CREDENTIALS);
        } else {
            credentialsProvider.setCredentials(
                    new AuthScope(url.getHost(), url.getPort(), realm.length()==0 ? null : realm),
                    new NTCredentials(username, auth.getPass(), localHost, domain));
        }
    }
}

/**
 * Setup credentials for url AuthScope but keeps Proxy AuthScope credentials
 * @param client HttpClient
 * @param url URL
 * @param authManager {@link AuthManager}
 * @param key key
 */
private void setConnectionAuthorization(HttpClient client, URL url, AuthManager authManager, HttpClientKey key) {
    CredentialsProvider credentialsProvider = 
        ((AbstractHttpClient) client).getCredentialsProvider();
    if (authManager != null) {
        if(authManager.hasAuthForURL(url)) {
            authManager.setupCredentials(client, url, credentialsProvider, localHost);
        } else {
            credentialsProvider.clear();
        }
    } else {
        Credentials credentials = null;
        AuthScope authScope = null;
        if(key.hasProxy && !StringUtils.isEmpty(key.proxyUser)) {
            authScope = new AuthScope(key.proxyHost, key.proxyPort);
            credentials = credentialsProvider.getCredentials(authScope);
        }
        credentialsProvider.clear(); 
        if(credentials != null) {
            credentialsProvider.setCredentials(authScope, credentials);
        }
    }
}

public static AbstractHttpClient createHttpClient()
{
    try
    {
        if (IS_HTTP_CLIENT_GE_4_2)
        {
            ClientConnectionManager poolingManager = (ClientConnectionManager) Class.forName(
                    "org.apache.http.impl.conn.PoolingClientConnectionManager").newInstance();
            ((ConnPoolControl<?>) poolingManager).setMaxTotal(DEFAULT_MAX_TOTAL);
            ((ConnPoolControl<?>) poolingManager).setDefaultMaxPerRoute(DEFAULT_MAX_PER_ROUTE);
            return new DefaultHttpClient(poolingManager, (HttpParams) null);
        } else {
            return new ThreadSafeHttpClient();
        }
    }
    catch (Exception e)
    {
        throw new IllegalStateException("Can not create http client.", e);
    }
}

@Override
   protected Client newClient() {
ResteasyClientBuilder resteasyClientBuilder = new ResteasyClientBuilder();
ResteasyClient client = resteasyClientBuilder.establishConnectionTimeout(getTimeout(), TimeUnit.MILLISECONDS).socketTimeout(getTimeout(), TimeUnit.MILLISECONDS).build();
AbstractHttpClient httpClient = (AbstractHttpClient) ((ApacheHttpClient4Engine) client.httpEngine()).getHttpClient();
httpClient.setRedirectStrategy(new DefaultRedirectStrategy() {

    @Override
    protected boolean isRedirectable(String method) {
    return true;
    }
});
httpClient.addRequestInterceptor(new HttpRequestInterceptor() {

    @Override
    public void process(HttpRequest request, HttpContext context) throws HttpException, IOException {
    request.setParams(new AllowRedirectHttpParams(request.getParams()));
    }
});
return client;
   }

/**
 * 获得cookie
 *
 * @param httpClient
 */
public static void getCookie(HttpClient httpClient) {
    List<Cookie> cookies = ((AbstractHttpClient) httpClient).getCookieStore().getCookies();
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < cookies.size(); i++) {
        Cookie cookie = cookies.get(i);
        String cookieName = cookie.getName();
        String cookieValue = cookie.getValue();
        if (!TextUtils.isEmpty(cookieName)
                && !TextUtils.isEmpty(cookieValue)) {
            sb.append(cookieName + "=");
            sb.append(cookieValue + ";");
        }
    }
    SharedPreferences.Editor edit = DemoContext.getInstance().getSharedPreferences().edit();
    edit.putString("DEMO_COOKIE", sb.toString());
    edit.apply();
}

private void setProxySettings (org.apache.http.client.HttpClient client, HasProxySettings proxySettings, String prot)
{
    if (client == null)
        return ;
       if (proxySettings == null || !proxySettings.isActive())
        return ;
       if (prot == null || prot.isEmpty())
        return ;

    org.apache.http.HttpHost proxy = new org.apache.http.HttpHost(proxySettings.getHost(), proxySettings.getPort(), prot) ;
    client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy) ;

    CredentialsProvider credProvider = ((AbstractHttpClient) client).getCredentialsProvider();
    credProvider.setCredentials(
            new AuthScope(proxySettings.getHost(), proxySettings.getPort()), 
            new UsernamePasswordCredentials(proxySettings.getUsername(), proxySettings.getPassword()));  
}

/**
 * Returns the HttpClient singleton.
 */
public static synchronized HttpClient getHttpClient() {
    if (httpClient == null) {
        if (AppConfig.DEBUG) Log.d(TAG, "Creating new instance of HTTP client");

        HttpParams params = new BasicHttpParams();
        params.setParameter(CoreProtocolPNames.USER_AGENT, AppPreferences.USER_AGENT);
        params.setIntParameter("http.protocol.max-redirects", MAX_REDIRECTS);
        params.setBooleanParameter("http.protocol.reject-relative-redirect",
                false);
        HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
        HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
        HttpClientParams.setRedirecting(params, true);

        httpClient = new DefaultHttpClient(createClientConnectionManager(), params);
        // Workaround for broken URLs in redirection
        ((AbstractHttpClient) httpClient)
                .setRedirectHandler(new APRedirectHandler());
    }
    return httpClient;
}

@Override
public HttpClient get() {
    AbstractHttpClient client = new DefaultHttpClient() {
        @Override
        protected ClientConnectionManager createClientConnectionManager() {
            SchemeRegistry registry = new SchemeRegistry();
            registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            registry.register(new Scheme("https", getHttpsSocketFactory(), 443));

            final HttpParams params = getParams();
            HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
            HttpConnectionParams.setSoTimeout(params, SO_TIMEOUT);
            HttpProtocolParams.setUserAgent(params, getUserAgentString(HttpProtocolParams.getUserAgent(params)));
            return new ThreadSafeClientConnManager(params, registry);
        }
    };
    return client;
}

/**
 * 
 * This function adds support for pre-emptive HTTP Authentication for an HttpClient.
 * 
 * @param httpClient
 */
public static void makeAuthenticationPreemptive(HttpClient httpClient) {
    HttpRequestInterceptor preemptiveAuth = new HttpRequestInterceptor() {
        public void process(final HttpRequest request,final HttpContext context) throws HttpException,IOException{
            AuthState authState = (AuthState) context
                    .getAttribute(ClientContext.TARGET_AUTH_STATE);
            CredentialsProvider credsProvider = (CredentialsProvider) context
                    .getAttribute(ClientContext.CREDS_PROVIDER);
            HttpHost targetHost = (HttpHost) context
                    .getAttribute(ExecutionContext.HTTP_TARGET_HOST);

            if (authState.getAuthScheme() == null) {
                AuthScope authScope = new AuthScope(targetHost.getHostName(), targetHost.getPort());
                Credentials creds = credsProvider.getCredentials(authScope);
                if (creds != null) {
                    authState.setAuthScheme(new BasicScheme());
                    authState.setCredentials(creds);
                }
            }
        }
    };

    ((AbstractHttpClient) httpClient).addRequestInterceptor(preemptiveAuth,0);
}

/**
 * Returns the HttpClient singleton.
 */
public static synchronized HttpClient getHttpClient() {
    if (httpClient == null) {
        if (AppConfig.DEBUG) Log.d(TAG, "Creating new instance of HTTP client");

        HttpParams params = new BasicHttpParams();
        params.setParameter(CoreProtocolPNames.USER_AGENT, AppPreferences.USER_AGENT);
        params.setIntParameter("http.protocol.max-redirects", MAX_REDIRECTS);
        params.setBooleanParameter("http.protocol.reject-relative-redirect",
                false);
        HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
        HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
        HttpClientParams.setRedirecting(params, true);

        httpClient = new DefaultHttpClient(createClientConnectionManager(), params);
        // Workaround for broken URLs in redirection
        ((AbstractHttpClient) httpClient)
                .setRedirectHandler(new APRedirectHandler());
    }
    return httpClient;
}

public static AbstractHttpClient createNonverifyingHttpClient() throws Exception {

        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        trustStore.load(null, null);

        SSLSocketFactory sf = new NonverifyingSSLSocketFactory(trustStore);
        sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        HttpParams params = new BasicHttpParams();
        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);

        return new DefaultHttpClient(ccm, params);
    }

/**
 * Setup credentials for url AuthScope but keeps Proxy AuthScope credentials
 * @param client HttpClient
 * @param url URL
 * @param authManager {@link AuthManager}
 * @param key key
 */
private void setConnectionAuthorization(HttpClient client, URL url, AuthManager authManager, HttpClientKey key) {
    CredentialsProvider credentialsProvider = 
        ((AbstractHttpClient) client).getCredentialsProvider();
    if (authManager != null) {
        if(authManager.hasAuthForURL(url)) {
            authManager.setupCredentials(client, url, credentialsProvider, localHost);
        } else {
            credentialsProvider.clear();
        }
    } else {
        Credentials credentials = null;
        AuthScope authScope = null;
        if(key.hasProxy && !StringUtils.isEmpty(key.proxyUser)) {
            authScope = new AuthScope(key.proxyHost, key.proxyPort);
            credentials = credentialsProvider.getCredentials(authScope);
        }
        credentialsProvider.clear(); 
        if(credentials != null) {
            credentialsProvider.setCredentials(authScope, credentials);
        }
    }
}

public synchronized AbstractHttpClient create(String userAgent)
{
  if (userAgent == null)
  {
    userAgent = "";
  }
  // From Apache HttpClient doc: "HttpClient is fully thread-safe when used
  // with a thread-safe connection manager." The
  // PoolingClientConnectionManager we are using is such as thread-safe one.
  AbstractHttpClient client = new RedirectHttpClient(connectionManager);
  prepareHttpClient(client);
  if (userAgent.length() > 0)
  {
    client.getParams().setParameter(CoreProtocolPNames.USER_AGENT, userAgent);
  }
  return client;
}

private static SimplHttpResponse doRequest(String userAgent,
                                           final String url,
                                           HttpUriRequest request) throws IOException
{
  AbstractHttpClient client = factory.create(userAgent);
  // client must use BasicRedirectStrategy!
  final BasicRedirectStrategy redirectStrategy =
      (BasicRedirectStrategy) client.getRedirectStrategy();
  SimplHttpResponse result = client.execute(request, new ResponseHandler<SimplHttpResponse>()
  {
    @Override
    public SimplHttpResponse handleResponse(HttpResponse response)
        throws ClientProtocolException, IOException
    {
      List<String> redirectedLocations = redirectStrategy.getRedirectedLocations();
      return SimplHttpResponse.parse(url, redirectedLocations, response);
    }
  });
  return result;
}

@Factory("solrServer")
    public void connectToSolrServer() {
        log.info("Connecting to solr server");
        String url = "http://localhost:8080/solr/" + platform;
        solrServer = null;
        solrServer = new HttpSolrServer(url);
        HttpSolrServer server = (HttpSolrServer) solrServer;
        if (solrUsername != null && solrPassword != null)
            ((AbstractHttpClient)server.getHttpClient()).addRequestInterceptor(new PreEmptiveBasicAuthenticator(solrUsername, solrPassword));
        server.setSoTimeout(1000); // socket read timeout
        server.setConnectionTimeout(100);
        server.setDefaultMaxConnectionsPerHost(100);
        server.setMaxTotalConnections(100);
//          server.setFollowRedirects(false); // defaults to false
        // allowCompression defaults to false.
        // Server side must support gzip or deflate for this to have any effect.
        server.setAllowCompression(true);
        server.setMaxRetries(1); // defaults to 0. > 1 not recommended.
//          server.setParser(new XMLResponseParser()); // binary parser is used by default
    }

public static void enableAuth(final AbstractHttpClient client, final Keychain keychain, final KeyId keyId) {
    if (client == null) {
        throw new NullPointerException("client");
    }

    if (keychain == null) {
        throw new NullPointerException("keychain");
    }

    client.getAuthSchemes().register(Constants.SCHEME, new AuthSchemeFactory() {
        public AuthScheme newInstance(HttpParams params) {
            return new Http4SignatureAuthScheme();
        }
    });

    Signer signer = new Signer(keychain, keyId);
    client.getCredentialsProvider().setCredentials(AuthScope.ANY, new SignerCredentials(signer));
    client.getParams().setParameter(AuthPNames.TARGET_AUTH_PREF,
                                    Arrays.asList(Constants.SCHEME));

    HttpClientParams.setAuthenticating(client.getParams(), true);
}

/**
 * Uses the HttpClient provided instead of creating a new one. This lets the CopyJob reuse the
 * HttpClient (which caches the connections) for an entire Job. This is dirty, because not all
 * adapters have an HTTPClient.
 * 
 * @param profile
 * @param sslExceptionCallback
 * @param httpClient
 * @throws StorageAdapterException
 *             if we cannot initialize
 */
public Hcp3AuthNamespaceAdapter(Hcp3AuthNamespaceProfile profile,
        SSLCertificateCallback sslExceptionCallback,
        AbstractHttpClient httpClient) throws StorageAdapterException {
    super();
    this.profile = profile;
    this.httpClient = httpClient;
    if (httpClient == null) {
        init(sslExceptionCallback);
    }
    this.sslExceptionCallback = sslExceptionCallback;

    debugName = "hcap3AuthNamespaceAdapter" + ++adapterCnt;
}

/**
 * Uses the HttpClient provided instead of creating a new one. This lets the CopyJob reuse the
 * HttpClient (which caches the connections) for an entire Job. This is dirty, because not all
 * adapters have an HTTPClient.
 * 
 * @param profile
 * @param sslExceptionCallback
 * @param httpClient
 * @throws StorageAdapterException
 *             if we cannot initialize
 */
public Hcap2Adapter(Hcap2Profile profile,
        SSLCertificateCallback sslExceptionCallback,
        AbstractHttpClient httpClient) throws StorageAdapterException {
    super();
    this.profile = profile;
    this.httpClient = httpClient;
    if (httpClient == null) {
        init(sslExceptionCallback);
    }
    this.sslExceptionCallback = sslExceptionCallback;

    // debug start
    debugName = "hcp2adapter" + ++adapterCnt;
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request, AsyncHttpResponseHandler responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;
    if (responseHandler instanceof BinaryHttpResponseHandler) {
        this.isBinaryRequest = true;
    }
}

private String getCaptchaId(HttpClient httpClient) {
    List<Cookie> cookies = ((AbstractHttpClient) httpClient).getCookieStore().getCookies();
    String captchaId = null;
    for (int i = 0; i < cookies.size(); i++) {
        Cookie cookie = (Cookie) cookies.get(i);
        String cookieName = cookie.getName();
        if (!TextUtils.isEmpty(cookieName) && cookieName.equals("captchaId")) {
            captchaId = cookie.getValue();
        }
    }
    return captchaId;
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest
        request, ResponseHandlerInterface responseHandler) {
    this.client = (AbstractHttpClient) Utils.notNull(client, "client");
    this.context = (HttpContext) Utils.notNull(context, "context");
    this.request = (HttpUriRequest) Utils.notNull(request, SocialConstants.TYPE_REQUEST);
    this.responseHandler = (ResponseHandlerInterface) Utils.notNull(responseHandler,
            "responseHandler");
}

public AsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request,
        AsyncHttpResponseHandler responseHandler) {
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;
    if (responseHandler instanceof BinaryHttpResponseHandler) {
        this.isBinaryRequest = true;
    }
}

public HttpHandler(AbstractHttpClient client, HttpContext context, String charset, RequestCallBack<T> callback) {
    this.client = client;
    this.context = context;
    this.callback = callback;
    this.charset = charset;
    this.client.setRedirectHandler(notUseApacheRedirectHandler);
}

public HttpHandler(AbstractHttpClient client, HttpContext context, String charset, RequestCallBack<T> callback) {
    this.client = client;
    this.context = context;
    this.callback = callback;
    this.charset = charset;
    this.client.setRedirectHandler(notUseApacheRedirectHandler);
}

/**
 * If {@link #reusableHttpClient} is true the instance returned is always the same.
 *
 * @param authenticationRequest
 *            the external auth for the currrent request
 * @return the http client to be used
 */
private HttpClient getHttpClient(R authenticationRequest) {
    AbstractHttpClient httpClient = httpClientReusable ? reusableHttpClient
            : new DefaultHttpClient();
    httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY,
            CookiePolicy.IGNORE_COOKIES);
    if (!httpClientReusable) {
        configureHttpClient(httpClient, authenticationRequest);
    }
    return httpClient;
}

/**
     * 执行网络访问
     */
    private static void execute(String url, HttpRequestBase requestBase, HttpCallbackListener httpCallbackListener) {
        boolean isHttps = url.startsWith("https://");//判断是否需要采用https
        AbstractHttpClient httpClient = HttpClientFactory.create(isHttps);
        HttpContext httpContext = new SyncBasicHttpContext(new BasicHttpContext());
        HttpRequestRetryHandler retryHandler = httpClient.getHttpRequestRetryHandler();//获取重试机制
        int retryCount = 0;
        boolean retry = true;
        while (retry) {
            try {
                HttpResponse response = httpClient.execute(requestBase, httpContext);//访问网络
                int stateCode  = response.getStatusLine().getStatusCode();
//                LogUtils.e(TAG, "http状态码：" + stateCode);
                if (response != null) {
                    if (stateCode == HttpURLConnection.HTTP_OK){
                        HttpResult httpResult = new HttpResult(response, httpClient, requestBase);
                        String result = httpResult.getString();
                        if (!TextUtils.isEmpty(result)){
                            httpCallbackListener.onSuccess(result);
                            return;
                        } else {
                            throw new RuntimeException("数据为空");
                        }
                    } else {
                        throw new RuntimeException(HttpRequestCode.ReturnCode(stateCode));
                    }
                }
            } catch (Exception e) {
                IOException ioException = new IOException(e.getMessage());
                retry = retryHandler.retryRequest(ioException, ++retryCount, httpContext);//把错误异常交给重试机制，以判断是否需要采取从事
                LogUtils.e(TAG, "重复次数：" + retryCount + "   :"+ e);
                if (!retry){
                    httpCallbackListener.onError(e);
                }
            }
        }
    }

/**
 * 
 */
private void closeThreadLocalConnections() {
    // Does not need to be synchronised, as all access is from same thread
    Map<HttpClientKey, HttpClient> mapHttpClientPerHttpClientKey = HTTPCLIENTS_CACHE_PER_THREAD_AND_HTTPCLIENTKEY.get();
    if ( mapHttpClientPerHttpClientKey != null ) {
        for ( HttpClient cl : mapHttpClientPerHttpClientKey.values() ) {
            ((AbstractHttpClient) cl).clearRequestInterceptors(); 
            ((AbstractHttpClient) cl).clearResponseInterceptors();
            ((AbstractHttpClient) cl).close();
            cl.getConnectionManager().shutdown();
        }
        mapHttpClientPerHttpClientKey.clear();
    }
}

private Set<String> getRequestInterceptors(final AbstractHttpClient abstractHttpClient) {
    final LinkedHashSet<String> requestInterceptors = new LinkedHashSet<>();
    for (int ii = 0; ii < abstractHttpClient.getRequestInterceptorCount(); ii++) {
        requestInterceptors.add(abstractHttpClient.getRequestInterceptor(ii).getClass().getName());
    }
    return requestInterceptors;
}

private Set<String> getResponseInterceptors(final AbstractHttpClient abstractHttpClient) {
    final LinkedHashSet<String> responseInterceptors = new LinkedHashSet<>();
    for (int ii = 0; ii < abstractHttpClient.getResponseInterceptorCount(); ii++) {
        responseInterceptors.add(abstractHttpClient.getResponseInterceptor(ii).getClass().getName());
    }
    return responseInterceptors;
}

public CacheAsyncHttpRequest(AbstractHttpClient client, HttpContext context, HttpUriRequest request,
                             CacheTextResponseHandler responseHandler, boolean isCacheAble, String cacheKey, File cacheDir, int cacheTime) {
    super(client, context, request, responseHandler);
    this.client = client;
    this.context = context;
    this.request = request;
    this.responseHandler = responseHandler;

    //
    this.isCacheAble = isCacheAble;
    this.cacheDir = cacheDir;
    this.cacheTime = cacheTime;
    this.cacheKey = TextUtils.isEmpty(cacheKey) ? request.getURI().toString() : cacheKey;
}

public HttpHandler(AbstractHttpClient client, HttpContext context, String charset, RequestCallBack<T> callback) {
    this.client = client;
    this.context = context;
    this.callback = callback;
    this.charset = charset;
    this.client.setRedirectHandler(notUseApacheRedirectHandler);
}