import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
public static AbstractHttpClient wrapClient(HttpClient base) {
	try {
		SSLContext ctx = SSLContext.getInstance("TLS");
		X509TrustManager tm = new X509AlwaysTrust();

		ctx.init(null, new TrustManager[] { tm }, null);
		SSLSocketFactory ssf = new ch.boye.httpclientandroidlib.conn.ssl.SSLSocketFactory(
				ctx);
		ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
		ClientConnectionManager ccm = base.getConnectionManager();
		SchemeRegistry sr = ccm.getSchemeRegistry();
		sr.register(new Scheme("https", ssf, 443));
		return new DefaultHttpClient(ccm, base.getParams());
	} catch (Exception ex) {
		ex.printStackTrace();
		return null;
	}
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
public AutoRetryHttpClient(
        final HttpClient client, final ServiceUnavailableRetryStrategy retryStrategy) {
    super();
    Args.notNull(client, "HttpClient");
    Args.notNull(retryStrategy, "ServiceUnavailableRetryStrategy");
    this.backend = client;
    this.retryStrategy = retryStrategy;
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
HttpRequestTaskCallable(
        final HttpClient httpClient,
        final HttpUriRequest request,
        final HttpContext context,
        final ResponseHandler<V> responseHandler,
        final FutureCallback<V> callback,
        final FutureRequestExecutionMetrics metrics) {
    this.httpclient = httpClient;
    this.responseHandler = responseHandler;
    this.request = request;
    this.context = context;
    this.callback = callback;
    this.metrics = metrics;
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
DecompressingHttpClient(final HttpClient backend,
        final HttpRequestInterceptor requestInterceptor,
        final HttpResponseInterceptor responseInterceptor) {
    this.backend = backend;
    this.acceptEncodingInterceptor = requestInterceptor;
    this.contentEncodingInterceptor = responseInterceptor;
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
/**
 * Unconditionally close a httpClient. Shuts down the underlying connection
 * manager and releases the resources.
 * <p>
 * Example Code:
 *
 * <pre>
 * HttpClient httpClient = HttpClients.createDefault();
 * try {
 *   httpClient.execute(request);
 * } catch (Exception e) {
 *   // error handling
 * } finally {
 *   HttpClientUtils.closeQuietly(httpClient);
 * }
 * </pre>
 *
 * @param httpClient
 *            the HttpClient to close, may be null or already closed.
 * @since 4.2
 */
public static void closeQuietly(final HttpClient httpClient) {
    if (httpClient != null) {
        if (httpClient instanceof Closeable) {
            try {
                ((Closeable) httpClient).close();
            } catch (final IOException ignore) {
            }
        }
    }
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
/**
 * Create a new FutureRequestExecutionService.
 *
 * @param httpclient
 *            you should tune your httpclient instance to match your needs. You should
 *            align the max number of connections in the pool and the number of threads
 *            in the executor; it doesn't make sense to have more threads than connections
 *            and if you have less connections than threads, the threads will just end up
 *            blocking on getting a connection from the pool.
 * @param executorService
 *            any executorService will do here. E.g.
 *            {@link java.util.concurrent.Executors#newFixedThreadPool(int)}
 */
public FutureRequestExecutionService(
        final HttpClient httpclient,
        final ExecutorService executorService) {
    this.httpclient = httpclient;
    this.executorService = executorService;
}
 

import ch.boye.httpclientandroidlib.client.HttpClient; //导入依赖的package包/类
/**
 * Gets the HttpClient to issue request.
 *
 * @return the HttpClient to issue request
 */
public HttpClient getHttpClient() {
    return this.backend;
}