`

Ehcache集群环境配置

 
阅读更多

Ehcache缓存

概述

Ehcache的类层次模型主要为三层，最上层的是CacheManager,它是操作Ehcache的入口。我们可以通过CacheManager.getInstance()获得一个单CacheManager,或者通过CacheManager的构造函数创建一个新的CacheManager。每个CacheManager都管理着多个Cache。而每个Cache都以一种hash的方式关联着多个Element。而Element则是我们用于存放缓存内容的地方。

 

配置文件（ehcache.xml放置于项目根目录下）

例子：

ehcache.xml

<?xml version="1.0" encoding="UTF-8" ?>
<ehcache
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation=" ehcache.xsd"
updateCheck="true"
monitoring="autodetect"
dynamicConfig="true">
 
<defaultCache
maxElementsInMemory="2"
eternal="false"
timeToIdleSeconds="1"
timeToLiveSeconds="1"
overflowToDisk="false"
memoryStoreEvictionPolicy="LRU"/>
 
<cache name="sampleCache1"
     maxElementsInMemory="5"
     eternal="false"
     overflowToDisk="false"
     timeToIdleSeconds="1"
     timeToLiveSeconds="1"
     memoryStoreEvictionPolicy="LRU"/>

</ehcache>

 注：在ehcache的配置文件里面必须配置defaultCache。每个<cache>标签定义一个新的cache，属性的含义基本上可以从名字上得到。

 

 

实例程序：

package ehcache.test01;

import java.util.List;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

public class test01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//使用ehcache.xml配置文件创建一个缓存管理器
		CacheManager manager = new CacheManager("ehcache.xml");
		//获得ehcache.xml配置文件中sampleCache1缓存的句柄
		Cache cache = manager.getCache("sampleCache1");
		
		for(int i = 0; i< 10 ; i++){
			Element e = new Element("key"+ i ,"value" + i );
			System.out.println(e.toString());
			cache.put(e);
		}

		//更新一条记录
		cache.put(new Element("key7","NewValue7"));
		
		//根据key取得对应element的序列化value值
		System.out.println("Get Serializable value :  " + cache.get("key7").getValue().toString());
		
        //根据key取得对应element的非序列化value值
		System.out.println("Get Non Serializable value :  " + cache.get("key7").getObjectValue().toString());

		//SampleCache1的配置是支持磁盘持久化的。如果想要保证element即时的被输出到磁盘，可以调用cache.flush();
		//cache.flush();
		
		//获得当前cache中的element数量
		System.out.println("cache size =　" + cache.getSize());
		
		//获得当前MemoryStore中的element数量
		System.out.println("cache memorystore size =　" + cache.getMemoryStoreSize());
//获得当前DiskStore中element数量
		System.out.println("cache Diskstore size =　" + cache.getDiskStoreSize());
		
		List<String> keys = cache.getKeys();
		//System.out.println(cache.getKeys().size());
		for(String key : keys){
			System.out.println(key + "," + cache.get(key));
		}
	}
}

 

环境为两台机器

主机A ip：192.168.255.131

主机B ip：192.168.255.130

 

1. RMI方式：

rmi的方式配置要点（下面均是server1上的配置，server2上的只需要把ip兑换即可）

 

具体说明：配置cacheManagerPeerListenerFactory是配宿主主机配置监听程序，来发现其他主机发来的同步请求

配置cacheManagerPeerProviderFactory是指定除自身之外的网络群体中其他提供同步的主机列表，用“|”分开不同的主机。

下面的例子的测试过程是：主机B缓存开启，并从名为UserCache的缓存中循环抓取键值为“key1”的元素，直到取到，才退出循环。主机A缓存启动，并在名为UserCache的缓存中放入键值为“key1”的元素。显然，如果主机B取到的元素，那么就证明同步成功，也就是集群成功。

所以在测试过程中先启动主机B的测试程序，在启动主机A的测试程序。

注意：确保你所监听的端口已被服务器打开

下面具体说配置文件以及测试程序：

<!--[if !supportLists]-->1.       1、主机A的配置文件以及测试源代码

recluster_ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       
    xsi:noNamespaceSchemaLocation="ehcache.xsd">       
    <cacheManagerPeerProviderFactory       
        class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
properties="peerDiscovery=manual,rmiUrls=//192.168.255.130:40000/UserCache"/>       
       
    <cacheManagerPeerListenerFactory       
        class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"       
        properties="hostName=192.168.255.131,port=40000,socketTimeoutMillis=120000" />       
    <defaultCache maxElementsInMemory="10000" eternal="false"       
        timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"       
        diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"       
        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"       
        memoryStoreEvictionPolicy="LRU">       
        <cacheEventListenerFactory       
            class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />       
    </defaultCache>       
       
    <cache name="UserCache" maxElementsInMemory="1000" eternal="false"       
        timeToIdleSeconds="100000" timeToLiveSeconds="100000"       
        overflowToDisk="false">       
        <cacheEventListenerFactory       
            class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />       
    </cache>       
</ehcache>

 Java代码

package ehcache;

import java.net.URL;

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

public class clustertest {

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException{
		// TODO Auto-generated method stub
		//URL url = clustertest.class.getClassLoader().getResource("recluster_ehcache.xml"); 
		CacheManager manager = new CacheManager("recluster_ehcache.xml");
//get Cache        
		Cache cache = manager.getCache("UserCache");        
		Element element = new Element("key1", "value1");   
		cache.put(element);  
		System.out.println("Initial:\n"//+url.toString()
				+"\n"+manager.getName()
				+"\n"+cache.getName()
				+" 's size = "+cache.getSize()
				+"\n"+element.toString());     
		

		Element element1 = cache.get("key1");        
		System.out.println(element1.getValue());   
		//while(true){
		//	Thread.sleep(1000);
		//}
		}
}

 2、 主机B上的配置文件以及测试代码

 

 recluster_ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="ehcache.xsd">
	<cacheManagerPeerProviderFactory
		class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
		properties="peerDiscovery=manual,rmiUrls=//192.168.255.131:40000/UserCache" />

	<cacheManagerPeerListenerFactory
		class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
		properties="hostName=192.168.255.130,port=40000,socketTimeoutMillis=120000" />

	<defaultCache maxElementsInMemory="10000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
		diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
		<cacheEventListenerFactory
			class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />
	</defaultCache>

	<cache name="UserCache" maxElementsInMemory="1000" eternal="false"
		timeToIdleSeconds="100000" timeToLiveSeconds="100000"
overflowToDisk="false">
		<cacheEventListenerFactory
			class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />
	</cache>
</ehcache>

 Java代码

package ehcache;

import java.net.URL;

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

public class cluster_B {

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		//System.out.println("Test begin");
		//URL url = cluster_B.class.getClassLoader().getResource("recluster_ehcache.xml");   
		CacheManager manager = new CacheManager("recluster_ehcache.xml"); 
		//System.out.println(url.toString());
        //get Cache        
        Cache cache = manager.getCache("UserCache");    
        
        int i=0;
        while(true) {     
        	
        	i++;
        	System.out.println(i+". "+cache.getName()+" 's size = "+cache.getSize());
            Element e = cache.get("key1");        
            if(e != null) {        
                System.out.println(e.getValue());        
                break;        
            }        
            Thread.sleep(1000);        
        }  
	}
}

 主机B上成功取出value1即表示成功

 

2. JGroups方式：

ehcache 1.5.0之后版本支持的一种方式，配置起来比较简单，要点：

 

a. 配置PeerProvider，使用tcp的方式，例子如下：

<cacheManagerPeerProviderFactory class="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="::" />

 b.为每个cache添加cacheEventListener：

<cache name="userCache" maxElementsInMemory="10000" eternal="true"
		overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120">
		<cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
			properties="replicateAsynchronously=true, replicatePuts=true,
   				replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>
</cache>

  JGroup方式配置的两个server上的配置文件一样，若有多个server，在initial_hosts中将server ip加上即可。

一个完整的ehcache.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">
	<diskStore path="java.io.tmpdir" />

	<cacheManagerPeerProviderFactory class="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="::" />
<defaultCache maxElementsInMemory="10000" eternal="true"
		overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120">
		<cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
			properties="replicateAsynchronously=true, replicatePuts=true,
   				replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>
	</defaultCache>

	<cache name="velcroCache" maxElementsInMemory="10000" eternal="true"
		overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120">
		<cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
			properties="replicateAsynchronously=true, replicatePuts=true,
   				replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>
	</cache>
	<cache name="userCache" maxElementsInMemory="10000" eternal="true"
		overflowToDisk="true" timeToIdleSeconds="0" timeToLiveSeconds="0"
		diskPersistent="false" diskExpiryThreadIntervalSeconds="120">
		<cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
			properties="replicateAsynchronously=true, replicatePuts=true,
   				replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>
	</cache>
	<cache name="resourceCache" maxElementsInMemory="10000"
		eternal="true" overflowToDisk="true" timeToIdleSeconds="0"
		timeToLiveSeconds="0" diskPersistent="false"
		diskExpiryThreadIntervalSeconds="120">
		<cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
			properties="replicateAsynchronously=true, replicatePuts=true,
   				replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true"/>
	</cache>
</ehcache>

 

 

 

分享到：
| Python入门
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Ehcache集群实例

    4. **Ehcache集群配置**：要设置Ehcache集群，首先需要配置`ehcache.xml`或使用代码配置。在配置中，需要指定集群使用的通信机制，例如JGroups配置文件。JGroups配置文件定义了集群的网络拓扑、传输协议、心跳策略等...

    ehcache集群方案

    3. **JGroups配置**：为了使Ehcache集群正常工作，需要对JGroups进行适当的配置。这包括设置组名、选择适合的传输协议（如TCP或UDP）、配置消息确认机制等。正确的配置有助于优化网络通信，提高数据同步效率。 4. *...

    ehcache集群

    通过以上步骤，你就可以构建起一个基于Ehcache和JGroups的集群环境。在实践中，可能需要根据实际网络环境和应用需求进行更复杂的配置和优化。`ClusterTester`可能是一个用于测试集群连接和数据分发的工具类，你可以...

    Spring Boot 2.x基础教程：使用EhCache缓存集群.docx

    对于每个实例，我们需要创建一个特定的配置文件，例如`ehcache-1.xml`，`ehcache-2.xml`等，以适应集群环境。在配置文件中，我们需要指定`cacheEventListenerFactory`和`cacheManagerPeerProviderFactory`来实现缓存...

    集群环境中使用_EhCache_缓存系统&Ehcache配置文件的详细说明

    本篇文章将深入探讨EhCache在集群环境中的应用及其配置文件的详细设置。 一、EhCache概述 EhCache是由Terracotta公司开发的内存缓存系统，它支持本地缓存和分布式缓存两种模式。EhCache的特点包括：快速存取、内存...

    ehcache使用，以及集群配置

    在集群环境中，Ehcache 使用`terracotta-server`作为分布式管理器。以下是集群配置的关键步骤： 1. **安装Terracotta Server**: 在每台服务器上安装并启动Terracotta Server，它是Ehcache的分布式管理组件。 2. **...

    Ehcache通过Jgroups做集群

    在分布式环境中，为了实现数据共享和高可用性，Ehcache提供了集群功能。而Jgroups则是Java中一个强大的集群通信框架，用于创建容错的集群系统。在Ehcache中，Jgroups被用来实现节点间的通信和同步，确保在集群中的多...

    ehcache rmi集群demo

    这个“ehcache rmi集群demo”提供了一个实践平台，帮助开发者理解Ehcache在分布式环境下的工作原理和RMI通信机制。通过这个示例，我们可以深入学习如何在Java应用中部署和管理一个高性能、可扩展的缓存集群，这对于...

    Ehcache远程复制

    标题“Ehcache远程复制”涉及的知识点主要围绕Ehcache缓存技术中的远程复制机制。Ehcache是Java平台上广泛...开发者可以根据这份手册逐步配置集群环境，从而使得应用系统可以利用Ehcache带来的缓存优势，优化系统性能。

    Ehcache 3（ehcache-clustered-3.8.1-kit.zip）

    TSA 是一个专门用于Ehcache集群的服务器，它提供了分布式锁服务、数据复制和故障检测等功能。当一个节点更新缓存时，TSA会确保这些更改被传播到集群中的其他节点，从而保持数据一致性。 Ehcache 3 集群支持的主要...

    Ehcache RMI Replicated Cluster(RMI集群)

    1. **配置Ehcache**：首先，你需要在每个节点上配置Ehcache，指定使用RMI replication策略。这通常涉及到在`ehcache.xml`配置文件中设置`replicationStrategy`为`rmi`，并提供RMI注册服务器的地址和端口。 2. **...

    ehcache缓存的配置

    - 在集群环境中，这些配置尤其重要，因为它们可以确保不同节点之间的缓存数据一致性。 #### 四、ehcache配置详解 - **内存与硬盘缓存**：通过 `maxElementsInMemory` 和 `maxElementsOnDisk` 属性来控制缓存在内存...

    ehcache-clustered-3.3.1-kit.zip

    在集群环境中，配置需要设置为共享模式，以便所有节点都能访问同一份配置。 2. ** Terracotta服务器**：Ehcache集群依赖于Terracotta服务器进行通信和数据同步。你需要在集群中的所有节点上安装并启动Terracotta，...

    ehcache配置使用详解

    6. **分布式缓存**：通过RMI（Remote Method Invocation）和可插拔API，ehcache支持跨机器的缓存共享，适用于集群环境。 7. **监听接口**：ehcache提供了缓存和缓存管理器的监听接口，便于监控缓存状态和行为。 8. *...

    ehcache基本原理及配置

    3. **** 元素: 如果需要配置集群环境，可以设置Terracotta服务器的相关参数，使Ehcache支持分布式缓存。 4. **** 元素: 定义默认缓存配置，适用于所有未在中定义的缓存实例。 5. **** 和 **** 子元素: 用来设置...

    ehcache jroups tcp udp试用实例

    在Ehcache集群中，JGroups提供了一种机制，使得多个节点可以相互通信，共享数据，从而实现分布式缓存。JGroups支持多种协议栈，包括基于TCP和UDP的通信方式。 1. TCP配置： TCP协议是可靠的，面向连接的协议，适用...

    ehcache-terracotta代码配置

    当与Terracotta结合使用时，Ehcache可以实现分布式缓存，使得多台服务器上的应用可以共享同一份缓存数据，从而构建高可用的集群环境。在本篇中，我们将深入探讨如何在Java项目中配置Ehcache与Terracotta来实现这一...

    EHCache 分布式配置文件

    分布式配置文件是 EHCache 实现多节点共享缓存的关键，允许在分布式环境中存储和检索数据，以实现高可用性和负载均衡。 在 EHCache 中，配置文件是 XML 格式的，通过这些文件我们可以定义缓存策略，包括缓存的大小...

Magicbox
Global site tag (gtag.js) - Google Analytics