spring集成ehcache

1.引入ehcache-2.8.3.jar包

2.新建ehcache配置文件

<?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="java.io.tmpdir" />
	<!-- 缓存存放目录(此目录为放入系统默认缓存目录),也可以是"D:/cache" java.io.tmpdir -->
	<defaultCache 
	      maxElementsInMemory="10000" 
	      eternal="false"
		  timeToIdleSeconds="0" 
		  timeToLiveSeconds="0" 
		  overflowToDisk="false"
		  diskExpiryThreadIntervalSeconds="120" 
		  memoryStoreEvictionPolicy="LRU" />
		<!--  
			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（较少使用）   
		--> 
	<cache name="listIBE" maxElementsInMemory="10" timeToIdleSeconds="86400"
		timeToLiveSeconds="86400" eternal="false" overflowToDisk="true" />
		
	<cache name="eholiday" maxElementsInMemory="10" timeToIdleSeconds="3600"
		timeToLiveSeconds="3600" eternal="false" overflowToDisk="true" />
</ehcache>

3.在spring配置文件中引入ehcache

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
  		http://www.springframework.org/schema/beans/spring-beans.xsd
  		http://www.springframework.org/schema/context
  		http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">
  		<bean id="SpringContextUtil" class="com.ceair.common.util.SpringContextUtil" />	
   <!-- 引用ehCache的配置 
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">   
      <property name="configLocation">   
        <value>classpath:ehcache.xml</value>   
     </property>   
    </bean>
    
             定义ehCache的工厂，并设置所使用的Cache name  
    <bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">   
      <property name="cacheManager" ref="cacheManager">   
      </property>   
      <property name="cacheName">   
          <value>DEFAULT_CACHE</value>   
      </property>   
    </bean>  
     --> 
    
    
    <bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
		<property name="configLocation" value="classpath:/ehcache.xml" />
		<property name="shared" value="true" />
	</bean>

	<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
		<property name="cacheManager" ref="ehCacheManager" />
	</bean>
    
    
</beans>

4.创建ehcache工具类

package com.ceair.common.util;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;

/**
 * 缓存工具类
 * 
 * @author Team
 * 
 */
public class EhcacheUtil {

	private static EhcacheUtil ehcacheUtil;

	private static CacheManager manager;
	private EhcacheUtil() {
		if (manager == null) {
			manager = CacheManager.create();
		}
	}

	public static EhcacheUtil getInstance() {
		if (ehcacheUtil == null) {
			ehcacheUtil = new EhcacheUtil();
		}
		return ehcacheUtil;
	}

	/**
	 * 增加缓存
	 * 
	 * @param cacheName
	 * @param key
	 * @param value
	 */
	public void put(String cacheName, String key, Object value) {
		Cache cache = manager.getCache(cacheName);
		Element element = new Element(key, value);
		cache.put(element);
	}
	
	/**
	 * 增加缓存
	 * 
	 * @param cacheName
	 * @param key
	 * @param value
	 */
	public void putString(String cacheName, String key, String value) {
		Cache cache = manager.getCache(cacheName);
		Element element = new Element(key, value);
		cache.put(element);
	}

	/**
	 * 根据key获取缓存对象
	 * 
	 * @param cacheName
	 * @param key
	 * @return
	 */
	public Object get(String cacheName, String key) {
		Cache cache = manager.getCache(cacheName);
		Element element = cache.get(key);
		return element == null ? null : element.getObjectValue();
	}
	
	

	/**
	 * 获取ehcache配置文件中的cache对象
	 * 
	 * @param cacheName
	 * @return
	 */
	public Cache get(String cacheName) {
		return manager.getCache(cacheName);
	}

	/**
	 * 移除缓存对象
	 * 
	 * @param cacheName
	 * @param key
	 */
	public void remove(String cacheName, String key) {
		Cache cache = manager.getCache(cacheName);
		cache.remove(key);
	}

	/**
	 * 移除缓存对象
	 * 
	 * @param cacheName
	 * @param key
	 */
	public void removeAll(String cacheName) {
		Cache cache = manager.getCache(cacheName);
		cache.removeAll();
	}

	/**
	 * 获取页面缓存
	 * 
	 * @param name
	 * @return
	 */
	public Ehcache getPageCache(String name) {
		return manager.getEhcache(name);
	}

}

5.使用缓存

//添加缓存
EhcacheUtil cache = EhcacheUtil.getInstance();
User user = null;
Object object = cache.get("eholiday", "test");
if(object == null){
user = new User();
user.setName("kong");
user.setPassword("kong");
cache.putString("eholiday","test", JSON.toJSONString(user));
}else{
user = JSON.parseObject(object.toString(), User.class);
//若是list就用JSON.parseArray(object.toString(), User.class);
}