ehcache 使用实例

标签：缓存 echach

<?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>

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

③使用的时候，初始化echach对象，然后put对象进去。

//tokenId放入缓存中
				EhCacheUtil.init();
				EhCacheUtil.put(EhCacheUtil.getKentrasoftCache(), "TOKEN_ID","JIASJDFIOJIOAJI12341");

缓存可以设置有效期

//生成动态令牌 并设置有效期
//							user.setAuthToken(UuidUtil.get32UUID());
//							EhCacheUtil.init();
							EhCacheUtil.put(EhCacheUtil.getKentrasoftCache(), user.getAuthToken(), user.getAuthToken(), 1000*60*30, 1000*60*30);
							EhCacheUtil.put(cache, key, value, timeToLiveSeconds, timeToIdleSeconds);
							EhCacheUtil.put(cache, key, value, eternal);

④在需要使用的地方get该对象就可以了

// 获取令牌 tokenId
String tokenId = EhCacheUtil.get(EhCacheUtil.getKentrasoftCache(), "TOKEN_ID").toString();

⑤清除缓存中的数据

//清除缓存信息
EhCacheUtil.remove(EhCacheUtil.getKentrasoftCache(), loginName+"code");

ehcache 使用实例

标签：缓存 echach

原文地址：http://blog.51cto.com/jianboli/2072700