您的位置：首页 > 其它

EhCache 分布式缓存/缓存集群

2015-10-28 23:51 387 查看
开发环境：

System：Windows

JavaEEServer：tomcat5.0.2.8、tomcat6

JavaSDK：jdk6+

IDE：eclipse、MyEclipse6.6

开发依赖库：

JDK6、JavaEE5、ehcache-core-2.5.2.jar

Email：hoojo_@126.com

Blog：http://blog.csdn.net/IBM_hoojo

http://hoojo.cnblogs.com/

http://hoojo.blogjava.net

前面2篇文章介绍到Ehcache整合Spring使用页面、对象缓存/article/4791921.html

在Spring、Hibernate中使用Ehcache缓存/article/4791922.html

一、缓存系统简介

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

EhCache应用架构图，下图是EhCache在应用程序中的位置：



EhCache的主要特性有：


1.快速、精干；

2.简单；

3.多种缓存策略；

4.缓存数据有两级：内存和磁盘，因此无需担心容量问题；

5.缓存数据会在虚拟机重启的过程中写入磁盘；

6.可以通过RMI、可插入API等方式进行分布式缓存；

7.具有缓存和缓存管理器的侦听接口；

8.支持多缓存管理器实例，以及一个实例的多个缓存区域；

9.提供Hibernate的缓存实现；



由于EhCache是进程中的缓存系统，一旦将应用部署在集群环境中，每一个节点维护各自的缓存数据，当某个节点对缓存数据进行更新，这些更新的数据无法在其它节点中共享，这不仅会降低节点运行的效率，而且会导致数据不同步的情况发生。例如某个网站采用A、B两个节点作为集群部署，当A节点的缓存更新后，而B节点缓存尚未更新就可能出现用户在浏览页面的时候，一会是更新后的数据，一会是尚未更新的数据，尽管我们也可以通过SessionSticky技术来将用户锁定在某个节点上，但对于一些交互性比较强或者是非Web方式的系统来说，SessionSticky显然不太适合。

所以就需要用到EhCache的集群解决方案。


从1.2版本开始，Ehcache可以使用分布式的缓存了。EhCache从1.7版本开始，支持五种集群方案，分别是：


•Terracotta

•RMI

•JMS

•JGroups

•EhCacheServer

其中的三种最为常用集群方式，分别是RMI、JGroups以及EhCacheServer。本文主要介绍RMI的方式。

分布式这个特性是以plugin的方式实现的。Ehcache自带了一些默认的分布式缓存插件实现，这些插件可以满足大部分应用的需要。如果需要使用其他的插件那就需要自己开发了，开发者可以通过查看distribution包里的源代码及JavaDoc来实现它。尽管不是必须的，在使用分布式缓存时理解一些ehcahce的设计思想也是有帮助的。这可以参看分布式缓存设计的页面。以下的部分将展示如何让分布式插件同ehcache一起工作。


下面列出的是一些分布式缓存中比较重要的方面：


•你如何知道集群环境中的其他缓存？

•分布式传送的消息是什么形式？

•什么情况需要进行复制？增加（Puts），更新（Updates）或是失效（Expiries）？

•采用什么方式进行复制？同步还是异步方式？

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

它们对于一个CacheManager来说是全局的。每个进行分布式操作的cache都要添加一个cacheEventListener来传送消息。



二、集群缓存概念及其配置

正确的元素类型


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


成员发现（PeerDiscovery）


Ehcache进行集群的时候有一个cache组的概念。每个cache都是其他cache的一个peer，没有主cache的存在。刚才我们问了一个问题：你如何知道集群环境中的其他缓存？这个问题可以命名为成员发现（PeerDiscovery）。

Ehcache提供了两种机制用来进行成员发现，就像一辆汽车：手动档和自动档。要使用一个内置的成员发现机制要在ehcache的配置文件中指定cacheManagerPeerProviderFactory元素的class属性为

net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory。


自动的成员发现


自动的发现方式用TCP广播机制来确定和维持一个广播组。它只需要一个简单的配置可以自动的在组中添加和移除成员。在集群中也不需要什么优化服务器的知识，这是默认推荐的。

成员每秒向群组发送一个“心跳”。如果一个成员5秒种都没有发出信号它将被群组移除。如果一个新的成员发送了一个“心跳”它将被添加进群组。

