标签：ehcache
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。
非常简单，而且易用。
ehcache 是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，而且是hibernate 默认的缓存provider。ehcache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。
ehcache可以直接使用。也可以和Hibernate对象/关系框架结合使用。还可以做Servlet缓存。
Cache 存储方式 ：内存或磁盘。
主要特征：
1. 快速.
2. 简单.
3. 多种缓存策略
4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题
5. 缓存数据会在虚拟机重启的过程中写入磁盘
6. 可以通过RMI、可插入API等方式进行分布式缓存
7. 具有缓存和缓存管理器的侦听接口
8. 支持多缓存管理器实例，以及一个实例的多个缓存区域
9. 提供Hibernate的缓存实现
10. 等等
①创建ehcache.xml
<?xml version="1.0" encoding="UTF-8"?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="false"> <!-- 设置磁盘持久化的位置 --> <diskStore path="E:/temp" /> <defaultCache maxElementsInMemory="10000" eternal="true" overflowToDisk="true" /> <cache name="kentrasoftCache" maxElementsInMemory="0" maxElementsOnDisk="90000" eternal="false" overflowToDisk="true" diskSpoolBufferSizeMB="2048" timeToIdleSeconds="7200" timeToLiveSeconds="7200" memoryStoreEvictionPolicy="LFU" diskPersistent="true" logging="false" /> <!-- name：Cache的唯一标识 maxElementsInMemory：内存中最大缓存对象数 maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大 eternal：Element是否永久有效，一但设置了，timeout将不起作用 overflowToDisk：配置此属性，当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中 timeToIdleSeconds：设置Element在失效前的允许闲置时间。仅当element不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大 timeToLiveSeconds：设置Element在失效前允许存活时间。最大时间介于创建时间和失效时间之间。仅当element不是永久有效时使用，默认是0.，也就是element存活时间无穷大 diskPersistent：是否缓存虚拟机重启期数据 diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒 diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区 memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用） --> </ehcache>
②引入依赖
<dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.9.1</version> </dependency>
③EhCacheUtil类
package com.kentrasoft.util;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
public class EhCacheUtil {
private static Cache kentrasoftCache;
private static CacheManager manager;
private static EhCacheUtil instance;
static {
// init();
}
public static Cache getKentrasoftCache() {
return kentrasoftCache;
}
public static CacheManager getManager() {
return manager;
}
public static EhCacheUtil init() {
System.setProperty("net.sf.ehcache.enableShutdownHook", "true");
if (instance == null) {
instance = new EhCacheUtil();
manager = CacheManager.create(EhCacheUtil.class.getClassLoader().getResourceAsStream("ehcache/ehcache.xml"));
kentrasoftCache = manager.getCache("kentrasoftCache");
}
return instance;
}
public static EhCacheUtil init(String path) {
System.setProperty("net.sf.ehcache.enableShutdownHook", "true");
if (instance == null) {
instance = new EhCacheUtil();
manager = CacheManager.create(EhCacheUtil.class.getClassLoader().getResourceAsStream(path));
kentrasoftCache = manager.getCache("kentrasoftCache");
}
return instance;
}
private static boolean isNull(Element e) {
return e == null || e.getObjectValue() == null || e.getObjectValue() == null;
}
/**
* 存入
* @param <T>
* @param cache 缓存库
* @param key 键
* @param value 值
*/
public static <T extends Serializable> void put(Cache cache, String key, T value) {
Element e = new Element(key, value);
cache.put(e);
cache.flush();
}
/**
* 存入 并设置元素是否永恒保存
* @param <T>
* @param cache 缓存库
* @param key 键
* @param value 值
*/
public static <T extends Serializable> void put(Cache cache, String key, T value, boolean eternal) {
Element element = new Element(key, value);
element.setEternal(eternal);
cache.put(element);
cache.flush();
}
/**
* 存入
*
* @param <T>
* @param cache 缓存库
* @param key 键
* @param value 值
* @param timeToLiveSeconds 最大存活时间
* @param timeToIdleSeconds 最大访问间隔时间
*/
public static <T extends Serializable> void put(Cache cache, String key, T value, int timeToLiveSeconds,
int timeToIdleSeconds) {
Element element = new Element(key, value);
element.setTimeToLive(timeToLiveSeconds);
element.setTimeToIdle(timeToIdleSeconds);
cache.put(element);
cache.flush();
}
public static Object getCacheElement(Cache cache, String key) {
Element e = cache.get(key);
return e;
}
public static Object get(Cache cache, String key) {
Element e = cache.get(key);
if (e != null) {
return e.getObjectValue();
}
return null;
}
public static void remove(Cache cache, String key) {
cache.remove(key);
}
public static void removeAll(Cache cache, Collection<String> keys) {
cache.removeAll(keys);
}
@SuppressWarnings("unchecked")
public static void addToList(Cache cache, String key, Serializable value) {
Element e = cache.get(key);
if (isNull(e)) {
List<Serializable> list = Collections.synchronizedList(new LinkedList<Serializable>());
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static void addAllToList(Cache cache, String key, Collection<? extends Serializable> value) {
Element e = cache.get(key);
if (isNull(e)) {
List<Serializable> list = Collections.synchronizedList(new LinkedList<Serializable>());
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static void addToHashSet(Cache cache, String key, Serializable value) {
Element e = cache.get(key);
if (isNull(e)) {
Set<Serializable> list = Collections.synchronizedSet(new HashSet<Serializable>());
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static void addAllToHashSet(Cache cache, String key, Collection<? extends Serializable> value) {
Element e = cache.get(key);
if (isNull(e)) {
Set<Serializable> list = Collections.synchronizedSet(new HashSet<Serializable>());
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static void addToArrayList(Cache cache, String key, Serializable value) {
Element e = cache.get(key);
if (isNull(e)) {
List<Serializable> list = Collections.synchronizedList(new ArrayList<Serializable>());
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
list.add(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static void addAllToArrayList(Cache cache, String key, Collection<? extends Serializable> value) {
Element e = cache.get(key);
if (isNull(e)) {
List<Serializable> list = Collections.synchronizedList(new ArrayList<Serializable>());
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
} else {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
list.addAll(value);
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
}
cache.flush();
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> T popFromList(Cache cache, String key, Class<T> T) {
Element e = cache.get(key);
if (e != null) {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
Iterator<Serializable> it = list.iterator();
if (list.size() > 0) {
Serializable obj = it.next();
it.remove();
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return (T) obj;
}
}
return null;
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> List<T> popFromList(Cache cache, String key, int count, Class<T> T) {
Element e = cache.get(key);
if (e != null) {
List<Serializable> list = (List<Serializable>) e.getObjectValue();
if (count < 1) {
List<T> result = (List<T>) new ArrayList<Serializable>(list);
list.clear();
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return result;
}
List<T> result = new ArrayList<T>(count);
Iterator<Serializable> it = list.iterator();
for (int i = 0; i < count && it.hasNext(); i++) {
Serializable obj = it.next();
it.remove();
result.add((T) obj);
}
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return result;
}
return null;
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> T popFromHashSet(Cache cache, String key, Class<T> T) {
Element e = cache.get(key);
if (e != null) {
Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
Iterator<Serializable> it = list.iterator();
if (list.size() > 0) {
Serializable obj = it.next();
it.remove();
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return (T) obj;
}
}
return null;
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> List<T> popFromHashSet(Cache cache, String key, int count, Class<T> T) {
Element e = cache.get(key);
if (e != null) {
Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
if (count < 1) {
List<T> result = (List<T>) new ArrayList<Serializable>(list);
list.clear();
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return result;
}
List<T> result = new ArrayList<T>(count);
Iterator<Serializable> it = list.iterator();
for (int i = 0; i < count && it.hasNext(); i++) {
Serializable obj = it.next();
it.remove();
result.add((T) obj);
}
e = new Element(key, list);
e.setEternal(true);
cache.put(e);
cache.flush();
return result;
}
return null;
}
@SuppressWarnings("unchecked")
public static int getCollectionSize(Cache cache, String key) {
Element e = cache.get(key);
if (e != null) {
Collection<Serializable> list = (Collection<Serializable>) e.getObjectValue();
return list.size();
}
return 0;
}
@SuppressWarnings("rawtypes")
public static List getKeys(Cache cache) {
return cache.getKeys();
}
/**获取缓存名称集合
* @param cache Cache对象
* @param start 开始位置
* @return
*/
public static List<String> getKeys(Cache cache, String start) {
List<?> list = cache.getKeys();
List<String> result = new ArrayList<String>(list.size());
for (Object obj : list) {
if (obj != null && obj.getClass() == String.class) {
String s = (String) obj;
if (s.startsWith(start))
result.add(s);
}
}
return result;
}
}④使用示例：
//tokenId放入缓存中 EhCacheUtil.init(); EhCacheUtil.put(EhCacheUtil.getKentrasoftCache(),"tokenId","18484165"); // 获取令牌 tokenId String tokenId = EhCacheUtil.get(EhCacheUtil.getKentrasoftCache(), "tokenId").toString();
其他相关对ehcache请参考
http://blog.csdn.net/l271640625/article/details/20528573
本文出自 “JianBo” 博客，请务必保留此出处http://jianboli.blog.51cto.com/12075002/1983542
标签：ehcache
原文地址：http://jianboli.blog.51cto.com/12075002/1983542
