【Android開源項目分析】android輕量級開源緩存框架——ASimpleCache（ACache）源碼分析

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");
    }

}

可以看到緩存字符串的讀取方法很簡單！！！

在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)新建一個文件：

        //新建文件
        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內容前面加上了時間信息：

        //返回時間信息+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的源碼分析完成，其他緩存數據類型讀取方法分析過程一樣。
JsonObject、JsonArray、Bitmap、Drawable、序列化的存入緩存都是轉化爲字符串/byte格式，再調用函數put(String key, String value)即可。
比如BitMap的保存：

/**

* 保存 bitmap 到緩存中，有保存時間 *

* @param key * 保存的key *

@param value * 保存的 bitmap 數據 *

@param saveTime * 保存的時間，單位：秒

     */
    public void put(String key, Bitmap value, int saveTime) {
        put(key, Utils.Bitmap2Bytes(value), saveTime);
    }

Bitmap的讀取：

/** * 讀取 bitmap 數據 * * @param key * @return bitmap 數據 */
    public Bitmap getAsBitmap(String key) {
        if (getAsBinary(key) == null) {
            return null;
        }
        return Utils.Bytes2Bimap(getAsBinary(key));
    }

思想就是把bitmap轉化爲byte[]，再調用緩存byte的函數。通過Utils.Bitmap2Bytes(value)完成Bitmap → byte[] 的轉換。通過Utils.Bytes2Bimap(getAsBinary(key))完成byte[] → Bitmap的轉換。

       /* * Bitmap → byte[] */
        private static byte[] Bitmap2Bytes(Bitmap bm) {
            if (bm == null) {
                return null;
            }
                ByteArrayOutputStream baos = new ByteArrayOutputStream();//byte[]輸出流
            bm.compress(Bitmap.CompressFormat.PNG, 100, baos);//按指定的圖片格式以及畫質，將圖片轉換爲輸出流。壓縮圖片,不壓縮是100，表示壓縮率爲0
            return baos.toByteArray();
        }

        /* * byte[] → Bitmap */
        private static Bitmap Bytes2Bimap(byte[] b) {
            if (b.length == 0) {
                return null;
            }
                return BitmapFactory.decodeByteArray(b, 0, b.length);//解析
        }

很簡單吧。Drawable的緩存就是先轉化爲Bitmap，之後就是上面的步驟轉換成byte。

總結

該開源庫類簡單，容易理解。

可以使用ACache把那些不需要實時更新的數據緩存起來，一來減少網絡請求,二來本地加載速度也快。
可以設置緩存時間。
可以替換SharePreference當做配置文件，保存多種數據類型，比如可以保存頭像信息。

轉自：http://blog.csdn.net/zhoubin1992/article/details/46379055

【Android開源項目分析】android輕量級開源緩存框架——ASimpleCache（ACache）源碼分析

ASimpleCache框架源碼鏈接

官方介紹

1、它可以緩存什麼東西？

2、它有什麼特色？

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

4、如何使用 ASimpleCache？

源碼分析

一、ACache類結構圖

二、官方demo分析

三、ACache源碼分析

1、獲取緩存實例

2、往緩存實例存入數據

3、從緩存實例讀取數據

總結

10分鐘搞定Mysql主從部署配置

如何使用 JS 判斷用戶是否處於活躍狀態

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

[轉帖]

python列出centos7內存使用前50的進程信息

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

一鍵自動化博客發佈工具,用過的人都說好(掘金篇)

lightdb數據庫超時相關控制參數

lightdb秒級增加列和刪除列（not null帶默認值）

Java ThreadPoolShutdown

Android中封裝Http請求

【Android開源項目分析】android輕量級開源緩存框架——ASimpleCache（ACache）源碼分析

android R文件Syntax error on token "int", VariableDeclaratorId expected after this token

Android支持自定義的ttf字體Demo

Android發送GET和POST以及HttpClient發送POST請求給服務器響應

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結