从零开始撸一个Fresco之硬盘缓存

时间 2019-12-06

原文原文链接

转载请注明出处 Fresco源代码文档翻译项目请看这里：Fresco源代码文档翻译项目 硬盘缓存是android图片框架中比较重要的一个模块，Fresco中本身重写了一个硬盘缓存框架，代替了android自己的DiskLruCache，因此今天咱们就来介绍Fresco中的硬盘缓存，而且将其提取出来成为咱们本身的框架。我已经成功提取出了 Fresco 中的硬盘缓存框架，这是项目地址Frsco硬盘缓存框架项目地址，建议你们在看文章的时候结合项目代码，项目中的每一个class文件中都有注释，看起来仍是比较容易的。android

1、目录介绍

1.binaryResource包：这里面有一个接口和一个类，Fresco遵循面向接口编程这一原则，因此不少地方都会用接口来加强可扩展性。总的来讲BinaryResource这个接口表明一个字节序列，它抽象了底层的资源，好比一个file文件。FileBinaryResource内部就有一个File成员，以方便对File进行操做。
2.cacheEventAndListenner包：在硬盘缓存的过程当中，会有许多的事件发生，好比查找缓存时候命中了、要插入一个缓存、读取缓存失败了等等。此时客户端会须要一个监听器来监听各类硬盘缓存事件的发生。此时CacheEventListener接口就能够当客户端对硬盘缓存的监听器，CacheEventListener中的每一个方法中都传入了一个CacheEvent。CacheEvent是一个接口，其实现类中包裹了许多与硬盘缓存相关的东西，SettableCacheEvent就是CacheEvent的惟一实现类，因为硬盘缓存事件产生的很频繁，因此SettableCacheEvent使用了享元模式(在内存中只维持两个对象，不断的回收重用)。CacheErrorLogger接口是硬盘缓存的读或写产生异常的时候使用到的类。CacheEventListener和CacheErrorLogger都只有一个空实现用来填充代码，具体的实现须要使用者实现。
3.cacheKey包：但咱们插入或者取出一个文件缓存的时候就会用到CacheKey，SimpleCacheKey的内部其实就是一个String，MultiCacheKey的内部只是一系列CacheKey的集合。咱们通常使用的是SimpleCacheKey，由于咱们去网络加载图片的时候Uri就是一个最好的key。
4.comparator包：这里的EntryEvictionComparator实现了Comparator<DiskStorage.Entry>，在后面咱们会知道DiskStorage.Entry表示一条文件缓存。因此这个接口是为了比较每一条文件缓存。EntryEvictionComparatorSupplier使用提供者模式，在get()中返回了一个EntryEvictionComparator，因此只须要实现EntryEvictionComparatorSupplier,在get()中返回EntryEvictionComparator的具体实现，咱们就能够定义一个DiskStorage.Entry的比较器。目前Fresco中自定义了两个比较器DefaultEntryEvictionComparatorSupplier和ScoreBasedEvictionComparatorSupplier，他们分别是基于LRU和权重的比较器。
5.fileTree包：硬盘缓存会使用到文件系统，因此此时对一个目录全部文件的遍历是必不可少的，这里FileTree负责遍历一个目录下的全部文件和提供一个安全的删除文件夹方式，其遍历的时候将每一个文件交与FileTreeVisitor进行处理。这是一个很好的访问文件系统的方式。FileTreeVisitor在DiskStorageCache中有两个具体实现。
6.trimmable包：在硬盘缓存中有一个类会直接负责和硬盘上的文件打交道，因此其会使用了大量硬盘空间，一旦硬盘空间不足的话，可能形成硬盘缓存失败的状况。因此此时咱们能够将该class实现DiskTrimmable接口，而后在DiskTrimmableRegistry的实现类中注册，一旦硬盘空间不够了，使用DiskTrimmableRegistry实现类通知全部实现了DiskTrimmable而且注册过的对象，让该对象删除缓存文件以释放硬盘空间，这里的释放规则是LRU。Fresco中只有一个NoOpDiskTrimmableRegistry空实现，这里须要让使用者本身去实现更符合本身app的通知方式。
7.util包：这个包中放了一些工具类，你们有兴趣能够去看看
8.core包：前面7个包都是辅助的包，Fresco真正的硬盘缓存核心类在这个包中，这里DiskStorage接口的实现类负责和android的文件系统直接打交道，提供缓存的文件的增删改api。FileCache接口的实现类则是负责缓存的逻辑，好比缓存满了的清除逻辑。FileCache接口的实现类直接持有DiskStorage接口的引用以操做文件系统。咱们接下来要看的就是这个包中的类

2、硬盘缓存核心类分析

