ehcache2.8.3入门示例:hello world

一、pom.xml 依赖项

 1 <dependency>
 2             <groupId>net.sf.ehcache</groupId>
 3             <artifactId>ehcache</artifactId>
 4             <version>2.8.3</version>
 5         </dependency>
 6 
 7         <dependency>
 8             <groupId>org.slf4j</groupId>
 9             <artifactId>slf4j-api</artifactId>
10             <version>1.7.7</version>
11         </dependency>

二、ehcache.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 
 3 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
 5     monitoring="autodetect" dynamicConfig="true">
 6 
 7 
 8     <diskStore path="java.io.tmpdir" />
 9 
10     <defaultCache maxEntriesLocalHeap="10000" eternal="false"
11         timeToIdleSeconds="120" timeToLiveSeconds="120" diskSpoolBufferSizeMB="30"
12         maxEntriesLocalDisk="10000000" diskExpiryThreadIntervalSeconds="120"
13         memoryStoreEvictionPolicy="LRU">
14         <persistence strategy="localTempSwap" />
15     </defaultCache>
16 
17     <cache name="sampleCache1" maxEntriesLocalHeap="10000"
18         maxEntriesLocalDisk="1000" eternal="false" diskSpoolBufferSizeMB="20"
19         timeToIdleSeconds="300" timeToLiveSeconds="600"
20         memoryStoreEvictionPolicy="LFU" transactionalMode="off">
21         <persistence strategy="localTempSwap" />
22     </cache>
23 
24     <cache name="sampleCache2" maxEntriesLocalHeap="1000" eternal="true"
25         memoryStoreEvictionPolicy="FIFO" />
26 
27 </ehcache>

三、示例代码

 1 package cnblogs.ehcache;
 2 
 3 import net.sf.ehcache.Cache;
 4 import net.sf.ehcache.CacheManager;
 5 import net.sf.ehcache.Element;
 6 
 7 public class App {
 8     public static void main(String[] args) throws InterruptedException {
 9         CacheManager manager = CacheManager.create();
10 
11         // 取出所有的cacheName
12         String names[] = manager.getCacheNames();
13         System.out.println("----all cache names----");
14         for (int i = 0; i < names.length; i++) {
15             System.out.println(names[i]);
16         }
17 
18         System.out.println("----------------------");
19         // 得到一个cache对象
20         Cache cache1 = manager.getCache(names[0]);
21 
22         // 向cache1对象里添加缓存
23         cache1.put(new Element("key1", "values1"));
24         Element element = cache1.get("key1");
25 
26         // 读取缓存
27         System.out.println("key1 \t= " + element.getObjectValue());
28 
29         // 手动创建一个cache(ehcache里必须有defaultCache存在,"test"可以换成任何值)
30         Cache cache2 = new Cache("test", 1, true, false, 2, 3);
31         manager.addCache(cache2);
32 
33         cache2.put(new Element("jimmy", "菩提树下的杨过"));
34 
35         // 故意停1.5秒,以验证是否过期
36         Thread.sleep(1500);
37 
38         Element eleJimmy = cache2.get("jimmy");
39 
40         //1.5s < 2s 不会过期
41         if (eleJimmy != null) {
42             System.out.println("jimmy \t= " + eleJimmy.getObjectValue());
43         }
44 
45         //再等上0.5s, 总时长:1.5 + 0.5 >= min(2,3),过期
46         Thread.sleep(500);
47 
48         eleJimmy = cache2.get("jimmy");
49 
50         if (eleJimmy != null) {
51             System.out.println("jimmy \t= " + eleJimmy.getObjectValue());
52         }
53 
54         // 取出一个不存在的缓存项
55         System.out.println("fake \t= " + cache2.get("fake"));
56 
57         manager.shutdown();
58     }
59 
60 }

运行结果:

----all cache names---- sampleCache2 sampleCache1 ---------------------- key1     = values1 jimmy     = 菩提树下的杨过 fake     = null

四、关于timeToLiveSeconds、timeToIdleSeconds