任何一个用这个配置安装了复制功能的cache都将被其他的成员发现并标识为可用状态。

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

multicastGroupAddress=multicastaddress|multicasthostname

multicastGroupPort=port

timeToLive=0-255(timeToLive属性详见常见问题部分的描述)


示例


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

[code]
[code]<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="peerDiscovery=automatic,multicastGroupAddress=230.0.0.1,

multicastGroupPort=4446,timeToLive=32"/>

[/code]
[/code]

手动进行成员发现


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

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


示例


假设你在集群中有两台服务器。你要同步sampleCache1和sampleCache2。下面是每个服务器需要的配置：
配置server1

[code]
[code]<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="peerDiscovery=manual,

rmiUrls=//server2:40001/sampleCache11|//server2:40001/sampleCache12"/>

[/code]
[/code]

配置server2

[code]
[code]<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="peerDiscovery=manual,

rmiUrls=//server1:40001/sampleCache11|//server1:40001/sampleCache12"/>

[/code]
[/code]

配置CacheManagerPeerListener


每个CacheManagerPeerListener监听从成员们发向当前CacheManager的消息。配置CacheManagerPeerListener需要指定一个CacheManagerPeerListenerFactory，它以插件的机制实现，用来创建CacheManagerPeerListener。

cacheManagerPeerListenerFactory的属性有：
class–一个完整的工厂类名。
properties–只对这个工厂有意义的属性，使用逗号分隔。

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

RMICacheManagerPeerListenerFactory来配置。

[code]
[code]<cacheManagerPeerListenerFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"

properties="hostName=localhost,port=40001,

socketTimeoutMillis=2000"/>

[/code]
[/code]
有效的属性是：
hostname(可选)–运行监听器的服务器名称。标明了做为集群群组的成员的地址，同时也是你想要控制的从集群中接收消息的接口。

在CacheManager初始化的时候会检查hostname是否可用。

如果hostName不可用，CacheManager将拒绝启动并抛出一个连接被拒绝的异常。

如果指定，hostname将使用InetAddress.getLocalHost().getHostAddress()来得到。

警告：不要将localhost配置为本地地址127.0.0.1，因为它在网络中不可见将会导致不能从远程服务器接收信息从而不能复制。在同一台机器上有多个CacheManager的时候，你应该只用localhost来配置。

port–监听器监听的端口。
socketTimeoutMillis(可选)–Socket超时的时间。默认是2000ms。当你socket同步缓存请求地址比较远，不是本地局域网。你可能需要把这个时间配置大些，不然很可能延时导致同步缓存失败。


配置CacheReplicators


每个要进行同步的cache都需要设置一个用来向CacheManagerr的成员复制消息的缓存事件监听器。这个工作要通过为每个cache的配置增加一个cacheEventListenerFactory元素来完成。

[code]
[code]<!--SamplecachenamedsampleCache2.-->

<cachename="sampleCache2"

maxElementsInMemory="10"

eternal="false"

timeToIdleSeconds="100"

timeToLiveSeconds="100"

overflowToDisk="false">

<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.RMICacheReplicatorFactory"

properties="replicateAsynchronously=true,replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>

</cache>

[/code]
[/code]
class–使用net.sf.ehcache.distribution.RMICacheReplicatorFactory

这个工厂支持以下属性：
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。

你可以使用ehcache的默认行为从而减少配置的工作量，默认的行为是以异步的方式复制每件事；你可以像下面的例子一样减少RMICacheReplicatorFactory的属性配置：

[code]
[code]<!--SamplecachenamedsampleCache4.AllmissingRMICacheReplicatorFactorypropertiesdefaulttotrue-->

<cachename="sampleCache4"

maxElementsInMemory="10"

eternal="true"

overflowToDisk="false"

memoryStoreEvictionPolicy="LFU">

<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>

</cache>

[/code]
[/code]

常见的问题

Windows上的Tomcat


有一个Tomcat或者是JDK的bug，在tomcat启动时如果tomcat的安装路径中有空格的话，在启动时RMI监听器会失败。参见http://archives.java.sun.com/cgi-bin/wa?A2=ind0205&L=rmi-users&P=797和http://www.ontotext.com/kim/doc/sys-doc/faq-howto-bugs/known-bugs.html。