先上一张图，让你们简单了解各个接口提供的api。 git

1.DefaultDiskStorage

这个class的代码就不贴了，强烈建议读者把我前面的项目下载下来，结合博客一块儿观看。github

这个类是DiskStorage接口的实现类，前面说了这个类是直接与android的文件系统打交道的类。这个类有如下几个功能特色：算法

1.该类构造函数中在传入的缓存根目录(下面称该文件夹为cache)下建立一个当前缓存版本的文件夹，接下来该对象经手的缓存文件都储存在这里文件夹中，咱们在后面称这个文件夹为 version1.0。
2.三星的老手机有一个问题，就是一个文件夹下面不能放置过多的文件，这个问题被称为RFS。所以在每次储存缓存文件的时候会将缓存文件key的hash值对100取模，这个值就是文件夹的名字，若是这个文件夹没建立就建立一个，而后将缓存文件放入其中。在取缓存文件的时候也要经历这个流程。
3.缓存文件在插入的时候，有两个步骤1.将该文件写成.tmp后缀的临时文件，此时该文件对使用者不可见。2.将.tmp后缀的文件更名为.cnt后缀的文件，此时该文件对使用者可见。
4.该对象在两种状况下须要使用到FileTree：
- 1.清理不须要的文件(如tmp文件或不是本版本的文件)，此时会调用purgeUnexpectedResources()使用FileTree.walkFileTree()遍历cache文件夹，而后使用FileTreeVisitor的实现类PurgingVisitor对每一个文件进行判断，看看是否须要清除该文件
- 2.获取Entry：由上面的图中咱们能够看见Entry是DiskStorage的一个内部接口，DefaultDiskStorage中用EntryImpl实现了它，而每个Entry就表明着一个文件缓存。因此要获取全部的缓存信息就应该遍历 version1.0。而这里使用的FileTree.walkFileTree()和EntriesCollector。
5.硬盘缓存的清理算法通常使用的都是LRU，因此在每次调用getResource()获取文件缓存的时候，都会将该文件的LastModified设置成目前的时间以便在后面进行缓存的清理。
6.咱们从前面的图中看见DiskStorage接口insert()方法返回了一个Inserter，这个Inserter在本class中被实现了。使用这种方式是为了进行并发地写入多条缓存条目。在Insert.commit()调用以前，这个缓存条目对客户端是不可见的。
7.除上面的功能，本class还提供了经过Key和Entry删除缓存、清理全部缓存、经过Key查询文件缓存这些功能。

2.DiskStorageCache

一样不贴代码，再次建议你们下载项目代码观看博客。编程

这个类是FileCache的实现类，其经过DefaultDiskStorage与android文件系统打交道，而且处理文件缓存的各类逻辑。来讲说它的功能特色：设计模式

1.这个对象是CacheEventListener监听的对象，用户能够传入一个本身的Listenner来监听硬盘缓存的各类活动，好比插入缓存、删除缓存、缓存失败等等事件。
2.在该类中有一个CacheStats内部类(用于储存该对象已经使用的硬盘空间，以及缓存条目数量)和一个HashSet(mResourceIndex用于储存全部缓存条目的Id)，因为在Fresco中硬盘缓存使用是很频繁的，因此若是实时刷新这两个东西是不值得的，所以该类中设置了一个时间(FILECACHE_SIZE_UPDATE_PERIOD_MS),每隔这么多时间上面两个对象的状态就会被刷新。
3.该对象能够在getResource(CacheKey)方法中经过DefaultDiskStorage#getResource()来获取传入key所对应的缓存文件，每次调用这个方法都会刷新该缓存文件的时间戳，为以后的LRU删除缓存作准备
4.该对象能够在probe(CacheKey)方法中经过DefaultDiskStorage#touch()查询传入Key的缓存文件是否存在，若是存在，一样会改变该缓存文件的时间戳。
5.使用者能够调用该对象的insert(CacheKey，WriterCallback)方法插入一个缓存文件，这里须要在使用者覆盖WriterCallback的write(OutputStream)方法，经过OutputStream将须要储存的数据写入缓存文件。instert(CacheKey，WriterCallback)方法中会建立一个缓存文件的OutputStream，而后将其传入WriterCallback#get()中以供使用者使用。
6.在remove(CacheKey)会经过DefaultDiskStorage#remove()方法，删除传入key对应的缓存文件，同时会删除mResourceIndex中该缓存文件的id。
7.clearOldEntries(long cacheExpirationMs)会经过DefaultDiskStorage#getEntries()和DefaultDiskStorage#remove()这两个方法删除比传入时间cacheExpirationMs老的缓存文件。
8.maybeEvictFilesInCacheDir()会在插入一个缓存文件以前，判断本对象使用的硬盘空间是否已经超过初始化时设置的限制，若是超过限制就会调用evictAboveSize()(先在getSortedEntries()方法中经过DefaultEntryEvictionComparatorSupplier将全部Entry排序，而后按时间顺序一个个删除缓存文件，直至达到缓存空间要求)。
9.hasKeySync(CacheKey)在mResourceIndex中判断该文件缓存是否存在，因为该对象不是实时刷新，因此会出现滞后性即有些文件缓存已经存在，可是mResourceIndex中并无其id。
10.hasKey(CacheKey)该方法是hasKeySync()的升级版，其不只会经过hasKeySync()在mResourceIndex查找，若是没找到还会经过DefaultDiskStorage#contains()方法查找，这样也提升了查找效率。
11.因为该class实现了DiskTrimmable接口，因此其在硬盘空间吃紧的时候也会调用evictAboveSize()进行缓存文件的清理，不过Fresco中DiskTrimmableRegistry的默认实现是NoOpDiskTrimmableRegistry，这个实现中不会作任何事情。因此具体的监听须要使用者来作。

