Ehcache与terracotta集群配置

逃离我推掉我的手 2022-05-15 13:34 178阅读 0赞

首先下载Ehcache，我下载的是ehcache-2.5.2，下载后解压文件，目录结构如下：

![d0e5b636-5170-3979-bf61-f7366a8498ef.jpg][]

主要说明下terracotta这个目录，这个是terracotta服务器，里面有个bin目录，包含启动服务器和关闭服务的脚本，以及开发控制台：

start-tc-server.bat   开启服务器

dev-console.bat    开发控制台（可以监控terracotta服务器）

下面开始进入正题（搭建ehcache环境、java环境的省略了，大家自己动动手），主要说明下服务器，为了与正式环境贴近，我在自己电脑上开了个虚拟机，这样就相当于2台电脑了：

A服务器：192.168.1.100

B服务器：192.168.1.131

然后将ehcache分别放到A服务器和B服务器里。服务器搭建好后，开始动手写ehcache测试类，分别建立一个ehcache（放到A服务器中）与ehcache\_1（放到B服务器中）的项目（项目代码基本一样，ehcache项目有点区别），下面说明2个项目的ehcache.xml的配置信息：

Ehcache项目中的ehcache.xml的配置信息：

Xml代码 [![复制代码][icon_copy.gif]][icon_copy.gif 1] [![收藏代码][icon_star.png]![spinner.gif][]][icon_star.png_spinner.gif]

1. <?xml version="1.0" encoding="UTF-8"?> 
2.  
3. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
4.          xsi:noNamespaceSchemaLocation="ehcache.xsd" 
5.          updateCheck="true" monitoring="off" 
6.          dynamicConfig="true"> 
7.  
8.    
9.     <cacheManagerEventListenerFactory class="" properties=""/> 
10.  
11.     <terracottaConfig url="192.168.1.100:9510,192.168.1.131:9510"/>  
12.  
13.     <defaultCache 
14.            maxEntriesLocalHeap="0" 
15.            eternal="false" 
16.            overflowToDisk="false" 
17.            timeToIdleSeconds="30" 
18.            timeToLiveSeconds="60"> 
19.            <terracotta clustered="true" />  
20.     </defaultCache> 
21.      
22.     <cache name="demoCache"  
23.             maxBytesLocalHeap="200M" 
24.             eternal="false" 
25.             overflowToDisk="false" 
26.             timeToIdleSeconds="30" 
27.             timeToLiveSeconds="60" 
28.             memoryStoreEvictionPolicy="LFU" 
29.             maxElementsOnDisk="100000" 
30.             > 
31.     <terracotta clustered="true" />  
32.     </cache> 
33.  
34. </ehcache> 
35.

<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true" monitoring="off" dynamicConfig="true"> <cacheManagerEventListenerFactory class="" properties=""/> <terracottaConfig url="192.168.1.100:9510,192.168.1.131:9510"/>  <defaultCache maxEntriesLocalHeap="0" eternal="false" overflowToDisk="false" timeToIdleSeconds="30" timeToLiveSeconds="60"> <terracotta clustered="true" />  </defaultCache> <cache name="demoCache" 		maxBytesLocalHeap="200M" 		eternal="false" 		overflowToDisk="false" 		timeToIdleSeconds="30" 		timeToLiveSeconds="60" 		memoryStoreEvictionPolicy="LFU" 		maxElementsOnDisk="100000" 		> <terracotta clustered="true" /> </cache></ehcache>

Ehcache\_1项目中的ehcache.xml的配置信息与ehcache项目中的一样。

项目配置好后，准备启动terracotta服务器，启动服务器之前，先写一段terracotta的配置文件，新建一个tc-config.xml的文件，内容如下：

Xml代码 [![复制代码][icon_copy.gif]][icon_copy.gif 1] [![收藏代码][icon_star.png]![spinner.gif][]][icon_star.png_spinner.gif]

