Volley源码解析（一）——发送请求与结束请求

Volley是一个Android HTTP库，只支持异步方式。

发送请求样例

final TextView mTextView = (TextView) findViewById(R.id.text);... // Instantiate the RequestQueue. RequestQueue queue = Volley.newRequestQueue(this);String url ="http://www.google.com";// Request a string response from the provided URL. StringRequest stringRequest = new StringRequest(Request.Method.GET, url,            new Response.Listener<String>() {    @Override     public void onResponse(String response) {        // Display the first 500 characters of the response string.         mTextView.setText("Response is: "+ response.substring(0,500));    } }, new Response.ErrorListener() {    @Override     public void onErrorResponse(VolleyError error) {        mTextView.setText("That didn't work!");    } }); // Add the request to the RequestQueue. queue.add(stringRequest);

发送请求源码分析

一个请求的生命周期如下图：

从上图可以看出，在Volley中会有三个线程：UI线程负责发请求和收响应；缓存分发器；网络分发器。
Volley类中只负责一件事情，就是创建一个RequestQueue对象，用于存放请求，该对象最好是单例的，供整个APP使用。
其具体实现如下：

public static RequestQueue newRequestQueue(Context context, HttpStack stack) {        //创建缓存目录        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);        String userAgent = "volley/0";        //更新userAgent字段        try {            String packageName = context.getPackageName();            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);            userAgent = packageName + "/" + info.versionCode;        } catch (NameNotFoundException e) {        }        //对HttpStack赋值        if (stack == null) {            //如果SDK大于8，使用HurlStack，否则使用HttpClientStack            if (Build.VERSION.SDK_INT >= 9) {                stack = new HurlStack();            } else {                // Prior to Gingerbread, HttpUrlConnection was unreliable.                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));            }        }        Network network = new BasicNetwork(stack);        //创建RequestQueue对象        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);        queue.start();        return queue;    }

RequestQueue的构造方法中有两个参数，一个是Cache，负责将响应保存到磁盘，一个是Network，负责执行HTTP操作。
下面先看一下RequestQueue的内部定义，RequestQueue内部主要有四个字段是在初始化的时候指定的，分别是：

    private final Cache mCache;    private final Network mNetwork;    /** 分发HTTP响应 */    private final ResponseDelivery mDelivery;    /** 网络分发器 */    private NetworkDispatcher[] mDispatchers;

RequestQueue的构造方法一共有三个，但最终都会调用下面的这个构造器，如下：

 public RequestQueue(Cache cache, Network network, int threadPoolSize,            ResponseDelivery delivery) {        mCache = cache;        mNetwork = network;        mDispatchers = new NetworkDispatcher[threadPoolSize];        mDelivery = delivery;    }

RequesteQueue#start()

当创建好RequestQueue之后，调用了start()方法，start()方法如下：

    public void start() {        stop();  // Make sure any currently running dispatchers are stopped.        // 创建缓存分发器，然后启动        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);        mCacheDispatcher.start();        // 创建网络分发器，然后启动        for (int i = 0; i < mDispatchers.length; i++) {            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,                    mCache, mDelivery);            mDispatchers[i] = networkDispatcher;            networkDispatcher.start();        }    }

可以看到RequestQueue的start方法就是启动其内部的分发器，主要包括一个缓存分发器和多个网络分发器，网络分发器的数量实在构造方法中设置的，默认为4个。
前面的例子中，当创建好Request和RequestQueue之后，就将Request放进RequestQueue中就可以了。

RequestQueue#add()方法

add()方法实现如下：

public <T> Request<T> add(Request<T> request) {        //Request和RequestQueue关联        request.setRequestQueue(this);        //将请求加入到Set中        synchronized (mCurrentRequests) {            mCurrentRequests.add(request);        }        // Process requests in the order they are added.        request.setSequence(getSequenceNumber());        request.addMarker("add-to-queue");        // 如果这个请求不应该被缓存，那么直接添加进网络队列中        if (!request.shouldCache()) {            mNetworkQueue.add(request);            return request;        }        synchronized (mWaitingRequests) {            String cacheKey = request.getCacheKey();            //如果该请求已经在执行了            if (mWaitingRequests.containsKey(cacheKey)) {                Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);                if (stagedRequests == null) {                    stagedRequests = new LinkedList<Request<?>>();                }                stagedRequests.add(request);                mWaitingRequests.put(cacheKey, stagedRequests);                if (VolleyLog.DEBUG) {                    VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);                }            } else {                mWaitingRequests.put(cacheKey, null);                mCacheQueue.add(request);            }            return request;        }    }

这里面涉及到RequestQueue中的多个个集合，定义分别如下：

    //如果当前请求已经在执行了，那么将会加入到该集合中    private final Map<String, Queue<Request<?>>> mWaitingRequests =            new HashMap<String, Queue<Request<?>>>();    //当前正在执行的请求    private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();    //缓存请求优先级队列    private final PriorityBlockingQueue<Request<?>> mCacheQueue =        new PriorityBlockingQueue<Request<?>>();    //网络请求优先级队列    private final PriorityBlockingQueue<Request<?>> mNetworkQueue =        new PriorityBlockingQueue<Request<?>>();

可以看到，add()方法主要做的就是根据不同情况将请求加入到不同的队列中。由于缓存请求队列和网络请求队列都是使用的优先级队列，所以可以给Request设置优先级。
1. 如果请求不应该从缓存中得到，那么直接加入到网络请求队列中；
2. 如果请求已经在执行了，那么将其加入到正在执行的一个HashMap中，其中key是请求，值是一个请求的队列；
3. 如果请求没有在执行，那么将其加入到缓存队列中。

在这里，我们已经将一个请求提交了，下面看一下，Request的缓存键值是如何得到的。

Request#getCacheKey()

public String getCacheKey() {        return getUrl();    }public String getUrl() {        return mUrl;    }

可以看到一个Request的键值就是其URL。
现在考虑一个问题：创建了同一个相同URL的两个Request，或者说同一个Request添加到RequestQueue两次，情况是怎么样的呢？下面分别分析：

RequestQueue添加同一相同URL的两个Request对象

设为Request1和Request2，添加时，由于Request没有重写equals方法和hashCode方法，所以mCurrentRequests会人为这是两个不同的请求，都添加进Set，然后比如说Request1首先获得了mWaitingRequests的锁，由于mWaitingRequests中还没有该URL，所以被添加进mWaitingRequests和放到了缓存队列中，然后当Request2再获取到mWaitingRequests时候，由于已经有了URL，所以会在mWaitingRequests中创建一个链表并把该请求放入链表中，从而可以看出同一时刻相同URL的请求只会被执行一次。不过具体放在链表中的请求在Request1被处理之后是如何处理的，下面一篇博客会分析到。

Request添加同一相同的Request两次

经过前面的分析，可以知道，在mCurrentRequests中后一个Request会代替前一个Request，而后一个Request会被放入mWaitingRequests的链表中。可以发现同一个Request对象即在缓存队列中，又在待处理的队列中。

下面就Request被执行完之后，看是怎样操作的来解释上面两个问题。

结束请求源码分析

当想取消一个Request的执行时，可以调用RequestQueue的finish()来主要取消执行，也可以在Request被正常执行完之后自己调用finish()方法，下面先从Request的finish()方法看起，其实现如下：

Request#finish()

 void finish(final String tag) {        if (mRequestQueue != null) {            mRequestQueue.finish(this);        }        if (MarkerLog.ENABLED) {            final long threadId = Thread.currentThread().getId();            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.                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());            }        }    }

可以看到，首先也是调用了RequestQueue的finish()方法，下面再来分析RequestQueue的finish()方法。

RequestQueue#finish()

void finish(Request<?> request) {        // 首先从当前执行集合中删除        synchronized (mCurrentRequests) {            mCurrentRequests.remove(request);        }        //如果请求应该被缓存        if (request.shouldCache()) {            synchronized (mWaitingRequests) {                //得到请求的键值，即URL                String cacheKey = request.getCacheKey();                //得到与URL关联的等待队列                Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);                //如果队列不为null                if (waitingRequests != null) {                    //将所有请求都加入到缓存队列中                    mCacheQueue.addAll(waitingRequests);                }            }        }    }

这儿，可以看到，首先是从Set集合中删除当前请求，然后判断请求是否应该被缓存，这和add()方法里面是相一致的，add()方法里只有请求允许使用缓存，才会被加入到URL关联的等待队列中。然后就是将与URL关联的请求都加入到缓存队列中。下面就上面两个问题再次给出解释。
1. RequestQueue添加同一相同URL的两个Request对象：对于这种情况，Request1被执行，Request2被存在等待队列中，当Request1执行完成后，将会从URL关联的队列中得到Request2对象，然后将Request2加入到缓存队列，由于Request1之前已经有缓存结果了，所以执行Request2时只需要经过CacheDispatcher就可以得到结果然后finish了，可以发现这种情况下，同一个URL的只会进行一次网络请求，其余的都是走缓存请求；不过这是针对于可以缓存响应的情况，如果不能缓存响应，那么都会直接加入到网络请求中执行两次网络操作。
2. Request添加同一相同的Request两次：当执行了第一次之后，就从Set中成功移除了Request，然后再从等待队列中取出，加入到缓存队列，可以当发现这一次的Request依然会走CacheDispatcher中一趟。

至此，我们将一个请求提交给了RequestQueue，那么RequestQueue是如何执行请求，又是如何将响应交付给UI线程处理呢？这一部分，我们下一篇再讲。下一篇文章Volley源码解析（二）——CacheDispatcher将会介绍CacheDispatcher是如何进行缓存分发的。