当前位置 : 首页 » 文章分类 :  开发  »  Ehcache

Ehcache

[TOC]

概述

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

EhCache 从1.7版本开始，支持五种集群方案，分别是：

  • RMI
  • JGroups
  • JMS
  • EhCache Server
  • Terracotta
    其中的三种最为常用集群方式，分别是 RMI、JGroups 以及 EhCache Server 。

ehcache.xml配置

ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。一切Ehcache的应用都是从CacheManager开始的。在不指定配置信息参数创建CacheManager时，CacheManager将首先在类路径的根目录下寻找一个叫ehcache.xml的文件作为CacheManager的配置文件。如果不存在这样的文件则将使用封装在ehcache jar包中的ehcahce-failsafe.xml文件作为创建CacheManager的默认配置信息。除了使用Configuration作为参数外，使用其它参数构造CacheManager都是基于xml格式的配置信息的。当我们使用xml配置文件作为CacheManager的配置信息时，我们的文件名不一定叫ehcache.xml

ehcache元素

首先我们的ehcache.xml文件必须遵守Ehcache的Xml Schema的定义，我们可以直接使用在线的http://ehcache.org/ehcache.xsd ，也可以直接从该地址把ehcache.xsd文件下载到本地。ehcache.xml文件的根元素必须是<ehcache>，一个ehcache元素就相当于一个CacheManager，我们在ehcache元素上指定的属性以及在ehcache元素下定义的子元素都是针对于当前CacheManager的，比如我们在ehcache元素下定义了一个cache元素，那就代表我们所定义的CacheManager中有这么一个Cache存在。ehcache元素上的属性都是可选的，我们可以在ehcache元素上指定ehcache.xml文件所遵循的schema所在的位置，如：

  1. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
  3. ...
  4. </ehcache>

除了指定ehcache.xml文件所遵循的schema之外，我们的ehcache元素还可以指定很多的属性，主要有如下这些。

  • name：指定当前CacheManager的名称。
  • dynamicConfig：boolean类型。表示是否可以动态的更新配置，默认为true。当设置为false的时候，我们在运行期通过CacheManager的Configuration来改变配置信息时将不会发生作用。使用代码进行配置时我们可以通过Configuration对象的dynamicConfig(boolean dynamicConfig)方法来指定该配置。
  • maxBytesLocalDisk：在CacheManager级别指定能够使用的本地磁盘的最大容量。当指定了该属性后隐式的使所有Cache的overflowToDisk变为true，如需关闭则需要在对应的Cache上设置overflowToDisk为false。
  • maxBytesLocalHeap：在CacheManager级别指定能够使用的堆内存的最大容量。
  • maxBytesLocalOffHeap：在CacheManager级别指定能够使用的非堆内存的最大容量。当指定了该属性后会隐式的使所有Cache的overflowToDisk变为true，如需关闭则需在对应的Cache上设置overflowToOffHeap为false。该属性只对企业版Ehcache有用。
  • defaultTransactionTimeoutInSeconds:
  • updateCheck：boolean类型，是否检查更新，默认为true。当设置为true时，CacheManager会定期的从网上去检查当前的Ehcache是否是最新的版本，如果不是，则会将比当前版本新的版本列出来。

需要注意的是当我们在CacheManager级别上指定了maxBytesLocalOffHeap时会使overflowToOffHeap的默认值变为true。也就是说该CacheManager里面所有的Cache在没有显示的指定overflowToOffHeap属性值时其值默认都是true，原本默认是false。

cache元素

