【EhCache一】EhCache版Hello World

点击打开链接

首先到ehcache官网下载：ehcache官网

下载完后解压。

打开Myeclipse 创建web项目，然后在项目classpath根目录下创建ehchache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    updateCheck="true" monitoring="autodetect"
    dynamicConfig="true">

    <defaultCache
       maxElementsInMemory="20"
       eternal="false"
       overflowToDisk="false"
       timeToIdleSeconds="1800"
       timeToLiveSeconds="1800">
    </defaultCache>

    <cache name="data-cache"
      maxElementsInMemory="20"
      overflowToDisk="false"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      memoryStoreEvictionPolicy="LRU"
      transactionalMode="off"
       >
   <searchable keys="true"/> <!--可以根据Key进行查询，查询的Attribute就是keys-->
    </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

参数含义：

name：Cache的唯一标识，程序中使用这个名字获得缓存实例

maxElementsInMemory：内存中最大缓存对象数 。

overflowToDisk：当overflowToDisk配置为true，当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中。

eternal：Element是否永久有效，一但设置了， timeToIdleSeconds和 timeToLiveSeconds 将不起作用

timeToIdleSeconds: Element在缓存中空闲的最大时间。也就是说，这个时间控制的是一个Element 在一直没有被访问的前提下，这个对象可以在cache中的存活时间。若是0，表示永远存活

timeToLiveSeconds： 设置对象在cache中的最大存活时间，就是 无论对象被访问或是闲置,这个对象在cache中总的存活时间。也就是说， timeToLiveSeconds的值得应该大于等于 timeToIdleSeconds， 若是0，表示永远存活。

memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内 存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）

maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大。 该选项只有在overflowToDisk为true时有效

diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区

EhCache CRUD例子

package com.mayi.ehcache.demo;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.search.Attribute;
import net.sf.ehcache.search.Query;
import net.sf.ehcache.search.Result;
import net.sf.ehcache.search.Results;
import org.junit.Assert;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;
import java.util.Set;

public class EhcacheTest {

    @Test
    public void testCacheManager() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  //列出所有的缓存名称，不包括配置文件中的<defaultCache>
  String[] names = cm.getCacheNames();

  //只有一个名称为data-cache的cache
  Assert.assertEquals(1, names.length);
  Assert.assertEquals(names[0], "data-cache");

  //根据指定名称查找缓存对象
  Cache cache = cm.getCache("data-cache"); //根据缓存名称获取缓存
  Assert.assertNotNull(cache);

  //获取，更新Cache配置的接口
//  CacheConfiguration configuration = cache.getCacheConfiguration();
//  configuration.setTimeToIdleSeconds(3600);

  //缓存在内存中的配置信息，缓存配置动态修改也会体现出来,
  System.out.println(cm.getActiveConfigurationText());

  //清除所有缓存的数据，但是缓存本身仍然存在
//  cm.clearAll();

  //从内存中删除一个缓存以及所有的数据，Cache被销毁
//  cm.removeCache("data-cache");


    }

    @Test
    public void testCache() {
  //只有被有初始化生效的Cache允许改名字
  //cache.setName("data-cache-changed");
    }

    @Test
    public void testAddElementToCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  cache.putIfAbsent(new Element(p1,p1, 1));
  cache.put(new Element(p2,p2, 1));
  cache.putIfAbsent(new Element(p2, p1,1));//只有Key为p2的数据不存在才插入

  //得到的是p2,而不是p1
  Element e = cache.get(p2);
  Assert.assertEquals(p2, e.getObjectValue());

  //把数据从内存刷到DiskStore，从DiskStore刷新到Disk中
  cache.flush();

    }

    @Test
    public void testRemoveElementFromCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  Element e1  = new Element(p1,p1, 1);
  cache.putIfAbsent(e1);
  Element e2 = new Element(p2,p2, 1);
  cache.put(e2);

  cache.remove(p1);
  boolean isSucc = cache.removeElement(e1);
  //e1已经被删除，因此操作返回false
  Assert.assertFalse(isSucc);

  cache.put(e1);

  cache.removeAll();

  Assert.assertEquals(0, cache.getSize());
    }

    @Test
    public void testUpdateElementInCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  Element e1  = new Element(p1,p1, 1);
  cache.putIfAbsent(e1);
  Element e2 = new Element(p2,p2, 1);
  cache.put(e2);

  e2 = new Element(p2, p1, 1);
  cache.replace(e2);

  Assert.assertEquals(p1, e2.getObjectValue());

    }

    @Test
    public void testQueryElementsFromCache() {
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);
  Cache cache = cm.getCache("data-cache");

  //EhCache中的数据类型是Element，它包含Key,Value和一个版本信息
  Element e = new Element(1000, 10000, 1);
  cache.put(e);

  //添加第二个数据
  e = new Element(2000, 20000, 1);
  cache.put(e);

  //缓存中有两条数据
  Assert.assertEquals(2, cache.getSize());

  //通过get方法获得key对应的数据
  e = cache.get(1000);
  Assert.assertEquals(10000, e.getObjectValue());

  //创建查询
  Query q = cache.createQuery();

  //Cache没有配置任何查询属性，这里察看下默认的查询属性有哪些
  //set中包含两个可查询元素：key和value
  Set<Attribute> set = cache.getSearchAttributes();

  //属性是范型类，得到key都应的查询属性对象
  Attribute<Integer> keyAttribute = cache.getSearchAttribute("key"); //根据默认提供的可查询属性key进行查询

  //构造查询条件,这是一个链式写法，一个Query对象可以写多个查询条件
  //创建查找key的值为2000的查询
  q = q.addCriteria(keyAttribute.eq(2000));

  //如果不includeKeys和q.includeValues();,则测试结果集中不包括Keys和Values信息
  q.includeKeys();
  q.includeValues();

  //执行查询
  Results results = q.execute();//执行查询
  Assert.assertNotNull(results);
  Assert.assertEquals(results.size(), 1);

  //列出所有结果
  List<Result> resultList = results.all();
  Result result = resultList.get(0);
  Assert.assertEquals(2000, result.getKey());

  Assert.assertEquals(20000, result.getValue());
    }

}

 
 
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

Person 类

package com.mayi.ehcache.demo;

public class Person {
    private int id;
    private String name;
    private int age;

    public Person(int id, String name, int age) {
  this.id = id;
  this.name = name;
  this.age = age;
    }

    @Override
    public boolean equals(Object o) {
  if (this == o) return true;
  if (o == null || getClass() != o.getClass()) return false;

  Person person = (Person) o;

  if (age != person.age) return false;
  if (id != person.id) return false;
  if (name != null ? !name.equals(person.name) : person.name != null) return false;

  return true;
    }

    @Override
    public int hashCode() {
  int result = id;
  result = 31 * result + (name != null ? name.hashCode() : 0);
  result = 31 * result + age;
  return result;
    }
}

 
 
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

最后运行junit即可

案例下载