Volley设计思想和流程分析

本文是对Volley思路的整体整理，并不是Volley教程，建议有Volley使用经验，但是对Volley整体不是很清楚的同学阅读。

我认为，弄清整体的流程很重要，以避免一叶障目不见泰山的囧境，而对于面向对象编程，弄清每个类是干什么的，类与类之间的关系后，就不难搞懂整个流程了。

所以本文不会深入源码细节，从每个类的构造参数最全的构造函数入手，讲解这个类是干什么的，由什么构成，每个元素的作用是什么。

因为不会深入细节，所以建议最好了解Volley的基本使用方法。

1.Volley类初始化RequestQueue

在整个Volley流程里，原始类是Volley,这个类中有一个静态方法会new一个RequestQueue,而一切都从这里开始

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
        String userAgent = "volley/0";
        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }
        if (stack == null) {
            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 queue;
        if (maxDiskCacheBytes <= -1)
        {
            // No maximum size specified
            queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        }
        else
        {
            // Disk cache size specified
            queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
        }
        queue.start();
        return queue;
    }

RequestQueue

可以看到我们首先根据SDK版本来选择合适的HTTP请求方案，版本大于等于9的时候使用HTTPUrlConnection进行请求。

根据你请求方案来初始化我们的RequestQueue，看一下RequestQueue的构造：

public RequestQueue(Cache cache, 
                    Network network, 
                    int threadPoolSize,
                    ResponseDelivery delivery) {/*...*/}

四个参数：缓存，请求方案，网络连接池大小，请求结果分发器

缓存:Volley默认使用DiskBasedCache

请求方案：HttpClient和HttpUrlConnection两种

网络连接池：即建立几个网络请求线程NetWorkDispatchThread，默认的大小是4

请求结果分发器：当我们获得请求结果后，有它分发出去，通常回调我们之前定义的处理方法。

剩下的细节暂且不表，建立了RequestQueue后，我们会获得两个队列，缓存请求队列和网络请求队列，那由谁来到队列里取出请求呢？

2.建立线程处理请求队列，两种请求对应两种线程

public CacheDispatcher(BlockingQueue<Request<?>> cacheQueue, 
                        BlockingQueue<Request<?>> networkQueue,
                        Cache cache, ResponseDelivery delivery) {/*...*/}

public NetworkDispatcher(BlockingQueue<Request<?>> queue,
                         Network network, 
                         Cache cache,        
                         ResponseDelivery delivery){/*...*/}

CahceDispathcher，即缓存请求处理线程，四个初始化参数，这里看到第二个参数是：networkQueue。咦？既然是处理缓存请求的线程，为什么要在这里传入网络请求队列呢？

从cachequeue中拿到请求，根据请求信息去chche中获取，如果缓存没问题，则通过delivery分发，如果我们会遇到缓存过期，或者缓存没过期但是需要更新的情况，这个时候就需要把请求放入networkqueue中，以供下一步请求。

NetworkDispatcher，即网络请求处理线程，也是四个初始化参数：从queue中获得请求，有network方案执行请求，返回结果后如果可以缓存则放入cache,最后将返回的结果通过delivery送到处理的地方。

3.由HttpStack进行网络工作

cache部分就像上面说的那样，最后回到网络部分，这部分请求工作就需要单独说一说了。

public interface HttpStack {
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
        throws IOException, AuthFailureError;
}

public HttpClientStack(HttpClient client) {/*...*/}

public HurlStack(UrlRewriter urlRewriter, 
                 SSLSocketFactory sslSocketFactory){/*...*/}

在HttpStack接口中，只有一个要实现的方法：performRequest。顾名思义，就是执行请求的意思，我们所有的Request都要实现这个方法，根据请求的不同网络请求执行过程有很大不同。

有两个参数，一个是请求本身，还有一个是附加的头信息，在Volley中，根据不同的请求阶段和请求状态，我们会定义不同的附加说明信息，这些信息会放在header里。

如上文所说，根据SDK版本不用，我们使用不同的请求方案，在这里对应的就是HttpClentStack和HurlStack了。

剩下的就是android的网络请求知识，在本篇文章中不是重点。

总之最后我们会拿到请求的回应response，而在不同的请求中，由于数据格式不同，我们需要将response返回的二进制字节流转化成需要的格式，

这时候就要调用resquest的 request.parseNetworkResponse(networkResponse)方法，解析response，按照要求解析之后，我们拿到的才是自习想用的数据，如：BitMap、Json等等，这才是我们真正需要要的Response，然后呢？

4.Delivery将Response运走

public interface ResponseDelivery {

    public void postResponse(Request<?> request, Response<?> response);
    /**
     * 解析从网络或者缓存中获取的响应并分发出去。
     * 所定义的的线程将在分发后执行
     */
    public void postResponse(Request<?> request, Response<?> response, Runnable runnable);

    /**
     * Posts an error for the given request.
     */
    public void postError(Request<?> request, VolleyError error);
}