3、Fresco硬盘缓存框架的使用

Fresco在使用硬盘缓存框架的时候，与其余模块通讯的时候使用了两个类DiskCacheConfig和DiskStorageCache。DiskCacheConfig很好理解，负责用Builder模式建立一个DiskStorageCache。因此这里归更到底就是使用DiskStorageCache暴露出来的增删改查等api，而硬盘缓存框架中的其余类与Fresco的其余模块是解耦的，这也是软件工程中的一个重要的思想。因此接下来咱们就来使用一下DiskStorageCache，也算是对这篇博客的总结。api

这里代码很少因此贴下代码：缓存

public class MainActivity extends AppCompatActivity {
FileCache mFileCache;
Button buttonInsert;
Button buttonHasKey;
Button buttonRemove;
Button buttonClearAll;
Button buttonGetCache;
ImageView imageView;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    initDiskCache();
    initView();

    final int[] times = {0};
    buttonInsert.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            SimpleCacheKey simpleCacheKey=new SimpleCacheKey(String.valueOf(times[0]));
            times[0]++;
            insert(simpleCacheKey);
        }
    });

    buttonHasKey.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Toast.makeText(MainActivity.this, "key 5 是否存在？" + mFileCache.hasKey(new SimpleCacheKey("5")), Toast.LENGTH_SHORT).show();
        }
    });

    buttonRemove.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            times[0]--;
            SimpleCacheKey simpleCacheKey=new SimpleCacheKey(String.valueOf(times[0]));
            mFileCache.remove(simpleCacheKey);
        }
    });

    buttonClearAll.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            mFileCache.clearAll();
            times[0]=0;
        }
    });

    buttonGetCache.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            getCache();
        }
    });
}

private void initDiskCache(){

    DiskCacheConfig diskCacheConfig=DiskCacheConfig.newBuilder(this).build();
    Toast.makeText(this, "缓存文件夹："+diskCacheConfig.getBaseDirectoryPathSupplier().get().getPath(), Toast.LENGTH_SHORT).show();
    DefaultDiskStorage defaultDiskStorage=new DefaultDiskStorage(
            diskCacheConfig.getBaseDirectoryPathSupplier().get(),
            diskCacheConfig.getVersion(),
            diskCacheConfig.getCacheErrorLogger());

    DiskStorageCache.Params params = new DiskStorageCache.Params(
            diskCacheConfig.getMinimumSizeLimit(),
            diskCacheConfig.getLowDiskSpaceSizeLimit(),
            diskCacheConfig.getDefaultSizeLimit());


    CacheEventListener cacheEventListener=new CacheEventListener() {
        @Override
        public void onHit(CacheEvent cacheEvent) throws IOException {
            Log.d("MainActivity Cache hit", cacheEvent.getCacheKey().getUriString());
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }

        @Override
        public void onMiss(CacheEvent cacheEvent) throws IOException {
            Log.d("MainActivity Cache miss", cacheEvent.getCacheKey().getUriString());
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }

        @Override
        public void onWriteAttempt(CacheEvent cacheEvent) throws IOException {
            Log.d("MainActivity Cache write start", cacheEvent.getCacheKey().getUriString());
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }

        @Override
        public void onWriteSuccess(CacheEvent cacheEvent) throws IOException {
            Log.d("MainActivity Cache write success", cacheEvent.getCacheKey().getUriString());
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }

        @Override
        public void onReadException(CacheEvent cacheEvent) {
            Log.d("MainActivity Cache ReadException", cacheEvent.getCacheKey().getUriString());
        }

        @Override
        public void onWriteException(CacheEvent cacheEvent) {
            Log.d("MainActivity Cache WriteException", cacheEvent.getCacheKey().getUriString());
        }

        @Override
        public void onEviction(CacheEvent cacheEvent) throws IOException {
            Log.d("MainActivity Cache Eviction", cacheEvent.getCacheKey().getUriString());
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }

        @Override
        public void onCleared() throws IOException {
            Log.d("MainActivity", "Cleared");
            Log.d("MainActivity", "mFileCache.getDumpInfo():" + mFileCache.getDumpInfo());
        }
    };

    mFileCache=new DiskStorageCache(
            defaultDiskStorage,
            diskCacheConfig.getEntryEvictionComparatorSupplier(),
            params,
            cacheEventListener,
            diskCacheConfig.getCacheErrorLogger(),
            diskCacheConfig.getDiskTrimmableRegistry(),
            diskCacheConfig.getContext(),
            Executors.newSingleThreadExecutor(),
            diskCacheConfig.getIndexPopulateAtStartupEnabled());

}

