移动开发最新android轻量级开源缓存框架——ASimpleCache（ACache）源码分析，腾讯T3面试官透露

本文链接：https://blog.csdn.net/2401_84563438/article/details/138735157

最后

针对于上面的问题，我总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料。
（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。
Android进阶视频+面试资料部分截图

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ASimpleCache框架源码链接

https://github.com/yangfuhai/ASimpleCache

杨神作品，大家最熟悉他的应该是afinal框架吧

官方介绍

ASimpleCache 是一个为android制定的轻量级的开源缓存框架。轻量到只有一个java文件（由十几个类精简而来）。

1、它可以缓存什么东西？

普通的字符串、JsonObject、JsonArray、Bitmap、Drawable、序列化的java对象，和 byte数据。

2、它有什么特色？

特色主要是：

1：轻，轻到只有一个JAVA文件。

2：可配置，可以配置缓存路径，缓存大小，缓存数量等。

3：可以设置缓存超时时间，缓存超时自动失效，并被删除。

4：支持多进程。

3、它在android中可以用在哪些场景？

1、替换SharePreference当做配置文件

2、可以缓存网络请求数据，比如oschina的android客户端可以缓存http请求的新闻内容，缓存时间假设为1个小时，超时后自动失效，让客户端重新请求新的数据，减少客户端流量，同时减少服务器并发量。

3、您来说…

4、如何使用 ASimpleCache？

以下有个小的demo，希望您能喜欢：


ACache mCache = ACache.get(this);

mCache.put("test_key1", "test value");

mCache.put("test_key2", "test value", 10);//保存10秒，如果超过10秒去获取这个key，将为null

mCache.put("test_key3", "test value", 2 * ACache.TIME_DAY);//保存两天，如果超过两天去获取这个key，将为null

获取数据


ACache mCache = ACache.get(this);

String value = mCache.getAsString("test_key1");

源码分析

一、ACache类结构图

ASimpleCache里只有一个JAVA文件——ACache.java

首先我用思维导图制作了ACache类的详细结构图：

二、官方demo分析

通过分析官方给的demo来驱动源码分析吧

以字符串存储为例（官方给的demo里给出了很多种数据读取的例子，其实方法相似），打开SaveStringActivity.java:


package com.yangfuhai.asimplecachedemo;



import org.afinal.simplecache.ACache;



import android.app.Activity;

import android.os.Bundle;

import android.view.View;

import android.widget.EditText;

import android.widget.TextView;

import android.widget.Toast;



/** * * @ClassName: SaveStringActivity * @Description: 缓存string * @Author Yoson Hao * @WebSite www.haoyuexing.cn * @Email haoyuexing@gmail.com * @Date 2013-8-7 下午9:59:43 * */

public class SaveStringActivity extends Activity {



    private EditText mEt_string_input;

    private TextView mTv_string_res;



    private ACache mCache;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_save_string);

        // 初始化控件

        initView();



        mCache = ACache.get(this);

    }



    /** * 初始化控件 */

    private void initView() {

        mEt_string_input = (EditText) findViewById(R.id.et_string_input);

        mTv_string_res = (TextView) findViewById(R.id.tv_string_res);

    }



    /** * 点击save事件 * * @param v */

    public void save(View v) {

        if (mEt_string_input.getText().toString().trim().length() == 0) {

            Toast.makeText(

                    this,

                    "Cuz u input is a nullcharacter ... So , when u press \"read\" , if do not show any result , plz don't be surprise",

                    Toast.LENGTH_SHORT).show();

        }

// mCache.put("testString", mEt_string_input.getText().toString());

        mCache.put("testString", mEt_string_input.getText().toString(),300);

    }



    /** * 点击read事件 * * @param v */

    public void read(View v) {

        String testString = mCache.getAsString("testString");

        if (testString == null) {

            Toast.makeText(this, "String cache is null ...", Toast.LENGTH_SHORT)

                    .show();

            mTv_string_res.setText(null);

            return;

        }

        mTv_string_res.setText(testString);

    }



    /** * 点击clear事件 * * @param v */

    public void clear(View v) {

        mCache.remove("testString");

    }



}

可以看到缓存字符串的读取方法很简单！！！

在onCreate里通过get方式获取缓存实例

mCache = ACache.get(this);
在save按钮的点击事件里，通过put方法往缓存实例里保存字符串

mCache.put(“testString”, mEt_string_input.getText().toString(),300);
在read按钮的点击事件里，通过getAsString方法从缓存实例里读取字符串

mCache.getAsString(“testString”)；

其他数据读取，方法相似，也是这三个步骤。300为保存时间300秒。

三、ACache源码分析

1、获取缓存实例

那我们就从ACache.get()开始吧，其实查看上面的思维导图，ACache类的构造方法为private的，所以新建缓存实例只能通过ACache.get方式获取。


    //实例化应用程序场景缓存

    public static ACache get(Context ctx) {

        return get(ctx, "ACache");

    }

    //新建缓存目录

    public static ACache get(Context ctx, String cacheName) {

        //新建文件夹，文件路径为应用场景缓存路径目录，文件夹名为ACache(new File()也可新建文件，带上后缀即可)

        File f = new File(ctx.getCacheDir(), cacheName);    

        return get(f, MAX_SIZE, MAX_COUNT);

    }

    //新建缓存实例，存入实例map，key为缓存目录+每次应用开启的进程id

    public static ACache get(File cacheDir, long max_zise, int max_count) {

        //返回key为缓存目录+每次应用开启的进程id的map的value值，赋给缓存实例manager

        ACache manager = mInstanceMap.get(cacheDir.getAbsoluteFile() + myPid());

        if (manager == null) { //缓存实例为空时，

            manager = new ACache(cacheDir, max_zise, max_count);

            mInstanceMap.put(cacheDir.getAbsolutePath() + myPid(), manager);//插入map

        }

        return manager;

    }

