java实现缓存

Myth丶恋晨 2022-05-16 07:25 219阅读 0赞

缓存可以分为两大类：

1、通过文件缓存，就是把数据存储在磁盘上，不管是以XML格式、序列化文件DAT还是其他文件格式；

2、内存缓存，也就是实现一个类中静态Map，对这个Map进行常规的增删查

public class Cache {
        /*缓存ID*/
        private String key;
        /*缓存数据*/
        private Object value;
        /*更新时间*/
        private long timeout;
        /*是否终止*/
        private boolean expired;
    
        public Cache() {
        }
    
        public Cache(String key, Object value, long timeout, boolean expired) {
            this.key = key;
            this.value = value;
            this.timeout = timeout;
            this.expired = expired;
        }
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public Object getValue() {
            return value;
        }
    
        public void setValue(Object value) {
            this.value = value;
        }
    
        public long getTimeout() {
            return timeout;
        }
    
        public void setTimeout(long timeout) {
            this.timeout = timeout;
        }
    
        public boolean isExpired() {
            return expired;
        }
    
        public void setExpired(boolean expired) {
            this.expired = expired;
        }
    }

* 内存缓存就是实现一个类中静态的Map，对这个Map进行常规的增删改查
     *
     * 可扩展功能：当cache内存溢出时必须清理掉最早期的一些缓存对象，
     * 这就要求每个缓存对象保存创建时间
     */
    public class CacheManager {
        private static Map cacheMap = new HashMap();
        //单实例构造函数
        public CacheManager() {
            super();
        }
        //获取Boolean值的缓存
        public static boolean getSimpleFlag(String key){
            return (boolean) cacheMap.get(key);
        }
    
        public static long getServerStartdt(String key){
            return (long) cacheMap.get(key);
        }
    
        //设置Boolean值的缓存
        public synchronized static boolean setSimpleFlag(String key,boolean flag){
            if (flag &&  getSimpleFlag(key)){
                //为真不允许覆盖
                return false;
            }else {
                cacheMap.put(key,flag );
                return true;
            }
        }
    
        public synchronized static boolean setSimpleFlag(String key,Long serverbegrundt){
            if (cacheMap.get(key) == null){
                cacheMap.put(key,serverbegrundt );
                return true;
            }else {
                return false;
            }
        }
    
        //得到缓存同步静态方法
        private synchronized static Cache getCache(String key){
            return (Cache) cacheMap.get(key);
        }
    
        //判断是否存在一个缓存
        private synchronized static boolean hasCache(String key){
            return cacheMap.containsKey(key) ;
    
        }
    
        //清除所有缓存
        public synchronized static void clearAll(){
            cacheMap.clear();
        }
    
        //清除某一特定缓存，通过遍历HashMap下的所有对象，来判断它的key和传入的type是否匹配
        public synchronized static void clearOneType(String type){
            Iterator iterator = cacheMap.keySet().iterator();
            String key;
            List<String> list = new ArrayList<String>();
            while (iterator.hasNext()){
                  key = (String) iterator.next();
                  if (key.equals(type)){
                      list.add(key);
                  }
            }
            for (int i = 0; i < list.size(); i++) {
                cacheMap.remove(list.get(i));
            }
        }
    
        //载入缓存
        public synchronized static void putCache(String key,Cache ojb){
            cacheMap.put(key,ojb );
        }
    
        //获取缓存信息
        public static Cache getCacheInfo(String key){
            if (hasCache(key)){
                Cache cache = (Cache) cacheMap.get(key);
                if (cacheExpired(cache)){//判断是否终止方法
    
                }
            }
            return null;
        }
    
        private static boolean cacheExpired(Cache cache) {
            if (null == cache){
                return false;//传入的缓存不存在
            }
            /*系统当前毫秒数*/
            long nowTime = System.currentTimeMillis();
            /*缓存内的过期毫秒数*/
            long cacheTimeout = cache.getTimeout();
            /*过期时间小于等于零时，或者过期时间大于当前时间则为false*/
            if (cacheTimeout <= 0 || cacheTimeout > nowTime){
                return false;
            }else {//大于过期时间，即过期
                return true;
            }
        }
    
        //获取缓存大小
        public static int getCacheSize(){
            return cacheMap.size();
        }
        //获取指定类型的大小
        public static int getCacheSize(String type){
            int k = 0;
            Iterator iterator = cacheMap.keySet().iterator();
            String key;
            while (iterator.hasNext()){
                key = (String) iterator.next();
                if (key.indexOf(type) != -1){//如果匹配则删除掉
                    k++;
                }
            }
            return k;
        }
    
        //获取缓存对象中所有键值名称
        public static List<Set> getAllCacheKeys(){
            return (List<Set>) cacheMap.keySet();
        }
        //获取缓存对象中指定类型的键值名称
        public static List getAllCacheKeyValue(){
            return (List) cacheMap.entrySet();
        }
    
    
    }

转：[http://www.iteye.com/topic/544021][http_www.iteye.com_topic_544021]

[http_www.iteye.com_topic_544021]: http://www.iteye.com/topic/544021