import entity.Dog;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class CacheTest {
	public static void main(String[] args) {
		// 1. 创建缓存管理器
		CacheManager cacheManager = CacheManager.create("./src/main/resources/ehcache.xml");
		
		// 2. 获取缓存对象
		Cache cache = cacheManager.getCache("HelloWorldCache");
		
		// 3. 创建元素
		Element element = new Element("key1", "value1");
		
		// 4. 将元素添加到缓存
		cache.put(element);
		
		// 5. 获取缓存
		Element value = cache.get("key1");
		System.out.println("value: " + value);
		System.out.println(value.getObjectValue());
		
		// 6. 删除元素
		cache.remove("key1");
		
		Dog dog = new Dog("xiaohei", "black", 2);
		Element element2 = new Element("dog", dog);
		cache.put(element2);
		Element value2 = cache.get("dog");
		System.out.println("value2: "  + value2);
		Dog dog2 = (Dog) value2.getObjectValue();
		System.out.println(dog2);
		
		System.out.println(cache.getSize());
		
		// 7. 刷新缓存
		cache.flush();
		
		// 8. 关闭缓存管理器
		cacheManager.shutdown();

	}
}

public class Dog {
	private String name;
	private String color;
	private int age;
	
	public Dog() {
	}
	
	public Dog(String name, String color, int age) {
		super();
		this.name = name;
		this.color = color;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Dog [name=" + name + ", color=" + color + ", age=" + age + "]";
	}
}

Cache cache = manager.getCache("mycache"); 
CacheConfiguration config = cache.getCacheConfiguration(); 
config.setTimeToIdleSeconds(60); 
config.setTimeToLiveSeconds(120); 
config.setmaxEntriesLocalHeap(10000); 
config.setmaxEntriesLocalDisk(1000000);

// 可以自己创建一个Cache对象添加到CacheManager中
public void addCache(Cache cache);
public synchronized void removeCache(String cacheName);

public static CacheManager create();
public static CacheManager create(String configurationFileName);
public static CacheManager create(InputStream inputStream);
public static CacheManager create(URL configurationFileURL);

public static CacheManager newInstance();

// CacheManager.create() == CacheManager.create("./src/main/resources/ehcache.xml")
// 使用Ehcache默认配置新建一个CacheManager实例
CacheManager cacheManager = CacheManager.create();
cacheManager = CacheManager.newInstance();

cacheManager = CacheManager.newInstance("./src/main/resources/ehcache.xml");

InputStream inputStream = new FileInputStream(new File("./src/main/resources/ehcache.xml"));
cacheManager = CacheManager.newInstance(inputStream);

String[] cacheNames = cacheManager.getCacheNames();  // [HelloWorldCache]