<cache>元素是ehcache元素的子元素，一个cache元素就代表一个Ehcache对象的定义。对于一个cache元素而言我们最简单的定义方式是只需要指定所定义的Ehcache的名称，其它的都使用默认配置。默认配置将使用defaultCache元素的定义（这将在后文中讲到）
cache元素中可以指定的属性也有很多，但只有一个是必须的，那就是name属性。

  • name：指定cache的名称
  • maxElementsInMemory：缓存中允许创建的最大对象数
  • eternal：boolean类型，表示是否永恒，默认为false。如果设为true，将忽略timeToIdleSeconds和timeToLiveSeconds，Cache内的元素永远都不会过期，也就不会因为元素的过期而被清除了。
  • timeToIdleSeconds：单位是秒，表示一个元素所允许闲置的最大时间，也就是说一个元素在不被请求的情况下允许在缓存中待的最大时间，超过此时间则会被销毁。默认是0，表示不限制，可以停顿无穷长的时间。
  • timeToLiveSeconds：单位是秒，表示无论一个元素闲置与否，其允许在Cache中存在的最大时间，超过这个时间就会被销毁。默认是0，表示不限制。
  • overflowToDisk：boolean类型，默认为false。内存不足时，是否启用磁盘缓存。当内存里面的缓存已经达到预设的上限时是否允许将按驱除策略驱除的元素保存在硬盘上，默认是LRU（最近最少使用）。当指定为false的时候表示缓存信息不会保存到磁盘上，只会保存在内存中。该属性现在已经废弃，推荐使用cache元素的子元素<persistence>来代替，如：<persistence strategy=localTempSwap”/>
  • memoryStoreEvictionPolicy：缓存满了之后的淘汰算法。
    • LRU，是Least Recently Used 近期最少使用算法；
    • FIFO，以一种队列方式谁先进谁先出
    • LFU，least frequently used 即最不经常使用页置换算法
  • diskPersistent：是否disk store在虚拟机启动时持久化。默认为false
  • diskExpiryThreadIntervalSeconds：单位是秒，表示多久检查元素是否过期的线程多久运行一次，默认是120秒。

示例：

  1. <!-- Sample cache named sampleCache4. All missing RMICacheReplicatorFactory properties default to true -->
  2. <cache name="sampleCache4"
  3.    maxElementsInMemory="10"
  4.    eternal="true"
  5.    overflowToDisk="false"
  6.    memoryStoreEvictionPolicy="LFU">
  7.    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
  8. </cache>

defaultCache元素

<defaultCache>元素是用来指定cache的默认配置的，其可以指定的信息大体上跟cache元素是一样的，cache元素中未指定的参数将使用默认配置。这些配置只会对在程序中通过CacheManager的addCache(String cacheName)方法添加的Cache起作用。

示例：

  1. <defaultCache
  2.     maxElementsInMemory="10000"
  3.     eternal="false"
  4.     overflowToDisk="true"
  5.     timeToIdleSeconds="120"
  6.     timeToLiveSeconds="120"
  7.     diskPersistent="false"
  8.     diskExpiryThreadIntervalSeconds="120"/>

diskStore元素

<diskStore>元素指定一个文件目录，当EhCache把数据写到硬盘上时，将把数据写到这个文件目录下。
其只接收一个参数path，表示表示磁盘存储的路径，如：<diskStore path="d:\\ehcache" />
如果不希望Ehcache创建磁盘存储的路径，则可以不定义diskStore元素。在没有定义diskStore，但有cache需要使用磁盘存储时会默认使用java.io.tmpdir作为磁盘存储的路径。

diskStore元素的path属性使用如下值时将自动替换为实际对应的值。

  • java.io.tmpdir：默认的临时文件存放路径。
  • user.home：用户的主目录。
  • user.dir：用户的当前工作目录，即当前程序所对应的工作路径。
  • 其它通过命令行指定的系统属性，如java –DdiskStore.path=D:\\abc ……

集群配置

为了安装分布式缓存，你需要配置一个PeerProvider，一个CacheManagerPeerListener

元素可序列化

只有可序列化的元素可以进行复制，也就是必须实现java.io.Serializable接口。一些操作，比如移除，只需要元素的键值而不用整个元素；在这样的操作中即使元素不是可序列化的但键值是可序列化的也可以被复制。

RMI方式缓存集群

