201709011工作日记--Volley源码详解（二）

1.Cache接口和DiskBasedCache实现类

  首先，DiskBasedCache类是Cache接口的实现类，因此我们需要先把Cache接口中的方法搞明白。

 

    

  首先分析下Cache接口中的东西，首先是接口的内部类 class entry{}，用途是返回缓存的数据，下面是内部类的具体实现：

 

class Entry {
        /**
         * 从缓存中返回的数据
         * The data returned from cache.
         * */
        public byte[] data;

        /**
         * 缓存一致性
         * ETag for cache coherency. */
        public String etag;

        /**
         * 从服务端返回的响应数据
         * Date of this response as reported by the server. */
        public long serverDate;

        /**
         * 请求的最后修改时间
         * The last modified date for the requested object. */
        public long lastModified;

        /**
         * 记录的TTL值。IP包被路由器丢弃之前允许通过的最大网段数量
         * 作用是限制IP数据包在计算机网络中的存在的时间，IP数据包在计算机网络中可以转发的最大跳数
         * TTL for this record. */
        public long ttl;

        /** Soft TTL for this record. */
        public long softTtl;

        /** Immutable response headers as received from server; must be non-null. */
        public Map<String, String> responseHeaders = Collections.emptyMap();

        /**过期，返回true
         * True if the entry is expired. */
        public boolean isExpired() {
            return this.ttl < System.currentTimeMillis();
        }

        /**
         * 如果需要从数据源跟新数据则返回TRUE
         * True if a refresh is needed from the original data source. */
        public boolean refreshNeeded() {
            return this.softTtl < System.currentTimeMillis();
        }
    }

 

  上面的是在接口中定义了一个内部类Entry，这种情况之前没见过，还不知道有什么具体作用，下面是接口内部类举例：

  

public class QuestionMain implements ITest{
    public static void main(String[] args) {
        ITest.TestInternal.test(new QuestionMain());
    }
    @Override
    public void print() {
        System.out.println("真正实现方法");
    }
}
interface ITest {
    void print();
    public static class TestInternal {
        public static void test(ITest test) {
            test.print();
        }
    }
}

 

  链接中有一点点相关讨论，但是仍然不知道有啥作：http://www.th7.cn/Program/java/201412/329066.shtmlhttp://bbs.csdn.net/topics/390735550

我的一点理解是：由于接口中的所有方法都需要重写，但是有些方法不想重写的话可以放到接口内部类中去。

  接口 Cache 里面封装了一个静态内部类 Entry（登记），这个内部类非常重要，看了 HTTP 协议的同学们会发现，Entry 里面定义的这些成员变量跟 headers（消息报头）里面关于缓存的标签是一样的，这也是前面强调要看协议的原因。其中还维护了一个map 用来保存消息报头中的 key / value，data 来保存 entity 消息实体。除此之外就是一些集合操作了。接口的内部类 Entry，他真的太重要了，我们看连个判断过期和需要刷新的方法分别是，两个成员变量跟当前时间的对比。而 data 是二进制数组，我们都知道在 HTTP 中 start line 和 headers 是明文存储的，而 Entity 是没有规定的，一般我们都用二进制流传输，可以减少传输流量，并且安全，data 这里就是用来保存 Entity 的。

  这个接口的作用就是对外提供一个查询、存入、删除缓存条目的作用。

  Cache 的默认实现是 DiskBasedCache，实现类的目的是：类的目的是 将文件直接缓存到指定目录中的硬盘上的缓存实现。

  参数与初始化函数：