由于在Windows上安装Tomcat默认是装在“ProgramFiles”文件夹里的，所以这个问题经常发生。


广播阻断


自动的peerdiscovery与广播息息相关。广播可能被路由阻拦，像Xen和VMWare这种虚拟化的技术也可以阻拦广播。如果这些都打开了，你可能还在要将你的网卡的相关配置打开。一个简单的办法可以告诉广播是否有效，

那就是使用ehcacheremotedebugger来看“心跳”是否可用。


广播传播的不够远或是传得太远


你可以通过设置badlymisnamedtimetolive来控制广播传播的距离。用广播IP协议时，timeToLive的值指的是数据包可以传递的域或是范围。约定如下：

0是限制在同一个服务器

1是限制在同一个子网

32是限制在同一个网站

64是限制在同一个region

128是限制在同一个大洲

255是不限制

译者按：上面这些资料翻译的不够准确，请读者自行寻找原文理解吧。

在Java实现中默认值是1，也就是在同一个子网中传播。改变timeToLive属性可以限制或是扩展传播的范围。


三、RMI方式缓存集群/配置分布式缓存


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



下图是RMI集群模式的结构图：




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

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



分布式同步缓存要让这边的cache知道对方的cache，叫做PeerDiscovery（成员发现）EHCache实现成员发现的方式有两种：

1、手动查找


A、在ehcache.xml中配置PeerDiscovery成员发现对象

Server1配置，配置本地hostName、port是400001，分别监听192.168.8.32:400002的mobileCache和192.168.5.231:400003的mobileCache。注意这里的mobileCache是缓存的名称，分别对应着server2、server3的cache的配置。

[code]
[code]<?xmlversion="1.0"encoding="gbk"?>

<ehcachexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="ehcache.xsd">

<diskStorepath="java.io.tmpdir"/>


<!--

集群多台服务器中的缓存，这里是要同步一些服务器的缓存

server1hostName:192.168.8.9port:400001cacheName:mobileCache

server2hostName:192.168.8.32port:400002cacheName:mobileCache

server3hostName:192.168.8.231port:400003cacheName:mobileCache

注意：每台要同步缓存的服务器的RMI通信socket端口都不一样，在配置的时候注意设置

-->


<!--server1的cacheManagerPeerProviderFactory配置-->

<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="hostName=localhost,

port=400001,

socketTimeoutMillis=2000,

peerDiscovery=manual,

rmiUrls=//192.168.8.32:400002/mobileCache|//192.168.5.231:400003/mobileCache"

/>

</ehcache>

[/code]
[/code]
以上注意cacheManagerPeerProviderFactory元素出现的位置在diskStore下

同样在你的另外2台服务器上增加配置

Server2，配置本地host，port为400002，分别同步192.168.8.9:400001的mobileCache和192.168.5.231:400003的mobileCache

[code]
[code]<!--server2的cacheManagerPeerProviderFactory配置-->

<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="hostName=localhost,

port=400002,

socketTimeoutMillis=2000,

peerDiscovery=manual,

rmiUrls=//192.168.8.9:400001/mobileCache|//192.168.5.231:400003/mobileCache"

/>

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

[code]
[code]<!--server3的cacheManagerPeerProviderFactory配置-->

<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="hostName=localhost,

port=400003,

socketTimeoutMillis=2000,

peerDiscovery=manual,

rmiUrls=//192.168.8.9:400001/mobileCache|//192.168.8.32:400002/mobileCache"

/>

[/code]
[/code]
这样就在三台不同的服务器上配置了手动查找cache的PeerProvider成员发现的配置了。值得注意的是你在配置rmiUrls的时候要特别注意url不能重复出现，并且端口、地址都是对的。

如果指定，hostname将使用InetAddress.getLocalHost().getHostAddress()来得到。

警告：不要将localhost配置为本地地址127.0.0.1，因为它在网络中不可见将会导致不能从远程服务器接收信息从而不能复制。在同一台机器上有多个CacheManager的时候，你应该只用localhost来配置。

B、下面配置缓存和缓存同步监听，需要在每台服务器中的ehcache.xml文件中增加cache配置和cacheEventListenerFactory、cacheLoaderFactory的配置


[code]
[code]<defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="30"timeToLiveSeconds="30"overflowToDisk="false"/>