RMI 是 Java 的一种远程方法调用技术，是一种点对点的基于 Java 对象的通讯方式。EhCache 从 1.2 版本开始就支持 RMI 方式的缓存集群。在集群环境中 EhCache 所有缓存对象的键和值都必须是可序列化的，也就是必须实现 java.io.Serializable 接口，这点在其它集群方式下也是需要遵守的。

采用 RMI 集群模式时，集群中的每个节点都是对等关系，并不存在主节点或者从节点的概念，因此节点间必须有一个机制能够互相认识对方，必须知道其它节点的信息，包括主机地址、端口号等。EhCache 提供两种节点的发现方式：手工配置和自动发现。手工配置方式要求在每个节点中配置其它所有节点的连接信息，一旦集群中的节点发生变化时，需要对缓存进行重新配置。

由于 RMI 是 Java 中内置支持的技术，因此使用 RMI 集群模式时，无需引入其它的 Jar 包，EhCache 本身就带有支持 RMI 集群的功能。使用 RMI 集群模式需要在 ehcache.xml 配置文件中定义 cacheManagerPeerProviderFactory 节点。

成员发现

Ehcache进行集群的时候有一个cache组的概念。每个cache都是其他cache的一个peer，没有主cache的存在。刚才我们问了一个问题：你如何知道集群环境中的其他缓存？这个问题可以命名为成员发现（Peer Discovery）。
Ehcache提供了两种机制用来进行成员发现，自动发现和手动配置，就像一辆汽车：手动档和自动档。要使用一个内置的成员发现机制要在ehcache的配置文件中指定<cacheManagerPeerProviderFactory>元素的class属性为net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory

自动成员发现

自动的发现方式用TCP广播机制来确定和维持一个广播组。它只需要一个简单的配置可以自动的在组中添加和移除成员。在集群中也不需要什么优化服务器的知识，这是默认推荐的。
成员每秒向群组发送一个“心跳”。如果一个成员 5秒种都没有发出信号它将被群组移除。如果一个新的成员发送了一个“心跳”它将被添加进群组。
任何一个用这个配置安装了复制功能的cache都将被其他的成员发现并标识为可用状态。

要设置自动的成员发现，需要指定ehcache配置文件中<cacheManagerPeerProviderFactory>元素的properties属性，就像下面这样：

  • peerDiscovery=automatic/manual，peer发现方式
  • multicastGroupAddress=multicast address | multicast hostname，广播组地址
  • multicastGroupPort=port，广播组端口
  • timeToLive=0-255，搜索范围，在Java实现中默认值是1，也就是在同一个子网中传播。timeToLive属性规定数据包可以传递的域或是范围，约定如下：
    • 0是限制在同一个服务器
    • 1是限制在同一个子网
    • 32是限制在同一个站点
    • 64是限制在同一个地域region
    • 128是限制在同一个大洲
    • 255是不限制

示例
假设你在集群中有两台服务器。你希望同步sampleCache1和sampleCache2。每台独立的服务器都要有这样的配置：
配置server1和server2

  1. <cacheManagerPeerProviderFactory
  2. class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  3. properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,
  4. multicastGroupPort=4446, timeToLive=32"/>

手动成员发现

进行手动成员配置要知道每个监听器的IP地址和端口。成员不能在运行时动态地添加和移除。在技术上很难使用广播的情况下就可以手动成员发现，例如在集群的服务器之间有一个不能传送广播报文的路由器。你也可以用手动成员发现进行单向的数据复制，只让server2知道server1，而server1不知道server2。

配置手动成员发现，需要指定ehcache配置文件中cacheManagerPeerProviderFactory的properties属性，像下面这样：
properties="peerDiscovery=manual, rmiUrls=//server:port/cacheName | //server:port/cacheName |..."
rmiUrls配置的是服务器cache peers的列表。注意不要重复配置。

手动成员发现配置示例

