spring ehcache配置以及使用(afterPropertiesSet)

spring 配置ehcache例子：http://blog.csdn.net/linfanhehe/article/details/7693091 
  主要特性
     1. 快速.
     2. 简单.
     3. 多种缓存策略
     4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题
     5. 缓存数据会在虚拟机重启的过程中写入磁盘
     6. 可以通过RMI、可插入API等方式进行分布式缓存
     7. 具有缓存和缓存管理器的侦听接口
     8. 支持多缓存管理器实例，以及一个实例的多个缓存区域
     9. 提供Hibernate的缓存实现

举例说明：timeToLiveSeconds =3600 timeToIdleSeconds =300

以上配置代表缓存有效时间为3600秒（自缓存建立起一个小时有效 ），在有效的一个小时内，如果连续五分钟未访问缓存，则缓存失效，特别说明的是，就算缓存访问从未间断，到一个小时后，缓存也会失效

<!--                                 配置 ehcache                              -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
        <property name="configLocation">  
            <value>classpath:ehcache.xml</value>  
        </property>  
	</bean>
    <!-- cacheName ehcache配置文件中的名称 -->  
	<bean id="mmsCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">  
        <property name="cacheManager" ref="cacheManager" />  
        <property name="cacheName" value="mmsCache" />  
    </bean>
    
	<bean id="dataProviderService" class="xxx.DataProviderServiceImpl">
		<property name="commonDao">
			<ref bean="commonDao" />
		</property>
		<property name="cache" ref="mmsCache"></property>
	</bean>		

<ehcache updateCheck="false" name="mmsCache">

    <defaultCache 
    		maxElementsInMemory="10000" 
    		eternal="true"
    		overflowToDisk="true">
    </defaultCache>

    <cache name="mmsCache" 
    		maxElementsInMemory="10000" 
    		eternal="true"
			overflowToDisk="false">
    </cache>
    
</ehcache>

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.dao.DataAccessException;

import xxx.dao.cfg.CommonDao;
import xxx.service.cfg.DataProviderService;


public class DataProviderServiceImpl implements DataProviderService,InitializingBean{
	private static final Log log = LogFactory.getLog(DataProviderServiceImpl.class);
	private  net.sf.ehcache.Cache cache;
	private CommonDao commonDao;
	
	public Cache getCache() {
		return cache;
	}
	public void setCache(Cache cache) {
		this.cache = cache;
	}
	public CommonDao getCommonDao() {
		return commonDao;
	}

	public void setCommonDao(CommonDao commonDao) {
		this.commonDao = commonDao;
	}
	/**
	 * InitializingBean 仅仅提供了初始化的方法
	 */
	@Override
	public void afterPropertiesSet() throws Exception {
		doCacheMenu();
		doCacheUser();
		doCacheDeth();
	}
	private void doCacheMenu() {
		String sql = "" ;
		// 查询所有开启的菜单
		try {
			this.put("TMENU", this.commonDao.findNativeSQL(sql,new Object[]{"1","0"}));
			log.info("缓存菜单成功！");
		} catch (Exception e) {
			e.printStackTrace();
			log.info("缓存菜单失败！");
		}
	}
	private void doCacheUser() {
		// 查询所有用户
		try {
			this.put("TUSER", this.commonDao.find("from Tuscuser t"));
			log.info("缓存用户成功！");
		} catch (DataAccessException e) {
			e.printStackTrace();
			log.info("缓存用户失败！");
		}
	}
	private void doCacheDeth(){
		// 查询所有部门
		try {
			this.put("TDEPT", this.commonDao.find("from Tuscdept t"));
			log.info("缓存部门成功！");
		} catch (DataAccessException e) {
			e.printStackTrace();
			log.info("缓存部门失败！");
		}
	}
	
	public Object get(String key) {
		return cache.get(key)!=null?cache.get(key).getObjectValue():key ;
	}
	public void put(String key, Object value) {
		cache.put(new Element(key,value));
	}
	public void reloadAllCache() {
		cache.flush();
	}
	public void reloadCacheByType(String type) {
		// 缓存菜单
		if("TMENU".equals(type)){
			doCacheMenu();
		}
		// 刷新用户
		if("TUSER".equals(type)){
			doCacheUser();
		}
		// 刷新部门
		if("TDEPT".equals(type)){
			doCacheDeth();
		}
	}
}