/**
     * 缓存条目
     * Map of the Key, CacheHeader pairs */
    private final Map<String, CacheHeader> mEntries =
            new LinkedHashMap<String, CacheHeader>(16, .75f, true);

    /**
     * 目前所使用到的缓存字节数组
     * Total amount of space currently used by the cache in bytes. */
    private long mTotalSize = 0;

    /**
     * 缓存的根目录
     * The root directory to use for the cache. */
    private final File mRootDirectory;

    /**
     * 缓存的最大字节数组
     * The maximum size of the cache in bytes. */
    private final int mMaxCacheSizeInBytes;

    /**
     * 默认的最大硬盘缓存
     * Default maximum disk usage in bytes. */
    private static final int DEFAULT_DISK_USAGE_BYTES = 5 * 1024 * 1024;

    /** High water mark percentage for the cache */
    private static final float HYSTERESIS_FACTOR = 0.9f;

    /** Magic number for current version of cache file format. */
    private static final int CACHE_MAGIC = 0x20150306;

    /**缓存根目录，最大缓存字节数
     * Constructs an instance of the DiskBasedCache at the specified directory.
     * @param rootDirectory The root directory of the cache.
     * @param maxCacheSizeInBytes The maximum size of the cache in bytes.
     */
    public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {
        mRootDirectory = rootDirectory;
        mMaxCacheSizeInBytes = maxCacheSizeInBytes;
    }

    /**
     * Constructs an instance of the DiskBasedCache at the specified directory using
     * the default maximum cache size of 5MB.
     * @param rootDirectory The root directory of the cache.
     */
    public DiskBasedCache(File rootDirectory) {
        this(rootDirectory, DEFAULT_DISK_USAGE_BYTES);
    }

 

  针对缓存数据的处理：

 

 /**
     * 清空缓存，并将缓存目录下面的所有缓存文件删除
     * Clears the cache. Deletes all cached files from disk.
     */
    @Override
    public synchronized void clear() {
        File[] files = mRootDirectory.listFiles();
        if (files != null) {
            for (File file : files) {
                file.delete();
            }
        }
            mEntries.clear();
        mTotalSize = 0;
        VolleyLog.d("Cache cleared.");
    }

    /**
     * 利用指定----key，去获取缓存条目
     * Returns the cache entry with the specified key if it exists, null otherwise.
     */
    @Override
    public synchronized Entry get(String key) {
        CacheHeader entry = mEntries.get(key);
        // if the entry does not exist, return.
        //缓存为空则直接返回
        if (entry == null) {
            return null;
        }
        File file = getFileForKey(key);
        try {
            CountingInputStream cis = new CountingInputStream(
                    new BufferedInputStream(createInputStream(file)), file.length());
            try {
                CacheHeader entryOnDisk = CacheHeader.readHeader(cis);
                if (!TextUtils.equals(key, entryOnDisk.key)) {
                    // File was shared by two keys and now holds data for a different entry!
                    VolleyLog.d("%s: key=%s, found=%s",
                            file.getAbsolutePath(), key, entryOnDisk.key);
                    // Remove key whose contents on disk have been replaced.
                    removeEntry(key);
                    return null;
                }
                byte[] data = streamToBytes(cis, cis.bytesRemaining());
                return entry.toCacheEntry(data);
            } finally {
                // Any IOException thrown here is handled by the below catch block by design.
                //noinspection ThrowFromFinallyBlock
                cis.close();
            }
        } catch (IOException e) {
            VolleyLog.d("%s: %s", file.getAbsolutePath(), e.toString());
            remove(key);
            return null;
        }
    }

    /**
     * Initializes the DiskBasedCache by scanning for all files currently in the
     * specified root directory. Creates the root directory if necessary.
     */
    @Override
    public synchronized void initialize() {
        if (!mRootDirectory.exists()) {
            if (!mRootDirectory.mkdirs()) {
                VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
            }
            return;
        }
        File[] files = mRootDirectory.listFiles();
        if (files == null) {
            return;
        }
        for (File file : files) {
            try {
                long entrySize = file.length();
                CountingInputStream cis = new CountingInputStream(
                        new BufferedInputStream(createInputStream(file)), entrySize);
                try {
                    CacheHeader entry = CacheHeader.readHeader(cis);
                    // NOTE: When this entry was put, its size was recorded as data.length, but
                    // when the entry is initialized below, its size is recorded as file.length()
                    entry.size = entrySize;
                    putEntry(entry.key, entry);
                } finally {
                    // Any IOException thrown here is handled by the below catch block by design.
                    //noinspection ThrowFromFinallyBlock
                    cis.close();
                }
            } catch (IOException e) {
                //noinspection ResultOfMethodCallIgnored
                file.delete();
            }
        }
    }

    /**
     * Invalidates an entry in the cache.
     * @param key Cache key
     * @param fullExpire True to fully expire the entry, false to soft expire
     */
    @Override
    public synchronized void invalidate(String key, boolean fullExpire) {
        Entry entry = get(key);
        if (entry != null) {
            entry.softTtl = 0;
            if (fullExpire) {
                entry.ttl = 0;
            }
            put(key, entry);
        }
    }

    /**
     * Puts the entry with the specified key into the cache.
     */
    @Override
    public synchronized void put(String key, Entry entry) {
        pruneIfNeeded(entry.data.length);
        File file = getFileForKey(key);
        try {
            BufferedOutputStream fos = new BufferedOutputStream(createOutputStream(file));
            CacheHeader e = new CacheHeader(key, entry);
            boolean success = e.writeHeader(fos);
            if (!success) {
                fos.close();
                VolleyLog.d("Failed to write header for %s", file.getAbsolutePath());
                throw new IOException();
            }
            fos.write(entry.data);
            fos.close();
            putEntry(key, e);
            return;
        } catch (IOException e) {
        }
        boolean deleted = file.delete();
        if (!deleted) {
            VolleyLog.d("Could not clean up file %s", file.getAbsolutePath());
        }
    }

    /**
     * Removes the specified key from the cache if it exists.
     */
    @Override
    public synchronized void remove(String key) {
        boolean deleted = getFileForKey(key).delete();
        removeEntry(key);
        if (!deleted) {
            VolleyLog.d("Could not delete cache entry for key=%s, filename=%s",
                    key, getFilenameForKey(key));
        }
    }

    /**为指定的缓存键创建伪唯一文件名。利用key，创建key相关的文件名
     * Creates a pseudo-unique filename for the specified cache key.
     * @param key The key to generate a file name for.
     * @return A pseudo-unique filename.
     */
    private String getFilenameForKey(String key) {
        int firstHalfLength = key.length() / 2;
        String localFilename = String.valueOf(key.substring(0, firstHalfLength).hashCode());
        localFilename += String.valueOf(key.substring(firstHalfLength).hashCode());
        return localFilename;
    }

    /**
     * 根据给定的缓存键，创建该文件，并返回该键对应的文件对象
     * Returns a file object for the given cache key.
     */
    public File getFileForKey(String key) {
        return new File(mRootDirectory, getFilenameForKey(key));
    }

    /**
     * 修剪缓存以适应指定的字节数
     * Prunes the cache to fit the amount of bytes specified.
     * @param neededSpace The amount of bytes we are trying to fit into the cache.
     */
    private void pruneIfNeeded(int neededSpace) {
        //如果已经用的和需要用的大小，小于最大缓存字节数，则直接返回
        if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes) {
            return;
        }
        if (VolleyLog.DEBUG) {
            VolleyLog.v("Pruning old cache entries.");
        }

        long before = mTotalSize;
        int prunedFiles = 0;
        long startTime = SystemClock.elapsedRealtime();

        Iterator<Map.Entry<String, CacheHeader>> iterator = mEntries.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, CacheHeader> entry = iterator.next();
            CacheHeader e = entry.getValue();
            boolean deleted = getFileForKey(e.key).delete();
            if (deleted) {
                mTotalSize -= e.size;
            } else {
               VolleyLog.d("Could not delete cache entry for key=%s, filename=%s",
                       e.key, getFilenameForKey(e.key));
            }
            iterator.remove();
            prunedFiles++;

            if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes * HYSTERESIS_FACTOR) {
                break;
            }
        }

        if (VolleyLog.DEBUG) {
            VolleyLog.v("pruned %d files, %d bytes, %d ms",
                    prunedFiles, (mTotalSize - before), SystemClock.elapsedRealtime() - startTime);
        }
    }

    /**
     * 利用特定的key去添加缓存条目
     * Puts the entry with the specified key into the cache.
     * @param key The key to identify the entry by.
     * @param entry The entry to cache.
     */
    private void putEntry(String key, CacheHeader entry) {
        //存入条目之前需要需要更改缓存容量的大小
        if (!mEntries.containsKey(key)) {
            mTotalSize += entry.size;
        } else {
            CacheHeader oldEntry = mEntries.get(key);
            mTotalSize += (entry.size - oldEntry.size);
        }
        mEntries.put(key, entry); //存入缓存条目
    }

    /**
     * 删除缓存并且更改缓存大小
     * Removes the entry identified by 'key' from the cache.
     */
    private void removeEntry(String key) {
        CacheHeader removed = mEntries.remove(key);
        if (removed != null) {
            mTotalSize -= removed.size;
        }
    }

 

  实现类里面还有一个静态内部类CacheHeader，作用是将缓存一个条目。其中pruneIfNeeded（）方法是在 put 方法的第一行执行的，做的就是这件事，Volley 并没有使用 LRU。而是使用的 FIFO。DiskBasedCache 剩下的就是一些文件操作了，就不挨着看了。

 

  这里顺便提一下内部接口，具体例子在Response.java这个类中，存在着两个接口：

 

 /** Callback interface for delivering parsed responses.  传递相应信息时，回调此接口*/
    public interface Listener<T> {
        /** Called when a response is received. */
        void onResponse(T response);
    }

    /** Callback interface for delivering error responses.    传递错误响应信息时，回调此接口*/
    public interface ErrorListener {
        /**
         * Callback method that an error has been occurred with the
         * provided error code and optional user-readable message.
         */
        void onErrorResponse(VolleyError error);
    }

 

  看下内部接口的使用场景：

 

