ASimpleCache（ACache）源码分析（android轻量级开源缓存框架）

转载请注明出处：http://blog.csdn.net/zhoubin1992/article/details/46379055

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 [email protected]
 * @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");
    }

}

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

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

    mCache = ACache.get(this);

  2. 在save按钮的点击事件里，通过put方法往缓存实例里保存字符串

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

  3. 在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从等待队列中选择一个另一个线程进入。

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

  1. 新建了缓存目录
  2. 通过ACache构造方法构造新实例，并且将该实例引用插入mInstanceMap
  3. 实例化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)新建一个文件：

        //新建文件
        private File newFile(String key) {
            return new File(cacheDir, key.hashCode() + "");     //新建文件，文件名为key的整型哈希码
        }

新建的文件名为key的整型哈希码。回到put(String key, String value)中，然后通过out.write(value);将数据存入文件。最后调用mCache.put(file);进行ACacheManager实例的更新操作：

    //更新cacheCount和cacheSize  lastUsageDates插入新建文件和时间的键值对
    //文件放入程序缓存后，统计缓存总量，总数，文件存放到文件map中（value值为文件最后修改时间，便于根据设置的销毁时间进行销毁）
    //缓存没有超过限制，则增加缓存总量，总数的数值
    //缓存超过限制，则减少缓存总量，总数的数值
    //通过removeNext方法找到最老文件的大小
        private void put(File file) {
            int curCacheCount = cacheCount.get();   //获取数量
            while (curCacheCount + 1 > countLimit) {    //大于上限
                long freedSize = removeNext();          //移除旧的文件,返回文件大小
                cacheSize.addAndGet(-freedSize);        //更新cacheSize

                curCacheCount = cacheCount.addAndGet(-1);//更新cacheCount
            }
            cacheCount.addAndGet(1);//更新cacheCount

            long valueSize = calculateSize(file);       //计算文件大小
            long curCacheSize = cacheSize.get();        //获取当前缓存大小
            while (curCacheSize + valueSize > sizeLimit) {  //大于上限
                long freedSize = removeNext();              //移除旧的文件,返回文件大小
                curCacheSize = cacheSize.addAndGet(-freedSize);     //更新curCacheSize
            }
            cacheSize.addAndGet(valueSize);                         //更新cacheSize

            Long currentTime = System.currentTimeMillis();
            file.setLastModified(currentTime);          //设置文件最后修改时间
            lastUsageDates.put(file, currentTime);      //插入map
        }

分析完ACacheManager的put()后，我们回到put(key, Utils.newStringWithDateInfo(saveTime, value))

其中第二个参数value传入的是Utils.newStringWithDateInfo(saveTime, value)，而newStringWithDateInfo是ACache的内部工具类的一个方法：

        //返回时间信息+value
        private static String newStringWithDateInfo(int second, String strInfo) {
            return createDateInfo(second) + strInfo;
        }

返回拼接createDateInfo(second)和value的字符串。createDateInfo（）如下：

        //时间信息
        private static String createDateInfo(int second) {
            String currentTime = System.currentTimeMillis() + "";
            while (currentTime.length() < 13) {     //小于13，前面补0
                currentTime = "0" + currentTime;
            }
            return currentTime + "-" + second + mSeparator; //当前时间-保存时间
        }

返回字符串格式为 当前时间-保存时间“ ”

3、从缓存实例读取数据