在其具体实现类ExecutorDelivery中，无论如何都会执行runnable，即使初始化为null。因为我们将最后的结果处理统一放在了那个线程里，简化版源码如下所示

public class ExecutorDelivery implements ResponseDelivery {

 public ExecutorDelivery(final Handler handler) {
        // Make an Executor that just wraps the handler.
        mResponsePoster = new Executor() {
            @Override
            public void execute(Runnable command) {
                handler.post(command);
            }
        };
    }

    @Override
    public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
        request.markDelivered();
        request.addMarker("post-response");
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
    }

    private class ResponseDeliveryRunnable implements Runnable {

        public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
            //...
        }

        public void run() {
            //...
            if (mResponse.isSuccess()) {
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }
            //...
            // If we have been provided a post-delivery runnable, run it.
            if (mRunnable != null) {
                mRunnable.run();
            }
       }
    }
}

可以看到，最后调用的是mRequest.deliverResponse，这个才是处理了最后求的方法，所以，我们需要关注一下这些请求本身了。

5.各种请求

上面就是大概的请求分发过程，至于具体的处理请求方法就涉及到HTTP的知识了，此处都不细讲，过两天会专门结合HTPP语义和Volley来写一篇文章。

Volley有一大特性就是灵活，因为Volley设计中有一个很重要的思想是“面向接口编程”，我们可以定制符合自己要求的Request，Request接口中这样初始化一个Request:

public Request(int method, 
               String url, 
               Response.ErrorListener listener){/*...*/}

三个参数：请求方法(GET、PUT、POST…)，请求的URL，请求错误的监听器。

也就是说，我们至少要让自己的请求具备这个三个参数，剩下的就随意我们扩展了，而Volley也为大家提供了几种定制好的请求，下面就来看一看吧。

public ImageRequest(String url, 
                    Response.Listener<Bitmap> listener, 
                    int maxWidth, 
                    int maxHeight,
                    ScaleType scaleType, 
                    Config decodeConfig, 
                    Response.ErrorListener errorListener) {/*...*/}

public JsonArrayRequest(String url, 
                        Listener<JSONArray> listener, 
                        ErrorListener errorListener) {/*...*/}

public JsonObjectRequest(int method, 
                         String url, 
                         JSONObject jsonRequest,
                         Listener<JSONObject> listener, 
                         ErrorListener errorListener) {/***/}

public StringRequest(int method, 
                     String url, 
                     Listener<String> listener,
                     ErrorListener errorListener) {/*...*/}

public JsonRequest(int method, 
                   String url, 
                   String requestBody, 
                   Listener<T> listener,
                   ErrorListener errorListener){/*...*/}

最复杂的就是ImageRequest,这里初始化没有method，因为默认是使用GET方法的，随后定义了结果监听器，最大宽度，最大高度，缩放方式，解码配置，错误监听，这个就涉及到在Android中加载图片需要注意的事项了，也会写一篇单独的文章讲一下。

后面的几种，他们的参数顾名思义就可以了，哈哈，我就偷个懒，不讲了。

为什么要单独将这些请求列出来呢？

因为有一个很重要的参数，这个参数的存在，将Volley整个流程形成的闭环，那就是，上述所有构造器中都有的一个参数： Lister<T> listener (T表示请求数据的类型)

这个Listener就用来接收delievery分发回来的结果数据，对数据进行处理，这个listener需要由我们自己重写，按照想要的方式展示结果数据。

在第4小节中提到了mRequest.deliverResponse的方法，此时可以看看它的真面目了，此处以ImageQequest为例：

@Override
protected void deliverResponse(Bitmap response) {
    mListener.onResponse(response);
}

这回大家都明白了吧。

一切都自Request始，到这里又有request终。

回过头来一看，是这样的一个过程：

START

1.定义你的Request，并定义好相应请求结果的回调Listener

2.建立RequestQueue

3.将你的Request放入RequestQueue中(RequestQueue.add())

4.由cacheDispatcher和networkDispatcher线程进行请求的分发

5.按照请求的性质，有cache或者HttpStack进行处理请求，获取返回的数据

6.处理返回数据，该放入缓存的放入缓存，然后使用ExecutorDelivery将结果分发出去。

7.调用Request的Listener，接受并处理Delivery给我们分发回来的结果。

END

本文尽量从一个清晰的思路讲解Volley的流程，从中体会Volley的设计思想。

为了清晰简洁，除了ExecutorDelivery以为，并没有深究细节，但是希望看完后可以去仔细研究Volley的细节，因为不研究细节是无法总结出来整体流程的。我也是翻来覆去看了几遍源码，才总结出来的这篇文章。

有浅入深，而后深入浅出。

这是学习Volley的过程中最大的心得，Volley并不难懂，难的是将从Volley学到思想用在自己的程序中，这就需要多多练习了。

如果有错误的地方，麻烦大家指正。

如需转载，请注明原作：