volley介绍03

/** 
 * 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;  

/** 
     * 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);//设置流量标志  
    }  

/** 
     *  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;  
    }  

/** 
 * 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;  
}  

/** 
     * 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;//最大重试次数  
    }  

/** 
     * 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);  

/** 
 * 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;  
    }  

@Override  
public void deliverResponse(String response) {  
    mListener.onResponse(response);  
}