本地缓存实现
public class LazyRemovalCache<K,V> {
/**
* 缓存对象的hashMap
*/
private final ConcurrentMap<K,Entry<V>> map=new ConcurrentHashMap<K,Entry<V>>();
/** Max number of elements, if exceeded, we remove all elements marked as removable and older than max_age ms
* 缓存允许的最大条目
* */
private final int max_elements;
/**
* 缓存对象的最大生命周期
*/
private final long max_age;
/**
* 打印函数接口
* @author Administrator
*
* @param <K>
* @param <V>
*/
public interface Printable<K,V> {
String print(K key,V val);
}
/**
* 无参构造函数
*/
public LazyRemovalCache() {
this(200, 5000L);
}
/**
* 带参数的构造函数
* @param max_elements
* @param max_age
*/
public LazyRemovalCache(int max_elements, long max_age) {
this.max_elements=max_elements;
this.max_age=max_age;
}
/**
* 缓存中添加缓存对象
* @param key
* @param val
*/
public void add(K key, V val) {
if(key != null && val != null)
map.put(key, new Entry<V>(val)); // overwrite existing element (new timestamp, and possible removable mark erased)
checkMaxSizeExceeded();
}
/**
* 得到一个缓存对象
* @param key
* @return
*/
public V get(K key) {
if(key == null)
return null;
Entry<V> entry=map.get(key);
return entry != null? entry.val : null;
}
/**
* 根据缓存对象得到缓存KEY值
* @param val
* @return
*/
public K getByValue(V val) {
if(val == null) return null;
for(Map.Entry<K,Entry<V>> entry: map.entrySet()) {
Entry<V> v=entry.getValue();
if(v.val != null && v.val.equals(val))
return entry.getKey();
}
return null;
}
/**
* 删除一个缓存对象
* @param key
*/
public void remove(K key) {
remove(key, false);
}
/**
* 删除缓存对象
* @param key
* @param force true:强制删除，false:非强制删除
*/
public void remove(K key, boolean force) {
if(key == null)
return;
if(force)
map.remove(key);
else {
Entry<V> entry=map.get(key);
if(entry != null)
entry.removable=true;
}
checkMaxSizeExceeded();
}
/**
* 删除一个集合的缓存的key值
* @param keys
*/
public void removeAll(Collection<K> keys) {
removeAll(keys, false);
}
public void removeAll(Collection<K> keys, boolean force) {
if(keys == null || keys.isEmpty())
return;
if(force)
map.keySet().removeAll(keys);
else {
for(K key: keys) {
Entry<V> entry=map.get(key);
if(entry != null)
entry.removable=true;
}
}
checkMaxSizeExceeded();
}
/**
* 清空缓存对象
* @param force true:强制清空，false:非强制清空
*/
public void clear(boolean force) {
if(force)
map.clear();
else {
for(Map.Entry<K,Entry<V>> entry: map.entrySet()) {
Entry<V> val=entry.getValue();
if(val != null) {
Entry<V> tmp=entry.getValue();
if(tmp != null)
tmp.removable=true;
}
}
}
}
public void retainAll(Collection<K> keys) {
retainAll(keys, false);
}
/**
* 移除交集的key值
* @param keys
* @param force
*/
public void retainAll(Collection<K> keys, boolean force) {
if(keys == null || keys.isEmpty())
return;
if(force)
map.keySet().retainAll(keys);
else {
for(Map.Entry<K,Entry<V>> entry: map.entrySet()) {
if(!keys.contains(entry.getKey())) {
Entry<V> val=entry.getValue();
if(val != null)
val.removable=true;
}
}
}
checkMaxSizeExceeded();
}
/**
* 得到Key值set数组
* @return
*/
public Set<V> values() {
Set<V> retval=new HashSet<V>();
for(Entry<V> entry: map.values()) {
retval.add(entry.val);
}
return retval;
}
/**
* 得到缓存的内容
* @return
*/
public Map<K,V > contents() {
Map<K,V> retval=new HashMap<K,V>();
for(Map.Entry<K,Entry<V>> entry: map.entrySet())
retval.put(entry.getKey(), entry.getValue().val);
return retval;
}
public int size() {
return map.size();
}
public String printCache() {
StringBuilder sb=new StringBuilder();
for(Map.Entry<K,Entry<V>> entry: map.entrySet()) {
sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\n");
}
return sb.toString();
}
public String printCache(Printable print_function) {
StringBuilder sb=new StringBuilder();
for(Map.Entry<K,Entry<V>> entry: map.entrySet()) {
K key=entry.getKey();
V val=entry.getValue().val;
sb.append(print_function.print(key, val));
}
return sb.toString();
}
public String toString() {
return printCache();
}
private void checkMaxSizeExceeded() {
if(map.size() > max_elements) {
removeMarkedElements();
}
}
/**
* Removes elements marked as removable
* 删除掉被标志删除的元素
*
*/
public void removeMarkedElements() {
long curr_time=System.currentTimeMillis();
for(Iterator<Map.Entry<K,Entry<V>>> it=map.entrySet().iterator(); it.hasNext();) {
Map.Entry<K, Entry<V>> entry=it.next();
Entry<V> tmp=entry.getValue();
if(tmp.removable && (curr_time - tmp.timestamp) >= max_age) {
it.remove();
}
}
}
/**
*
* @author 缓存条目的封装类
*
* @param <V>
*/
private static class Entry<V> {
/**
* 缓存的对象
*/
private final V val;
/**
* 时间戳
*/
private final long timestamp=System.currentTimeMillis();
/**
* 是否被移除的标志
*/
private boolean removable=false;
public Entry(V val) {
this.val=val;
}
public String toString() {
return val + " (" + (System.currentTimeMillis() - timestamp) + "ms old" + (removable? ", removable" : "") + ")";
}
}
}