volley介绍03
------------------------------------------------------------------------------
转载:http://blog.csdn.net/crazy__chen/article/details/46486123
------------------------------------------------------------------------------
在上一篇文章中,我们已经提到volley的使用方式和设计的整体思路,从这篇文章开始,我就要结合具体的源码来给大家说明volley功能的具体实现。
我们第一个要介绍的类是Request<T>这个一个抽象类,我将Request称为一个请求,通过继承Request<T>来自定义request,为volley提供了更加灵活的接口。
Request<T>中的泛型T,是指解析response以后的结果。在上一篇文章中我们知道,ResponseDelivery会把response分派给对应的request(中文翻译就是,把响应分派给对应的请求)。在我们定义的请求中,需要重写parseNetworkResponse(NetworkResponse response)这个方法,解析请求,解析出来的结果,就是T类型的。
OK,我们现在来直接看源码。
首先是一些属性
/** * Base class for all network requests. * 请求基类 * @param <T> The type of parsed response this request expects. * T为响应类型 */ public abstract class Request<T> implements Comparable<Request<T>> { /** * Default encoding for POST or PUT parameters. See {@link #getParamsEncoding()}. * 默认编码 */ private static final String DEFAULT_PARAMS_ENCODING = "UTF-8"; /** * Supported request methods. * 支持的请求方式 */ public interface Method { int DEPRECATED_GET_OR_POST = -1; int GET = 0; int POST = 1; int PUT = 2; int DELETE = 3; int HEAD = 4; int OPTIONS = 5; int TRACE = 6; int PATCH = 7; } /** * An event log tracing the lifetime of this request; for debugging. * 用于跟踪请求的生存时间,用于调试 * */ private final MarkerLog mEventLog = MarkerLog.ENABLED ? new MarkerLog() : null; /** * Request method of this request. Currently supports GET, POST, PUT, DELETE, HEAD, OPTIONS, * TRACE, and PATCH. * 当前请求方式 */ private final int mMethod; /** * URL of this request. * 请求地址 */ private final String mUrl; /** * The redirect url to use for 3xx http responses * 重定向地址 */ private String mRedirectUrl; /** * The unique identifier of the request * 该请求的唯一凭证 */ private String mIdentifier; /** * Default tag for {@link TrafficStats}. * 流量统计标签 */ private final int mDefaultTrafficStatsTag; /** * Listener interface for errors. * 错误监听器 */ private final Response.ErrorListener mErrorListener; /** * Sequence number of this request, used to enforce FIFO ordering. * 请求序号,用于fifo算法 */ private Integer mSequence; /** * The request queue this request is associated with. * 请求所在的请求队列 */ private RequestQueue mRequestQueue; /** * Whether or not responses to this request should be cached. * 是否使用缓存响应请求 */ private boolean mShouldCache = true; /** * Whether or not this request has been canceled. * 该请求是否被取消 */ private boolean mCanceled = false; /** * Whether or not a response has been delivered for this request yet. * 该请求是否已经被响应 */ private boolean mResponseDelivered = false; /** * A cheap variant of request tracing used to dump slow requests. * 一个简单的变量,跟踪请求,用来抛弃过慢的请求 * 请求产生时间 */ private long mRequestBirthTime = 0; /** Threshold at which we should log the request (even when debug logging is not enabled). */ private static final long SLOW_REQUEST_THRESHOLD_MS = 3000; /** * The retry policy for this request. * 请求重试策略 */ private RetryPolicy mRetryPolicy; /** * When a request can be retrieved from cache but must be refreshed from * the network, the cache entry will be stored here so that in the event of * a "Not Modified" response, we can be sure it hasn't been evicted from cache. * 缓存记录。当请求可以从缓存中获得响应,但必须从网络上更新时。我们保留这个缓存记录,所以一旦从网络上获得的响应带有Not Modified * (没有更新)时,来保证这个缓存没有被回收. */ private Cache.Entry mCacheEntry = null; /** * An opaque token tagging this request; used for bulk cancellation. * 用于自定义标记,可以理解为用于请求的分类 */ private Object mTag;
不得不说,上面的属性非常之多(我都有写注释),但是每个属性都有其相应的用处,而且有些属性的设置,是我们不大能考虑到的。我要来介绍一下。
1,DEFAULT_PARAMS_ENCODING = "UTF-8"默认编码
2,mMethod请求方式
3,mUrl请求地址
4,mRedirectUrl重定向地址,这个地址在网络响应状态码是403时,会被使用
5,mSequence序列号,就是这个request在队列中的序号(不是顺序)
6,mRequestQueue请求所在的请求队列
7,mErrorListener错误监听器
9,mShouldCache是否缓存,如果这个属性为真,就会先视图从缓存中查询请求结果
10,mCacheEntry缓存记录,这个记录用于缓存响应头等
11,mTag自定义标记,用户可以给一些请求自定义标记,使用这些标记,我们可以统一管理用于这些标记的请求,例如统一取消它们
接下来看构造方法
/** * Creates a new request with the given method (one of the values from {@link Method}), * URL, and error listener. Note that the normal response listener is not provided here as * delivery of responses is provided by subclasses, who have a better idea of how to deliver * an already-parsed response. * 根据请求方式,创建新的请求(需要地址,错误监听器等参数) */ public Request(int method, String url, Response.ErrorListener listener) { mMethod = method; mUrl = url; mIdentifier = createIdentifier(method, url);//为请求创建唯一凭证 mErrorListener = listener;//设定监听器 setRetryPolicy(new DefaultRetryPolicy());//设置默认重试策略 mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);//设置流量标志 }
首先是请求方式,请求地址的设定,这是作为一个请求必须有的。然后是监听器的设定,注意这里只是这是了ErrorListner,说明errorListener是必须的,但是正确响应,我们有可能不处理。这样设定是合理的,因为出错了,我们必须处理,至于请求成功,我们可以不处理。那么我们想处理成功的请求怎么办呢,这需要在子类中重写构造方法(例如StringRequest)。
然后是创建了一个唯一凭证
/** * sha1(Request:method:url:timestamp:counter) * @param method http method * @param url http request url * @return sha1 hash string * 利用请求方式和地址,进行sha1加密,创建该请求的唯一凭证 */ private static String createIdentifier(final int method, final String url) { return InternalUtils.sha1Hash("Request:" + method + ":" + url + ":" + System.currentTimeMillis() + ":" + (sCounter++)); }
由上面的方法可以看出,这个凭证和当前时间有关,因此是独一无二的
接着是设置重试策略,这个类等下再介绍,接下来是流量标志的设置,所谓流量标志,是用于调试日志记录的,不是重点
/** * @return The hashcode of the URL's host component, or 0 if there is none. * 返回url的host(主机地址)部分的hashcode,如果host不存在,返回0 */ private static int findDefaultTrafficStatsTag(String url) { if (!TextUtils.isEmpty(url)) { Uri uri = Uri.parse(url); if (uri != null) { String host = uri.getHost(); if (host != null) { return host.hashCode(); } } } return 0; }
我们再回过头来看这个重试策略。
volley为重试策略专门定义了一个类,这样我们就可以根据需要实现自己的重试策略了,至于源码内部,为我们提供了一个默认的重试策略DefaultRetryPolicy()
要介绍重试策略,我们先看重试策略的基类RetryPolicy
/** * Retry policy for a request. * 请求重试策略类 */ public interface RetryPolicy { /** * Returns the current timeout (used for logging). * 获得当前时间,用于日志 */ public int getCurrentTimeout(); /** * Returns the current retry count (used for logging). * 返回当前重试次数,用于日志 */ public int getCurrentRetryCount(); /** * Prepares for the next retry by applying a backoff to the timeout. * @param error The error code of the last attempt. * @throws VolleyError In the event that the retry could not be performed (for example if we * ran out of attempts), the passed in error is thrown. * 重试实现 */ public void retry(VolleyError error) throws VolleyError; }
重要的是retry()这个方法,我们来看DefaultRetryPolicy里面这个方法的具体实现
/** * Prepares for the next retry by applying a backoff to the timeout. * @param error The error code of the last attempt. */ @Override public void retry(VolleyError error) throws VolleyError { mCurrentRetryCount++;//当前重试次数 mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);//当前超出时间 if (!hasAttemptRemaining()) {//是否已经到达最大重试次数 throw error; } } /** * Returns true if this policy has attempts remaining, false otherwise. * 是否还重试 */ protected boolean hasAttemptRemaining() { return mCurrentRetryCount <= mMaxNumRetries;//最大重试次数 }
可以看到,在默认的重试策略中,只是简单地统计了重试的次数,然后,在超出最大次数以后,抛出异常。
就这么简单,那么究竟volley是怎么实现重试的呢?
实际上,当从队列中取出一个request去进行网络请求的时候,我们是写在一个死循环里面的(在以后的代码可以看到,这样不贴出来以免类过多造成困扰)。
一旦请求失败,就会调用上面的retry()方法,但是没有跳出循环。直到请求成功获得response,才return。如果一直请求失败,根据上面的重试策略,最后会抛出VolleyError异常,这个异常不处理,而是通过throws向外抛,从而结束死循环。
从程序设计的角度来说,通过抛出异常结束死循环,显得不是那么的优雅(通常我们用设置标记的方法结束循环),但是在volley中使用了这个方式,原因是对于这个异常,要交给程序员自己处理,虽然这样使异常传递的过程变得复杂,但是增加了程序的灵活性。
最终的异常,我们会在Request<T>的parseNetworkError()和deliverError()方法里面处理,parseNetworkError()用于解析Volleyerror,deliverError()方法回调了上面一开始就提到的ErrorListener
其实除了上面两个处理错误的方法,还有两个方法用于处理成功响应,是必须要继承的
/** * Subclasses must implement this to parse the raw network response * and return an appropriate response type. This method will be * called from a worker thread. The response will not be delivered * if you return null. * @param response Response from the network * @return The parsed response, or null in the case of an error * 解析响应 */ public abstract Response<T> parseNetworkResponse(NetworkResponse response); <pre name="code" class="java">/** * Subclasses must implement this to perform delivery of the parsed * response to their listeners. The given response is guaranteed to * be non-null; responses that fail to parse are not delivered. * @param response The parsed response returned by * {@link #parseNetworkResponse(NetworkResponse)} * 分发响应 */ public abstract void deliverResponse(T response);
parseNetworkResponse(NetworkResponse response)用于将网络response解析为本地response,解析出来的response,会交给deliverResponse(T response)方法。
为什么要解析,其实上面已经说过,要将结果解析为T类型。至于这两个方法,其实是在ResponseDelivery响应分发器里面调用的。
看完初始化方法,我们来看结束请求的方法finish(),有时候我们想要主动终止请求,例如停止下载文件,又或者请求已经成功了,我们从队列中去除这个请求
/** * Notifies the request queue that this request has finished (successfully or with error). * 提醒请求队列,当前请求已经完成(失败或成功) * <p>Also dumps all events from this request's event log; for debugging.</p> * */ public void finish(final String tag) { if (mRequestQueue != null) { mRequestQueue.finish(this);//该请求完成 } if (MarkerLog.ENABLED) {//如果开启调试 final long threadId = Thread.currentThread().getId();//线程id if (Looper.myLooper() != Looper.getMainLooper()) {//请求不是在主线程 // If we finish marking off of the main thread, we need to // actually do it on the main thread to ensure correct ordering. //如果我们不是在主线程记录log,我们需要在主线程做这项工作来保证正确的顺序 Handler mainThread = new Handler(Looper.getMainLooper()); mainThread.post(new Runnable() { @Override public void run() { mEventLog.add(tag, threadId); mEventLog.finish(this.toString()); } }); return; } //如果在主线程,直接记录 mEventLog.add(tag, threadId); mEventLog.finish(this.toString()); } else {//不开启调试 long requestTime = SystemClock.elapsedRealtime() - mRequestBirthTime; if (requestTime >= SLOW_REQUEST_THRESHOLD_MS) { VolleyLog.d("%d ms: %s", requestTime, this.toString()); } } }
上面主要是做了一些日志记录的工作,最重要的是调用了mRequestQueue的finish()方法,来从队列中去除这个请求。
看完上面的介绍以后,大家是否注意到,Request<T>继承了Comparable<Request<T>>接口,为什么要继承这个接口了,我们当然要来看compareTo()方法了
这个方法比较了两个请求的优先级,如果优先级相等,就按照顺序。
实现这个接口的目的,正如上一篇文章提到的,有的请求比较重要,希望早点执行,也就是说让它排在请求队列的前头
通过比较方法,我们就可以设定请求在请求队列中排队顺序的根据,从而让优先级高的排在前面。
OK,Request<T>就基本介绍完了,当然有些属性,例如缓存mCacheEntry,mRedirectUrl重定向地址等我们还没有用到,我们先记住它们,在以后会使用到的。
其实Request<T>类并不复杂,主要就是一些属性的设置,这些属性有的比较难考虑到,例如优先级,重定向地址,自定义标记,重试策略等。
最后,我们通过StringRequest来看一下Request<T>类的具体实现
/** * A canned request for retrieving the response body at a given URL as a String. */ public class StringRequest extends Request<String> { private final Listener<String> mListener; /** * Creates a new request with the given method. * * @param method the request {@link Method} to use * @param url URL to fetch the string at * @param listener Listener to receive the String response * @param errorListener Error listener, or null to ignore errors */ public StringRequest(int method, String url, Listener<String> listener, ErrorListener errorListener) { super(method, url, errorListener); mListener = listener; }
上面的构造方法中,添加了一个新的接口Listener<String> listener,用于监听成功的response
然后是parseNetworkResponse(NetworkResponse response),这个方法
可以看到,将NetworkResponse解析为String类型的了,然后再构造成对应的本地response
@Override public void deliverResponse(String response) { mListener.onResponse(response); }
至于deliverResponse(String response),则调用了构造方法里面要求的,新的监听器。
到此为止,对于Request<T>的介绍就结束了,由于Request<T>和其他类的耦合并不是特别重,相信是比较容易理解。
在下一篇文章中,我们会来看RequestQueue队列,看看这个队列的作用到底是什么,我们为什么要创建一个队列来保存request而不是直接每个request开启一个线程去加载网络数据。