在ehcache.xml中配置PeerDiscovery成员发现对象
Server1配置，配置本地hostName、port是400001，分别监听192.168.8.32:400002的mobileCache和192.168.5.231:400003 的mobileCache。注意这里的mobileCache是缓存的名称，分别对应着server2、server3的cache的配置。

  1. <?xml version="1.0" encoding="gbk"?>
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd">
  3.     <diskStore path="java.io.tmpdir"/>
  5.     <!--
  6.         集群多台服务器中的缓存，这里是要同步一些服务器的缓存
  7.         server1 hostName:192.168.8.9 port:400001 cacheName:mobileCache
  8.         server2 hostName:192.168.8.32 port:400002 cacheName:mobileCache
  9.         server3 hostName:192.168.8.231 port:400003 cacheName:mobileCache
  10.         注意：每台要同步缓存的服务器的RMI通信socket端口都不一样，在配置的时候注意设置
  11.     -->
  13.     <!-- server1 的cacheManagerPeerProviderFactory配置 -->
  14.     <cacheManagerPeerProviderFactory
  15.         class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  16.         properties="hostName=localhost,
  17.         port=400001,
  18.         socketTimeoutMillis=2000,
  19.         peerDiscovery=manual,
  20.         rmiUrls=//192.168.8.32:400002/mobileCache|//192.168.5.231:400003/mobileCache"
  21.     />
  22. </ehcache>

以上注意cacheManagerPeerProviderFactory元素出现的位置在diskStore下

同样在你的另外2台服务器上增加配置
Server2，配置本地host，port为400002，分别同步192.168.8.9:400001的mobileCache和192.168.5.231:400003的mobileCache

  1. <!-- server2 的cacheManagerPeerProviderFactory配置 -->
  2. <cacheManagerPeerProviderFactory
  3.     class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  4.     properties="hostName=localhost,
  5.     port=400002,
  6.     socketTimeoutMillis=2000,
  7.     peerDiscovery=manual,
  8.     rmiUrls=//192.168.8.9:400001/mobileCache|//192.168.5.231:400003/mobileCache"
  9. />

Server3，配置本地host，port为400003，分别同步192.168.8.9:400001的mobileCache缓存和192.168.8.32:400002的mobileCache缓存

  1. <!-- server3 的cacheManagerPeerProviderFactory配置 -->
  2. <cacheManagerPeerProviderFactory
  3.     class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  4.     properties="hostName=localhost,
  5.     port=400003,
  6.     socketTimeoutMillis=2000,
  7.     peerDiscovery=manual,
  8.     rmiUrls=//192.168.8.9:400001/mobileCache|//192.168.8.32:400002/mobileCache"
  9. />

这样就在三台不同的服务器上配置了手动查找cache的PeerProvider成员发现的配置了。 值得注意的是你在配置rmiUrls的时候要特别注意url不能重复出现，并且端口、地址都是对的。
如果指定，hostname将使用InetAddress.getLocalHost().getHostAddress()来得到。
警告：不要将localhost配置为本地地址127.0.0.1，因为它在网络中不可见将会导致不能从远程服务器接收信息从而不能复制。在同一台机器上有多个CacheManager的时候，你应该只用localhost来配置。

成员监听

将成员发现方式配好之后需要配置listener才会有用，Listener是用来监听从集群发送过来的信息。
每个CacheManagerPeerListener监听从成员们发向当前CacheManager的消息。配置CacheManagerPeerListener需要指定一个<cacheManagerPeerListenerFactory>，它以插件的机制实现，用来创建CacheManagerPeerListener。

Ehcache有一个内置的基于RMI的分布系统。它的监听器是RMICacheManagerPeerListener，这个监听器可以用RMICacheManagerPeerListenerFactory来配置。

