思享工具箱

JAVA缓存的实现

摘要：
缓存可以分为两类：首先，通过文件缓存，顾名思义，文件缓存是指将数据存储在磁盘上，无论您是XML格式、序列化文件DAT格式还是其他文件格式；2、 内存缓存，即在类中实现静态映射，并对该映射执行常规添加、删除和查询。以下是一个简单的缓存代码：Java代码packagelhm.hcy.gue.frameset.cache；importjava.util.*；/*** 标题：**De

缓存可分为二大类: 
一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式；  
二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查. 
下面为一个简单的缓存代码 

Java代码 复制代码
  1. package lhm.hcy.guge.frameset.cache;   
  2.   
  3. import java.util.*;   
  4.   
  5. /**  
  6.  * <p>Title: </p>  
  7.  *  
  8.  * <p>Description: 管理缓存</p>  
  9.  * Deep blue 2008-11-28 think  
  10.  * 可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 
  11.  * <p>Copyright: Copyright (c) 2008</p>  
  12.  *  
  13.  * <p>Company: </p>  
  14.  *  
  15.  * @author Deepblue  2008-11-11  
  16.  * @version 1.0  
  17.  */  
  18. public class CacheManager {   
  19.     private static HashMap cacheMap = new HashMap();   
  20.   
  21.     //单实例构造方法   
  22.     private CacheManager() {   
  23.         super();   
  24.     }   
  25.     //获取布尔值的缓存   
  26.     public static boolean getSimpleFlag(String key){   
  27.         try{   
  28.             return (Boolean) cacheMap.get(key);   
  29.         }catch(NullPointerException e){   
  30.             return false;   
  31.         }   
  32.     }   
  33.     public static long getServerStartdt(String key){   
  34.         try {   
  35.             return (Long)cacheMap.get(key);   
  36.         } catch (Exception ex) {   
  37.             return 0;   
  38.         }   
  39.     }   
  40.     //设置布尔值的缓存   
  41.     public synchronized static boolean setSimpleFlag(String key,boolean flag){   
  42.         if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖   
  43.             return false;   
  44.         }else{   
  45.             cacheMap.put(key, flag);   
  46.             return true;   
  47.         }   
  48.     }   
  49.     public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){   
  50.         if (cacheMap.get(key) == null) {   
  51.             cacheMap.put(key,serverbegrundt);   
  52.             return true;   
  53.         }else{   
  54.             return false;   
  55.         }   
  56.     }   
  57.   
  58.   
  59.     //得到缓存。同步静态方法   
  60.     private synchronized static Cache getCache(String key) {   
  61.         return (Cache) cacheMap.get(key);   
  62.     }   
  63.   
  64.     //判断是否存在一个缓存   
  65.     private synchronized static boolean hasCache(String key) {   
  66.         return cacheMap.containsKey(key);   
  67.     }   
  68.   
  69.     //清除所有缓存   
  70.     public synchronized static void clearAll() {   
  71.         cacheMap.clear();   
  72.     }   
  73.   
  74.     //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配   
  75.     public synchronized static void clearAll(String type) {   
  76.         Iterator i = cacheMap.entrySet().iterator();   
  77.         String key;   
  78.         ArrayList<String> arr = new ArrayList<String>();   
  79.         try {   
  80.             while (i.hasNext()) {   
  81.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
  82.                 key = (String) entry.getKey();   
  83.                 if (key.startsWith(type)) { //如果匹配则删除掉   
  84.                     arr.add(key);   
  85.                 }   
  86.             }   
  87.             for (int k = 0; k < arr.size(); k++) {   
  88.                 clearOnly(arr.get(k));   
  89.             }   
  90.         } catch (Exception ex) {   
  91.             ex.printStackTrace();   
  92.         }   
  93.     }   
  94.   
  95.     //清除指定的缓存   
  96.     public synchronized static void clearOnly(String key) {   
  97.         cacheMap.remove(key);   
  98.     }   
  99.   
  100.     //载入缓存   
  101.     public synchronized static void putCache(String key, Cache obj) {   
  102.         cacheMap.put(key, obj);   
  103.     }   
  104.   
  105.     //获取缓存信息   
  106.     public static Cache getCacheInfo(String key) {   
  107.   
  108.         if (hasCache(key)) {   
  109.             Cache cache = getCache(key);   
  110.             if (cacheExpired(cache)) { //调用判断是否终止方法   
  111.                 cache.setExpired(true);   
  112.             }   
  113.             return cache;   
  114.         }else  
  115.             return null;   
  116.     }   
  117.   
  118.     //载入缓存信息   
  119.     public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) {   
  120.         Cache cache = new Cache();   
  121.         cache.setKey(key);   
  122.         cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存   
  123.         cache.setValue(obj);   
  124.         cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE   
  125.         cacheMap.put(key, cache);   
  126.     }   
  127.     //重写载入缓存信息方法   
  128.     public static void putCacheInfo(String key,Cache obj,long dt){   
  129.         Cache cache = new Cache();   
  130.         cache.setKey(key);   
  131.         cache.setTimeOut(dt+System.currentTimeMillis());   
  132.         cache.setValue(obj);   
  133.         cache.setExpired(false);   
  134.         cacheMap.put(key,cache);   
  135.     }   
  136.   
  137.     //判断缓存是否终止   
  138.     public static boolean cacheExpired(Cache cache) {   
  139.         if (null == cache) { //传入的缓存不存在   
  140.             return false;   
  141.         }   
  142.         long nowDt = System.currentTimeMillis(); //系统当前的毫秒数   
  143.         long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数   
  144.         if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE   
  145.             return false;   
  146.         } else { //大于过期时间 即过期   
  147.             return true;   
  148.         }   
  149.     }   
  150.   
  151.     //获取缓存中的大小   
  152.     public static int getCacheSize() {   
  153.         return cacheMap.size();   
  154.     }   
  155.   
  156.     //获取指定的类型的大小   
  157.     public static int getCacheSize(String type) {   
  158.         int k = 0;   
  159.         Iterator i = cacheMap.entrySet().iterator();   
  160.         String key;   
  161.         try {   
  162.             while (i.hasNext()) {   
  163.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
  164.                 key = (String) entry.getKey();   
  165.                 if (key.indexOf(type) != -1) { //如果匹配则删除掉   
  166.                     k++;   
  167.                 }   
  168.             }   
  169.         } catch (Exception ex) {   
  170.             ex.printStackTrace();   
  171.         }   
  172.   
  173.         return k;   
  174.     }   
  175.   
  176.     //获取缓存对象中的所有键值名称   
  177.     public static ArrayList<String> getCacheAllkey() {   
  178.         ArrayList a = new ArrayList();   
  179.         try {   
  180.             Iterator i = cacheMap.entrySet().iterator();   
  181.             while (i.hasNext()) {   
  182.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
  183.                 a.add((String) entry.getKey());   
  184.             }   
  185.         } catch (Exception ex) {} finally {   
  186.             return a;   
  187.         }   
  188.     }   
  189.   
  190.     //获取缓存对象中指定类型 的键值名称   
  191.     public static ArrayList<String> getCacheListkey(String type) {   
  192.         ArrayList a = new ArrayList();   
  193.         String key;   
  194.         try {   
  195.             Iterator i = cacheMap.entrySet().iterator();   
  196.             while (i.hasNext()) {   
  197.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
  198.                 key = (String) entry.getKey();   
  199.                 if (key.indexOf(type) != -1) {   
  200.                     a.add(key);   
  201.                 }   
  202.             }   
  203.         } catch (Exception ex) {} finally {   
  204.             return a;   
  205.         }   
  206.     }   
  207.   
  208. }   
  209.   
  210.   
  211. package lhm.hcy.guge.frameset.cache;   
  212.   
  213. /**  
  214.  * <p>Title: </p>  
  215.  *  
  216.  * <p>Description: 缓存DTO</p>  
  217.  *  
  218.  * <p>Copyright: Copyright (c) 2008</p>  
  219.  *  
  220.  * <p>Company: </p>  
  221.  *  
  222.  * @author Deepblue  2008-11-11  
  223.  * @version 1.0  
  224.  */  
  225. public class Cache {   
  226.         private String key;//缓存ID   
  227.         private Object value;//缓存数据   
  228.         private long timeOut;//更新时间   
  229.         private boolean expired; //是否终止   
  230.         public Cache() {   
  231.                 super();   
  232.         }   
  233.   
  234.         public Cache(String key, Object value, long timeOut, boolean expired) {   
  235.                 this.key = key;   
  236.                 this.value = value;   
  237.                 this.timeOut = timeOut;   
  238.                 this.expired = expired;   
  239.         }   
  240.   
  241.         public String getKey() {   
  242.                 return key;   
  243.         }   
  244.   
  245.         public long getTimeOut() {   
  246.                 return timeOut;   
  247.         }   
  248.   
  249.         public Object getValue() {   
  250.                 return value;   
  251.         }   
  252.   
  253.         public void setKey(String string) {   
  254.                 key = string;   
  255.         }   
  256.   
  257.         public void setTimeOut(long l) {   
  258.                 timeOut = l;   
  259.         }   
  260.   
  261.         public void setValue(Object object) {   
  262.                 value = object;   
  263.         }   
  264.   
  265.         public boolean isExpired() {   
  266.                 return expired;   
  267.         }   
  268.   
  269.         public void setExpired(boolean b) {   
  270.                 expired = b;   
  271.         }   
  272. }   
  273.   
  274. //测试类，   
  275. class Test {   
  276.     public static void main(String[] args) {   
  277.         System.out.println(CacheManager.getSimpleFlag("alksd"));   
  278. //        CacheManager.putCache("abc", new Cache());   
  279. //        CacheManager.putCache("def", new Cache());   
  280. //        CacheManager.putCache("ccc", new Cache());   
  281. //        CacheManager.clearOnly("");   
  282. //        Cache c = new Cache();   
  283. //        for (int i = 0; i < 10; i++) {   
  284. //            CacheManager.putCache("" + i, c);   
  285. //        }   
  286. //        CacheManager.putCache("aaaaaaaa", c);   
  287. //        CacheManager.putCache("abchcy;alskd", c);   
  288. //        CacheManager.putCache("cccccccc", c);   
  289. //        CacheManager.putCache("abcoqiwhcy", c);   
  290. //        System.out.println("删除前的大小："+CacheManager.getCacheSize());   
  291. //        CacheManager.getCacheAllkey();   
  292. //        CacheManager.clearAll("aaaa");   
  293. //        System.out.println("删除后的大小："+CacheManager.getCacheSize());   
  294. //        CacheManager.getCacheAllkey();   
  295.   
  296.   
  297.     }   
  298. }  

 

