EhCache使用说明

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，
是Hibernate中默认的CacheProvider。

ehcache是一个非常轻量级的缓存实现，而且从1.2之后就支持了集群，
而且是hibernate默认的缓存provider。
 
Ehcache的分布式缓存有传统的RMI，1.5版的JGroups，1.6版的JMS。
分布式缓存主要解决集群环境中不同的服务器间的数据的同步问题。
 
使用Spring的AOP进行整合，可以灵活的对方法的返回结果对象进行缓存。
 
CachingFilter功能可以对HTTP响应的内容进行缓存。
 
1、主要特性
     1. 快速.
     2. 简单.
     3. 多种缓存策略
     4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题
     5. 缓存数据会在虚拟机重启的过程中写入磁盘
     6. 可以通过RMI、可插入API等方式进行分布式缓存
     7. 具有缓存和缓存管理器的侦听接口
     8. 支持多缓存管理器实例，以及一个实例的多个缓存区域
     9. 提供Hibernate的缓存实现
 
=======================================
Cache 存储方式 ：内存或磁盘

1. EHCache 的特点，是一个纯Java ,过程中（也可以理解成插入式）缓存实现，单独安装Ehcache
需把ehcache-X.X.jar 和相关类库方到classpath中。如项目已安装了Hibernate ,则不需要做什么。。直接可以使用Ehcache

