Android缓存机制&缓存框架——ACache

缓存机制出现的意义：

Android开发本质上就是手机和互联网中的web服务器之间进行通信，就必然需要从服务端获取数据，而反复通过网络获取数据是比较耗时的，特别是访问比较多的时候，会极大影响了性能，Android中可通过二级缓存来减少频繁的网络操作，减少流量、提升性能。

二级缓存：

当Android端需要获得数据时比如获取网络中的图片，我们首先从内存中查找（按键查找），内存中没有的再从磁盘文件或sqlite中去查找，若磁盘中也没有才通过网络获取；当获得来自网络的数据，就以key-value对的方式先缓存到内存（一级缓存），同时缓存到文件或sqlite中（二级缓存）。注意：内存缓存会造成堆内存泄露，所有一级缓存通常要严格控制缓存的大小，一般控制在系统内存的1/4。

---

缓存框架—— ACache

ACache介绍：

ACache类似于SharedPreferences，但是比SharedPreferences功能更加强大，SharedPreferences只能保存一些基本数据类型、Serializable、Bundle等数据；
而Acache可以缓存如下数据：

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

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

特色：

• 轻，轻到只有一个JAVA文件。
• 可配置，可以配置缓存路径，缓存大小，缓存数量等。
• 可以设置缓存超时时间，缓存超时自动失效，并被删除。
• 多进程的支持。

应用场景：

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

下载链接：https://github.com/yangfuhai/ASimpleCache
框架分析：http://blog.csdn.net/zhoubin1992/article/details/46379055

使用：

初始化ACache组件：

ACacheacache = ACache.get(context)
　　　　　　或
ACacheacache=ACache.get(context,max_size,max_count)　　
//max_size:设置限制缓存大小，默认为50M
//max_count:设置缓存数据的数量，默认不限制 

设置缓存数据：
　　

//将数据同时上存入一级缓存（内存Map）和二级缓存（文件）中
acache.put(key,data,time)或acache.put(key,data)　
/**
Key：为存入缓存的数据设置唯一标识，取数据时就根据key来获得的
Data：要存入的数据，acache支持的数据类型如图所示：
有String、可序列化的对象、字节数组、Drawable等　　Time:设置缓存数据的有效时间，单位秒
*/

一个简单小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

官方demo分析

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

缓存字符串读取：

• 在onCreate里通过get方式获取缓存实例
  mCache = ACache.get(this);

• 在save按钮的点击事件里，通过put方法往缓存实例里保存字符串
  mCache.put(“testString”, mEt_string_input.getText().toString(),300);

• 在read按钮的点击事件里，通过getAsString方法从缓存实例里读取字符串
  mCache.getAsString(“testString”)；

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

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 
 */
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事件
     */
    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事件 
     */
    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事件
     */
    public void clear(View v) 
    {
        mCache.remove("testString");
    }
}

ACache源码分析

1、获取缓存实例
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());
    }
    //实例化ACacheManager内部类实例
    mCache = new ACacheManager(cacheDir, max_size, max_count);
}

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

//内部类ACacheManager的构造函数
private ACacheManager(File cacheDir, long sizeLimit, int countLimit)
{
    this.cacheDir = cacheDir;
    this.sizeLimit = sizeLimit;
    this.countLimit = countLimit;
    //原子类实例cacheSize，不用加锁保证线程安全
    cacheSize = new AtomicLong();       
    //原子类实例cacheCount，不用加锁保证线程安全
    cacheCount = new AtomicInteger();   
    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;
            //返回缓存目录cacheDir下的文件数组
            File[] cachedFiles = cacheDir.listFiles();  
            if (cachedFiles != null) 
            {
                //对文件数组遍历
                for (File cachedFile : cachedFiles) 
                {             
                    size += calculateSize(cachedFile);  
                    count += 1;
                    //将缓存文件和最后修改时间插入map
                    lastUsageDates.put(cachedFile, cachedFile.lastModified());  
                }
                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
 * @para