采用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();
}
}
以上所述就是本文的全部内容了，希望大家能够喜欢。