1. <?xml version="1.0" encoding="UTF-8" ?> 
2. <tc:tc-config xmlns:tc="http://www.terracotta.org/config"> 
3.    <servers> 
4.        
5.      <server host="192.168.1.100" name="Server1"> 
6.        <data>%(user.home)/terracotta/server-data</data> 
7.        <logs>%(user.home)/terracotta/server-logs</logs> 
8.      </server> 
9.        
10.       
11.    <server host="192.168.1.131" name="Server2">  
12.      <data>%(user.home)/terracotta/server-data</data> 
13.      <logs>%(user.home)/terracotta/server-logs</logs> 
14.    </server>  
15.     
17.    
18.    <ha>  
19.    <mode>networked-active-passive</mode> 
20.    <networked-active-passive> 
21.      <election-time>5</election-time> 
22.    </networked-active-passive> 
23. </ha> 
24.  
25.   </servers> 
26.   
27.    <clients> 
28.           <logs>%(user.home)/terracotta/client-logs</logs> 
29.    </clients> 
30. </tc:tc-config>

<?xml version="1.0" encoding="UTF-8" ?> <tc:tc-config xmlns:tc="http://www.terracotta.org/config"> <servers>  <server host="192.168.1.100" name="Server1"> <data>%(user.home)/terracotta/server-data</data> <logs>%(user.home)/terracotta/server-logs</logs> </server>  <server host="192.168.1.131" name="Server2"> <data>%(user.home)/terracotta/server-data</data> <logs>%(user.home)/terracotta/server-logs</logs> </server>  <ha> <mode>networked-active-passive</mode> <networked-active-passive> <election-time>5</election-time> </networked-active-passive> </ha> </servers>  <clients> <logs>%(user.home)/terracotta/client-logs</logs> </clients> </tc:tc-config>

上面的配置信息中配置了2个server，一个是本机的（A服务器），另外一个是B服务器的，如果此处只配置一个服务器，比如本机的服务器，而不将B服务器配置在这里，将无法建立集群。

然后将tc-config.xml分别放到A服务器和B服务器的ehcache\\terracotta\\bin下，下面开始分别启动A、B服务器的terracotta，在ehcache\\terracotta\\bin下找到start-tc-server.bat，下面是启动命令：

start-tc-server.bat–f tc-config.xml ---f表示从指定配置文件启动

启动结果如下图：

A服务器：

![aabf9a19-2140-36fa-a635-58b094534e78.png][]

B服务器：

![febe7859-df23-3b5e-9899-38e3f1174424.jpg][]

从启动结果中可以看到NodeID\[XXXXXX\] joined the cluster，节点已加入集群，代表terracotta结群建立成功，下面运行测试代码：  
A服务器：

Java代码 [![复制代码][icon_copy.gif]][icon_copy.gif 1] [![收藏代码][icon_star.png]![spinner.gif][]][icon_star.png_spinner.gif]

1. import net.sf.ehcache.Cache; 
2. import net.sf.ehcache.CacheManager; 
3. import net.sf.ehcache.Element; 
4.  
5. public class EhcacheDemo \{ 
6.      
7.     private static final CacheManager CACHE\_MANAGER = CacheManager.create(); 
8.      
9.     public static Cache getCache(String cacheName)\{ 
10.         return CACHE\_MANAGER.getCache(cacheName); 
11.     \} 
12.      
13.     public static Object getObjectValue(String key)\{ 
14.          Element e = getCache("demoCache").get(key); 
15.          Object val = null; 
16.          if(e == null)\{ 
17.                 System.out.println("缓存中不存在,读取数据"); 
18.                 /\*\*用于测试集群是否正常工作,当缓存中的数据超时时加入新数据，同时将B服务器中的terracotta服务器关闭，测试B服务器中的程序是否能够获取数据
19.                  \* 
20.                  \* \*/ 
21.                 EhcacheDemo.put("name", "11111"); 
22.                 EhcacheDemo.put("password", "333"); 
23.          \}else\{ 
24.              val = e.getObjectValue(); 
25.          \} 
26.          return val; 
27.     \} 
28.      
29.     public static void put(String key, Object val)\{ 
30.         Element e = new Element(key, val); 
31.         getCache("demoCache").put(e); 
32.     \} 
33.      
34.     public static void delete(String key)\{ 
35.         getCache("demoCache").remove(key); 
36.     \} 
37.      
38.      
39.     public void close()\{ 
40.         CACHE\_MANAGER.shutdown(); 
41.     \} 
42.  
43.     /\*\*
44.      \* @param args
45.      \*/ 
46.     public static void main(String\[\] args) \{ 
47.         EhcacheDemo.put("name", "sssssss"); 
48.         EhcacheDemo.put("password", "22222"); 
49.         Thread t = new Thread(new Runnable() \{ 
50.              
51.             @Override 
52.             public void run() \{ 
53.                 while(true)\{ 
54.                     try \{ 
55.                         Thread.currentThread().sleep(10000L); 
56.                     \} catch (InterruptedException e) \{ 
57.                         e.printStackTrace(); 
58.                     \} 
59.                     System.out.println(EhcacheDemo.getObjectValue("name") +"   "+ getObjectValue("password")); 
60.                 \} 
61.                  
62.             \} 
63.         \}); 
64.  
65.         t.start(); 
66.     \} 
67.  
68. \} 
69.