在调用ACache.get(Context)方法过程中，其实执行了三个get方法

(1)get(Context ctx)->(2)get(Context ctx, String cacheName)->(3)get(File cacheDir, long max_zise, int max_count)

在（2）中新建了缓存目录，路径为：

/data/data/app-package-name/cache/ACache

缓存大小MAX_SIZE和数量MAX_COUNT均由final变量控制。

其实最终调用（3）获取实例：

mInstanceMap的key为缓存目录+每次应用开启的进程id，value为ACache.

初次运行，mInstanceMap没有任何键值对，所以manager == null。故通过ACache构造方法构造新实例，最后将该实例引用存入mInstanceMap。

接下来我们来看看ACache构造方法：


    //ACache构造函数 为private私有（所以在其他类里获得实例只能通过get()方法）

    private ACache(File cacheDir, long max_size, int max_count) {

        if (!cacheDir.exists() && !cacheDir.mkdirs()) {     //缓存目录不存在并且无法创建时，抛出异常

            throw new RuntimeException("can't make dirs in " + cacheDir.getAbsolutePath());

        }

        mCache = new ACacheManager(cacheDir, max_size, max_count);//实例化ACacheManager内部类实例

    }

缓存目录不存在并且无法创建时，抛出异常，否则实例化ACacheManager内部类实例（缓存管理器）。ACacheManager内部类的构造函数如下：


        //内部类ACacheManager的构造函数

        private ACacheManager(File cacheDir, long sizeLimit, int countLimit) {

            this.cacheDir = cacheDir;

            this.sizeLimit = sizeLimit;

            this.countLimit = countLimit;

            cacheSize = new AtomicLong();       //原子类实例cacheSize，不用加锁保证线程安全

            cacheCount = new AtomicInteger();   //原子类实例cacheCount，不用加锁保证线程安全

            calculateCacheSizeAndCacheCount();

        }

构造函数得到原子类实例cacheSize和cacheCount，通过calculateCacheSizeAndCacheCount();方法计算cacheSize和cacheCount如下：


        /** * 计算 cacheSize和cacheCount */

        private void calculateCacheSizeAndCacheCount() {

            new Thread(new Runnable() {

                @Override

                public void run() {

                    //int size = 0;

                    long size = 0;  //这里long类型才对——by牧之丶

                    int count = 0;

                    File[] cachedFiles = cacheDir.listFiles();  //返回缓存目录cacheDir下的文件数组

                    if (cachedFiles != null) {

                        for (File cachedFile : cachedFiles) {   //对文件数组遍历

                            size += calculateSize(cachedFile);  

                            count += 1;

                            lastUsageDates.put(cachedFile, cachedFile.lastModified());  //将缓存文件和最后修改时间插入map

                        }

                        cacheSize.set(size);        //设置为给定值

                        cacheCount.set(count);      //设置为给定值

                    }

                }

            }).start();

        }

calculateCacheSizeAndCacheCount方法中开启线程进行大小和数量的计算。计算完后存入cacheSize和cacheCount，cacheSize和cacheCount在内部类中定义为AtomicLong和AtomicInteger量子类，也就是线程安全的。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入。

到这里获取缓存实例工作完成，主要完成了如下工作：

新建了缓存目录
通过ACache构造方法构造新实例，并且将该实例引用插入mInstanceMap
实例化ACacheManager，计算cacheSize和cacheCount

接下来就是数据存取操作。

2、往缓存实例存入数据

从上面的思维导图public method（各种数据的读写方法）中，有各种public的put和get等方法来缓存各种数据类型的数据。由上面的demo的put方法

mCache.put(“testString”, mEt_string_input.getText().toString(),300);我们找到原形：


    /** * 保存 String数据 到 缓存中 * * @param key * 保存的key * @param value * 保存的String数据 * @param saveTime * 保存的时间，单位：秒 */

    public void put(String key, String value, int saveTime) {

        put(key, Utils.newStringWithDateInfo(saveTime, value));

    }

这里的put方法可以指定缓存时间。调用他自身的另一个put方法:


/** * 保存 String数据 到 缓存中 * * @param key * 保存的key * @param value * 保存的String数据 */

    public void put(String key, String value) {

        File file = mCache.newFile(key);    //新建文件

        BufferedWriter out = null;          //缓冲字符输出流,作用是为其他字符输出流添加一些缓冲功能

        try {

            out = new BufferedWriter(new FileWriter(file), 1024);   //获取file字符流

            out.write(value);       // 把value写入

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            if (out != null) {

                try {

                    out.flush();        

                    out.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            mCache.put(file);   //更新cacheCount和cacheSize lastUsageDates插入新建文件和时间的键值对

        }

    }

在put(String key, String value)方法中首先调用mCache.newFile(key)新建一个文件：

尾声

评论里面有些同学有疑问关于如何学习material design控件，我的建议是去GitHub搜，有很多同行给的例子，这些栗子足够入门。

有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，无非就是一些代码格式以及原生/JAVA内存交互，进阶一点的有原生/JAVA线程交互，线程交互确实有点蛋疼，但平常避免用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

一句话，平常多写多练，这是最基本的程序员的素质，尽量挤时间，读理论基础书籍，JVM不是未来30年唯一的虚拟机，JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。
初学者，一句话，多练。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。**
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取