ACache-缓存-一个轻量级框架

今天介绍一个简单的轻量级缓存框架ASimpleCache

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

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

2、它有什么特色？

特色主要是：

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

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

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

使用方法

通过ACache.get(Context context)获取实例

put（）方法可以存入数据

getXXX()方法获取数据

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;
import android.text.TextUtils;



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

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
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;

/**
 * 项目 数据缓存工具类，可以缓存jsonObject bitmap Object String drawable byte jsonarray
 * 可自定义缓存时间
 */
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<String, ACache> mInstanceMap = new HashMap<String, ACache>();
    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);
    }

    public static final String STRING = "String";
    public static final String Binary = "Binary";
    public static final String Bitmap = "Bitmap";
    public static final String Drawable = "Drawable";
    public static final String Object = "Object";
    public static final String jsonArray = "jsonArray";
    public static final String jsonObject = "jsonObject";

    //判断本地数据是否存在
    public boolean isExist(String Cachekey,String Datatype){
        if (!TextUtils.isEmpty(Datatype)){
            if (Datatype.equals(STRING)){
                if (!TextUtils.isEmpty(getAsString(Cachekey))) return true;
            }else if (Datatype.equals(Binary)){
                if (getAsBinary(Cachekey)!=null) return true;
            }else if (Datatype.equals(Bitmap)){
                if (getAsBitmap(Cachekey)!=null) return true;
            }else if (Datatype.equals(Drawable)){
                if (getAsDrawable(Cachekey)!=null)return true;
            }else if (Datatype.equals(Object)){
                if (getAsObject(Cachekey)!=null) return true;
            }else if (Datatype.equals(jsonArray)){
                if (getAsJSONArray(Cachekey)!=null) return true;
            }else if (Datatype.equals(jsonObject)){
                if (getAsJSONObject(Cachekey)!=null)return true;
            }
        }
        return false;
    }

    /**
     * Provides a means to save a cached file before the data are available.
     * Since writing about the file is complete, and its close method is called,
     * its contents will be registered in the cache. Example of use:
     * 
     * ACache cache = new ACache(this) try { OutputStream stream =
     * cache.put("myFileName") stream.write("some bytes".getBytes()); // now
     * update cache! stream.close(); } catch(FileNotFoundException e){
     * e.printStackTrace() }
     */
    class xFileOutputSt