android实现缓存图片等数据

采用LinkedHashMap自带的LRU 算法缓存数据， 可检测对象是否已被虚拟机回收，并且重新计算当前缓存大小，清除缓存中无用的键值对象(即已经被虚拟机回收但未从缓存清除的数据)；
 * 默认内存缓存大小为: 4 * 1024 * 1024 可通过通过setMaxCacheSize重新设置缓存大小，可手动清空内存缓存
 * <br>支持内存缓存和磁盘缓存方式， 通过 {@link cc.util.cache.NetByteWrapper} 支持HTTP缓存 （注：详细参考cc.util.http包）； 注：使用JDK7

package cc.util.cache;

import java.io.Serializable;
import java.util.Objects;

/**
  封装网络数据， 将数据的Etag、lastModified获取到， 下次请求的时候提取出来到服务器比对
 * Help to wrap byte data which obtains from network, It will work with {@link cc.util.cache.NetChacheManager}
 * @author wangcccong
 * @version 1.1406
 * <br> create at: Tues, 10 Jun 2014
 */
public class NetByteWrapper implements Serializable {

  private final static long serialVersionUID = 1L;

  /** data from network */
  private byte[] data;
  /** data size */
  int contentLength;
  /** latested modify time */
  private long lastModified;
  /** ETag： look up HTTP Protocol */
  private String ETag;

  public NetByteWrapper(byte[] data, long lastModified, String Etag) {
    this.data = data;
    this.lastModified = lastModified;
    this.ETag = Etag;
  }

  public byte[] getData() {
    return data;
  }
  public void setData(byte[] data) {
    this.data = data;
  }

  public long getLastModified() {
    return lastModified;
  }
  public void setLastModified(long lastModified) {
    this.lastModified = lastModified;
  }

  public String getETag() {
    return ETag;
  }

  public void setETag(String eTag) {
    this.ETag = eTag;
  }

  public int getContentLength() {
    return Objects.isNull(data) ? 0 : data.length;
  }
}

package cc.util.cache;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

/**采用软引用方式将数据存放起来
 * enclose {@link cc.util.cache.NetByteWrapper} with {@link java.lang.ref.SoftReference}, In order to recycle the memory
 * @author wangcccong
 * @version 1.1406
 * <br> create at: Tues, 10 Jun. 2014
 */
public class NetByteSoftReference extends SoftReference<NetByteWrapper> {

  private String key = "";
  private long length = 0;

  public NetByteSoftReference(String key, NetByteWrapper arg0) {
    this(key, arg0, null);
  }

  public NetByteSoftReference(String key, NetByteWrapper arg0,
      ReferenceQueue<? super NetByteWrapper> arg1) {
    super(arg0, arg1);
    // TODO Auto-generated constructor stub
    this.key = key;
    this.length = arg0.getContentLength();
  }

  public String getKey() {
    return key;
  }

  public long getLength() {
    return length;
  }

}

package cc.util.cache;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Objects;

/**
 * 采用LinkedHashMap自带的LRU 算法缓存数据， 可检测对象是否已被虚拟机回收，并且重新计算当前缓存大小，清除缓存中无用的键值对象(即已经被虚拟机回收但未从缓存清除的数据)；
 * 默认内存缓存大小为: 4 * 1024 * 1024 可通过通过setMaxCacheSize重新设置缓存大小，可手动清空内存缓存，支持采用内存映射方式读取缓存
 * <br>支持内存缓存和磁盘缓存方式， 通过 {@link cc.util.cache.NetByteWrapper} 支持HTTP缓存 （注：详细参考cc.util.http包）
 * @author wangcccong
 * @version 1.1406
 * <br> create at: Tues, 10 Jun 2014
 */
public class NetCacheManager {

  /** max cache size */
  private long MAX_CACHE_SIZE = 4 * 1024 * 1024;
  private long cacheSize = 0; 

  private static NetCacheManager instance = null;

  private final ReferenceQueue<NetByteWrapper> referenceQueue;
  private final LinkedHashMap<String, NetByteSoftReference> cacheMap;

  private NetCacheManager(){
    referenceQueue = new ReferenceQueue<NetByteWrapper>();
    cacheMap = new LinkedHashMap<String, NetByteSoftReference>(16, 0.75f, true) {

      private static final long serialVersionUID = -8378285623387632829L;
      @Override
      protected boolean removeEldestEntry(
          java.util.Map.Entry<String, NetByteSoftReference> eldest) {
        // TODO Auto-generated method stub
        boolean shouldRemove = cacheSize > MAX_CACHE_SIZE;
        if (shouldRemove) {
          cacheSize -= eldest.getValue().getLength();
          System.gc();
        }
        return shouldRemove;
      }
    };
  }

  /** singleton model */
  public static synchronized NetCacheManager newInstance(){
    if (Objects.isNull(instance)) {
      instance = new NetCacheManager();
    }
    return instance;
  }

  /**
   * reset the memory cache size
   * @param cacheSize
   */
  public void setMaxCacheSize(long cacheSize) {
    this.MAX_CACHE_SIZE = cacheSize;
  }

  /**
   * 获取当前内存缓存大小
   * @return
   */
  public long getCacheSize() {
    return cacheSize;
  }

  /**
   * 将数据缓存至内存， 如果http返回的数据<b>不支持</b>缓存则采用此方法，缓存的key一般为请求的url
   * @param key
   * @param value
   */
  public void cacheInMemory(String key, byte[] value) {
    this.cacheInMemory(key, value, 0, null);
  }

  /**
   * 将数据缓存至内存， 如果http返回的数据<b>支持</b>缓存则采用此方法
   * @param key
   * @param value
   * @param lastModified
   */
  public void cacheInMemory(String key, byte[] value, long lastModified) {
    this.cacheInMemory(key, value, lastModified, null);
  }