这二个参数直接影响缓存项的过期时间,看文档说明基本上没啥用,直接看net.sf.ehcache.Element源码的片段:

  1 /**
  2      * The amount of time for the element to live, in seconds. 0 indicates unlimited.
  3      */
  4     private volatile int timeToLive = Integer.MIN_VALUE;
  5 
  6     /**
  7      * The amount of time for the element to idle, in seconds. 0 indicates unlimited.
  8      */
  9     private volatile int timeToIdle = Integer.MIN_VALUE;
 10     
 11     
 12     /**
 13      * Sets time to Live
 14      * <P/>
 15      * Value must be a positive integer, 0 means infinite time to live.
 16      * <P/>
 17      * If calling this method with 0 as the parameter, consider using {@link #setEternal(boolean)}
 18      * or make sure you also explicitly call {@link #setTimeToIdle(int)}.
 19      *
 20      * @param timeToLiveSeconds the number of seconds to live
 21      */
 22     public void setTimeToLive(final int timeToLiveSeconds) {
 23         if (timeToLiveSeconds < 0) {
 24             throw new IllegalArgumentException("timeToLive can't be negative");
 25         }
 26         this.cacheDefaultLifespan = false;
 27         this.timeToLive = timeToLiveSeconds;
 28     }
 29 
 30     /**
 31      * Sets time to idle
 32      * <P/>
 33      * Value must be a positive integer, 0 means infinite time to idle.
 34      * <P/>
 35      * If calling this method with 0 as the parameter, consider using {@link #setEternal(boolean)}
 36      * or make sure you also explicitly call {@link #setTimeToLive(int)}.
 37      *
 38      * @param timeToIdleSeconds the number of seconds to idle
 39      */
 40     public void setTimeToIdle(final int timeToIdleSeconds) {
 41         if (timeToIdleSeconds < 0) {
 42             throw new IllegalArgumentException("timeToIdle can't be negative");
 43         }
 44         this.cacheDefaultLifespan = false;
 45         this.timeToIdle = timeToIdleSeconds;
 46     }
 47     
 48     
 49 
 50     /**
 51      * An element is expired if the expiration time as given by {@link #getExpirationTime()} is in the past.
 52      *
 53      * @return true if the Element is expired, otherwise false. If no lifespan has been set for the Element it is
 54      *         considered not able to expire.
 55      * @see #getExpirationTime()
 56      */
 57     public boolean isExpired() {
 58         if (!isLifespanSet() || isEternal()) {
 59             return false;
 60         }
 61 
 62         long now = System.currentTimeMillis();
 63         long expirationTime = getExpirationTime();
 64 
 65         return now > expirationTime;
 66     }
 67     
 68     
 69     /**
 70      * An element is expired if the expiration time as given by {@link #getExpirationTime()} is in the past.
 71      * <p>
 72      * This method in addition propogates the default TTI/TTL values of the supplied cache into this element.
 73      *
 74      * @param config config to take default parameters from
 75      * @return true if the Element is expired, otherwise false. If no lifespan has been set for the Element it is
 76      *         considered not able to expire.
 77      * @see #getExpirationTime()
 78      */
 79     public boolean isExpired(CacheConfiguration config) {
 80         if (cacheDefaultLifespan) {
 81             if (config.isEternal()) {
 82                 timeToIdle = 0;
 83                 timeToLive = 0;
 84             } else {
 85                 timeToIdle = TimeUtil.convertTimeToInt(config.getTimeToIdleSeconds());
 86                 timeToLive = TimeUtil.convertTimeToInt(config.getTimeToLiveSeconds());
 87             }
 88         }
 89         return isExpired();
 90     }
 91 
 92     /**
 93      * Returns the expiration time based on time to live. If this element also has a time to idle setting, the expiry
 94      * time will vary depending on whether the element is accessed.
 95      *
 96      * @return the time to expiration
 97      */
 98     public long getExpirationTime() {
 99         if (!isLifespanSet() || isEternal()) {
100             return Long.MAX_VALUE;
101         }
102 
103         long expirationTime = 0;
104         long ttlExpiry = creationTime + TimeUtil.toMillis(getTimeToLive());
105 
106         long mostRecentTime = Math.max(creationTime, lastAccessTime);
107         long ttiExpiry = mostRecentTime + TimeUtil.toMillis(getTimeToIdle());
108 
109         if (getTimeToLive() != 0 && (getTimeToIdle() == 0 || lastAccessTime == 0)) {
110             expirationTime = ttlExpiry;
111         } else if (getTimeToLive() == 0) {
112             expirationTime = ttiExpiry;
113         } else {
114             expirationTime = Math.min(ttlExpiry, ttiExpiry);
115         }
116         return expirationTime;
117     }
118 
119     /**
120      * @return true if the element is eternal
121      */
122     public boolean isEternal() {
123         return (0 == timeToIdle) && (0 == timeToLive);
124     }
125     
126     
127     /**
128      * Sets whether the element is eternal.
129      *
130      * @param eternal
131      */
132     public void setEternal(final boolean eternal) {
133         if (eternal) {
134             this.cacheDefaultLifespan = false;
135             this.timeToIdle = 0;
136             this.timeToLive = 0;
137         } else if (isEternal()) {
138             this.cacheDefaultLifespan = false;
139             this.timeToIdle = Integer.MIN_VALUE;
140             this.timeToLive = Integer.MIN_VALUE;
141         }
142     }
143 
144     /**
145      * Whether any combination of eternal, TTL or TTI has been set.
146      *
147      * @return true if set.
148      */
149     public boolean isLifespanSet() {
150         return this.timeToIdle != Integer.MIN_VALUE || this.timeToLive != Integer.MIN_VALUE;
151     }
152 
153     /**
154      * @return the time to live, in seconds
155      */
156     public int getTimeToLive() {
157         if (Integer.MIN_VALUE == timeToLive) {
158             return 0;
159         } else {
160             return timeToLive;
161         }
162     }
163 
164     /**
165      * @return the time to idle, in seconds
166      */
167     public int getTimeToIdle() {
168         if (Integer.MIN_VALUE == timeToIdle) {
169             return 0;
170         } else {
171             return timeToIdle;
172         }
173     }
174     
175     
176     /**
177      * Set the default parameters of this element - those from its enclosing cache.
178      * @param tti TTI in seconds
179      * @param ttl TTL in seconds
180      * @param eternal <code>true</code> if the element is eternal.
181      */
182     protected void setLifespanDefaults(int tti, int ttl, boolean eternal) {
183         if (eternal) {
184             this.timeToIdle = 0;
185             this.timeToLive = 0;
186         } else if (isEternal()) {
187             this.timeToIdle = Integer.MIN_VALUE;
188             this.timeToLive = Integer.MIN_VALUE;
189         } else {
190             timeToIdle = tti;
191             timeToLive = ttl;
192         }
193     }