package com.dao.util;  
  
public class Util {  
    public interface Worker {  
        void work();  
    }  
}  
    
package com.dao.util;  
  
import com.dao.util.Util.Worker;  
  
public class Demo implements Worker {  
    public void work() {  
        System.out.println("Is working");  
    }  
}

 

  在这个util类里面封装了会改变的Worker，也就是说，util类里面有自己的算法：一部分是固定，另外一部分是可变的，而这个可变的部分就变成了一个接口，接口是特殊的抽象类~其实的意思大概的这个worker可能在不同的工作环境有不同的工作方式，所以在类里面放一个接口不是什么新的设计，而是一种思想方式，让代码扩展性更高。

 

2. 创建一个 StringRequest 请求

  这个是我们发起的请求，我们可以注意上边的方法有四个参数的方法，(int method, String url, Listener listener,ErrorListener errorListener) ，我们可以主要关注一个后边的两个回调，一个是成功的回调，一个是失败的回调，而且我们可以看一下他的源码。如下为利用构造函数创建的一个StringRequest请求代码：

 

StringRequest stringRequest = new StringRequest("http://www.baidu.com",
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {

                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

            }
        });

 

 

 

先看下StringRequest继承了Request类，需要实现其中的两个抽象方法；在构造函数中需要两个回调函数。他们之间的关系如下：

 

 

