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，希望您能喜欢：
|
1
2
3
4
|
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
|
获取数据
|
1
2
|
ACache mCache = ACache.get(
this
);
String value = mCache.getAsString(
"test_key1"
);
|
源码分析
一、ACache类结构图
ASimpleCache里只有一个JAVA文件——ACache.java
首先我用思维导图制作了ACache类的详细结构图：
二、官方demo分析
通过分析官方给的demo来驱动源码分析吧
以字符串存储为例（官方给的demo里给出了很多种数据读取的例子，其实方法相似），打开SaveStringActivity.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
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方式获取。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
//实例化应用程序场景缓存
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构造方法：
|
1
2
3
4
5
6
7
|
//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内部类的构造函数如下：
|
1
2
3
4
5
6
7
8
9
|
//内部类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如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* 计算 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方法
|
1
|
<strong> mCache.put(“testString”, mEt_string_input.getText().toString(),
300
);</strong>
|
我们找到原形：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/**
* 保存 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方法:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
/**
* 保存 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)新建一个文件：
|
1
2
3
4
|
//新建文件
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实例的更新操作：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
//更新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内容前面加上了时间信息：
|
1
2
3
4
|
//返回时间信息+value
private
static
String newStringWithDateInfo(
int
second, String strInfo) {
return
createDateInfo(second) + strInfo;
}
|
返回拼接createDateInfo(second)和value的字符串。createDateInfo（）如下：
|
1
2
3
4
5
6
7
8
|
//时间信息
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”);我们找到原形：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
/**
* 读取 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)判断：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/**
* 判断缓存的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的保存：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/**
* 保存 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的读取：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
/**
* 读取 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的转换。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/*
* 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当做配置文件，保存多种数据类型，比如可以保存头像信息。