<?xml version="1.0" encoding="UTF-8"?> 
<ehcache> 
<!--timeToIdleSeconds 当缓存闲置n秒后销毁 --> 
<!--timeToLiveSeconds 当缓存存活n秒后销毁 --> 
<!-- 
缓存配置 
       name:缓存名称。 
       maxElementsInMemory：缓存最大个数。 
       eternal:对象是否永久有效，一但设置了，timeout将不起作用。 
       timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。 
       timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。 
       overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。 
       diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。 
       maxElementsOnDisk：硬盘最大缓存个数。 
       diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false. 
       diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。 
       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。 
       clearOnFlush：内存数量最大时是否清除。 
-->
<diskStore path="java.io.tmpdir" />   
<defaultCache   
  maxElementsInMemory="500"   
  eternal="false"   
  timeToIdleSeconds="300"   
  timeToLiveSeconds="1200"   
  overflowToDisk="true" />   
 <cache name="com.Menu" maxElementsInMemory="150" 
        eternal="false" timeToLiveSeconds="36000" 
        timeToIdleSeconds="3600" overflowToDisk="true"/>   
</ehcache>  

EhcacheUtil工具类使用

public class EhcacheUtil {  
  
    private static final String path = "/ehcache.xml";  
  
    private URL url;  
  
    private CacheManager manager;  
  
    private static EhcacheUtil ehCache;  
  
    private EhcacheUtil(String path) {  
        url = getClass().getResource(path);  
        manager = CacheManager.create(url);  
    }  
  
    public static EhcacheUtil getInstance() {  
        if (ehCache== null) {  
            ehCache= new EhcacheUtil(path);  
        }  
        return ehCache;  
    }  
  
    public void put(String cacheName, String key, Object value) {  
        Cache cache = manager.getCache(cacheName);  
        Element element = new Element(key, value);  
        cache.put(element);  
    }  
  
    public Object get(String cacheName, String key) {  
 // 通过名称获取cache  cacheName在ehcache.xml上定义
        Cache cache = manager.getCache(cacheName);  
        Element element = cache.get(key);  
        return element == null ? null : element.getObjectValue();  
    }  
  
    public Cache get(String cacheName) {  
        return manager.getCache(cacheName);  
    }  
  
    public void remove(String cacheName, String key) {  
        Cache cache = manager.getCache(cacheName);  
        cache.remove(key);  
    }  
  
}  

单独使用ehcache

//从classes目录查找ehcache.xml配置文件  
CacheManager cacheManager = CacheManager.getInstance();  
  
//从classes目录查找指定名称的配置文件  
//CacheManager cacheManager = CacheManager.create(getClass().getResource("/ehcache.xml"));  
  
//根据配置文件获得Cache实例  
Cache cache = cacheManager.getCache("CACHE1");  
  
//清空Cache中的所有元素  
cache.removeAll();  
  
//往Cache中添加元素  
cache.put(new Element("s1", "11111"));  
cache.put(new Element("s2", "22222"));  
cache.put(new Element("s3", "33333"));  
  
//从Cache中取得元素  
Element e = cache.get("s3");  
System.out.println(e.getValue());  
  
//卸载缓存管理器  
cacheManager.shutdown();  

页面缓存

在web.xml文件中配置过滤器。此处对test_tag.jsp页面进行缓存。

<filter>   
    <filter-name>testPageCachingFilter</filter-name>   
    <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter</filter-class>   
</filter>  
<filter-mapping>   
    <filter-name>testPageCachingFilter</filter-name>   
    <url-pattern>/test_tag.jsp</url-pattern>  
</filter-mapping>  

在ehcache.xml文件中配置Cache节点。
注意：cache的name属性必需为SimplePageCachingFilter。

<cache name="SimplePageCachingFilter"   
   maxElementsInMemory="10"   
   overflowToDisk="true"   
   eternal="false"   
   timeToIdleSeconds="100"   
   timeToLiveSeconds="100"  
   memoryStoreEvictionPolicy="LFU" />