使用：
1.创建CacheManager有4种方式
  A.使用默认配置文件创建
     CacheManager manager = CacheManager.create();
  B.使用指定配置文件创建
     CacheManager manager = CacheManager.create("src/config/ehcache.xml");
  C.从classpath中找寻配置文件并创建
     URL url = getClass().getResource("/anothername.xml"); 
  CacheManager manager = CacheManager.create(url);
   D:通过输入流创建
     InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());
  try{
  manager=CacheManager.create(fis);
  }finally{
   fis.close();
  }
 
  卸载CacheManager ,关闭Cache
  manager.shutdown();
 
  使用Caches
  // 取得配置文件中预先 定义的sampleCache1设置,通过CacheManager生成一个Cache
  Cache cache = manager.getCache("sampleCache1");
  // 设置一个名为test 的新cache,test属性为默认
  CacheManager manager = CacheManager.create(); 
  manager.addCache("test"); 
  // 设置一个名为test 的新cache,并定义其属性
  CacheManager manager = CacheManager.create(); 
  Cache cache=new Cache("test", 1, true, false, 5, 2); 
  manager.addCache(cache);
 
  // 往cache中加入元素
  Element element = new Element("key1", "value1"); 
  cache.put(new Element(element);
  // 从cache中取得元素
  Element element = cache.get("key1");  
 
  所以大概步骤为：
  第一步：生成CacheManager对象
  第二步：生成Cache对象
  第三步：向Cache对象里添加由key,value组成的键值对的Element元素
 
下面是一个具体的例子 
  
  package test;

  import net.sf.ehcache.Cache;
  import net.sf.ehcache.CacheManager;
  import net.sf.ehcache.Element;
  /**
   * 第一步：生成CacheManager对象
   * 第二步：生成Cache对象
   * 第三步：向Cache对象里添加由key,value组成的键值对的Element元素
   * @author mahaibo
   *
   */
  public class Test {
   
   public static void main(String[] args) {
      //指定ehcache.xml的位置
      String fileName="E:\\1008\\workspace\\ehcachetest\\ehcache.xml";
      CacheManager manager = new CacheManager(fileName);
      //取出所有的cacheName
      String names[] = manager.getCacheNames();
      for(int i=0;i<names.length;i++){
       System.out.println(names[i]);
      }
      //根据cacheName生成一个Cache对象
      //第一种方式：
      Cache cache=manager.getCache(names[0]);
     
      //第二种方式，ehcache里必须有defaultCache存在,"test"可以换成任何值
  //    Cache cache = new Cache("test", 1, true, false, 5, 2);  
  //    manager.addCache(cache);
     
      //向Cache对象里添加Element元素，Element元素有key，value键值对组成
      cache.put(new Element("key1","values1"));
      Element element = cache.get("key1");
     
      System.out.println(element.getValue());
      Object obj = element.getObjectValue();
      System.out.println((String)obj);
      manager.shutdown();

    }

  }

==================================================  
  配置文件介绍（普通缓存）
  代码：
  
    <ehcache>
   <!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
   <diskStore path="java.io.tmpdir"/>

   <!-- 设定缓存的默认数据过期策略 -->
   <defaultCache
     maxElementsInMemory="10000"
     eternal="false"
     overflowToDisk="true"
     timeToIdleSeconds="0"
     timeToLiveSeconds="0"
     diskPersistent="false"
     diskExpiryThreadIntervalSeconds="120"/>
   
   <!-- 
    设定具体的命名缓存的数据过期策略

    cache元素的属性：
     name：缓存名称
     
     maxElementsInMemory：内存中最大缓存对象数
     
     maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大
     
     eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
     
     overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
     
     diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。
     
     diskPersistent：是否缓存虚拟机重启期数据
     
     diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒

     timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
     
     timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义

     memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
   -->
   <cache name="CACHE1"
       maxElementsInMemory="1000"
       eternal="true"
       overflowToDisk="true"/> 
      
   <cache name="CACHE2"
    maxElementsInMemory="1000"
    eternal="false"
    timeToIdleSeconds="200"
    timeToLiveSeconds="4000"
    overflowToDisk="true"/>
  </ehcache>
  
  
  配置文件介绍（分布式缓存）
  
   1）RMI集群模式
          A、手工发现
               需要指定节点发现模式peerDiscovery值为manual，rmiUrls设置为另一台服务器的IP、端口和缓存名等信息。
     
      <cacheManagerPeerProviderFactory
    class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
    properties="peerDiscovery=manual,
    rmiUrls=//192.168.0.12:4567/oschina_cache|//192.168.0.13:4567/oschina_cache"
   />
 
        B、自动发现
                需要指定节点发现模式peerDiscovery值为automatic自动，同时组播地址可以指定D类IP地址空间，范围从 224.0.1.0 到 238.255.255.255 中的任何一个地址。
 
         <cacheManagerPeerProviderFactory
    class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
    properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,
    multicastGroupPort=4446, timeToLive=32"
   />
 
       需要在每个cache属性中加入
    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
   
    代码：
    <cache name="demoCache"
    maxElementsInMemory="10000"
    eternal="true"
    overflowToDisk="true">
    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
    </cache>
   
   
    通过编程方式使用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();
   
  5.页面缓存 
       在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" />
    
    
    
========================================================
EHcache注解在Spring 中使用（ehcache-spring-annotations）

第一步在web.xml中配置加载配置ehcache的配置文件，如
<context-param> 
     <param-name>contextConfigLocation</param-name> 
     <param-value>classpath:config/applicationContext.xml,classpath:config/ehcacheApplication.xml</param-value> 
 </context-param>
第二部：编写ehcacheApplication.xml
<?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:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">
                                      
    <ehcache:annotation-driven /> 
     
    <ehcache:config cache-manager="cacheManager"> 

    </ehcache:config> 
     
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> 
        <property name="configLocation"  value="classpath:config/ehcache.xml"/> 
    </bean>

  《！--缓存的生成key--》
    <bean id="productKeyGenerator" class="lwz.web.ehcache.ProductCacheKeyGenerator"/>   
     
</beans> 

第三部：ehcache.xml
<?xml version="1.0" encoding="UTF-8"?> 
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> 
     
    <diskStore path="user.home/web_ehcache/" />  
     
    <defaultCache 
            maxElementsInMemory="3000" 
            eternal="false" 
            timeToIdleSeconds="3600" 
            timeToLiveSeconds="3600" 
            overflowToDisk="true" 
            diskPersistent="false" 
            diskExpiryThreadIntervalSeconds="100" 
            memoryStoreEvictionPolicy="LRU" 
            /> 
    <cache name="testCache" 
           maxElementsInMemory="3000" 
           eternal="false" 
           overflowToDisk="true" 
           timeToIdleSeconds="36000" 
           timeToLiveSeconds="36000" 
           memoryStoreEvictionPolicy="LFU" 
            /> 
</ehcache>  

第四部
然偶在dao的接口，或者类方法上加上@cacheable注解

@Cacheable(cacheName = "testCache")
public List<ApplicationMenu> findAllMenuValid(String flag);
记得最好不要在control类中的方法加上@Cacheable(cacheName = "testCache")，然后在方法内再去调用dao中的方法，这样缓存不到
如果要更新缓存 在方法上注释

@TriggersRemove(cacheName="testCache",removeAll=true)
public void deleteMenu(int id);

即删除缓存