文档章节

Java中常用缓存Cache机制的实现

Sheamus
 Sheamus
发布于 2015/04/15 17:34
字数 1091
阅读 352
收藏 35

所谓缓存,就是将程序或系统经常要调用的对象存在内存中,一遍其使用时可以快速调用,不必再去创建新的重复的实例。这样做可以减少系统开销,提高系统效率。

缓存主要可分为二大类:

一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上,不管你是以XML格式,序列化文件DAT格式还是其它文件格式;

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

代码如下 :

package lhm.hcy.guge.frameset.cache; 


import java.util.*; 


 //Description: 管理缓存 


 //可扩展的功能:当chche到内存溢出时必须清除掉最早期的一些缓存对象,这就要求对每个缓存对象保存创建时间 


public class CacheManager { 

    private static HashMap cacheMap = new HashMap(); 


    //单实例构造方法 

    private CacheManager() { 

        super(); 

    } 

    //获取布尔值的缓存 

    public static boolean getSimpleFlag(String key){ 

        try{ 

            return (Boolean) cacheMap.get(key); 

        }catch(NullPointerException e){ 

            return false; 

        } 

    } 

    public static long getServerStartdt(String key){ 

        try { 

            return (Long)cacheMap.get(key); 

        } catch (Exception ex) { 

            return 0; 

        } 

    } 

    //设置布尔值的缓存 

    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 clearAll(String type) { 

        Iterator i = cacheMap.entrySet().iterator(); 

        String key; 

        ArrayList arr = new ArrayList(); 

        try { 

            while (i.hasNext()) { 

                java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 

                key = (String) entry.getKey(); 

                if (key.startsWith(type)) { //如果匹配则删除掉 

                    arr.add(key); 

                } 

            } 

            for (int k = 0; k < arr.size(); k++) { 

                clearOnly(arr.get(k)); 

            } 

        } catch (Exception ex) { 

            ex.printStackTrace(); 

        } 

    } 


    //清除指定的缓存 

    public synchronized static void clearOnly(String key) { 

        cacheMap.remove(key); 

    } 


    //载入缓存 

    public synchronized static void putCache(String key, Cache obj) { 

        cacheMap.put(key, obj); 

    } 


    //获取缓存信息 

    public static Cache getCacheInfo(String key) { 


        if (hasCache(key)) { 

            Cache cache = getCache(key); 

            if (cacheExpired(cache)) { //调用判断是否终止方法 

                cache.setExpired(true); 

            } 

            return cache; 

        }else 

            return null; 

    } 


    //载入缓存信息 

    public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { 

        Cache cache = new Cache(); 

        cache.setKey(key); 

        cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存 

        cache.setValue(obj); 

        cache.setExpired(expired); //缓存默认载入时,终止状态为FALSE 

        cacheMap.put(key, cache); 

    } 

    //重写载入缓存信息方法 

    public static void putCacheInfo(String key,Cache obj,long dt){ 

        Cache cache = new Cache(); 

        cache.setKey(key); 

        cache.setTimeOut(dt+System.currentTimeMillis()); 

        cache.setValue(obj); 

        cache.setExpired(false); 

        cacheMap.put(key,cache); 

    } 


    //判断缓存是否终止 

    public static boolean cacheExpired(Cache cache) { 

        if (null == cache) { //传入的缓存不存在 

            return false; 

        } 

        long nowDt = System.currentTimeMillis(); //系统当前的毫秒数 

        long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数 

        if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时,则为FALSE 

            return false; 

        } else { //大于过期时间 即过期 

            return true; 

        } 

    } 


    //获取缓存中的大小 

    public static int getCacheSize() { 

        return cacheMap.size(); 

    } 


    //获取指定的类型的大小 

    public static int getCacheSize(String type) { 

        int k = 0; 

        Iterator i = cacheMap.entrySet().iterator(); 

        String key; 

        try { 

            while (i.hasNext()) { 

                java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 

                key = (String) entry.getKey(); 

                if (key.indexOf(type) != -1) { //如果匹配则删除掉 

                    k++; 

                } 

            } 

        } catch (Exception ex) { 

            ex.printStackTrace(); 

        } 


        return k; 

    } 


    //获取缓存对象中的所有键值名称 

    public static ArrayList getCacheAllkey() { 

        ArrayList a = new ArrayList(); 

        try { 

            Iterator i = cacheMap.entrySet().iterator(); 

            while (i.hasNext()) { 

                java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 

                a.add((String) entry.getKey()); 

            } 

        } catch (Exception ex) {} finally { 

            return a; 

        } 

    } 


    //获取缓存对象中指定类型 的键值名称 

    public static ArrayList getCacheListkey(String type) { 

        ArrayList a = new ArrayList(); 

        String key; 

        try { 

            Iterator i = cacheMap.entrySet().iterator(); 

            while (i.hasNext()) { 

                java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 

                key = (String) entry.getKey(); 

                if (key.indexOf(type) != -1) { 

                    a.add(key); 

                } 

            } 

        } catch (Exception ex) {} finally { 

            return a; 

        } 

    } 


} 


package lhm.hcy.guge.frameset.cache; 


public class Cache { 

        private String key;//缓存ID 

        private Object value;//缓存数据 