private void initView(){
    buttonInsert=(Button)findViewById(R.id.insert);
    buttonHasKey=(Button)findViewById(R.id.hasKey);
    buttonRemove=(Button)findViewById(R.id.remove);
    buttonClearAll=(Button)findViewById(R.id.clearAll);
    buttonGetCache=(Button)findViewById(R.id.getCache);
    imageView=(ImageView)findViewById(R.id.image);
}

private void insert(SimpleCacheKey simpleCacheKey){
    try {
        mFileCache.insert(simpleCacheKey, new WriterCallback() {
            @Override
            public void write(OutputStream os) throws IOException {
                FileUtils.bitmapToFile(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher),os);
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private void getCache(){
    BinaryResource diskCacheResource = mFileCache.getResource(new SimpleCacheKey("2"));
    if (diskCacheResource==null) Toast.makeText(this, "miss 2", Toast.LENGTH_SHORT).show();
    else {
        Toast.makeText(this, "hit 2", Toast.LENGTH_SHORT).show();
        try {
            imageView.setImageBitmap(BitmapFactory.decodeStream(diskCacheResource.openStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
}
复制代码

1.首先是使用DiskCacheConfig初始化DiskStorageCache：
- 1.因为DiskCacheConfig采用的是Bulider模式，因此Builder中内置了许多默认属性。若是咱们没有特殊要求能够直接获取一个DiskCacheConfig对象。
- 2.经过DiskCacheConfig中的默认属性建立DefaultDiskStorage和DiskStorageCache.Params以供后面使用。
- 3.咱们能够选择建立一个CacheEventListener以在客户端监听硬盘缓存的行为。固然也能够选择不监听。
- 4.最后使用上面的属性建立一个FileCache，由于解耦设计，咱们只须要获取一个FileCache而不是DiskStorageCache。这里要注意一下，这个硬盘缓存框架没有内置线程池，而通常来讲对于硬盘的读写都是在其余线程中的，Fresco中就是建立了一个读线程池和一个写线程池将DiskStorageCache的读写操做放在其中操做。我这里为了方便就直接在UI线程进行操做了。你们在使用的时候须要根据本身的需求建立线程池。此外咱们注意到在FileCache的建立过程当中传入了一个Executors.newSingleThreadExecutor()，注意这不是用于读写操做的，你们进入DiskStorageCache的构造器中能够看见，这个线程池根本没有被保存为成员变量，只是用于作了一些初始化的操做。
2.初始化了5个Button和一个ImageView
3.第一个按钮是插入硬盘缓存的按钮：能够看见我使用了SimpleCacheKey以从0递增的String做为缓存的id。而后在insert()方法中调用了FileCache#insert(),其中经过WriterCallback#get()提供的OutputStream将R.mipmap.ic_launcher写入了硬盘缓存中。
4.第二个按钮是判断是否有给定的缓存：我调用FileCache#hasKey()判断id为5的缓存是否存在。
5.第三个按钮是经过id删除硬盘缓存：调用的是FileCache.remove()方法
6.第四个按钮是清空缓存：经过FileCache.clearAll()实现；
7.第五个按钮显示id为2的缓存图片：在getCache()中经过FileCache.getResource()获取了一个BinaryResource，这个类其实是FileBinaryResource，能够直接获取其InputStream来显示图片。

以上就是Fresco硬盘缓存框架的使用。安全

4、总结

Fresco的硬盘缓存框架，仍是挺有趣的，其中用到了许多软件工程的思想与Java设计模式。Fresco中还有许多模块很是有趣，作个预告下一篇博客将会分析Fresco的内存缓存框架有兴趣的同窗必定别错过了。网络