1) ICache.java 緩存接口
package com.jgao.cache;
/** *//**
* 緩存接口
* @author jgao
*
*/
public interface ICache 
{
public static int Forever = -1; //緩存中對象生命周期的結束標志
/** *//**
* 判斷緩存中的對象是否存在
* @param key
* @return
*/
boolean contains(String key);
/** *//**
* 獲取緩存中的對象
* @param key 對象名稱
* @return
*/
Object get(String key);
/** *//**
* 向緩存中插入對象
* @param key 對象名稱
* @param obj 對象
* @param slidingExpiration 對象在緩存中存在的時間
*/
void Insert(String key, Object obj, int slidingExpiration);
/** *//**
*
* 向緩存中添加對象,并返回該對象
* @param key 對象名稱
* @param obj 對象
* @param slidingExpiration 對象在緩存中存在的時間
* @return
*/
Object Add(String key, Object obj, int slidingExpiration);
/** *//**
* 移除緩存中的對象
* @param key 對象名稱
* @return
*/
Object Remove(String key);
}2) DefaultCache.java 默認緩存
package com.jgao.cache;
import java.util.*;
/** *//**
* 系統默認的緩存
* @author jgao
*
*/
class DefaultCache implements ICache {
static int FreshTimerIntervalSeconds = 1; //緩存中對象生命周期的頻率(一秒)
Map<String, SimpleCacheInfo> datas; //緩存容器
private Timer timer; //時間任務
/** *//**
* 默認構造函數
*
*/
public DefaultCache() {
//實例化有防止線程同步操作的緩存容器
datas = Collections.synchronizedMap(new HashMap<String, SimpleCacheInfo>());
//刷新緩存
TimerTask task = new CacheFreshTask(this);
timer = new Timer("SimpleCache_Timer", true);
timer.scheduleAtFixedRate(task, 1000, FreshTimerIntervalSeconds * 1000);//每格一秒刷新一次(緩存中對象的生命周期減一)
}
/** *//**
* 判斷緩存中的對象是否存在
* @param key
* @return
*/
public boolean contains(String key){
return datas.containsKey(key);
}
/** *//**
* 獲取緩存中的對象
* @param key 對象名稱
* @return
*/
public Object get(String key) {
if (datas.containsKey(key)) {
SimpleCacheInfo sci = (SimpleCacheInfo)datas.get(key);
//sci.setSecondsRemain(sci.getSecondsTotal());
return sci.getObj();
}
return null;
}
/** *//**
* 向緩存中插入對象
* @param key 對象名稱
* @param obj 對象
* @param cacheSeconds 對象在緩存中存在的時間
*/
public void Insert(String key, Object obj, int cacheSeconds) {
Add(key, obj, cacheSeconds);
}
/** *//**
*
* 向緩存中添加對象,并返回該對象
* @param key 對象名稱
* @param obj 對象
* @param cacheSeconds 對象在緩存中存在的時間
* @return
*/
public Object Add(String key, Object obj, int cacheSeconds) {
if (cacheSeconds != 0) {
SimpleCacheInfo sci = new SimpleCacheInfo(obj, cacheSeconds);
datas.put(key, sci);
}
return obj;
}
/** *//**
* 移除緩存中的對象
* @param key 對象名稱
* @return
*/
public Object Remove(String key) {
SimpleCacheInfo sci = datas.remove(key);
if (sci != null) {
return sci.getObj();
}
return null;
}
/** *//**
* 緩存信息類(存儲緩存中的對象和緩存時間)
* @author jgao
*
*/
class SimpleCacheInfo {
private Object obj;
private int secondsRemain;
private int cacheSeconds;
public SimpleCacheInfo(Object obj, int cacheSeconds) {
this.obj = obj;
this.secondsRemain = cacheSeconds;
this.cacheSeconds = cacheSeconds;
}
public Object getObj() {
return obj;
}
int getSecondsTotal() {
return cacheSeconds;
}
int getSecondsRemain() {
return secondsRemain;
}
void setSecondsRemain(int value) {
secondsRemain = value;
}
}
/** *//**
* 管理緩存中對象的生命周期的任務類(用于定時刷新緩存中的對象)
* @author jgao
*
*/
class CacheFreshTask extends TimerTask {
private DefaultCache cache;
public CacheFreshTask(DefaultCache cache) {
this.cache = cache;
}
public void run() {
synchronized (cache.datas) {
Iterator<Map.Entry<String, SimpleCacheInfo>> iterator
= cache.datas.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, SimpleCacheInfo> entry = iterator.next();
SimpleCacheInfo sci = entry.getValue();
if (sci.getSecondsTotal() != ICache.Forever) {
sci.setSecondsRemain(sci.getSecondsRemain() - FreshTimerIntervalSeconds);
if (sci.getSecondsRemain() <= 0) {
iterator.remove();
}
}
}
}
}
}
}
3) CacheFactory.java 緩存工廠
package com.jgao.cache;
/** *//**
* 緩存工廠,用于獲取和制造緩存
* @author jgao
*
*/
public class CacheFactory {
private static ICache cache = null;
/** *//**
* 獲取caches指定的緩存
* @param caches
* @return
*/
public static ICache getCacheInstance(Class caches){
if(cache==null){
try {
cache = (ICache) caches.newInstance();
} catch (InstantiationException e) {
System.out.println("指定的緩存類有誤,caches參數必須是ICache的實現類");
e.printStackTrace();
} catch (IllegalAccessException e) {
System.out.println("指定的緩存類有誤,caches參數必須是ICache的實現類");
e.printStackTrace();
}
}
return cache;
}
/** *//**
* 獲取系統默認的緩存
* @return
*/
public static ICache getDefaultCache(){
if(cache==null){
cache = new DefaultCache();
}else if(!(cache instanceof DefaultCache)){
cache = new DefaultCache();
}
return cache;
}
public static void main(String[] args) {
ICache cache = CacheFactory.getDefaultCache();
if(cache.contains("area")){
System.out.println(cache.get("area"));
}else{
cache.Insert("area","福州",120);
}
}
}