<cacheManagerPeerListenerFactory>的属性有：

  • class，一个完整的工厂类名。
  • properties，只对这个工厂有意义的属性，使用逗号分隔。
    有效的properties属性是：
    • hostName，可选配置，运行监听器的服务器名称。标明了做为集群群组的成员的地址，同时也是你想要控制的从集群中接收消息的接口。
      在CacheManager初始化的时候会检查hostname是否可用。
      如果hostName不可用，CacheManager将拒绝启动并抛出一个连接被拒绝的异常。
      如果指定，hostname将使用InetAddress.getLocalHost().getHostAddress()来得到。
      警告：不要将localhost配置为本地地址127.0.0.1，因为它在网络中不可见将会导致不能从远程服务器接收信息从而不能复制。在同一台机器上有多个CacheManager的时候，你应该只用localhost来配置。
    • port，监听器监听的端口。
    • socketTimeoutMillis，可选配置，Socket超时的时间。默认是2000ms。当你socket同步缓存请求地址比较远，不是本地局域网。你可能需要把这个时间配置大些，不然很可能延时导致同步缓存失败。

示例

  1. <cacheManagerPeerListenerFactory
  2. class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
  3. properties="hostName=localhost, port=40001,
  4. socketTimeoutMillis=2000"/>

缓存事件监听

每个要进行同步的cache都需要设置一个用来向CacheManagerr的成员复制消息的缓存事件监听器，监听本地缓存增删改查的事件并发送到集群中其他服务器。通过为每个<cache>配置增加一个<cacheEventListenerFactory>子元素来完成。
属性有：

  • class，工厂类名，使用net.sf.ehcache.distribution.RMICacheReplicatorFactory
  • properties，配置Put、Update、Remove等哪些事件需要同步
    properties支持以下属性：
    • replicatePuts=true | false – 当一个新元素增加到缓存中的时候是否要复制到其他的peers. 默认是true。
    • replicateUpdates=true | false – 当一个已经在缓存中存在的元素被覆盖时是否要进行复制。默认是true。
    • replicateRemovals= true | false – 当元素移除的时候是否进行复制。默认是true。
    • replicateAsynchronously=true | false – 复制方式是异步的（指定为true时）还是同步的（指定为false时）。默认是true。
    • replicatePutsViaCopy=true | false – 当一个新增元素被拷贝到其他的cache中时是否进行复制指定为true时为复制，默认是true。
    • replicateUpdatesViaCopy=true | false – 当一个元素被拷贝到其他的cache中时是否进行复制（指定为true时为复制），默认是true。

cache子元素

  • <cacheEventListenerFactory>：注册相应的的缓存监听类，用于处理缓存事件，如put,remove,update,和expire
  • <bootstrapCacheLoaderFactory>：指定相应的BootstrapCacheLoader，用于在初始化缓存，以及自动设置。
    Ehcache在程序启动的时候并不会立即去加载位于磁盘上的数据到内存，而是在数据被用到的时候去加载（lazy load）。因此在cache启动的时候，其内部没有数据。如果我们想在用到这些数据之前，它们全部被装载进内存，应该怎么做？
    Ehcache提供了BootstrapCacheLoader机制来解决这个问题，在Cache被激活之前，它会得到运行。并且有两种模式：同步和异步。如果是同步模式，在CacheManager启动之前，加载便会完成；如果是异步模式，在CacheManager启动的时候，加载会在后台继续，而不是等到所需数据被需要的时候。
    例如将class设为net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory，启动时会从RMI成员加载缓存。

示例

  1. <!-- Sample cache named sampleCache2. -->
  2. <cache name="sampleCache2"
  3.    maxElementsInMemory="10"
  4.    eternal="false"
  5.    timeToIdleSeconds="100"
  6.    timeToLiveSeconds="100"
  7.    overflowToDisk="false">
  8.    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
  9.        properties="replicateAsynchronously=true,replicatePuts=true, replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true "/>
  10.    <!-- 用于在启动后立即从RMI初始化缓存 -->
  11.    <bootstrapCacheLoaderFactory class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>
  12. </cache>

配置bootstrapCacheLoaderFactory用于启动时初始化缓存。

Ehcache使用

