Java ResponseHandler类代码示例

import ch.boye.httpclientandroidlib.client.ResponseHandler; //导入依赖的package包/类
/**
 * Schedule a request for execution.
 *
 * @param <T>
 *
 * @param request
 *            request to execute
 * @param context
 *            optional context; use null if not needed.
 * @param responseHandler
 *            handler that will process the response.
 * @param callback
 *            callback handler that will be called when the request is scheduled,
 *            started, completed, failed, or cancelled.
 * @return HttpAsyncClientFutureTask for the scheduled request.
 * @throws InterruptedException
 */
public <T> HttpRequestFutureTask<T> execute(
        final HttpUriRequest request,
        final HttpContext context,
        final ResponseHandler<T> responseHandler,
        final FutureCallback<T> callback) {
    if(closed.get()) {
        throw new IllegalStateException("Close has been called on this httpclient instance.");
    }
    metrics.getScheduledConnections().incrementAndGet();
    final HttpRequestTaskCallable<T> callable = new HttpRequestTaskCallable<T>(
        httpclient, request, context, responseHandler, callback, metrics);
    final HttpRequestFutureTask<T> httpRequestFutureTask = new HttpRequestFutureTask<T>(
        request, callable);
    executorService.execute(httpRequestFutureTask);

    return httpRequestFutureTask;
}
 

import ch.boye.httpclientandroidlib.client.ResponseHandler; //导入依赖的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.ResponseHandler; //导入依赖的package包/类
public <T> T execute(final HttpHost target, final HttpRequest request,
        final ResponseHandler<? extends T> responseHandler, final HttpContext context)
        throws IOException, ClientProtocolException {
    final HttpResponse response = execute(target, request, context);
    try {
        return responseHandler.handleResponse(response);
    } finally {
        final HttpEntity entity = response.getEntity();
        if (entity != null) {
            EntityUtils.consume(entity);
        }
    }
}
 

import ch.boye.httpclientandroidlib.client.ResponseHandler; //导入依赖的package包/类
/**
 * Validate the response using the response handler. Aborts the request if
 * there is an exception.
 * 
 * @param <T>
 *            Return type
 * @param request
 *            Request to execute
 * @param responseHandler
 *            Determines the return type.
 * @return parsed response
 */
protected <T> T execute(HttpRequestBase request,
		ResponseHandler<T> responseHandler) throws IOException {
	try {
		//System.out.println("starn: requestSent="+request.toString());
		// Clear circular redirect cache
		// this.context.removeAttribute(DefaultRedirectStrategy.REDIRECT_LOCATIONS);
		// Execute with response handler
		return this.client.execute(request, responseHandler, this.context);
	} catch (IOException e) {
		request.abort();
		throw e;
	}
}
 

import ch.boye.httpclientandroidlib.client.ResponseHandler; //导入依赖的package包/类
public <T> T execute(final HttpHost target, final HttpRequest request,
        final ResponseHandler<? extends T> responseHandler) throws IOException {
    return execute(target, request, responseHandler, null);
}
 

import ch.boye.httpclientandroidlib.client.ResponseHandler; //导入依赖的package包/类
/**
 * Executes a request using the default context and processes the
 * response using the given response handler. The content entity associated
 * with the response is fully consumed and the underlying connection is
 * released back to the connection manager automatically in all cases
 * relieving individual {@link ResponseHandler}s from having to manage
 * resource deallocation internally.
 *
 * @param request   the request to execute
 * @param responseHandler the response handler
 * @param context   the context to use for the execution, or
 *                  <code>null</code> to use the default context
 *
 * @return  the response object as generated by the response handler.
 * @throws IOException in case of a problem or the connection was aborted
 * @throws ClientProtocolException in case of an http protocol error
 */
public <T> T execute(final HttpUriRequest request,
        final ResponseHandler<? extends T> responseHandler, final HttpContext context)
        throws IOException, ClientProtocolException {
    final HttpHost target = determineTarget(request);
    return execute(target, request, responseHandler, context);
}