由上面的demo的get方法mCache.getAsString(“testString”);我们找到原形：

    /**
     * 读取 String数据
     *
     * @param key
     * @return String 数据
     */
    public String getAsString(String key) {
        File file = mCache.get(key);    //获取文件
        if (!file.exists())
            return null;
        boolean removeFile = false;
        BufferedReader in = null;
        try {
            in = new BufferedReader(new FileReader(file));
            String readString = "";
            String currentLine;
            while ((currentLine = in.readLine()) != null) { //逐行遍历
                readString += currentLine;  //每行字符串连接
            }
            if (!Utils.isDue(readString)) { //String数据未到期
                    return Utils.clearDateInfo(readString);//去除时间信息的字符串内容
            } else {
                removeFile = true;      //移除文件标志位为真
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (removeFile)
                remove(key);    //移除缓存
        }
    }

getAsString(String key)方法里首先通过缓存管理器的mCache.get(key)方法获取文件，然后用Utils.isDue(readString)判断是否字符串数据到期，未到期返回去除时间信息的字符串内容；到期则移除缓存，返回空。Utils.isDue(readString)调用了isDue(byte[] data)判断：

        /**
         * 判断缓存的byte数据是否到期
         *
         * @param data
         * @return true：到期了 false：还没有到期
         */
        private static boolean isDue(byte[] data) {
            String[] strs = getDateInfoFromDate(data);
            if (strs != null && strs.length == 2) {
                String saveTimeStr = strs[0];
                while (saveTimeStr.startsWith("0")) {
                    saveTimeStr = saveTimeStr.substring(1, saveTimeStr.length());
                }
                long saveTime = Long.valueOf(saveTimeStr);
                long deleteAfter = Long.valueOf(strs[1]);
                if (System.currentTimeMillis() > saveTime + deleteAfter * 1000) {
                    return true;
                }
            }
            return false;
        }

至此整个缓存字符串在ACache的源码分析完成，其他方法分析过程一样。

时间： 2024-10-17 01:16:25

ASimpleCache（ACache）源码分析（android轻量级开源缓存框架）的相关文章

源码分析Android AsyncTask

Android UI操作是线程不安全的,若想在子线程红进行UI操作,需要借助Android提供的Handler.Android提供的AsyncTask其实是对Handler的封装,方便我们在子线程中更新UI元素.AsyncTask是一个泛型类,书写格式为: AsyncTask<Params, Progress, Result>.这三个参数的用途如下: 1. Params 这三个参数的用途如下: 1. Params 在执行AsyncTask时需要传入的参数,可用于在后台任务中使用. 2. Pro

android源码分析 android toast使用详解 toast自定义

在安卓开发过程中,toast使我们经常使用的一个类,当我们需要向用户传达一些信息,但是不需要和用户交互时,该方式就是一种十分恰当的途径. 我们习惯了这样使用toast:Toast.makeText(Context context, String info, int duration).show();该方法是 系统为我们提供的一个方便的创建toast对象的静态方法,其内部依然是调用toast的相关方法完成.下面 就从其源码对该类的实现做一个分析 在toast类中,最重要的用于显示该toast的sh

Mybatis源码分析之Cache二级缓存原理 （五）

一:Cache类的介绍 讲解缓存之前我们需要先了解一下Cache接口以及实现MyBatis定义了一个org.apache.ibatis.cache.Cache接口作为其Cache提供者的SPI(ServiceProvider Interface) ,所有的MyBatis内部的Cache缓存,都应该实现这一接口 Cache的实现类中,Cache有不同的功能,每个功能独立,互不影响,则对于不同的Cache功能,这里使用了装饰者模式实现. 看下cache的实现类,如下图: 1.FIFOCache:先进

mybatis源码分析之05一级缓存

首先需要明白,mybatis的一级缓存就是指SqlSession缓存,Map缓步! 通过前面的源码分析知道mybatis框架默认使用的是DefaultSqlSession,它是由DefaultSqlSessionFactory创建的,下面是源码 private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Tran

mybatis缓存源码分析之浅谈缓存设计

一般我们用到缓存的时候,只知道他很快,很强,还能持久,但是为什么他可以做到这些呢,有人会说这是天赋,遗传的,是的,你想的没错,确实是大佬们在构造这些的时候,赋予他这些能力,那今天我们就来剖析一下,大佬们干了啥,区区缓存就能这么厉害. 去大厂面试的时候,面试官总会喜欢问为什么,一开始,完全搞不懂我就去拧个螺丝,你问我造火箭怎么造我咋知道,后来在工作中遇到各种各样的问题,解决不了的时候,看着身边大佬们一层层点进去看源码分析问题的时候,瞬间觉得这多牛逼啊,或许一开始有动力看源码,了解为什么就是因为这个

Spring源码分析（十三）缓存中获取单例bean

摘要:本文结合<Spring源码深度解析>来分析Spring 5.0.6版本的源代码.若有描述错误之处,欢迎指正. 介绍过FactoryBean的用法后,我们就可以了解bean加载的过程了.前面已经提到过,单 例在Spring的同一个容器内只会被创建一次,后续再获取bean直接从单例缓存中获取,当然这里也只是尝试加载,首先尝试从缓存中加载,然后再尝试从singletonFactories中加载. 因为在创建单例bean的时候会存在依赖注人的情况,而在创建依赖的时候为了避免循环依赖, Sprin

JDK源码分析之集合01总体框架

集合类是java提供的工具类,主要包括List.Set.Map和vector等类型.所有的集合相关类都位于java.util.*内. 集合类的总体框架图如下图所示: 对总体框架的说明: 集合框架中最顶层的接口有Iterator.Collection和Map三个.其中Itireator是所有迭代器需要实现的接口,Collection是所有的线性结构集合所要实现的接口,Map是所有的非线性集合所要实现的接口,元素以Key.value的形式保存. Collection下层中包含了Queue.List和

CI源码分析(四)—DB查询缓存

(一) 使用 创建缓存文件目录, 保证目录可写 在config/database.php中配置缓存路径 : db['default′]['cachedir′]='path/to/cache/dir′启用||关闭缓存:可以使用代码控制,只对部分代码生效–this->db->cache_on(), this?>db?>cacheoff();也可以通过配置文件配置,对所有代码生效-db['default']['cache_on'] = true; 建议在配置文件中关闭,然后在使用的地方自

ACache【轻量级的开源缓存框架】

版权声明:本文为博主原创文章,未经博主允许不得转载. 前言 官方介绍 ASimpleCache 是一个为android制定的 轻量级的 开源缓存框架.轻量到只有一个java文件(由十几个类精简而来). 1.它可以缓存什么东西? 普通的字符串.JsonObject.JsonArray.Bitmap.Drawable.序列化的java对象,和 byte数据. 2.它有什么特色? 特色主要是: 1:轻,轻到只有一个JAVA文件. 2:可配置,可以配置缓存路径,缓存大小,缓存数量等. 3:可以设置缓存超