结论:

a) timeToIdleSeconds(空闲时间)、timeToLiveSeconds(生存时间)都设置为0时,表示不过期

b) 如果只有timeToLiveSeconds设置>0的值,则Element的过期时间为 timeToLiveSeconds

c) 如果只有timeToIdleSeconds设置>0的值,则Element的过期时间为 (上次访问时间+timeToIdleSeconds),说得更通俗点,上次get过了,现在又想get,若二次get的时间间隔>timeToIdleSeconds,则过期(即:最后一次get出来为null)

d) 如果timeToLiveSeconds、timeToIdleSeconds都有>0的值,则最终过期时间为 b),c)规则综合起来,取二者的最小值

测试1:

 1     @Test
 2     public void testTimeToIdleSeconds() throws InterruptedException {
 3         CacheManager manager = CacheManager.create();
 4 
 5         Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
 6         manager.addCache(myCache);
 7 
 8         String key = "A";
 9 
10         System.out.println("-------------------------");
11         Element elementPut = new Element(key, "Some Value", 2, 0); // timeToIdleSeconds为2秒
12 
13         myCache.put(elementPut);// 放入缓存
14         System.out.println(myCache.get(key));// 取出显示
15 
16         Thread.sleep(1500);// 停1.5秒
17         System.out.println(myCache.get(key));// 再次取出
18 
19         Thread.sleep(1500);// 停1.5秒
20         System.out.println(myCache.get(key));// 虽然总时间已达3秒,但刚刚被访问过了,所以又可以再"活"2秒,仍然有效
21 
22         Thread.sleep(2500);// 停2.5秒
23         System.out.println(myCache.get(key));// 距离上次访问已过2.5s,已经>2s,过期
24 
25     }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898361782, LastAccessTime = 1407898361787 ] [ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898361782, LastAccessTime = 1407898363287 ] [ key = A, value=Some Value, version=1, hitCount=3, CreationTime = 1407898361782, LastAccessTime = 1407898364787 ] null

测试2:

 1     @Test
 2     public void testTimeToLiveSeconds() throws InterruptedException {
 3         CacheManager manager = CacheManager.create();
 4 
 5         Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
 6         manager.addCache(myCache);
 7 
 8         String key = "A";
 9 
10         System.out.println("-------------------------");
11         Element elementPut = new Element(key, "Some Value", 0, 2); // timeToLiveSeconds为2秒
12 
13         myCache.put(elementPut);// 放入缓存
14         System.out.println(myCache.get(key));// 取出显示
15 
16         Thread.sleep(1500);// 停1.5秒
17         System.out.println(myCache.get(key));// 再次取出(1.5s<2s,还"活"着)
18 
19         Thread.sleep(1500);// 停1.5秒
20         System.out.println(myCache.get(key));// 总时间已达3s,>2s,已过期)
21 
22     }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898423291, LastAccessTime = 1407898423296 ] [ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898423291, LastAccessTime = 1407898424797 ] null

