APP本地缓存CacheManager

CacheManager(缓存)

通过将Bean对象缓存到SD，Bean对象需要序列化实现

CacheManager.java

public class CacheManager<T extends Serializable> {

private static String DIR = Environment.getExternalStorageDirectory().getPath();
private static int SPACE_MIN_CACHE = 1024 * 1024 * 20;//20M
private static CacheManager manager;

private CacheManager() {
    }

public synchronized static CacheManager getInstance() {
if (manager == null) {
            manager = new CacheManager();
        }
return manager;
    }

public void clearCache() {
        File file = null;
        File[] files = null;
if (BaseUtil.checkSDMounted()) {
            file = new File(DIR);
            files = file.listFiles();
if (files != null) {
for (File f : files) {
                    f.delete();
                }
            }
        }
    }

public synchronized void putCacheFile(String key, T t, long time) {
if (!TextUtils.isEmpty(key)) {
            String md_key = BaseUtil.getMD5(key);
if (!TextUtils.isEmpty(md_key)) {
                final CacheItem<T> cacheItem = new CacheItem<T>(md_key, t, time);
                saveCacheFile(md_key, cacheItem);
            }
        }
    }

private boolean saveCacheFile(String md_key, CacheItem cacheItem) {
if (BaseUtil.getSDSize() > SPACE_MIN_CACHE) {
            saveCacheObject(cacheItem);
return true;
        }
return false;
    }

private void saveCacheObject(CacheItem cacheItem) {
if (cacheItem != null) {
            BaseUtil.saveObject(cacheItem, DIR + cacheItem.getKey());
        }
    }

public synchronized T getCacheFile(String key) {
if (!TextUtils.isEmpty(key)) {
            String md_key = BaseUtil.getMD5(key);
if (!TextUtils.isEmpty(md_key)) {
                String path = DIR + md_key;
if (!TextUtils.isEmpty(path)) {
                    CacheItem<T> cacheItem = BaseUtil.getObject(path);
if (cacheItem != null) {
if (System.currentTimeMillis() < cacheItem.getTime()) {
return cacheItem.getData();
                        }
                    }
                }
            }
        }
return null;
    }

public void initCache() {
if (BaseUtil.checkSDMounted()) {
if (BaseUtil.getSDSize() < SPACE_MIN_CACHE) {
                clearCache();
            } else {
                File file = new File(DIR);
if (!file.exists()) {
                    file.mkdirs();
                }
            }
        }
    }
}

BaseUtil.java

public class BaseUtil {

private static final char[] HEX = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};


public static String getMD5(String key) {

if (!TextUtils.isEmpty(key)) {
try {
final MessageDigest md = MessageDigest.getInstance(key);
                md.update(key.trim().getBytes());
final byte[] bytes = md.digest();
return toHexString(bytes);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
return key;
    }

private static String toHexString(final byte[] bytes) {

final StringBuilder sb = new StringBuilder();

if (bytes != null) {
for (byte b : bytes) {
                sb.append(HEX[(b & 0xf0)] >>> 4);
                sb.append(HEX[b & 0x0f]);
            }
        }

return sb.toString();
    }

public static boolean checkSDMounted() {
        String state = Environment.getExternalStorageState();
return Environment.MEDIA_MOUNTED.equals(state) && !Environment.MEDIA_MOUNTED_READ_ONLY.equals(state);
    }

public static int getSDSize() {
        String path = Environment.getExternalStorageDirectory().getPath();
final StatFs s = new StatFs(path);
int block = s.getAvailableBlocks();
return s.getBlockSize() * block;
    }

public static <T extends Serializable> void saveObject(T t, String path) {

if (!TextUtils.isEmpty(path)) {
            ObjectOutputStream oos = null;
final File file = new File(path);
try {
                oos = new ObjectOutputStream(new FileOutputStream(file));
                oos.writeObject(t);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
if (oos != null) {
try {
                        oos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

public static <T extends Serializable> T getObject(String path) {
if (!TextUtils.isEmpty(path)) {
            ObjectInputStream ois = null;
final File file = new File(path);
if (file.exists()) {
try {
                    ois = new ObjectInputStream(new FileInputStream(file));
return (T) ois.readObject();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
if (ois != null) {
try {
                            ois.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
return null;
    }

}

CacheItem.java

public class CacheItem<T extends Serializable> implements Serializable {
private String key;//key
private T data;//缓存的数据
private long time;//时间戳

public CacheItem(String key, T data, long time) {
this.key = key;
this.data = data;
this.time = time;
    }

public String getKey() {
return key;
    }

public T getData() {
return data;
    }

public long getTime() {
return time;
    }
}