可定制生命周期的缓存

可定制生命周期的缓存

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);
        }
        
    }
}

原帖地址：http://www.blogjava.net/jgao/archive/2007/04/22/112541.html