StringRequest类：

 

 

/**
 * 一个用于在给定URL中以String形式检索响应正文的请求。
 * 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            用于获取字符串的URL
     * @param listener Listener to receive the String response  侦听器接收String响应
     * @param errorListener Error listener, or null to ignore errors        错误侦听器，或null忽略错误
     */
    public StringRequest(int method, String url, Listener<String> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    /**
     * 使用指定的GET方式创建新的请求消息
     * 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);
    }

    /**
     * 将解析到的响应传送给他们的监听器，给定的响应response保证为非空值;
     * 无法解析的响应不会传递。
     * @param response The parsed response returned by
     */
    @Override
    protected void deliverResponse(String response) {
        if (mListener != null) {
            mListener.onResponse(response);
        }
    }
    /**
     * 工作线程将会调用这个方法
     * 方法的目的是：按照HTTP头消息中的编码字符集，去重新构建这个消息的返回信息
     *
     * new String(byte[],"UTF-8")是新建了一个UTF-8编码的字符串
     *
     * @param response Response from the network
     * @return  返回成功响应的消息
     */
    @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));
    }
}

 

 

 

Response类的内部接口：

 

 

public class Response<T> {

    /** Callback interface for delivering parsed responses.  传递相应信息时，回调此接口*/
    public interface Listener<T> {
        /** Called when a response is received. */
        void onResponse(T response);
    }

    /** Callback interface for delivering error responses.    传递错误响应信息时，回调此接口*/
    public interface ErrorListener {
        /**
         * Callback method that an error has been occurred with the
         * provided error code and optional user-readable message.
         */
        void onErrorResponse(VolleyError error);
    }