http://www.javaeye.com/topic/544021


自己写的话，只能用在内存策略中，下面这代码我已经在好几个项目中应用过了，至今为止还未出现不正确的情况。

Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import net.blogjava.frankiegao123.log.slf4j.Log;
import net.blogjava.frankiegao123.log.slf4j.LogFactory;
 
/**
 * <p>System.Config 配置缓存</p>
 *
 * @author frankiegao123
 * 2010-6-10 下午02:48:35
 */
@Component("configCache")
public class ConfigCache implements ConfigService {
 
    private final static Log log = LogFactory.getLog(ConfigCache.class);
 
    /**
     * 更新缓存时记录的时间
     */
    private volatile long time = 0L;
 
    /**
     * 正在更新缓存时的门闩，为 true 时表示当前没有更新缓存，为 true 时表示当前正在更新缓存
     */
    private volatile boolean updateGate = true;
 
    /**
     * 缓存容器
     */
    private Map<String, SysConfig> cache = new ConcurrentHashMap<String, SysConfig>();
 
    private CommonDao commonDao;
 
    @Autowired
    public ConfigCache(CommonDao commonDao) {
        this.commonDao = commonDao;
        log.info("initializing cache...");
        refreshCache();
        time = System.currentTimeMillis();
        log.info("initialized cache finished, cache size: {}, set cache time to current: {}, cache timeout: {}ms", cache.size(), time, ConfigConstant.CACHE_TIMEOUT);
    }
 