import net.sf.ehcache.Cache;import net.sf.ehcache.CacheManager;import net.sf.ehcache.Element;public class EhcacheDemo {		private static final CacheManager CACHE_MANAGER = CacheManager.create();		public static Cache getCache(String cacheName){		return CACHE_MANAGER.getCache(cacheName);	}		public static Object getObjectValue(String key){		 Element e = getCache("demoCache").get(key);		 Object val = null;		 if(e == null){			 	System.out.println("缓存中不存在,读取数据");				/**用于测试集群是否正常工作,当缓存中的数据超时时加入新数据，同时将B服务器中的terracotta服务器关闭，测试B服务器中的程序是否能够获取数据				 * 				 * */			 	EhcacheDemo.put("name", "11111");				EhcacheDemo.put("password", "333");		 }else{			 val = e.getObjectValue();		 }		 return val;	}		public static void put(String key, Object val){		Element e = new Element(key, val);		getCache("demoCache").put(e);	}		public static void delete(String key){		getCache("demoCache").remove(key);	}			public void close(){		CACHE_MANAGER.shutdown();	}	/**	 * @param args	 */	public static void main(String[] args) {		EhcacheDemo.put("name", "sssssss");		EhcacheDemo.put("password", "22222");		Thread t = new Thread(new Runnable() {						@Override			public void run() {				while(true){					try {						Thread.currentThread().sleep(10000L);					} catch (InterruptedException e) {						e.printStackTrace();					}					System.out.println(EhcacheDemo.getObjectValue("name") +"   "+ getObjectValue("password"));				}							}		});		t.start();	}}

B服务器：

Java代码 [![复制代码][icon_copy.gif]][icon_copy.gif 1] [![收藏代码][icon_star.png]![spinner.gif][]][icon_star.png_spinner.gif]

1. import net.sf.ehcache.Cache; 
2. import net.sf.ehcache.CacheManager; 
3. import net.sf.ehcache.Element; 
4.  
5. public class EhcacheDemo \{ 
6.      
7.     private static final CacheManager CACHE\_MANAGER = CacheManager.create(); 
8.      
9.     public static Cache getCache(String cacheName)\{ 
10.         return CACHE\_MANAGER.getCache(cacheName); 
11.     \} 
12.      
13.     public static Object getObjectValue(String key)\{ 
14.          Element e = getCache("demoCache").get(key); 
15.          Object val = null; 
16.          if(e == null)\{ 
17.                 System.out.println("缓存中不存在,读取数据"); 
18.          \}else\{ 
19.              val = e.getObjectValue(); 
20.          \} 
21.          return val; 
22.     \} 
23.      
24.     public static void put(String key, Object val)\{ 
25.         Element e = new Element(key, val); 
26.         getCache("demoCache").put(e); 
27.     \} 
28.      
29.     public static void delete(String key)\{ 
30.         getCache("demoCache").remove(key); 
31.     \} 
32.      
33.      
34.     public void close()\{ 
35.         CACHE\_MANAGER.shutdown(); 
36.     \} 
37.  
38.     /\*\*
39.      \* @param args
40.      \*/ 
41.     public static void main(String\[\] args) \{ 
42.         EhcacheDemo.put("name", "sssssss"); 
43.         EhcacheDemo.put("password", "22222"); 
44.         Thread t = new Thread(new Runnable() \{ 
45.              
46.             @Override 
47.             public void run() \{ 
48.                 while(true)\{ 
49.                     try \{ 
50.                         Thread.currentThread().sleep(10000L); 
51.                     \} catch (InterruptedException e) \{ 
52.                         e.printStackTrace(); 
53.                     \} 
54.                     System.out.println(EhcacheDemo.getObjectValue("name") +"   "+ getObjectValue("password")); 
55.                 \} 
56.                  
57.             \} 
58.         \}); 
59.  
60.         t.start(); 
61.     \} 
62.  
63. \} 
64.

