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
转载于:https://blog.51cto.com/jianboli/1983542