Ehcache 緩存組件

Bladexu的文庫 2017-10-24

展開全文

Ehcache介紹

ehcache是一個非常輕量級的緩存實現(xiàn),ehcache 是一個純Java的進程內緩存框架特別高效。

Ehcache學習使用

使用ehcache最核心的一點就在于其ehcache.xml配置文件。
ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www./2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="false"
monitoring="autodetect" dynamicConfig="false" name="talent-default-ehcache">

    <diskStore path="D:/cache/ehcache.txt" />
    <!-- Mandatory Default Cache configuration. These settings will be applied 
        to caches created programmtically using CacheManager.add(String cacheName). 
        通常保留defaultCache的配置 The defaultCache has an implicit name "default" which 
        is a reserved cache name. -->
    <defaultCache maxElementsInMemory="1000000" eternal="false"
        timeToIdleSeconds="1200" timeToLiveSeconds="1200" overflowToDisk="true"
        diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU" />

    <!-- 定義緩存對象-->
    <!-- 商品品牌緩存 根據(jù)品牌id查詢品牌name -->
    <cache name="goodsBrand" maxElementsInMemory="200" eternal="false"
        overflowToDisk="true" diskSpoolBufferSizeMB="200" timeToIdleSeconds="7200"
        timeToLiveSeconds="7200" memoryStoreEvictionPolicy="LRU">
    </cache>

    <!-- 城市名 根據(jù)城市站id查詢城市name -->
    <cache name="cityName" maxElementsInMemory="2000" eternal="false"
        overflowToDisk="true" diskSpoolBufferSizeMB="200" timeToIdleSeconds="7200"
        timeToLiveSeconds="7200" memoryStoreEvictionPolicy="LRU">
    </cache>
</ehcache>
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

緩存對象清除策略:

1、FIFO:first in first out,先進先出策略(不推薦使用)
2、LFU:Less Frequently Used,最少使用原則(清除最少使用的元素對象)緩存的元素有一個hit 屬性,hit 值最小的將會被清出緩存。
3、LRU:Least Recently Used,最近最少使用原則,緩存的元素有一個時間戳,當緩存容量滿了，而又需要騰出地方來緩存新的元素的時候，那么現(xiàn)有緩存元素中時間戳離當前時間最遠的元素將被清出緩存。

1、創(chuàng)建EhcacheManage對象

1)使用默認配置文件(類路徑下的ehcache.xml)

CacheManager manager = CacheManager.create();
1
2

2)使用指定的配置文件

CacheManager cacheManager = CacheManager.create(String configurationFileName);
1
2

3)使用輸入流方式

CacheManager cacheManager = CacheManager.create(InputStream inputStream);
1
2

主要有兩種方式,使用任何一種方式都可以。

2、創(chuàng)建Cache對象

1)獲得配置文件中事先已經(jīng)配置好的Cache緩存對象

Cache cache=cacheManager.getCache(String name);
1
2

2)新建一個Cache并添加到CacheManager里

Cache cache=new Cache(String name,
                 int maxElementsInMemory,
                 MemoryStoreEvictionPolicy memoryStoreEvictionPolicy,
                 boolean overflowToDisk,
                 String diskStorePath,
                 boolean eternal,
                 long timeToLiveSeconds,
                 long timeToIdleSeconds,
                 boolean diskPersistent,
                 long diskExpiryThreadIntervalSeconds,
                 RegisteredEventListeners registeredEventListeners);

一大推相關的配置,推薦在cache.xml配置文件里面配置Cache對象,以便緩存對象管理。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、使用Cache緩存對象

1)添加元素

cache.put(Element element);
Element類似java中的Entry對象,可以去看看Element的源碼結構。
1
2
3

2)獲取元素

Element element=cache.get(Object key);
1
2

3)刪除元素

boolean flag=cache.remove(Object key);
1
2

自定義的工具類（EhCacheUtil）

/**
 * EhCache工具類,主要包含取元素和插入元素。
 * @author xuyi
 *
 */
public class EhCacheUtil {
        private static CacheManager cacheManager;
        private EhCacheUtil() {
        //私有化構造方法
        }

        //靜態(tài)代碼塊,保證singleton。
        static {
        cacheManager = CacheManager.create();
        }

        /**
         * 根據(jù)緩存名字獲得某個緩存
         * @param cacheName
         * @return
         */
        public static Cache getCache(String cacheName) {
        return cacheManager.getCache(cacheName);
        }

        /**
         * 根據(jù)緩存名字,元素的key值,獲得緩存中對應的value值對象。
         * @param cacheName
         * @param key
         * @param isRemoveKey
         * @return
         */
        public static Object getValue(String cacheName, Object key, boolean isRemoveKey) {
        Cache cache = getCache(cacheName);
        Element e = null;
        if (isRemoveKey) {
        e = cache.get(key);
        } else {
        e = cache.getQuiet(key);
        }
        if (e == null) {
        return null;
        }
        return e.getObjectValue();
        }

        /**
         * 根據(jù)緩存名字,元素的key值,獲得緩存中對應的value值對象。
         * @param cacheName
         * @param key
         * @return
         */
        public static Object getValue(String cacheName, Object key) {
        return getValue(cacheName, key, false);
        }

        /**
         * 靜態(tài)的獲取元素，不會產(chǎn)生update.
         * @param cacheName
         * @param key
         * @return
         */
        public static Element getElementByQuite(String cacheName, Object key) {
        Cache cache = getCache(cacheName);
        return cache.getQuiet(key);
        }

        /**
         * 動態(tài)的獲取元素，會產(chǎn)生update.
         * @param cacheName
         * @param key
         * @return
         */
        public static Element getElementByDynic(String cacheName, Object key){
        Cache cache = getCache(cacheName);
        return cache.get(key);
        }

        /**
         * 向某個緩存中添加元素
         * @param cacheName
         * @param key
         * @param value
         */
        public static void put(String cacheName, Object key, Object value) {
        Element element = new Element(key, value);
        getCache(cacheName).put(element);
        }

        /**
         * 移除某個緩存中的元素
         * @param cacheName
         * @param key
         */
        public static void remove(String cacheName, Object key) {
        Cache cache = getCache(cacheName);
        if (cache != null) {
        cache.remove(key);
        }
        }

        /**
         * 判斷某個緩存是否包含某個元素
         * @param cacheName
         * @param key
         * @return
         */
        public static boolean contains(String cacheName, Object key) {
        Cache cache = getCache(cacheName);
        Element e = cache.get(key);
        if (e != null) {
        return true;
        }
        return false;
        }

        @SuppressWarnings("unchecked")
        public static <T> List<T> getKeys(String cacheName, Class<T> t) {
        Cache cache = getCache(cacheName);
        return (List<T>) cache.getKeys();
        }
}
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