参考别人的分析对于Volley的理解（三）

àì夳堔傛蜴生んèń 2022-07-25 15:57 123阅读 0赞

本文是接着[参考别人的分析对于Volley的理解（一）][Volley]和[参考别人的分析对于Volley的理解（二）][Volley 1]写的第三篇对于Volley库的理解和分析，其中参考了大牛的[Volley 源码解析][Volley 2]这篇文章，在这里再次表示感谢。

### Request.java ###

表示一个请求的抽象类。StringRequest、JsonRequest、ImageRequest 都是它的子类，表示某种类型的请求。它还实现了Comparable接口。

/** * Our comparator sorts from high to low priority, and secondarily by * sequence number to provide FIFO ordering. */
        @Override
        public int compareTo(Request<T> other) {
            Priority left = this.getPriority();
            Priority right = other.getPriority();
    
            // High-priority requests are "lesser" so they are sorted to the front.
            // Equal priorities are sorted by sequence number to provide FIFO ordering.
            return left == right ?
                    this.mSequence - other.mSequence :
                    right.ordinal() - left.ordinal();
        }

在这里可以看出这里的request的比较是根据优先级，其次是我们的队列的先到先出的比较。FIFO是先到先出。

### CacheDispatcher.java ###

在RequestQuene里开启的线程。一个线程，用于调度处理走缓存的请求。启动后会不断从缓存请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给ResponseDelivery去执行后续处理。当结果未缓存过、缓存失效或缓存需要刷新的情况下，该请求都需要重新进入NetworkDispatcher去调度处理。在这里最重要的是run()方法：

@Override
        public void run() {
            if (DEBUG) VolleyLog.v("start new dispatcher");
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    
            // Make a blocking call to initialize the cache.
            mCache.initialize();
    
            Request<?> request;
            while (true) {
                // release previous request object to avoid leaking request object when mQueue is drained.
                request = null;
                try {
                    // Take a request from the queue.
                    request = mCacheQueue.take();
                } catch (InterruptedException e) {
                    // We may have been interrupted because it was time to quit.
                    if (mQuit) {
                        return;
                    }
                    continue;
                }
                try {
                    request.addMarker("cache-queue-take");
    
                    // If the request has been canceled, don't bother dispatching it.
                    if (request.isCanceled()) {
                        request.finish("cache-discard-canceled");
                        continue;
                    }
    
                    // Attempt to retrieve this item from cache.
                    Cache.Entry entry = mCache.get(request.getCacheKey());
                    if (entry == null) {
                        request.addMarker("cache-miss");
                        // Cache miss; send off to the network dispatcher.
                        mNetworkQueue.put(request);
                        continue;
                    }
    
                    // If it is completely expired, just send it to the network.
                    if (entry.isExpired()) {
                        request.addMarker("cache-hit-expired");
                        request.setCacheEntry(entry);
                        mNetworkQueue.put(request);
                        continue;
                    }
    
                    // We have a cache hit; parse its data for delivery back to the request.
                    request.addMarker("cache-hit");
                    Response<?> response = request.parseNetworkResponse(
                            new NetworkResponse(entry.data, entry.responseHeaders));
                    request.addMarker("cache-hit-parsed");
    
                    if (!entry.refreshNeeded()) {
                        // Completely unexpired cache hit. Just deliver the response.
                        mDelivery.postResponse(request, response);
                    } else {
                        // Soft-expired cache hit. We can deliver the cached response,
                        // but we need to also send the request to the network for
                        // refreshing.
                        request.addMarker("cache-hit-refresh-needed");
                        request.setCacheEntry(entry);
    
                        // Mark the response as intermediate.
                        response.intermediate = true;
    
                        // Post the intermediate response back to the user and have
                        // the delivery then forward the request along to the network.
                        final Request<?> finalRequest = request;
                        mDelivery.postResponse(request, response, new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    mNetworkQueue.put(finalRequest);
                                } catch (InterruptedException e) {
                                    // Not much we can do about this.
                                }
                            }
                        });
                    }
                } catch (Exception e) {
                    VolleyLog.e(e, "Unhandled exception %s", e.toString());
                }
            }
        }

