android-----XUtils框架之HttpUtils源码分析
Posted 她说巷尾的樱花开了
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了android-----XUtils框架之HttpUtils源码分析相关的知识，希望对你有一定的参考价值。
之前我们对Volley框架源码进行了分析，知道了他适用于频繁的网络请求，但是不太适合post较大数据以及文件的上传操作，在项目中为了弥补Volley的这个缺陷，使用了XUtils框架的HttpUtils实现了文件上传的操作，上一篇博客我们通过HttpUtils实现了照片上传的实例，见：android-----基于XUtils客户端以及服务器端实现，当然文件上传的方法类似于照片上传，有时间的话单独写一篇博客介绍，这篇博客我们从源码角度来分析HttpUtils的实现原理，希望对这几天的学习做个总结：先来回顾下HttpUtils的使用步骤：
(1)创建HttpUtils对象：HttpUtils httpUtils = new HttpUtils();
(2)调用HttpUtils的send方法进行上传操作；
(3)或者调用download方法来进行下载任务，虽然download方法有多个重载方法并且需要传入不同个参数，但是最后他们都会归结到同一个download方法上面；
就是这么简单，那么具体在这两步中做了些什么事呢？我们就该慢慢看看啦！
先来从HttpUtils httpUtils = new HttpUtils()开始
HttpUtils有四个构造函数，但是最终他们都会调用public HttpUtils(int connTimeout, String userAgent)这个构造函数，第一个参数是连接超时时间，默认的超时时间是15s，第二个参数是用户代理，其实也就是浏览器访问头啦：
public HttpUtils(int connTimeout, String userAgent) {
HttpParams params = new BasicHttpParams();
ConnManagerParams.setTimeout(params, connTimeout);
HttpConnectionParams.setSoTimeout(params, connTimeout);
HttpConnectionParams.setConnectionTimeout(params, connTimeout);
if (!TextUtils.isEmpty(userAgent)) {
HttpProtocolParams.setUserAgent(params, userAgent);
}
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", DefaultSSLSocketFactory.getSocketFactory(), 443));
httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);
httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));
httpClient.addRequestInterceptor(new HttpRequestInterceptor() {
@Override
public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.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 org.apache.http.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;
}
}
}
}
});
}构造函数首先在2到17行进行请求参数的设置，其中ConnManagerParams是一个final类型的类，他是HTTP协议参数的集合，主要用于客户端连接管理，第19到21行进行的是协议模式的设置，另外同样也可以使用他来进行协议属性的设置，比如设置默认端口号等等，第23行创建了HttpClient对象，注意他是使用ThreadSafeClientConnManager来进行连接管理的，也就是他是线程安全的，第25行设置他的请求重试次数，这里是默认值5次，27行添加请求拦截器，36行添加响应拦截器；
接着我们通过send来实现上传操作了，先来看看send方法：
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) {
if (url == null) throw new IllegalArgumentException("url may not be null");
HttpRequest request = new HttpRequest(method, url);
return sendRequest(request, params, callBack);
}private <T> HttpHandler<T> sendRequest(HttpRequest request, RequestParams params, RequestCallBack<T> callBack) {
HttpHandler<T> handler = new HttpHandler<T>(httpClient, httpContext, responseTextCharset, callBack);
handler.setExpiry(currentRequestExpiry);
handler.setHttpRedirectHandler(httpRedirectHandler);
request.setRequestParams(params, handler);
Priority priority = null;
if (params != null) {
priority = params.getPriority();
}
if (priority == null) {
priority = Priority.DEFAULT;
}
handler.executeOnExecutor(EXECUTOR, priority, request);
return handler;
}第3行利用我们之前在HttpUtils构造函数中创建的httpClient，以及httpContext，responseTextCharset, callBack来创建一个HttpHandler对象，其中httpContext用于保存请求的上下文信息，这个值得设置函数是：
public HttpUtils configCookieStore(CookieStore cookieStore) {
httpContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
return this;
}private final HttpContext httpContext = new BasicHttpContext();public HttpUtils configResponseTextCharset(String charSet) {
if (!TextUtils.isEmpty(charSet)) {
this.responseTextCharset = charSet;
}
return this;
}
来进行设置，默认的值是UTF-8类型的啦：
private String responseTextCharset = HTTP.UTF_8;接着sendRequest的第5行设置了请求有效期，第6行设置了重定向请求，这个值默认情况下是null，当然你可以通过以下方法来进行设置：
public HttpUtils configHttpRedirectHandler(HttpRedirectHandler httpRedirectHandler) {
this.httpRedirectHandler = httpRedirectHandler;
return this;
}public class HttpHandler<T> extends PriorityAsyncTask<Object, Object, Void> implements RequestCallBackHandler很明显了吧，他实现了PriorityAsyncTask抽象类，证明了我们的猜测，但是这还不够，我们会发现HttpHandler中并没有第16行的executeOnExecutor这个方法，显然需要到他的父类PriorityAsyncTask中去查看该方法，这个类中存在两个executeOnExecutor方法
public final PriorityAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
return executeOnExecutor(exec, Priority.DEFAULT, params);
}
public final PriorityAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Priority priority,
Params... params) {
}
public final PriorityAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Priority priority,
Params... params) {
if (mExecuteInvoked) {
throw new IllegalStateException("Cannot execute task:"
+ " the task is already executed.");
}
mExecuteInvoked = true;
onPreExecute();
mWorker.mParams = params;
exec.execute(new PriorityRunnable(priority, mFuture));
return this;
}
@Override
public void run() {
this.obj.run();
}
public PriorityRunnable(Priority priority, Runnable obj) {
super(priority, obj);
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
LogUtils.w(e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
public PriorityAsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
@Override
protected Void doInBackground(Object... params) {
if (this.state == State.CANCELLED || params == null || params.length == 0) return null;
if (params.length > 3) {
fileSavePath = String.valueOf(params[1]);
isDownloadingFile = fileSavePath != null;
autoResume = (Boolean) params[2];
autoRename = (Boolean) params[3];
}
try {
if (this.state == State.CANCELLED) return null;
// init request & requestUrl
request = (HttpRequestBase) params[0];
requestUrl = request.getURI().toString();
if (callback != null) {
callback.setRequestUrl(requestUrl);
}
this.publishProgress(UPDATE_START);
lastUpdateTime = SystemClock.uptimeMillis();
ResponseInfo<T> responseInfo = sendRequest(request);
if (responseInfo != null) {
this.publishProgress(UPDATE_SUCCESS, responseInfo);
return null;
}
} catch (HttpException e) {
this.publishProgress(UPDATE_FAILURE, e, e.getMessage());
}
return null;
}首先如果当前线程被暂停或者请求参数为null或者没有设置请求参数的话，直接return，第5行判断如果请求参数的个数大于三的话(这种情况是我们在调用download方法进行文件下载的时候会进入到if语句块中的，源码在分析完send方法之后分析)，第15行获取到request请求，并且在16行通过request请求获取到请求url，如果我们在创建HttpHandler的时候传入了RequestCallBack对象的话，则在18行将请求url设置到RequestCallBack对象上面，第21行调用publishProgress方法传入UPDATE_START参数，这个方法会调用onProgressUpdate方法，那么他到底为什么调用publishProgress的时候会调用onProgressUpdate方法呢？查看第21行看到他调用的是this的publishProgress方法，可以发现HttpHandler中并没有publishProgress方法方法，那么就需要到他的父类PriorityAsyncTask查看是否存在了，很庆幸我们找到了定义为protected的方法了，也就是说这个方法是允许子类访问的，来看看他的定义：
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}发现他实际上是通过InternalHandler类型的handler发送了一条标志为MESSAGE_POST_PROGRESS的消息，InternalHandler是PriorityAsyncTask的内部类，那么这条消息的具体实现就是在InternalHandler的handleMessage方法里面了：
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
} 从onProgressUpdate的定义可以看出，这个方法是需要子类实现的，也就是说实际上调用的是HttpHandler的onProgressUpdate方法啦；
在看onProgressUpdate方法之前呢，我们需要看看通过HttpHandler传入的RequestCallBack到底是什么样子的，查看源码可以发现他是一个抽象类，其中抽象方法如下：
public abstract void onSuccess(ResponseInfo<T> responseInfo);
public abstract void onFailure(HttpException error, String msg); public void onStart() {
public void onCancelled() {
}
public void onLoading(long total, long current, boolean isUploading) {
}我们可以在继承RequestCallBack抽象类的时候进行重写这三个方法，回到doInBackground方法里面，在第21行调用publishProgress方法传入UPDATE_START参数后转而执行的方法是onProgressUpdate，我们看看他的源码：
protected void onProgressUpdate(Object... values) {
if (this.state == State.CANCELLED || values == null || values.length == 0 || callback == null) return;
switch ((Integer) values[0]) {
case UPDATE_START:
this.state = State.STARTED;
callback.onStart();
break;
case UPDATE_LOADING:
if (values.length != 3) return;
this.state = State.LOADING;
callback.onLoading(
Long.valueOf(String.valueOf(values[1])),
Long.valueOf(String.valueOf(values[2])),
isUploading);
break;
case UPDATE_FAILURE:
if (values.length != 3) return;
this.state = State.FAILURE;
callback.onFailure((HttpException) values[1], (String) values[2]);
break;
case UPDATE_SUCCESS:
if (values.length != 2) return;
this.state = State.SUCCESS;
callback.onSuccess((ResponseInfo<T>) values[1]);
break;
default:
break;
}
}接着第25行调用sendRequest方法来执行request请求返回ResponseInfo对象，来看看sendRequest方法：
private ResponseInfo<T> sendRequest(HttpRequestBase request) throws HttpException {
HttpRequestRetryHandler retryHandler = client.getHttpRequestRetryHandler();
while (true) {
if (autoResume && isDownloadingFile) {
File downloadFile = new File(fileSavePath);
long fileLen = 0;
if (downloadFile.isFile() && downloadFile.exists()) {
fileLen = downloadFile.length();
}
if (fileLen > 0) {
request.setHeader("RANGE", "bytes=" + fileLen + "-");
}
}
boolean retry = true;
IOException exception = null;
try {
requestMethod = request.getMethod();
if (HttpUtils.sHttpCache.isEnabled(requestMethod)) {
String result = HttpUtils.sHttpCache.get(requestUrl);
if (result != null) {
return new ResponseInfo<T>(null, (T) result, true);
}
}
ResponseInfo<T> responseInfo = null;
if (!isCancelled()) {
HttpResponse response = client.execute(request, context);
responseInfo = handleResponse(response);
}
return responseInfo;
} catch (UnknownHostException e) {
exception = e;
retry = retryHandler.retryRequest(exception, ++retriedCount, context);
} catch (IOException e) {
exception = e;
retry = retryHandler.retryRequest(exception, ++retriedCount, context);
} catch (NullPointerException e) {
exception = new IOException(e.getMessage());
exception.initCause(e);
retry = retryHandler.retryRequest(exception, ++retriedCount, context);
} catch (HttpException e) {
throw e;
} catch (Throwable e) {
exception = new IOException(e.getMessage());
exception.initCause(e);
retry = retryHandler.retryRequest(exception, ++retriedCount, context);
}
if (!retry) {
throw new HttpException(exception);
}
}
}第3行首先获取retry的设置，里面可能包括一些如果连接发生错误需要重新开启连接的连接次数限制等等属性，可以看到这个方法里面是一个while死循环，也就是说只有里面的return语句以及连接次数超出retry中的设置值才会结束当前方法，第6到15行是download方法用来判断是否需要断点下载的部分，稍后我们再分析，第21行判断是否使用了缓存，如果使用了的话则从httpCache获取对应于我们请求的内容，并且当前内容获取成功的话通过24行的ResponseInfo构造方法创建ResponseInfo的实例对象返回；如果没有启用缓存或者从缓存中获取到的内容为空的话，则执行第29行判断当前请求是否被暂停的判断语句，如果没有的话，第30行执行http请求，从网络中获取到对应请求的内容，31行调用handleResponse方法封装一个ResponseInfo类型的对象出来，想必handleResponse里面肯定有存缓存的操作啦，我们可以验证一下：
@SuppressWarnings("unchecked")
private ResponseInfo<T> handleResponse(HttpResponse response) throws HttpException, IOException {
if (response == null) {
throw new HttpException("response is null");
}
if (isCancelled()) return null;
StatusLine status = response.getStatusLine();
int statusCode = status.getStatusCode();
if (statusCode < 300) {
Object result = null;
HttpEntity entity = response.getEntity();
if (entity != null) {
isUploading = false;
if (isDownloadingFile) {
autoResume = autoResume && OtherUtils.isSupportRange(response);
String responseFileName = autoRename ? OtherUtils.getFileNameFromHttpResponse(response) : null;
result = mFileDownloadHandler.handleEntity(entity, this, fileSavePath, autoResume, responseFileName);
} else {
result = mStringDownloadHandler.handleEntity(entity, this, charset);
if (HttpUtils.sHttpCache.isEnabled(requestMethod)) {
HttpUtils.sHttpCache.put(requestUrl, (String) result, expiry);
}
}
}
return new ResponseInfo<T>(response, (T) result, false);
} else if (statusCode == 301 || statusCode == 302) {
if (httpRedirectHandler == null) {
httpRedirectHandler = new DefaultHttpRedirectHandler();
}
HttpRequestBase request = httpRedirectHandler.getDirectRequest(response);
if (request != null) {
return this.sendRequest(request);
}
} else if (statusCode == 416) {
throw new HttpException(statusCode, "maybe the file has downloaded completely");
} else {
throw new HttpException(statusCode, status.getReasonPhrase());
}
return null;
}
public String handleEntity(HttpEntity entity, RequestCallBackHandler callBackHandler, String charset) throws IOException {
if (entity == null) return null;
long current = 0;
long total = entity.getContentLength();
if (callBackHandler != null && !callBackHandler.updateProgress(total, current, true)) {
return null;
}
InputStream inputStream = null;
StringBuilder sb = new StringBuilder();
try {
inputStream = entity.getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, charset));
String line = "";
while ((line = reader.readLine()) != null) {
sb.append(line).append('\\n');
current += OtherUtils.sizeOfString(line, charset);
if (callBackHandler != null) {
if (!callBackHandler.updateProgress(total, current, false)) {
break;
}
}
}
if (callBackHandler != null) {
callBackHandler.updateProgress(total, current, true);
}
} finally {
IOUtils.closeQuietly(inputStream);
}
return sb.toString().trim();
}
@Override
public boolean updateProgress(long total, long current, boolean forceUpdateUI) {
if (callback != null && this.state != State.CANCELLED) {
if (forceUpdateUI) {
this.publishProgress(UPDATE_LOADING, total, current);
} else {
long currTime = SystemClock.uptimeMillis();
if (currTime - lastUpdateTime >= callback.getRate()) {
lastUpdateTime = currTime;
this.publishProgress(UPDATE_LOADING, total, current);
}
}
}
return this.state != State.CANCELLED;
}
case UPDATE_LOADING:
if (values.length != 3) return;
this.state = State.LOADING;
callback.onLoading(
Long.valueOf(String.valueOf(values[1])),
Long.valueOf(String.valueOf(values[2])),
isUploading);
break;继续回到handleResponse方法中，在20行我们获取到result值之后，21行判断是否开启了缓存功能，如果开启的话，则将当前值添加到缓存中，并且在第26行返回一个封装好的ResponseInfo对象；
如果返回状态码是301或者302的话，表示需要进行重定向操作了；
返回状态码是416的话表示文件早已下载结束了；
这样handleResponse方法分析结束，接着我们的sendRequest方法分析，如果我们在请求的过程中出现异常的话，就会执行34---50行部分，可以看到这部分都有一个retryRequest方法，目的就是用来进行请求失败之后重新请求的，至于最多请求多少次呢，sendRequest方法的第3行的HttpRequestRetryHandler的对象中就有啦，这样我们的整个请求就结束啦，请求结束之后我们有时候就需要来通知用户上传或者下载成功了，那么这里的调用时机是在什么时候呢？不用说，当然是回到doInBackground方法中了，第25行通过sendRequest方法获取到请求结果之后，26行判断该请求结果是否为空，不为空的话调用publishProgress方法，传入的标志信息是UPDATE_SUCCESS，此时就会执行onProgressUpdate的case值是UPDATE_SUCCESS的语句块，进而执行RequestCallBack的onSuccess方法，在这个方法中我们就可以进行提示用户的操作了；如果说在doInBackground方法中13--29行部分出现异常的话，那么他会执行标志信息是UPDATE_FAILURE的onProgressUpdate case语句块，进而调用RequestCallBack的onFailure方法，这个方法是用户自己实现的，在此方法中可以提示用户下载失败的信息；
好了，在上面我们并没有分析mFuture的done方法，现在是时候分析一下了，为了方便查看，我们再次贴出mFuture的定义：
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
LogUtils.w(e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
}至此通过Httputils实现上传操作的源码分析完毕了，当然这个只是android客户端在上传操作过程中的一些操作，我们还需要相应的服务器端代码来配合实现真正的上传操作，上面分析的过程中我们都避开了download文件下载部分的代码，其实下载部分的代码分析流程和上传过程是非常类似的，只不过在下载的过程中我们需要处理一些断点下载、重命名下载的问题，下面简单分析一下：
众所周知，使用HttpUtils实现下载操作只需要调用HttpUtils对象的download方法就可以了，这个方法有多个重载类型实现，但是最终他们都会执行到下面这个方法：
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, responseTextCharset, callback);
handler.setExpiry(currentRequestExpiry);
handler.setHttpRedirectHandler(httpRedirectHandler);
request.setRequestParams(params, handler);
handler.executeOnExecutor(EXECUTOR, request, target, autoResume, autoRename);
return handler;
}可以发现和send方法的最大差别在第15行部分，这里在调用executeOnExecutor方法时传入的参数要多于send方法，这里面的target指的是下载文件的存储路径，autoResume指的是是否允许在下载暂停恢复之后从断点处下载，autoRename指的是当下载完成之后是否需要根据返回的头部信息来重命名下载的文件，这两个值默认情况下都是false，接着真正的执行者就是PriorityAsyncTask里面的
executeOnExecutor方法了，通过mFuture的run方法调用mWorker的call方法，而call方法中存在doInBackground方法，在PriorityAsyncTask中他又是没有实现的方法，因而它会执行HttpHandler的doInBackground方法，重点就来了，正是这个方法里面有一些处理断点下载以及重命名下载方面的内容，doInBackground中会执行sendRequest方法，sendRequest方法的前几行有如下代码：
if (autoResume && isDownloadingFile) {
File downloadFile = new File(fileSavePath);
long fileLen = 0;
if (downloadFile.isFile() && downloadFile.exists()) {
fileLen = downloadFile.length();
}
if (fileLen > 0) {
request.setHeader("RANGE", "bytes=" + fileLen + "-");
}
}
result = mFileDownloadHandler.handleEntity(entity, this, fileSavePath, autoResume, responseFileName);至此，这几天的学习总结完毕，希望能够帮助到大家，有什么错误的地方望指正，赠人玫瑰，手留余香！！！！！
以上是关于android-----XUtils框架之HttpUtils源码分析的主要内容，如果未能解决你的问题，请参考以下文章