缓存之 ACache

1.android缓存的介绍

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

1.二级缓存定义：

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

2.保存在本地了怎么更新网络数据呢？

　　理解了二级缓存大家可能会有个问题网络中的数据是变化的，数据一旦放入缓存中，再取该数据就是从缓存中获得，这样岂不是不能体现数据的变化？我们在缓存数据时会设置有效时间，比如说30分钟，若超过这个时间数据就失效并释放空间，然后重新请求网络中的数据。有的童鞋就问30分钟内咋办？那好吧，我也没招了，只有下拉刷新了吧，实际上这不是问题。</div>

2.本篇就介绍下Acache缓存

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

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

普通的字符串、json、序列化的java对象，和字节数字。</div>

2、它有什么特色？

特色主要是：</div> 1：轻，轻到只有一个JAVA文件。</div> 2：可配置，可以配置缓存路径，缓存大小，缓存数量等。</div> 3：可以设置缓存超时时间，缓存超时自动失效，并被删除。</div> 4：多进程的支持。</div>

3.使用

1.初始化ACache组件

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

2.设置缓存数据

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

3.从缓存中取数据

　提供一系列getAsXXX()方法，如图所示。</div> 　　根据不同存入数据，调用不同的方法取数据</div> </div> 4.ACache代码片</div>

package com.example.acachetest.util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import org.json.JSONArray;
import org.json.JSONObject;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.PixelFormat;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

public class ACache {
    public static final int TIME_HOUR = 60 * 60;
    public static final int TIME_DAY = TIME_HOUR * 24;
    private static final int MAX_SIZE = 1000 * 1000 * 50; // 50 mb
    private static final int MAX_COUNT = Integer.MAX_VALUE; // 不限制存放数据的数量
    private static Map mInstanceMap = new HashMap();
    private ACacheManager mCache;
 
    public static ACache get(Context ctx) {
        return get(ctx, "ACache");
    }
 
    public static ACache get(Context ctx, String cacheName) {
        File f = new File(ctx.getCacheDir(), cacheName);
        return get(f, MAX_SIZE, MAX_COUNT);
    }
 
    public static ACache get(File cacheDir) {
        return get(cacheDir, MAX_SIZE, MAX_COUNT);
    }
 
    public static ACache get(Context ctx, long max_zise, int max_count) {
        File f = new File(ctx.getCacheDir(), "ACache");
        return get(f, max_zise, max_count);
    }
 
    public static ACache get(File cacheDir, long max_zise, int max_count) {
        ACache manager = mInstanceMap.get(cacheDir.getAbsoluteFile() + myPid());
        if (manager == null) {
            manager = new ACache(cacheDir, max_zise, max_count);
            mInstanceMap.put(cacheDir.getAbsolutePath() + myPid(), manager);
        }
        return manager;
    }
 
    private static String myPid() {
        return "_" + android.os.Process.myPid();
    }
 
    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);
    }
 
    // =======================================
    // ============ String数据 读写 ==============
    // =======================================
    /**
     * 保存 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);
            out.write(value);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            mCache.put(file);
        }
    }
 
    /**
     * 保存 String数据 到 缓存中
     * 
     * @param key
     *            保存的key
     * @param value
     *            保存的String数据
     * @param saveTime
     *            保存的时间，单位：秒
     */
    public void put(String key, String value, int saveTime) {
        put(key, Utils.newStringWithDateInfo(saveTime, value));
    }
 
    /**
     * 读取 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)) {
                return Utils.clearDateInfo(readString);
            } else {
                removeFile = true;
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (in != null) {
                try {
                    in.clos