测试3:

 1 @Test
 2     public void testTimeToIdleSecondsAndTimeToLiveSeconds()
 3             throws InterruptedException {
 4         CacheManager manager = CacheManager.create();
 5 
 6         Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
 7         manager.addCache(myCache);
 8 
 9         String key = "A";
10 
11         System.out.println("-------------------------");
12         Element elementPut = new Element(key, "Some Value", 2, 5); // timeToIdleSeconds为2秒,timeToLiveSeconds为3秒
13 
14         myCache.put(elementPut);// 放入缓存
15         System.out.println(myCache.get(key));// 取出显示
16 
17         Thread.sleep(1600);// 停1.6秒
18         System.out.println(myCache.get(key));// 再次取出(1.6s < min(2 ,5),还"活"着)
19 
20         Thread.sleep(1600);// 停1.6秒
21         System.out.println(myCache.get(key));// 总时间已达3.2s,< min((1.6+2) ,5),还"活"着)
22         
23         Thread.sleep(1600);// 停1.6秒
24         System.out.println(myCache.get(key));// 总时间已达4.8s,< min((3.2+2) ,5),还"活"着)
25         
26         Thread.sleep(500);// 停0.5秒
27         System.out.println(myCache.get(key));// 总时间已达4.8+0.5=5.3s,> min((4.8+2) ,5),过期)
28 
29     }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898480892, LastAccessTime = 1407898480897 ] [ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898480892, LastAccessTime = 1407898482499 ] [ key = A, value=Some Value, version=1, hitCount=3, CreationTime = 1407898480892, LastAccessTime = 1407898484099 ] [ key = A, value=Some Value, version=1, hitCount=4, CreationTime = 1407898480892, LastAccessTime = 1407898485699 ] null

关于这二个参数的设置,个人建议是:

a) 如果缓存的数据本身不存在更新(比如:一些几乎从来不动的基础数据),只设置timeToIdleSeconds,这样的好处是,如果缓存项一直有人在访问,就永远不会过期,反之,如果没人用,空闲一段时间后,会自动过期,释放资源

b) 如果缓存的数据本身存在定期的更新问题(比如:天气预报之类每隔几小时,db中会更新的数据),可同时设置二个参数,timeToLiveSeconds的值应该要小于db中的更新周期,这样db中的数据变化后,过一段时间就会更新到缓存中

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏好好学java的技术栈

Java11震撼发布了,我们该怎么办?

Java11已经发布了,我们今天聊聊大家还停留在哪个版本呢?大家对于新版本的迅速的发布有什么想说的呢?

2072
来自专栏大内老A

ASP.NET MVC Model元数据及其定制: 初识Model元数据

Contronoller激活之后,ASP.NET MVC会根据当前请求上下文得到目标Action的名称,然后解析出对应的方法并执行之。在整个Action方法的执...

3339
来自专栏码匠的流水账

聊聊storm trident的coordinator

storm-1.2.2/storm-core/src/jvm/org/apache/storm/trident/topology/MasterBatchCoor...

1374
来自专栏蓝天

sed 学习笔记(转)

声明:这些代码只是为了学习和理解sed命令而为之,并不代表问题的唯一解或最佳解,希望各位拍砖

842
来自专栏君赏技术博客

Object-C中的黑魔法

在Swift中存在Option类型,也就是使用?和!声明的变量。但是OC里面没有这个特征,因为在XCODE6.3之后出现新的关键词定义用于OC转SWIFT时候可...

1881
来自专栏北京马哥教育

hiphop原理分析1

Hiphop是Facebook开发一款PHP二进制化的一个工具,最开始是由php转为C++,但是后来发现编译为c++的话,许多的时间会花费在编译代码上面,调试不...

3097
来自专栏漫漫深度学习路

pytorch学习笔记(十四): DataLoader源码阅读

pytorch 数据加载部分的 接口可以说是现存 深度学习框架中设计的最好的, 给了我们足够的灵活性。本博文就对 pytorch 的多线程加载 模块(Data...

2.1K9
来自专栏机器人网

只会G代码不会宏,就别说你是数控师傅

一、变量 普通加工程序直接用数值指定G代码和移动距离;例如,GO1和X100.0。使用用户宏程序时,数值可以直接指定或用变量指定。当用变量时,变量值可用程序或用...

2874
来自专栏我是攻城师

理解Java8并发工具类ConcurrentHashMap的实现

前面的文章已经分析过List和Queue相关的接口与并发实现类,本篇我们来分析一下非常Java里面非常重要的一个数据结构HashMap。(注意Set类型在这里我...

2682
来自专栏夏时

PHP 常用函数大全

6002

扫码关注云+社区

领取腾讯云代金券