import net.sf.ehcache.Cache;import net.sf.ehcache.CacheManager;import net.sf.ehcache.Element;public class EhcacheDemo {		private static final CacheManager CACHE_MANAGER = CacheManager.create();		public static Cache getCache(String cacheName){		return CACHE_MANAGER.getCache(cacheName);	}		public static Object getObjectValue(String key){		 Element e = getCache("demoCache").get(key);		 Object val = null;		 if(e == null){			 	System.out.println("缓存中不存在,读取数据");		 }else{			 val = e.getObjectValue();		 }		 return val;	}		public static void put(String key, Object val){		Element e = new Element(key, val);		getCache("demoCache").put(e);	}		public static void delete(String key){		getCache("demoCache").remove(key);	}			public void close(){		CACHE_MANAGER.shutdown();	}	/**	 * @param args	 */	public static void main(String[] args) {		EhcacheDemo.put("name", "sssssss");		EhcacheDemo.put("password", "22222");		Thread t = new Thread(new Runnable() {						@Override			public void run() {				while(true){					try {						Thread.currentThread().sleep(10000L);					} catch (InterruptedException e) {						e.printStackTrace();					}					System.out.println(EhcacheDemo.getObjectValue("name") +"   "+ getObjectValue("password"));				}							}		});		t.start();	}}

A与B服务器中的程序有一点区别，详见注释部分，主要为了测试集群是否工作正常，当一个节点挂掉之后，B服务器上的测试程序是否能获取新的缓存数据。

同时运行2个测试程序后，我们可以观察terracotta是否正常工作，运行ehcache\\terracotta\\bin下的dev-console.bat并连接到2个服务器的terracotta服务器：

![556f5b27-01dc-3b18-8ff0-e66e5055a8bd.jpg][]

从上图中可以看到数据与请求已经同步（connected clients），下面我们再测试将B服务器中的terracotta服务器关闭，然后观察B服务器上的测试数据是否能获取数据：

![bc62208e-c2b8-31ab-acd0-3575da32c8d5.jpg][]

从上图可以看出，可以获取数据。代表数据获取正常而B服务器中的terracotta服务器已经关闭了（如下图）：

![9d4a193d-e0a1-395b-bfd7-1fba076e2654.jpg][]

至此Ehcache与terracotta的分布式缓存配置就完成了。下面说下配置过程中需要注意的位置，也是本人刚开始搭建的时候遇到的问题，主要是数据与请求不能同步的问题，该问题主要是tc-config.xml没有配置好，刚开始我只配置了一个server，也就是分别只配置了本机的IP，后来查看官方文档后，将A、B服务器的terracotta服务器都加入进去就可以了。

[d0e5b636-5170-3979-bf61-f7366a8498ef.jpg]: /images/20220515/50857f21f1dc4e848f334320d2efbb80.png
[icon_copy.gif]: http://bluewind1521.iteye.com/images/icon_copy.gif
[icon_copy.gif 1]: http://bluewind1521.iteye.com/blog/1636283#
[icon_star.png]: http://bluewind1521.iteye.com/images/icon_star.png
[spinner.gif]: /images/20220515/247ae129bd7f496d98ccd42dd7e5a7ca.png
[icon_star.png_spinner.gif]: http://lib.csdn.net/article/java/66318?knId=273
[aabf9a19-2140-36fa-a635-58b094534e78.png]: /images/20220515/8b59a638b26b4a36b58d1ffcf60831a3.png
[febe7859-df23-3b5e-9899-38e3f1174424.jpg]: /images/20220515/8523df9aa19849bb9051ea9f2ff24349.png
[556f5b27-01dc-3b18-8ff0-e66e5055a8bd.jpg]: /images/20220515/b56caa58b30d4a54ad54fb3ce2dcc2ec.png
[bc62208e-c2b8-31ab-acd0-3575da32c8d5.jpg]: /images/20220515/e96cdd46cbca4ac6822d00fa29a50a98.png
[9d4a193d-e0a1-395b-bfd7-1fba076e2654.jpg]: /images/20220515/d91460260b01485998b81538d71385af.png