EHCache工具类

EHCache是一款优秀的缓存框架，关于EHCache的介绍网上已经有很多了，这里分享一份EHCache在实际项目中的使用例子：

package com.avic.smartb.utils;

/**
*

• @className:EHCacheConfig.java

*/

public class EHCacheConfig {

/**
 * 元素最大数量
 */

public static int MAXELEMENTSINMEMORY = 50000;

/**
 * 
 * 是否把溢出数据持久化到硬盘
 */

public static boolean OVERFLOWTODISK = true;

/**
 * 
 * 是否会死亡
 */

public static boolean ETERNAL = false;

/**
 * 
 * 缓存的间歇时间
 */

public static int TIMETOIDLESECONDS = 600;

/**
 * 
 * 存活时间(默认一天)
 */

public static int TIMETOlIVESECONDS = 86400;

/**
 * 
 * 需要持久化到硬盘否
 */

public static boolean DISKPERSISTENT = false;

/**
 * 
 * 内存存取策略
 */

public static String MEMORYSTOREEVICTIONPOLICY = "LFU";

}

package com.avic.smartb.utils;

import java.util.List;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;

import org.apache.commons.lang.StringUtils;

/**

• ehcache工具类
  */

public class EHCacheUtil {
private static CacheManager cacheManager = null;
private static Cache cache = null;

static{
	EHCacheUtil.initCacheManager();
	EHCacheUtil.initCache("cache");
}
/**
 * 
 * 初始化缓存管理容器
 */
public static CacheManager initCacheManager() {
	try {
		if (cacheManager == null)
			cacheManager = CacheManager.getInstance();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return cacheManager;
}

/**
 * 
 * 初始化缓存管理容器
 * 
 * @param path
 *            ehcache.xml存放的路徑
 */
public static CacheManager initCacheManager(String path) {
	try {
		if (cacheManager == null) {
			cacheManager = CacheManager.getInstance().create(path);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	return cacheManager;
}

/**
 * 初始化cache
 */

public static Cache initCache(String cacheName) {
	checkCacheManager();
	if (null == cacheManager.getCache(cacheName)) {
		cacheManager.addCache(cacheName);
	}
	cache = cacheManager.getCache(cacheName);
	return cache;
}

/**
 * 
 * 添加缓存
 * 
 * @param key
 *            关键字
 * @param value
 *            值
 */
public static void put(Object key, Object value) {
	checkCache();
	// 创建Element,然后放入Cache对象中
	Element element = new Element(key, value);
	cache.put(element);
}

/**
 * 获取cache
 * 
 * @param key
 *            关键字
 * @return
 */
public static Object get(Object key) {
	checkCache();
	Element element = cache.get(key);
	if (null == element) {
		return null;
	}
	return element.getObjectValue();
}

/**
 * 初始化缓存
 * 
 * @param cacheName
 *            缓存名称
 * @param maxElementsInMemory
 *            元素最大数量
 * @param overflowToDisk
 *            是否持久化到硬盘
 * @param eternal
 *            是否会死亡
 * @param timeToLiveSeconds
 *            缓存存活时间
 * @param timeToIdleSeconds
 *            缓存的间隔时间
 * @return 缓存
 * @throws Exception
 */
public static Cache initCache(String cacheName, int maxElementsInMemory, boolean overflowToDisk, boolean eternal,
		long timeToLiveSeconds, long timeToIdleSeconds) throws Exception {
	try {
		CacheManager singletonManager = CacheManager.create();
		Cache myCache = singletonManager.getCache(cacheName);
		if (myCache != null) {
			CacheConfiguration config = cache.getCacheConfiguration();
			config.setTimeToLiveSeconds(timeToLiveSeconds);
			config.setMaxElementsInMemory(maxElementsInMemory);
			config.setOverflowToDisk(overflowToDisk);
			config.setEternal(eternal);
			config.setTimeToIdleSeconds(timeToIdleSeconds);
		}
		if (myCache == null) {
			Cache memoryOnlyCache = new Cache(cacheName, maxElementsInMemory, overflowToDisk, eternal, timeToLiveSeconds,
					timeToIdleSeconds);
			singletonManager.addCache(memoryOnlyCache);
			myCache = singletonManager.getCache(cacheName);
		}
		return myCache;
	} catch (Exception e) {
		throw new Exception("init cache " + cacheName + " failed!!!");
	}
}

/**
 * 初始化cache
 * 
 * @param cacheName
 *            cache的名字
 * @param timeToLiveSeconds
 *            有效时间
 * @return cache 缓存
 * @throws Exception
 */
public static Cache initCache(String cacheName, long timeToLiveSeconds) throws Exception {
	return EHCacheUtil.initCache(cacheName, EHCacheConfig.MAXELEMENTSINMEMORY, EHCacheConfig.OVERFLOWTODISK,
			EHCacheConfig.ETERNAL, timeToLiveSeconds, EHCacheConfig.TIMETOIDLESECONDS);
}

/**
 * 初始化Cache
 * 
 * @param cacheName
 *            cache容器名
 * @return cache容器
 * @throws Exception
 */
public static Cache initMyCache(String cacheName) throws Exception {
	return EHCacheUtil.initCache(cacheName, EHCacheConfig.TIMETOlIVESECONDS);
}

/**
 * 修改缓存容器配置
 * 
 * @param cacheName
 *            缓存名
 * @param timeToLiveSeconds
 *            有效时间
 * @param maxElementsInMemory
 *            最大数量
 * @throws Exception
 */

public static boolean modifyCache(String cacheName, long timeToLiveSeconds, int maxElementsInMemory) throws Exception {
	try {
		if (StringUtils.isNotBlank(cacheName) && timeToLiveSeconds != 0L && maxElementsInMemory != 0) {
			CacheManager myManager = CacheManager.create();
			Cache myCache = myManager.getCache(cacheName);
			CacheConfiguration config = myCache.getCacheConfiguration();
			config.setTimeToLiveSeconds(timeToLiveSeconds);
			config.setMaxElementsInMemory(maxElementsInMemory);
			return true;
		} else {
			return false;
		}
	} catch (Exception e) {
		throw new Exception("modify cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 向指定容器中设置值
 * 
 * @param vesselName
 *            容器名
 * 
 * @param key
 *            键
 * 
 * @param value
 *            值
 * 
 * @return 返回真
 * 
 * @throws Exception
 *             异常
 */

public static boolean setValue(String cacheName, String key, Object value) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		Cache myCache = myManager.getCache(cacheName);
		if (myCache == null) {
			myCache = initCache(cacheName);
		}
		myCache.put(new Element(key, value));
		return true;
	} catch (Exception e) {
		throw new Exception("set cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 向指定容器中设置值
 * 
 * @param cacheName
 *            容器名
 * 
 * @param key
 *            键
 * 
 * @param value
 *            值
 * 
 * @param timeToIdleSeconds
 *            间歇时间
 * 
 * @param timeToLiveSeconds
 *            存活时间
 * 
 * @return 真
 * 
 * @throws Exception
 *             抛出异常
 */

public static boolean setValue(String cacheName, String key, Object value, Integer timeToLiveSeconds) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		Cache myCache = myManager.getCache(cacheName);
		if (myCache == null) {
			initCache(cacheName, timeToLiveSeconds);
			myCache = myManager.getCache(cacheName);
		}
		myCache.put(new Element(key, value, EHCacheConfig.ETERNAL, EHCacheConfig.TIMETOIDLESECONDS, timeToLiveSeconds));
		return true;
	} catch (Exception e) {
		throw new Exception("set cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 从ehcache的指定容器中取值
 * 
 * @createTime 2012-4-23
 * 
 * @param key
 *            键
 * 
 * @return 返回Object类型的值
 * 
 * @throws Exception
 *             异常
 */

public static Object getValue(String cacheName, String key) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		Cache myCache = myManager.getCache(cacheName);
		if (myCache == null) {
			myCache = initMyCache(cacheName);
		}
		return myCache.get(key).getValue();
	} catch (Exception e) {
		return null;
	}
}

/**
 * 
 * 删除指定的ehcache容器
 * 
 * @param vesselName
 * 
 * @return 真
 * 
 * @throws Exception
 *             失败抛出异常
 */

public static boolean removeEhcache(String cacheName) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		myManager.removeCache(cacheName);
		return true;
	} catch (Exception e) {
		throw new Exception("remove cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 删除所有的EHCache容器
 * 
 * @param cacheName
 *            容器名
 * 
 * @return 返回真
 * 
 * @throws Exception
 *             失败抛出异常
 */

public static boolean removeAllEhcache(String cacheName) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		myManager.removalAll();
		return true;
	} catch (Exception e) {
		throw new Exception("remove cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 删除EHCache容器中的元素
 * 
 * @param cacheName
 *            容器名
 * 
 * @param key
 *            键
 * 
 * @return 真
 * 
 * @throws Exception
 *             失败抛出异常
 */

public static boolean removeElment(String cacheName, String key) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		Cache myCache = myManager.getCache(cacheName);
		myCache.remove(key);
		return true;
	} catch (Exception e) {
		throw new Exception("remove cache " + cacheName + " failed!!!");
	}
}

/**
 * 
 * 删除指定容器中的所有元素
 * 
 * @param cacheName
 *            容器名
 * 
 * @param key
 *            键
 * 
 * @return 真
 * 
 * @throws Exception
 *             失败抛出异常
 */

public static boolean removeAllElment(String cacheName, String key) throws Exception {
	try {
		CacheManager myManager = CacheManager.create();
		Cache myCache = myManager.getCache(cacheName);
		myCache.removeAll();
		return true;
	} catch (Exception e) {
		throw new Exception("remove cache " + cacheName + " failed!!!");
	}
}

/**
 * 释放CacheManage
 */

public static void shutdown() {
	cacheManager.shutdown();
}

/**
 * 移除cache
 * 
 * @param cacheName
 */

public static void removeCache(String cacheName) {
	checkCacheManager();
	cache = cacheManager.getCache(cacheName);
	if (null != cache) {
		cacheManager.removeCache(cacheName);
	}
}

/**
 * 移除cache中的key
 * 
 * @param cacheName
 */

public static void remove(String key) {
	checkCache();
	cache.remove(key);
}

/**
 * 移除所有cache
 */

public static void removeAllCache() {
	checkCacheManager();
	cacheManager.removalAll();
}

/**
 * 
 * 移除所有Element
 */

public static void removeAllKey() {
	checkCache();
	cache.removeAll();
}

/**
 * 
 * 获取所有的cache名称
 * 
 * @return
 */

public static String[] getAllCaches() {
	checkCacheManager();
	return cacheManager.getCacheNames();
}

/**
 * 
 * 获取Cache所有的Keys
 * 
 * @return
 */

public static List getKeys() {
	checkCache();
	return cache.getKeys();
}

/**
 * 
 * 检测cacheManager
 */

private static void checkCacheManager() {
	if (null == cacheManager) {
		throw new IllegalArgumentException("调用前请先初始化CacheManager值：EHCacheUtil.initCacheManager");
	}
}

private static void checkCache() {
	if (null == cache) {
		throw new IllegalArgumentException("调用前请先初始化Cache值：EHCacheUtil.initCache(参数)");
	}
}

public static void main(String[] arg) {
	// 初始化--必须
	EHCacheUtil.initCacheManager();
	EHCacheUtil.initCache("cache");
	EHCacheUtil.put("A", "AAAAA");
	EHCacheUtil.put("B", "BBBBB");
	EHCacheUtil.put("F", "FFFFF");
	System.out.println(EHCacheUtil.get("F"));
	List keys = EHCacheUtil.getKeys();
	for(int i=0;i<keys.size();i++){
		System.out.println(keys.get(i));
	}
	EHCacheUtil.shutdown();
}

}

<?xml version="1.0" encoding="UTF-8"?>

<diskStore path="java.io.tmpdir"/>

<defaultCache
        maxEntriesLocalHeap="10000"
        eternal="true"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        diskSpoolBufferSizeMB="30"
        maxEntriesLocalDisk="10000000"
        diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU">
    <persistence strategy="localTempSwap"/>
</defaultCache>

<cache name="cache"
       maxEntriesLocalHeap="10000"
       maxEntriesLocalDisk="1000"
       eternal="true"
       diskSpoolBufferSizeMB="20"
       timeToIdleSeconds="300"
       timeToLiveSeconds="600"
       memoryStoreEvictionPolicy="LFU"
       transactionalMode="off">
    <persistence strategy="localTempSwap"/>
</cache>

---

作者：wyc_cs
来源：CSDN
原文：https://blog.csdn.net/wyc_cs/article/details/40112365
版权声明：本文为博主原创文章，转载请附上博文链接！