Java中使用Ehcache示例

  1. CacheManager manager = CacheManager.newInstance("src/config/ehcache.xml");
  2. manager.addCache("testCache");
  3. Cache test = singletonManager.getCache("testCache");
  4. test.put(new Element("key1", "value1"));
  5. manager.shutdown();

ehcache封装

maven依赖

  1. <properties>
  2.     <ehcache.version>2.7.4</ehcache.version>
  3. </properties>
  5. <dependencies>
  6.     <dependency>
  7.         <groupId>net.sf.ehcache</groupId>
  8.         <artifactId>ehcache</artifactId>
  9.         <version>2.7.4</version>
  10.         <scope>compile</scope>
  11.     </dependency>
  12. </dependencies>

接口ICacheService

  1. package com.masikkk;
  3. import java.io.Serializable;
  4. import java.util.List;
  6. public interface ICacheService
  7. {
  8.     /**
  9.      *
  10.      * put:设置缓存值. <br/>
  11.      */
  12.     public void put(String key, Serializable val);
  14.     /**
  15.      *
  16.      * putWithoutNotice:设置缓存不通知其他服务器. <br/>
  17.      */
  18.     public void putWithoutNotice(String key, Serializable val);
  20.     /**
  21.      *
  22.      * remove:根据key来移除缓存. <br/>
  23.      */
  24.     public void remove(String key);
  26.     /**
  27.      *
  28.      * removeWithoutNotice:根据key来移除缓存不通知其他服务器. <br/>
  29.      */
  30.     public void removeWithoutNotice(String key);
  32.     /**
  33.      *
  34.      * removeAll:清空缓存. <br/>
  35.      */
  36.     public void removeAll();
  38.     /**
  39.      *
  40.      * removeAllWithoutNotice:清空缓存不通知其他服务器. <br/>
  41.      */
  42.     public void removeAllWithoutNotice();
  44.     /**
  45.      *
  46.      * get:获取缓存值. <br/>
  47.      */
  48.     public Serializable get(String key);
  50.     /**
  51.      *
  52.      * getKeys:获取所有的缓存值. <br/>
  53.      */
  54.     public List getKeys();
  55. }

实现类CacheService

  1. package com.masikkk;
  3. import java.io.Serializable;
  4. import java.util.List;
  6. import net.sf.ehcache.Cache;
  7. import net.sf.ehcache.Element;
  9. public class CacheService implements ICacheService
  10. {
  11.     private Cache cache;
  13.     public Cache getCache()
  14.     {
  15.         return cache;
  16.     }
  18.     public void setCache(Cache cache)
  19.     {
  20.         this.cache = cache;
  21.     }
  23.     public void put(String key, Serializable val)
  24.     {
  25.         Element element = new Element(key,val);
  26.         this.getCache().put(element);
  28.     }
  30.     public void putWithoutNotice(String key, Serializable val)
  31.     {
  32.         Element element = new Element(key,val);
  33.         this.getCache().put(element,true);
  35.     }
  37.     public void remove(String key)
  38.     {
  39.         this.getCache().remove(key);
  40.     }
  42.     public void removeWithoutNotice(String key)
  43.     {
  44.         this.getCache().remove(key,true);
  46.     }
  48.     public void removeAll()
  49.     {
  50.         this.getCache().removeAll();
  52.     }
  54.     public void removeAllWithoutNotice()
  55.     {
  56.         this.getCache().removeAll(true);
  58.     }
  60.     @SuppressWarnings("deprecation")
  61.     public Serializable get(String key)
  62.     {
  63.         Element element = this.getCache().get(key);
  64.         if (element != null)
  65.         {
  66.             return element.getValue();
  67.         }
  68.         return null;
  70.     }
  72.     public List getKeys()
  73.     {
  74.         return this.getCache().getKeys();
  76.     }
  78. }

ehcache.xml配置