  /**
   * 将数据缓存至内存， 如果http返回的数据<b>支持</b>缓存则采用此方法
   * @param key
   * @param value
   * @param Etags
   */
  public void cacheInMemory(String key, byte[] value, String Etags) {
    this.cacheInMemory(key, value, 0, Etags);
  }

  /**
   * 将数据缓存至内存， 如果http返回的数据<b>支持</b>缓存则采用此方法
   * @param key
   * @param value
   * @param lastModified
   * @param Etags
   */
  private void cacheInMemory(String key, byte[] value, long lastModified, String Etags) {
    Objects.requireNonNull(key, "key must not be null");
    clearRecycledObject();
    NetByteWrapper wrapper = new NetByteWrapper(value, lastModified, Etags);
    NetByteSoftReference byteRef = new NetByteSoftReference(key, wrapper, referenceQueue);
    cacheMap.put(key, byteRef);
    value = null;
    wrapper = null;
  }

  /**
   * 缓存至磁盘, 默认不首先缓存到内存
   * @param key
   * @param value
   * @param path
   */
  public void cacheInDisk(String key, byte[] value, String path) {
    cacheInDisk(key, value, path, false);
  }

  /**
   *
   * @param key
   * @param value
   * @param path
   * @param cacheInMemory
   */
  public void cacheInDisk(String key, byte[] value, String path, boolean cacheInMemory) {
    this.cacheInDisk(key, value, 0, null, path, cacheInMemory);
  }

  /**
   *
   * @param key
   * @param value
   * @param lastModified
   * @param Etags
   * @param path
   * @param cacheInMemory
   */
  private void cacheInDisk(String key, byte[] value, long lastModified, String Etags, String path, boolean cacheInMemory) {
    if (cacheInMemory) cacheInMemory(key, value, lastModified, Etags);
    try (FileOutputStream fos = new FileOutputStream(path);
        ObjectOutputStream oos = new ObjectOutputStream(fos)) {
        NetByteWrapper wrapper = new NetByteWrapper(value, lastModified, Etags);
        oos.writeObject(wrapper);
    } catch (Exception e) {
        // TODO: handle exception
      e.printStackTrace();
    }
  }

  /**
   * get {@link cc.util.cache.NetByteWrapper} from memory according to key
   * @param key
   * @return {@link cc.util.cache.NetByteWrapper}
   */
  public NetByteWrapper getFromMemory(String key) {
    SoftReference<NetByteWrapper> softReference = cacheMap.get(key);
    return Objects.nonNull(softReference) ? softReference.get() : null;
  }

  /**
   * get byte[] from memory according to key
   * @param context
   * @param key
   * @return
   */
  public byte[] getByteFromMemory(String key) {
    NetByteWrapper wrapper = getFromMemory(key);
    return Objects.nonNull(wrapper) ? wrapper.getData() : null;
  }

  /**
   * 从磁盘获取数据
   * @param path
   * @return {@link cc.util.cache.NetByteWrapper}
   */
  public NetByteWrapper getFromDisk(String path) {
    try (FileInputStream fis = new FileInputStream(path);
        ObjectInputStream ois = new ObjectInputStream(fis)) {
      NetByteWrapper wrapper = (NetByteWrapper) ois.readObject();
      return wrapper;
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
      return null;
    }
  }

  /**
   * 采用内存映射的方式从磁盘获取数据（加快读取缓存的大文件）
   * @param path
   * @return
   */
  public NetByteWrapper getFromDiskByMapped(String path) {
    try (FileInputStream fis = new FileInputStream(path);
        FileChannel channel= fis.getChannel();
        ByteArrayOutputStream baos = new ByteArrayOutputStream()){
      MappedByteBuffer mbb = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
      byte[] bts = new byte[1024];
      int len = (int) channel.size();
      for (int offset = 0; offset < len; offset += 1024) {
        if (len - offset > 1024) mbb.get(bts);
        else mbb.get((bts = new byte[len - offset]));
        baos.write(bts);
      }
      ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
      ObjectInputStream ois = new ObjectInputStream(bais);
      NetByteWrapper wrapper = (NetByteWrapper) ois.readObject();
      bais.close();
      ois.close();
      return wrapper;
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
      return null;
    }
  }

  /**
   * 从磁盘获取缓存的byte[] 数据
   * @param path
   * @return
   */
  public byte[] getByteFromDisk(String path) {
    NetByteWrapper wrapper = getFromDisk(path);
    return Objects.isNull(wrapper) ? null : wrapper.getData();
  }

  /**
   * 通过内存映射放射从磁盘获取缓存的byte[] 数据
   * @param path
   * @return
   */
  public byte[] getByteFromDiskByMapped(String path) {
    NetByteWrapper wrapper = getFromDiskByMapped(path);
    return Objects.isNull(wrapper) ? null : wrapper.getData();
  }

  /**
   * calculate the size of the cache memory
   */
  private void clearRecycledObject() {
    NetByteSoftReference ref = null;
    //检测对象是否被回收，如果被回收则从缓存中移除死项
    while (Objects.nonNull((ref = (NetByteSoftReference) referenceQueue.poll()))) {
      cacheMap.remove(ref.getKey());
    }
    cacheSize = 0;
    Iterator<String> keys = cacheMap.keySet().iterator();
    while (keys.hasNext()) {
      cacheSize += cacheMap.get(keys.next()).getLength();
    }
  }

  /**
   * clear the memory cache
   */
  public void clearCache() {
    clearRecycledObject();
    cacheMap.clear();
    System.gc();
    System.runFinalization();
  }

}

以上所述就是本文的全部内容了，希望大家能够喜欢。