public interface EhcacheService { // 测试失效情况，有效期为5秒 public String getTimestamp(String param); public String getDataFromDB(String key); public void removeDataAtDB(String key); public String refreshData(String key); public User findById(String userId); public boolean isReserved(String userId); public void removeUser(String userId); public void removeAllUser(); } 

import org.springframework.cache.annotation.CacheEvict; import org.springframework.cache.annotation.CachePut; import org.springframework.cache.annotation.Cacheable; import org.springframework.stereotype.Service; @Service public class EhcacheServiceImpl implements EhcacheService{ // value的值和ehcache.xml中的配置保持一致 @Cacheable(value="HelloWorldCache", key="#param") public String getTimestamp(String param) { Long timestamp = System.currentTimeMillis(); return timestamp.toString(); } @Cacheable(value="HelloWorldCache", key="#key") public String getDataFromDB(String key) { System.out.println("从数据库中获取数据..."); return key + ":" + String.valueOf(Math.round(Math.random()*1000000)); } @CacheEvict(value="HelloWorldCache", key="#key") public void removeDataAtDB(String key) { System.out.println("从数据库中删除数据"); } @CachePut(value="HelloWorldCache", key="#key") public String refreshData(String key) { System.out.println("模拟从数据库中加载数据"); return key + "::" + String.valueOf(Math.round(Math.random()*1000000)); } // ------------------------------------------------------------------------ @Cacheable(value="UserCache", key="'user:' + #userId") public User findById(String userId) { System.out.println("模拟从数据库中查询数据"); return new User(1, "mengdee"); } @Cacheable(value="UserCache", condition="#userId.length()<12") public boolean isReserved(String userId) { System.out.println("UserCache:"+userId); return false; } //清除掉UserCache中某个指定key的缓存 @CacheEvict(value="UserCache",key="'user:' + #userId") public void removeUser(String userId) { System.out.println("UserCache remove:"+ userId); } //allEntries：true表示清除value中的全部缓存，默认为false //清除掉UserCache中全部的缓存 @CacheEvict(value="UserCache", allEntries=true) public void removeAllUser() { System.out.println("UserCache delete all"); } }

public class User { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public User() { } public User(int id, String name) { super(); this.id = id; this.name = name; } @Override public String toString() { return "User [id=" + id + ", name=" + name + "]"; } } 

// 将缓存保存到名称为UserCache中，键为"user:"字符串加上userId值，如 'user:1' @Cacheable(value="UserCache", key="'user:' + #userId") public User findById(String userId) { return (User) new User("1", "mengdee"); } // 将缓存保存进UserCache中，并当参数userId的长度小于12时才保存进缓存，默认使用参数值及类型作为缓存的key // 保存缓存需要指定key，value， value的数据类型，不指定key默认和参数名一样如："1" @Cacheable(value="UserCache", condition="#userId.length() < 12") public boolean isReserved(String userId) { System.out.println("UserCache:"+userId); return false; }　　

//清除掉UserCache中某个指定key的缓存 @CacheEvict(value="UserCache",key="'user:' + #userId") public void removeUser(User user) { System.out.println("UserCache"+user.getUserId()); } //清除掉UserCache中全部的缓存 @CacheEvict(value="UserCache", allEntries=true) public final void setReservedUsers(String[] reservedUsers) { System.out.println("UserCache deleteall"); } 

import org.junit.runner.RunWith; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @ContextConfiguration(locations = {"classpath:spring-base.xml","classpath:spring-ehcache.xml"}) @RunWith(SpringJUnit4ClassRunner.class) public class SpringTestCase extends AbstractJUnit4SpringContextTests{ } 

import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import com.gdut.ehcache.EhcacheService; public class EhcacheServiceTest extends SpringTestCase{ @Autowired //@Autowired 是通过 byType 的方式去注入的， 使用该注解，要求接口只能有一个实现类。 private EhcacheService ehcacheService; // 有效时间是5秒，第一次和第二次获取的值是一样的，因第三次是5秒之后所以会获取新的值 @Test public void testTimestamp() throws InterruptedException{ System.out.println("第一次调用：" + ehcacheService.getTimestamp("param")); Thread.sleep(2000); System.out.println("2秒之后调用：" + ehcacheService.getTimestamp("param")); Thread.sleep(4000); System.out.println("再过4秒之后调用：" + ehcacheService.getTimestamp("param")); } @Test public void testCache(){ String key = "zhangsan"; String value = ehcacheService.getDataFromDB(key); // 从数据库中获取数据... ehcacheService.getDataFromDB(key); // 从缓存中获取数据，所以不执行该方法体 ehcacheService.removeDataAtDB(key); // 从数据库中删除数据 ehcacheService.getDataFromDB(key); // 从数据库中获取数据...（缓存数据删除了，所以要重新获取，执行方法体） } @Test public void testPut(){ String key = "mengdee"; ehcacheService.refreshData(key); // 模拟从数据库中加载数据 String data = ehcacheService.getDataFromDB(key); System.out.println("data:" + data); // data:mengdee::103385 ehcacheService.refreshData(key); // 模拟从数据库中加载数据 String data2 = ehcacheService.getDataFromDB(key); System.out.println("data2:" + data2); // data2:mengdee::180538 } @Test public void testFindById(){ ehcacheService.findById("2"); // 模拟从数据库中查询数据 ehcacheService.findById("2"); } @Test public void testIsReserved(){ ehcacheService.isReserved("123"); ehcacheService.isReserved("123"); } @Test public void testRemoveUser(){ // 线添加到缓存 ehcacheService.findById("1"); // 再删除 ehcacheService.removeUser("1"); // 如果不存在会执行方法体 ehcacheService.findById("1"); } @Test public void testRemoveAllUser(){ ehcacheService.findById("1"); ehcacheService.findById("2"); ehcacheService.removeAllUser(); ehcacheService.findById("1"); ehcacheService.findById("2"); // 模拟从数据库中查询数据 // 模拟从数据库中查询数据 // UserCache delete all // 模拟从数据库中查询数据 // 模拟从数据库中查询数据 } }