一开始，先设置线程优先级为后台，这样当多个线程并发后很多无关紧要的线程分配的CPU时间将会减少，有利于主线程的处理。  
然后，调用接口的initialize方法，用于初始化。  
后面是一个while循环，其中的条件是true，表示一直循环。  
后面的request = mCacheQueue.take();表示取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止。通过这个方式取出一个缓存队列中的请求。

### NetworkDispatcher.java ###

一个线程，用于调度处理走网络的请求。启动后会不断从网络请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给 ResponseDelivery 去执行后续处理，并判断结果是否要进行缓存。

// Write to cache if applicable.
                    // TODO: Only update cache metadata instead of entire record for 304s.
                    if (request.shouldCache() && response.cacheEntry != null) {
                        mCache.put(request.getCacheKey(), response.cacheEntry);
                        request.addMarker("network-cache-written");
                    }

通过上面的代码来进行缓存。

### Cache.java ###

缓存接口，代表了一个可以获取请求结果，存储请求结果的缓存。同时提供了一个Entry缓存类。

### StringRequest.java ###

继承 Request 类,代表了一个返回值为 String 的请求。将网络返回的结果数据用parseCharset解析为 String 类型。通过构造函数的 listener 传参，支持请求成功后的 onResponse(…) 回调。

private 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;
        }
    
        /** * Creates a new GET request. * * @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(String url, Listener<String> listener, ErrorListener errorListener) {
            this(Method.GET, url, listener, errorListener);
        }
    
        @Override
        protected void onFinish() {
            super.onFinish();
            mListener = null;
        }
    
        @Override
        protected void deliverResponse(String response) {
            if (mListener != null) {
                mListener.onResponse(response);
            }
        }
    
        @Override
        protected Response<String> parseNetworkResponse(NetworkResponse response) {
            String parsed;
            try {
                parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
            } catch (UnsupportedEncodingException e) {
                parsed = new String(response.data);
            }
            return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
        }

在这个类里，除了构造函数，重载了父类request类的onFinish，deliverResponse和parseNetworkResponse方法。最主要的parseNetworkResponse方法把我们的服务器端返回的值转换成为了String类型来供客户端解析。

### JsonRequest.java ###

抽象类，继承自 Request，代表了 body 为 JSON 的请求。提供了构建 JSON 请求参数的方法。它同时被JsonObjectRequest和JsonArrayRequest这两个类继承。

### JsonObjectRequest.java ###

继承自 JsonRequest，将网络返回的结果数据解析为 JSONObject 类型。

### JsonArrayRequest.java ###

继承自 JsonRequest，将网络返回的结果数据解析为 JSONArray 类型。

### ImageRequest.java ###

继承 Request 类，代表了一个返回值为 Image 的请求。将网络返回的结果数据解析为 Bitmap 类型。  
可以设置图片的最大宽度和最大高度，并计算出合适尺寸返回。每次最多解析一张图片防止 OOM。同时，Volley类封装了ImageLoader库，可以用ImageLoader来显示网络图片，体现了很高的定制性。

在这里，主要是参考了别人的Volley分析，在这里我发现Java基础也是极其重要的，在阅读Volley源码的过程中，我查阅了很多关于Java线程，枚举之类的知识，所以在进行Android编码的同时，Java也是极其重要的。目前是主要借助别人的代码分析，同时结合一些自己的注解用来帮助自己理解。后面尽量更加详细地把Volley剩下的一些内容理解一下，同时尽量多的使用自己的语言，而是以参考为辅。

[Volley]: http://blog.csdn.net/y505772146/article/details/50777786
[Volley 1]: http://blog.csdn.net/y505772146/article/details/51019146
[Volley 2]: http://a.codekk.com/detail/Android/grumoon/Volley%20%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90