<!--

配置自定义缓存

maxElementsInMemory：缓存中允许创建的最大对象数

eternal：缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。

timeToIdleSeconds：缓存数据空闲的最大时间，也就是说如果有一个缓存有多久没有被访问就会被销毁，如果该值是0就意味着元素可以停顿无穷长的时间。

timeToLiveSeconds：缓存数据存活的时间，缓存对象最大的的存活时间，超过这个时间就会被销毁，这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。

overflowToDisk：内存不足时，是否启用磁盘缓存。

memoryStoreEvictionPolicy：缓存满了之后的淘汰算法。


每一个小时更新一次缓存（1小时过期）

-->

<cachename="mobileCache"

maxElementsInMemory="10000"

eternal="false"

overflowToDisk="true"

timeToIdleSeconds="1800"

timeToLiveSeconds="3600"

memoryStoreEvictionPolicy="LFU">

<!--

RMI缓存分布同步查找class使用net.sf.ehcache.distribution.RMICacheReplicatorFactory

这个工厂支持以下属性：

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。

asynchronousReplicationIntervalMillis=1000

-->

<!--监听RMI同步缓存对象配置注册相应的的缓存监听类，用于处理缓存事件，如put,remove,update,和expire-->

<cacheEventListenerFactory

class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"

properties="replicateAsynchronously=true,

replicatePuts=true,

replicateUpdates=true,

replicateUpdatesViaCopy=false,

replicateRemovals=true"/>

<!--用于在初始化缓存，以及自动设置-->

<bootstrapCacheLoaderFactoryclass="net.sf.ehcache.bootstrap.BootstrapCacheLoaderFactory"/>

</cache>

[/code]
[/code]

C、这样就完成了3台服务器的配置，下面给出server1的完整的ehcache.xml的配置

[code]
[code]<?xmlversion="1.0"encoding="gbk"?>

<ehcachexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="ehcache.xsd">

<diskStorepath="java.io.tmpdir"/>


<!--

集群多台服务器中的缓存，这里是要同步一些服务器的缓存

server1hostName:192.168.8.9port:400001cacheName:mobileCache

server2hostName:192.168.8.32port:400002cacheName:mobileCache

server3hostName:192.168.8.231port:400003cacheName:mobileCache

注意每台要同步缓存的服务器的RMI通信socket端口都不一样，在配置的时候注意设置

-->


<!--server1的cacheManagerPeerProviderFactory配置-->

<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="hostName=localhost,

port=400001,

socketTimeoutMillis=2000,

peerDiscovery=manual,

rmiUrls=//192.168.8.32:400002/mobileCache|//192.168.5.231:400003/mobileCache"

/>


<defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="30"timeToLiveSeconds="30"overflowToDisk="false"/>

<!--

配置自定义缓存

maxElementsInMemory：缓存中允许创建的最大对象数

eternal：缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。

timeToIdleSeconds：缓存数据空闲的最大时间，也就是说如果有一个缓存有多久没有被访问就会被销毁，

如果该值是0就意味着元素可以停顿无穷长的时间。

timeToLiveSeconds：缓存数据存活的时间，缓存对象最大的的存活时间，超过这个时间就会被销毁，

这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。

overflowToDisk：内存不足时，是否启用磁盘缓存。

memoryStoreEvictionPolicy：缓存满了之后的淘汰算法。


每一个小时更新一次缓存（1小时过期）

-->

<cachename="mobileCache"

maxElementsInMemory="10000"

eternal="false"

overflowToDisk="true"

timeToIdleSeconds="1800"

timeToLiveSeconds="3600"

memoryStoreEvictionPolicy="LFU">

<!--

RMI缓存分布同步查找class使用net.sf.ehcache.distribution.RMICacheReplicatorFactory

这个工厂支持以下属性：

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。

asynchronousReplicationIntervalMillis=1000

-->

<!--监听RMI同步缓存对象配置注册相应的的缓存监听类，用于处理缓存事件，如put,remove,update,和expire-->

<cacheEventListenerFactory

class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"

properties="replicateAsynchronously=true,

replicatePuts=true,

replicateUpdates=true,

replicateUpdatesViaCopy=false,

replicateRemovals=true"/>

<!--用于在初始化缓存，以及自动设置-->