    /**
     * <p>根据配置的键名获取配置值</p>
     *
     * @param configKey
     * @return
     * @author frankiegao123
     * 2010-6-10 上午11:18:33
     */
    public SysConfig getSysConfig(String configKey) {
        long current = System.currentTimeMillis();
        if(updateGate && isTimeout(current)) {
            synchronized (this) {
                if(updateGate) {
                    timeoutSynRefresh(current);
                }
            }
        }
        return cache.get(configKey);
    }
 
    /**
     * <p>超时时更新缓存。该方法需要在同步环境中调用</p>
     * @param current
     * @author frankiegao123
     * 2010-6-10 上午11:16:30
     */
    private void timeoutSynRefresh(long current) {
        updateGate = false;
        log.info("refresh cache start..., time out: {}, size: {}, set updateGate to false", (current - time) / 1000.0, cache.size());
        try {
            refreshCache();
            time = current;
            log.info("refresh cache finished, size after update: {}, set cache time to current: {}", cache.size(), String.valueOf(time));
        } catch (Exception e) {
            log.error("refresh cache failed", e);
        } finally {
            updateGate = true;
            log.info("refresh cache finished, set updateGate to true");
        }
    }
 
    /**
     * <p>更新缓存数据</p>
     *
     * @author frankiegao123
     * 2010-6-10 上午11:15:55
     */
    private void refreshCache() {
        List<SysConfig> configs = commonDao.getSysConfigs();
        for(Iterator<SysConfig> i = configs.iterator(); i.hasNext(); ) {
            SysConfig config = i.next();
            cache.put(config.getKey(), config);
        }
        commonDao.clear();
        SysConfig config = cache.get(SysConfig.TEST_KEY);
        if(config == null) {
            log.error("refresh cache, cannot find TEST_KEY");
        } else {
            log.info("refresh cache, find TEST_KEY = [{}]", config.getValue());
        }
    }
 
