EhCache版Hello World

本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍

环境准备

1.新建Maven项目

2 .添加EhCache的Maven依赖

<dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.8.3</version>
        </dependency>

3. 添加仓库，获得EhCache源代码

<repositories>
        <repository>
            <id>jboss-maven2-release-repository</id>
            <url>https://repository.jboss.org/nexus/content/groups/developer/ </url>
        </repository>
    </repositories>

4. 创建EhCache配置文件

在项目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>

参数含义：

• 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.tom;


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;

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;
    }
}

public class EhcacheTest {

    @Test
    public void testCacheManager() {
	//加载EhCache配置文件
	InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache-test1.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-test1.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-test1.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-test1.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-test1.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());
    }

}

http://www.tuicool.com/articles/u2MRZb