classpath:config/ehcache.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ehcache updateCheck="false">
  4.     <!-- Sets the path to the directory where cache .data files are created.
  6.          If the path is a Java System Property it is replaced by
  7.          its value in the running VM.
  9.          The following properties are translated:
  10.          user.home - User's home directory
  11.          user.dir - User's current working directory
  12.          java.io.tmpdir - Default temp file path -->
  13.     <diskStore path="java.io.tmpdir"/>
  15.     <cacheManagerPeerProviderFactory
  16.         class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  17.         properties="peerDiscovery=manual,rmiUrls=//10.220.43.86:5000/re|//10.220.43.86:5000/rule" />
  19.     <cacheManagerPeerListenerFactory
  20.         class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
  21.         properties="hostName=10.220.43.85,port=5000,socketTimeoutMillis=120000" />
  23.     <defaultCache
  24.         maxElementsInMemory="10000"
  25.         eternal="false"
  26.         overflowToDisk="true"
  27.         timeToIdleSeconds="120"
  28.         timeToLiveSeconds="120"
  29.         diskPersistent="false"
  30.         diskExpiryThreadIntervalSeconds="120"/>
  32.     <cache name="authCache" maxElementsInMemory="10000"
  33.          eternal="false" overflowToDisk="false"
  34.          timeToIdleSeconds="60"
  35.         timeToLiveSeconds="120" memoryStoreEvictionPolicy="LFU" />
  37.     <cache name="resourceCache" maxElementsInMemory="10000"
  38.          eternal="true" overflowToDisk="false"
  39.          timeToIdleSeconds="0"
  40.         timeToLiveSeconds="0" memoryStoreEvictionPolicy="LFU" />
  42.     <cache name="re" maxElementsInMemory="10000"
  43.          eternal="false" overflowToDisk="false"
  44.          timeToIdleSeconds="0"
  45.          timeToLiveSeconds="0" memoryStoreEvictionPolicy="LFU" >
  46.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
  47.     </cache>
  49.     <cache name="rule" maxElementsInMemory="1000"
  50.          eternal="false" overflowToDisk="false"
  51.          timeToIdleSeconds="0"
  52.          timeToLiveSeconds="0" memoryStoreEvictionPolicy="LFU" >
  53.         <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
  54.     </cache>
  55. </ehcache>

Spring配置

classpath:config/applicationContext-cache.xml

  1. <!-- 配置eh缓存管理器，加载配置文件ehcache.xml -->
  2. <bean id="cacheManager"
  3.     class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
  4.     <property name="configLocation">
  5.         <value>classpath:config/ehcache.xml</value>
  6.     </property>
  7.     <property name="shared"><value>true</value></property>
  8. </bean>
  10. <!-- 配置一个简单的缓存工厂bean对象 -->
  11. <bean id="reCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  12.     <property name="cacheManager" ref="cacheManager" />
  13.     <!-- 使用缓存 关联ehcache.xml中的缓存配置 -->
  14.     <property name="cacheName" value="re" />
  15. </bean>
  17. <bean id="cacheService" class="com.masikkk.CacheService">
  18.     <property name="cache" ref="reCache" />
  19. </bean>
  21. <!-- 配置一个简单的缓存工厂bean对象 -->
  22. <bean id="ruleCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  23.     <property name="cacheManager" ref="cacheManager" />
  24.     <!-- 使用缓存 关联ehcache.xml中的缓存配置 -->
  25.     <property name="cacheName" value="rule" />
  26. </bean>
  28. <bean id="ruleRegistryCache" class="com.masikkk.RuleRegistryCache">
  29.     <property name="cache" ref="ruleCache"/>
  30. </bean>

参考

上一篇 Apache-Camel

下一篇 TortoiseSVN使用笔记

阅读
评论
5.8k字
阅读预计24分钟
创建日期 2016-11-03
修改日期 2017-07-25
类别
标签
目录

页面信息

location:
protocol: http:
host: devgou.com
hostname: devgou.com
origin: http://devgou.com
pathname: /article/Ehcache/
href: http://devgou.com/article/Ehcache/
document:
referrer:
navigator:
platform: Linux x86_64
userAgent: Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)

评论

▲