        private long timeOut;//更新时间 

        private boolean expired; //是否终止 

        public Cache() { 

                super(); 

        } 


        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 long getTimeOut() { 

                return timeOut; 

        } 


        public Object getValue() { 

                return value; 

        } 


        public void setKey(String string) { 

                key = string; 

        } 


        public void setTimeOut(long l) { 

                timeOut = l; 

        } 


        public void setValue(Object object) { 

                value = object; 

        } 


        public boolean isExpired() { 

                return expired; 

        } 


        public void setExpired(boolean b) { 

                expired = b; 

        } 

} 


//测试类, 

class Test { 

    public static void main(String[] args) { 

        System.out.println(CacheManager.getSimpleFlag("alksd")); 

//        CacheManager.putCache("abc", new Cache()); 

//        CacheManager.putCache("def", new Cache()); 

//        CacheManager.putCache("ccc", new Cache()); 

//        CacheManager.clearOnly(""); 

//        Cache c = new Cache(); 

//        for (int i = 0; i < 10; i++) { 

//            CacheManager.putCache("" + i, c); 

//        } 

//        CacheManager.putCache("aaaaaaaa", c); 

//        CacheManager.putCache("abchcy;alskd", c); 

//        CacheManager.putCache("cccccccc", c); 

//        CacheManager.putCache("abcoqiwhcy", c); 

//        System.out.println("删除前的大小:"+CacheManager.getCacheSize()); 

//        CacheManager.getCacheAllkey(); 

//        CacheManager.clearAll("aaaa"); 

//        System.out.println("删除后的大小:"+CacheManager.getCacheSize()); 

//        CacheManager.getCacheAllkey(); 


    } 

}

本文转载自:http://www.codeceo.com/article/java-cache-ways.html

Sheamus

Sheamus

粉丝 45
博文 213
码字总数 29920
作品 0
海淀
程序员
私信 提问
MyBatis一级缓存原理解析

MyBatis是一个简单,小巧但功能非常强大的ORM开源框架,它的功能强大也体现在它的缓存机制上。MyBatis提供了一级缓存、二级缓存 这两个缓存机制,能够很好地处理和维护缓存,以提高系统的性能...

编程SHA
03/28
22
0
堆外内存及其在 RxCache 中的使用

RxCache RxCache 是一款支持 Java 和 Android 的 Local Cache 。目前,支持堆内存、堆外内存(off-heap memory)、磁盘缓存。 github地址:https://github.com/fengzhizi715/RxCache 堆外内存(...

fengzhizi715
01/13
0
0
Java自动装箱和拆箱,包装类缓存机制和JVM调节

关于Java自动装箱和拆箱 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能 自动装箱,个人感觉也就是为了所谓的java泛型,泛型就是一种糖,装箱是...

BakerZhu
2017/07/17
31
0
hibernate学习笔记:hibernate中的Cache管理

Hibernate 中实现了良好的Cache 机制,我们可以借助Hibernate 内部的Cache迅速提高系统数据读取性能。 需要注意的是:Hibernate做为一个应用级的数据访问层封装,只能在其作用范围内保持Cac...

crazyinsomnia
2010/01/10
1K
0
【Java并发编程的艺术】Java并发机制的底层的实现原理

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zlt995768025/article/details/80717660 首先Java并发的实现依赖于JVM的实现和CPU的指令 【volatile】 定义:...

周丽同
2018/06/17
0
0

没有更多内容

加载失败,请刷新页面

加载更多

64.监控平台介绍 安装zabbix 忘记admin密码

19.1 Linux监控平台介绍 19.2 zabbix监控介绍 19.3/19.4/19.6 安装zabbix 19.5 忘记Admin密码如何做 19.1 Linux监控平台介绍: 常见开源监控软件 ~1.cacti、nagios、zabbix、smokeping、ope...

oschina130111
今天
13
0
当餐饮遇上大数据,嗯真香!

之前去开了一场会,主题是「餐饮领袖新零售峰会」。认真听完了餐饮前辈和新秀们的分享,觉得获益匪浅,把脑子里的核心纪要整理了一下,今天和大家做一个简单的分享,欢迎感兴趣的小伙伴一起交...

数澜科技
今天
7
0
DNS-over-HTTPS 的下一代是 DNS ON BLOCKCHAIN

本文作者:PETER LAI ,是 Diode 的区块链工程师。在进入软件开发领域之前,他主要是在做工商管理相关工作。Peter Lai 也是一位活跃的开源贡献者。目前,他正在与 Diode 团队一起开发基于区块...

红薯
今天
13
0
CC攻击带来的危害我们该如何防御?

随着网络的发展带给我们很多的便利,但是同时也带给我们一些网站安全问题,网络攻击就是常见的网站安全问题。其中作为站长最常见的就是CC攻击,CC攻击是网络攻击方式的一种,是一种比较常见的...

云漫网络Ruan
今天
12
0
实验分析性专业硕士提纲撰写要点

为什么您需要研究论文的提纲? 首先当您进行研究时,您需要聚集许多信息和想法,研究论文提纲可以较好地组织你的想法, 了解您研究资料的流畅度和程度。确保你写作时不会错过任何重要资料以此...

论文辅导员
今天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部