缓存之EHcache

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。
主要的特性有：
1. 快速.
2. 简单.
3. 多种缓存策略
4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题
5. 缓存数据会在虚拟机重启的过程中写入磁盘
6. 可以通过RMI、可插入API等方式进行分布式缓存
7. 具有缓存和缓存管理器的侦听接口
8. 支持多缓存管理器实例，以及一个实例的多个缓存区域
9. 提供Hibernate的缓存实现
下面是个人的写的一个通用类

package com.xyj.com.tool.cache.ehcache;

import java.io.Serializable;
import java.util.List;


import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheException;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.ObjectExistsException;

/**
 * @className:EHCacheUtil.java
 * @classDescription:ehcache工具类
 * @author:xiayingjie
 * @createTime:2010-12-1
 */

public class EHCacheUtil {

	private  static CacheManager cacheManager = null;

	private static Cache cache=null;

//------------------简化---------------------

	/**
	 * 初始化缓存管理容器
	 */
	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.create(path);
		} catch (Exception e) {
			e.printStackTrace();

		}
		return cacheManager;
	}

	/**
	 * 初始化cache
	 * @param cacheName
	 * @return
	 */
	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);
		return element.getObjectValue();
	}

	//------------------方便调用------------

	/**
	 * 释放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
	 */
	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();
		//放入Test Cache中
		EHCacheUtil.initCache("ceshi");
		EHCacheUtil.put("F", "Test1");		
		System.out.println(EHCacheUtil.get("F"));



//		//放入Test Cache中
//		EHCacheUtil.initCache("Test");
//		EHCacheUtil.put("s", "Test");	
//		String[]caches=EHCacheUtil.getAllCaches();
//		for(String s:caches){
//			System.out.println(s);
//		}
//		


	}
}