AsyncHttpClient 有几个构造方法。
最终调用都是public AsyncHttpClient(SchemeRegistry schemeRegistry)，如下：
/**
* Creates a new AsyncHttpClient.
*
* @param schemeRegistry SchemeRegistry to be used
*/
public AsyncHttpClient(SchemeRegistry schemeRegistry) {
……
}
可以看到 封装的是DefaultHttpClient类。
httpClient = new DefaultHttpClient(cm, httpParams);
这里面创建了线程池，是用于网络访问子线程操作。
threadPool = getDefaultThreadPool();
/**
* Get the default threading pool to be used for this HTTP client.
*
* @return The default threading pool to be used
*/
protected ExecutorService getDefaultThreadPool() {
return Executors.newCachedThreadPool();
}
get、post的执行：
/**
* Perform a HTTP GET request and track the Android Context which initiated the request.
*
* @param context the Android Context which initiated the request.
* @param url the URL to send the request to.
* @param params additional GET parameters to send with the request.
* @param responseHandler the response handler instance that should handle the response.
* @return RequestHandle of future request process
*/
public RequestHandle get(Context context, String url, RequestParams params, ResponseHandlerInterface responseHandler) {
return sendRequest(httpClient, httpContext, new HttpGet(getUrlWithQueryString(isUrlEncodingEnabled, url, params)), null, responseHandler, context);
}
public RequestHandle put(Context context, String url, HttpEntity entity, String contentType, ResponseHandlerInterface responseHandler) {
return sendRequest(httpClient, httpContext, addEntityToRequestBase(new HttpPut(getURI(url)), entity), contentType, responseHandler, context);
}
get、post封装访问数据的方式不一样，但是都封装成HttpUriRequest 。
/**
* Puts a new request in queue as a new thread in pool to be executed
*
* @param client HttpClient to be used for request, can differ in single requests
* @param contentType MIME body type, for POST and PUT requests, may be null
* @param context Context of Android application, to hold the reference of request
* @param httpContext HttpContext in which the request will be executed
* @param responseHandler ResponseHandler or its subclass to put the response into
* @param uriRequest instance of HttpUriRequest, which means it must be of HttpDelete,
* HttpPost, HttpGet, HttpPut, etc.
* @return RequestHandle of future request process
*/
protected RequestHandle sendRequest(DefaultHttpClient client, HttpContext httpContext, HttpUriRequest uriRequest, String contentType, ResponseHandlerInterface responseHandler, Context context) {
……
AsyncHttpRequest request = newAsyncHttpRequest(client, httpContext, uriRequest, contentType, responseHandler, context);
threadPool.submit(request);
RequestHandle requestHandle = new RequestHandle(request);
if (context != null) {
List<RequestHandle> requestList;
// Add request to request map
synchronized (requestMap) {
requestList = requestMap.get(context);
if (requestList == null) {
requestList = Collections.synchronizedList(new LinkedList<RequestHandle>());
requestMap.put(context, requestList);
}
}
requestList.add(requestHandle);
……
}
AsyncHttpRequest request = new AsyncHttpRequest(client, httpContext, uriRequest, contentType, responseHandler, context);
threadPool.submit(request);
具体的网络访问操作封装在AsyncHttpRequest 类里，然后把该对象放在线程池里进行管理。
sendRequest 返回值是RequestHandle ，这个返回值用来做什么呢？
if (context != null) {
List<RequestHandle> requestList;
// Add request to request map
synchronized (requestMap) {
requestList = requestMap.get(context);
if (requestList == null) {
requestList = Collections.synchronizedList(new LinkedList<RequestHandle>());
requestMap.put(context, requestList);
}
}
requestList.add(requestHandle);
在这里可以看到RequestHandle 对象被放进来了List<RequestHandle>里。
猜测，把RequestHandle 存放起来无非是管理其生命周期，那么启动了就有可能中断，查看List<RequestHandle>的使用，可以看到，该集合主要使用来中断网络访问，
public void cancelRequests(final Context context, final boolean mayInterruptIfRunning) {
……
注释说明：
* Cancels any pending (or potentially active) requests associated with the passed Context.
* <p> </p> <b>Note:</b> This will only affect requests which were created with a non-null
* android Context. This method is intended to be used in the onDestroy method of your android
* activities to destroy all requests which are no longer required.
*
* @param context the android Context instance associated to the request.
* @param mayInterruptIfRunning specifies if active requests should be cancelled along with
* pending requests.
*/取消（终止）所有与该上下文关联的准备中或者已经活跃的请求。
该方法最后调用
private void cancelRequests(final List<RequestHandle> requestList, final boolean mayInterruptIfRunning) {
if (requestList != null) {
for (RequestHandle requestHandle : requestList) {
requestHandle.cancel(mayInterruptIfRunning);
}
}
}
由RequestHandle通知AsyncHttpRequest 网络访问中断。
/**
* Attempts to cancel this request. This attempt will fail if the request has already completed,
* has already been cancelled, or could not be cancelled for some other reason. If successful,
* and this request has not started when cancel is called, this request should never run. If the
* request has already started, then the mayInterruptIfRunning parameter determines whether the
* thread executing this request should be interrupted in an attempt to stop the request.
* <p> </p> After this method returns, subsequent calls to isDone() will always return
* true. Subsequent calls to isCancelled() will always return true if this method returned
* true. Subsequent calls to isDone() will return true either if the request got cancelled by
* this method, or if the request completed normally
*
* @param mayInterruptIfRunning true if the thread executing this request should be interrupted;
* otherwise, in-progress requests are allowed to complete
* @return false if the request could not be cancelled, typically because it has already
* completed normally; true otherwise
*/
public boolean cancel(final boolean mayInterruptIfRunning) {
final AsyncHttpRequest _request = request.get();
if (_request != null) {
……
_request.cancel(mayInterruptIfRunning);
……
} else {
return _request.cancel(mayInterruptIfRunning);
}
}
return false;
}
AsyncHttpRequest 的cancel 方法。
public boolean cancel(boolean mayInterruptIfRunning) {
isCancelled.set(true);
request.abort();
return isCancelled();
}
看到这里我们已经很清楚地看到整个AsyncHttpClient的模块了，分别是AsyncHttpClient、RequestHandle 和AsyncHttpRequest ，对应的是高层模块的用户操作、回调接口和网络访问执行。
接下来我们分别来看看AsyncHttpRequest 和RequestHandle 所封装的内容。
AsyncHttpRequest ：
AsyncHttpRequest 对象被submit到threadPool时，便开始run()方法。
@Override
public void run() {
if (isCancelled()) {
return;
}
// Carry out pre-processing for this request only once.
if (!isRequestPreProcessed) {
isRequestPreProcessed = true;
onPreProcessRequest(this);
}
if (isCancelled()) {
return;
}
responseHandler.sendStartMessage();
if (isCancelled()) {
return;
}
try {
makeRequestWithRetries();
} catch (IOException e) {
if (!isCancelled()) {
responseHandler.sendFailureMessage(0, null, null, e);
} else {
AsyncHttpClient.log.e("AsyncHttpRequest", "makeRequestWithRetries returned error", e);
}
}
if (isCancelled()) {
return;
}
responseHandler.sendFinishMessage();
if (isCancelled()) {
return;
}
// Carry out post-processing for this request.
onPostProcessRequest(this);
isFinished = true;
}
其中多次调用isCancelled()方法判断是否已经被中断，
最后调用到的是。
private void makeRequest() throws IOException {
……
HttpResponse response = client.execute(request, context); <span style="font-family: Arial, Helvetica, sans-serif;"> …… </span>
RequestHandle ：
主要是实现了ResponseHandlerInterface接口的子类，对网络访问结果进行解析并封装
// Carry out pre-processing for this response.
responseHandler.onPreProcessResponse(responseHandler, response);
再通过sendMessage通过主线程网络访问的结果或者中断的情况。
扫一扫
1116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