<bootstrapCacheLoaderFactoryclass="net.sf.ehcache.bootstrap.BootstrapCacheLoaderFactory"/>

</cache>

</ehcache>

[/code]
[/code]

2、自动发现


自动发现配置和手动查找的方式有一点不同，其他的地方都基本是一样的。同样在ehcache.xml中增加配置，配置如下

[code]
[code]<!--

搜索某个网段上的缓存

timeToLive

0是限制在同一个服务器

1是限制在同一个子网

32是限制在同一个网站

64是限制在同一个region

128是限制在同一个大洲

255是不限制

-->

<cacheManagerPeerProviderFactory

class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"

properties="peerDiscovery=automatic,multicastGroupAddress=192.168.0.1,

multicastGroupPort=400004,timeToLive=32"

/>

[/code]
[/code]
其他的配置和手动查找方式的配置是一样的，这里就不再赘述了。关于ehcache的其他缓存配置方式这里将不再介绍，大家可以自己去研究。可以参考：


官方文档：http://www.ehcache.org/documentation/user-guide/cache-topologies#using-a-cache-server

ibmdeveloperworks文档：http://www.ibm.com/developerworks/cn/java/j-lo-ehcache/index.html

JGroups集群模式
EhCache从1.5.版本开始增加了JGroups的分布式集群模式。与RMI方式相比较，JGroups提供了一个非常灵活的协议栈、可靠的单播和多播消息传输，主要的缺点是配置复杂以及一些协议栈对第三方包的依赖。

JGroups也提供了基于TCP的单播(Unicast)和基于UDP的多播(Multicast)，对应RMI的手工配置和自动发现。使用单播方式需要指定其它节点的主机地址和端口，下面是两个节点，并使用了单播方式的配置：



[code]<?xmlversion="1.0"encoding="UTF-8"?>
<ehcachexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">
<diskStorepath="java.io.tmpdir"/>
<cacheManagerPeerProviderFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
properties="connect=TCP(start_port=7800):
TCPPING(initial_hosts=192.168.2.154[7800],192.168.2.23[7800];port_range=10;timeout=3000;
num_initial_members=3;up_thread=true;down_thread=true):
VERIFY_SUSPECT(timeout=1500;down_thread=false;up_thread=false):
pbcast.NAKACK(down_thread=true;up_thread=true;gc_lag=100;retransmit_timeout=3000):
pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;
print_local_addr=false;down_thread=true;up_thread=true)"
propertySeparator="::"/>
<defaultCachemaxElementsInMemory="10000"eternal="true"
overflowToDisk="true"timeToIdleSeconds="0"timeToLiveSeconds="0"
diskPersistent="false"diskExpiryThreadIntervalSeconds="120">
<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
properties="replicateAsynchronously=true,replicatePuts=true,
replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>
</defaultCache>
<cachename="velcroCache"maxElementsInMemory="10000"eternal="true"
overflowToDisk="true"timeToIdleSeconds="0"timeToLiveSeconds="0"
diskPersistent="false"diskExpiryThreadIntervalSeconds="120">
<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
properties="replicateAsynchronously=true,replicatePuts=true,
replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>
</cache>
<cachename="userCache"maxElementsInMemory="10000"eternal="true"
overflowToDisk="true"timeToIdleSeconds="0"timeToLiveSeconds="0"
diskPersistent="false"diskExpiryThreadIntervalSeconds="120">
<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
properties="replicateAsynchronously=true,replicatePuts=true,
replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>
</cache>
<cachename="resourceCache"maxElementsInMemory="10000"
eternal="true"overflowToDisk="true"timeToIdleSeconds="0"
timeToLiveSeconds="0"diskPersistent="false"
diskExpiryThreadIntervalSeconds="120">
<cacheEventListenerFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
properties="replicateAsynchronously=true,replicatePuts=true,
replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>
</cache>
</ehcache>

[/code]

[/code]
                                            
                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                
            

            

                
相关文章推荐

                

                
            

        
        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航

                    

                        

                        
    
                        

                    

                

            

        
 
        

    


    



    

        https://www.geek-share.com/ 
        GeekShare·极客分享·来自极客的分享  © 2016-2019 ·  
        粤ICP备17045047号
         点击这里给我发消息