    /**
     * <p>缓存是否超时</p>
     *
     * @param current
     * @return
     * @author frankiegao123
     * 2010-6-10 上午11:16:12
     */
    private boolean isTimeout(long current) {
        return (current - time >= ConfigConstant.CACHE_TIMEOUT);
    }
 
    Collection<SysConfig> getSysConfigs() {
        return Collections.unmodifiableCollection(cache.values());
    }
 
    int getSize() {
        return cache.size();
    }
 
    long getTime() {
        return time;
    }
 
    boolean isUpdateGate() {
        return updateGate;
    }
 
    void refresh() {
        time = 0L;
        log.info("refresh: reset cache time to 0");
        getSysConfig("none");
        log.info("refresh: refresh cache finished, cache: {0}", String.valueOf(time));
    }
}

import java.util.*;

public class SimpleCacheManager {

    private static SimpleCacheManager instance;
    private static Object monitor = new Object();
    private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>());

    private SimpleCacheManager() {
    }

    public void put(String cacheKey, Object value) {
        cache.put(cacheKey, value);
    }

    public Object get(String cacheKey) {
        return cache.get(cacheKey);
    }

    public void clear(String cacheKey) {
        cache.put(cacheKey, null);
    }

    public void clear() {
        cache.clear();
    }

    public static SimpleCacheManager getInstance() {
        if (instance == null) {
            synchronized (monitor) {
                if (instance == null) {
                    instance = new SimpleCacheManager();
                }
            }
        }
        return instance;
    }

}


标签：#string#缓存 | 浏览：392 | 发布日期：

免责声明：文章转载自《JAVA缓存的实现》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇mysql压缩包安装方式Python股票历史数据的获取下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

C#修改SVG图片显示大小

private void Main() { if (File.Exists(_svgFile)) { SetSvgSize(_svgFile, spnWidth.Value, spnHeight.Value); }...

HBase海量数据存储

HBaseHBase是一个基于HDFS的非关系型数据库（海量数据存储） HBase的特点 1.海量数据存储，HBase中的表可以容纳上百亿行x上百万列的数据。 2.列式存储，HBase中的数据是基于列进行存储的，能够动态的增加和删除列。 3.准实时查询，HBase在海量的数据量下能够接近准实时的查询（百毫秒以内） 4.多版本，HBase中每一列的数据都有多...

审计基础-PHP命令执行

1. 命令执行 1.1 程序执行函数 程序执行函数 这些函数和 执行运算符 是紧密关联的。 因此，当运行在 安全模式 时，你必须考虑 safe_mode_exec_dir指示 exec PHP 457 exec — 执行一个外部程序 exec ( string $command ) : string 返回命令执行结果的最后一行内容，实际不echo出来的话回...

Java 后端微信支付demo

Java 后端微信支付demo 一、导入微信SDK 二、在微信商户平台下载证书放在项目的resources目录下的cert文件夹下（cert文件夹需要自己建） 三、实现微信的WXPayConfig接口 1 packagecom.ieou.demo.common; 2 3 4 importcom.github.wxpay.sdk.WXPayCo...

Java Json 数据下划线与驼峰格式进行相互转换

概述 今天遇见一个需求，需要对json数据进行下划线与驼峰格式之间进行转换，在Fastjson、Jackson、Gson都提供了转换的方式，在这里进行一下列举。 User类： public class User { private String nameInfo; private String ageInfo; public...

Java 音频加水印

先解释一下什么是音频加水印： 音频加水印就是在一段音频中通过混音加入另一段音频，目的是让音频可以公开分享并有效保护原创。 本文主要纪录自己关于给音频加水印的技术调研。 开发语言：Java，开发所处系统环境Mac 使用了开源软件：FFmpeg 4.2.4 FFmpeg官网下载链接：https://ffmpeg.org/download.html#build-...

最新文章

随机推荐

思享工具箱导航