图片 13

5个强大的Java分布式缓存框架推荐

本文由码农网 –
小峰原创,转发请看清文末的转发须要,迎接出席大家的付费投稿布置!

在付出中山高校型Java软件项目时,超多Java构造师都会遇见数据库读写瓶颈,假使您在系统构造时并未将缓存计策思虑进来,大概并不曾接纳更优的
缓存战略,那么到时候重构起来将会是三个梦魇。本文重借使享受了5个常用的Java布满式缓存框架,那一个缓存框架扶持多台服务器的缓存读写作用,能够让你的缓存系统更便于扩大。

EhCache 缓存系统简要介绍

EhCache 是三个纯 Java 的经过内缓存框架,具备高效、精干等风味,是
Hibernate 中暗许的 CacheProvider。

下图是 EhCache 在应用程序中之处:

Voldemort是一款基于Java开垦的遍布式键-值缓存系统,像JBoss
Cache无异于,Voldemort相像协助多台服务器之间的缓存同步,以拉长系统的可信赖性和读取质量。

 1、Ehcache – Java遍及式缓存框架

  Ehcache是一个Java实现的开源遍及式缓存框架,EhCache
能够使得地减轻数据库的载重,可以让多都督存在不一致服务器的内部存款和储蓄器中,在须要多少的时候可以快捷存取。同期EhCache
增加特别轻便,官方提供的Cache配置格局有好二种。你能够由此注明配置、在xml中安顿、在程序里计划也许调用结构方法时传出分歧的参数。

图片 1

  官方网址:

  Ehcache有以下特征:

  • 存取速度超级快,质量很科学。
  • 能够动用多种缓存战术。
  • 分别缓存,客户能够钦命哪些数据在硬盘中缓存,哪些数据在内部存款和储蓄器中缓存。
  • 能够透过RMI、可插入API等格局张开布满式缓存。
  • 具有缓存和缓存管理器的侦听接口。
  • 支持多缓存微处理机实例,以至三个实例的多个缓存区域。
  • 暗许提供Hibernate的缓存达成。

  Ehcache的安插示范代码:

总结  

在同类的Java缓存框架中,Ehcache配置相对简便易行,也相比便于上手,最大的优势是它扶持分布式缓存

 

图 1. EhCache 利用结构图

图片 2

EhCache 的首要特征有:

  1. 快速;
  2. 简单;
  3. 各个缓存战术;
  4. 缓存数占领两级:内部存款和储蓄器和磁盘,因而无需忧虑体积难题;
  5. 缓存数据会在虚构机重启的进度中写入磁盘;
  6. 能够因此 RMI、可插入 API 等办法实行布满式缓存;
  7. 不无缓存和缓存微处理机的侦听接口;
  8. 扶植多缓存微型机实例,以至二个实例的五个缓存区域;
  9. 提供 Hibernate 的缓存达成;
  10. 等等 …

出于 EhCache
是经过中的缓存系统,一旦将利用布置在集群情况中,每一个节点维护各自的缓存数据,当某些节点对缓存数据举办翻新,这么些立异的数据不恐怕在其它节点中国共产党享,那不光会减低节点运转的功效,而且会产生数据不一同的动静时有产生。举例某些网址使用
A、B 七个节点作为集群陈设,当 A 节点的缓存更新后,而 B
节点缓存还未有更新就恐怕现身客商在浏览页面包车型地铁时候,一会是翻新后的多少,一会是还未有更新的数据,固然大家也足以由此Session Sticky
能力来将客户锁定在有些节点上,但对此某个人机联作性比较强只怕是非 Web
格局的种类来说,Session Sticky 鲜明不太相符。所以就要求用到 EhCache
的集群应用方案。

EhCache 从 1.7 版本开端,扶助两种集群方案,分别是:

  • Terracotta
  • RMI
  • JMS
  • JGroups
  • EhCache Server

正文主要介绍个中的二种最为常用集群形式,分别是 RMI、JGroups 以至 EhCache
Server 。


 

Voldemort的特点

  • 缓存数据能够自动在依次服务器节点之间联合复制。
  • 每八个服务器的缓存数据被横向分割,由此是总缓存的四个子集。
  • 严格保持缓存的一致性。
  • 提供服务器宕机连忙还原方案。
  • 可配置的数据存储引擎。
  • 可配备的数额连串化情势。
  • 每叁个数码项都有版本标记,用来有限支撑数据的完整性和可用性。
  • 每二个缓存节点都以独立的,由此任何二个节点的故障都不会影响系统的健康运维。

2、Cacheonix – 高品质Java分布式缓存系统

  Cacheonix同样也是八个基于Java的遍及式集群缓存系统,它相仿能够扶植你完结分布式缓存的配置。

图片 3

  官网:

  Cacheonix的特点

  • 有限支撑的分布式 Java 缓存
  • 透过复制完结高可用性
  • 支撑泛型的缓存 API
  • 可与 ORM 框架集成
  • 行使数据分区完毕负载均衡
  • 支撑非多播互连网
  • 高质量总括
  • 高速的地面 Java 缓存
  • 遍布式锁机制

  Cacheonix的结构图

图片 4

  Cacheonix布满式缓存XML配置

<?xml version ="1.0"?>
<cacheonix xmlns="http://www.cacheonix.com/schema/configuration"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.cacheonix.com/schema/configuration http://www.cacheonix.com/schema/cacheonix-config-2.0.xsd">

   <server>

      <listener>
         <tcp port="8879" buffer="128k"/>
      </listener>

      <broadcast>
         <multicast multicastAddress="225.0.1.2" multicastPort="9998" multicastTTL="0"/>
      </broadcast>

      <partitionedCache name="customer.cache">
         <store>
            <lru maxElements="10000" maxBytes="10mb"/>
            <expiration idleTime="120s"/>
         </store>
      </partitionedCache>

      <partitionedCache name="invoice.cache">
         <store>
            <lru maxElements="10000" maxBytes="10mb"/>
            <expiration idleTime="120s"/>
         </store>
      </partitionedCache>

      <partitionedCache name="search.results.cache">
         <store>
            <lru maxBytes="5mb"/>
         </store>
      </partitionedCache>
   </server>
</cacheonix>

 

  Cacheonix缓存的存取

  从配置中取得Cacheonix实例

/**
 * Tester for CacheManager.
 */
public final class CacheonixTest extends TestCase {

   private Cacheonix cacheonix;

   /**
    * Tests getting an instance of CacheManager using a default Cacheonix configuration.
    */
   public void testGetInstance() {

      assertNotNull("Cacheonix created in setUp() method should not be null", cacheonix);
   }

   /**
    * Sets up the fixture. This method is called before a test is executed.
    * <p/>
    * Cacheonix receives the default configuration from a <code>cacheonix-config.xml</code> found in a class path or
    * using a file that name is defined by system parameter <code>cacheonix.config.xml<code>.
    */
   protected void setUp() throws Exception {

      super.setUp();

      // Get Cacheonix using a default Cacheonix configuration. The configuration
      // is stored in the conf/cacheonix-config.xml
      cacheonix = Cacheonix.getInstance();
   }

   /**
    * Tears down the fixture. This method is called after a test is executed.
    */
   protected void tearDown() throws Exception {

      // Cache manager has be be shutdown upon application exit.
      // Note that call to shutdown() here uses unregisterSingleton
      // set to true. This is necessary to support clean restart on setUp()
      cacheonix.shutdown(ShutdownMode.GRACEFUL_SHUTDOWN, true);
      cacheonix = null;

      super.tearDown();
   }
}

 

  读取缓存

Cacheonix cacheonix = Cacheonix.getInstance();
Cache<String, String> cache = cacheonix.getCache("my.cache");
String cachedValue = cache.get("my.key");

  设置缓存

Cacheonix cacheonix = Cacheonix.getInstance();
Cache<String, String> cache = cacheonix.getCache("my.cache");
String replacedValue = cache.put("my.key", "my.value");

  删除缓存

Cacheonix cacheonix = Cacheonix.getInstance();
Cache<String, String> cache = cacheonix.getCache("my.cache");
String removedValue = cache.remove("my.key");

 

总结

Cacheonix作为一款开源的布满式缓存框架,能够满意中型集团规模的系统构造,对进级系统天性有那些棒的功力。

 

RMI 集群方式

RMI 是 Java 的一种远程方法调用技术,是一种点对点的基于 Java
对象的简报方式。EhCache 从 1.2 版本最早就协助 RMI
情势的缓存集群。在集群景况中 EhCache
全部缓存对象的键和值都必得是可系列化的,也便是必需实现java.io.Serializable 接口,那点在任何集群格局下也是内需服从的。

下图是 RMI 集群方式的布局图:

Voldemort键-值原理图

图片 5

Voldemort逻辑构造图

图片 6

Voldemort物理布局图

3、ASimpleCache – 轻量级Android缓存框架

  ASimpleCache是一款基于Android的轻量级缓存框架,它独有二个Java文件,ASimpleCache基本得以缓存常用的Android对象,包罗不足为道字符串、JSON对象、经过系列化的Java对象、字节数组等。

图片 7

  官方网站:

  ASimpleCache能够缓存哪些东西

  ASimpleCache基本得以缓存常用的Android对象,包涵但不遏抑以下两种等级次序:

  • 平淡无奇字符串
  • JSON对象
  • 通过类别化的Java对象
  • 字节数组

  ASimpleCache的特点

  • 轻量级,唯有四个Java文件
  • 完全而灵活的铺排,能够安插缓存路线,缓存大小,缓存数量,缓存超时时间等。
  • 逾期缓存自动失效,并从内部存款和储蓄器中机动删除。
  • 多进度的支撑

  在Android开荒中,大家得以用ASimpleCache来替换SharePreference配置文件,特别是只要您的使用常常要从互联英特网读
取数据,那么利用ASimpleCache能够缓存那些央浼数据,等一段时间失效后再去重新读取,那样能够减弱顾客端流量,同时收缩服务器并发量。

  ASimpleCache的身教重于言教代码

  设置缓存数据:

ACache mCache = ACache.get(this);
mCache.put("test_key1", "test value");
mCache.put("test_key2", "test value", 10);//保存10秒,如果超过10秒去获取这个key,将为null
mCache.put("test_key3", "test value", 2 * ACache.TIME_DAY);//保存两天,如果超过两天去获取这个key,将为null

 

  获取缓存数据:

ACache mCache = ACache.get(this);
String value = mCache.getAsString("test_key1");

 

总结  

ASimpleCache的作者是同胞,代码托管在Github上,也用过ASimpleCache的同室能够大饱眼福一下使用体验,为开源职业进献一份力量。

 

图 2. RMI 集群格局布局图

图片 8

运用 RMI
集群形式时,集群中的每种节点都以对等关系,并空中楼阁主节点或许从节点的概念,由此节点间必需有四个体制能够互相认知对方,必需精晓其余节点的消息,满含主机地址、端口号等。EhCache
提供三种节点的发掘方法:手工业配置和电动发掘。手工业配置方式供给在种种节点中配置其余具备节点的三回九转消息,一旦集群中的节点产生变化时,需求对缓存进行重新配置。

由于 RMI 是 Java 中放置扶助的本领,因而利用 RMI
集群情势时,无需引进其余的 Jar 包,EhCache 自身就带有辅助 RMI
集群的作用。使用 RMI 集群格局必要在 ehcache.xml 配置文件中定义
cacheManagerPeerProviderFactory 节点。假使集群中有多个节点,分别对应的
RMI 绑定消息是:

节点 1 192.168.0.11 4567 /oschina_cache
节点 2 192.168.0.12 4567 /oschina_cache
节点 3 192.168.0.13 4567 /oschina_cache

那么相应的手工业配置音信如下:

<cacheManagerPeerProviderFactory 
    class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory" 
    properties="hostName=localhost,
    port=4567,
    socketTimeoutMillis=2000,
    peerDiscovery=manual,
    rmiUrls=//192.168.0.12:4567/oschina_cache|//192.168.0.13:4567/oschina_cache"
/>

 

任何节点配置相同,只需把 rmiUrls 中的三个 IP 地址换到此外三个节点对应的
IP 地址就能够。

接下去在急需进行缓存数据复制的区域(Region)上安顿如下就可以:

<cache name="sampleCache2"
    maxElementsInMemory="10"
    eternal="false"
    timeToIdleSeconds="100"
    timeToLiveSeconds="100"
    overflowToDisk="false">
    <cacheEventListenerFactory
        class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
        properties="replicateAsynchronously=true, 
    replicatePuts=true, 
    replicateUpdates=true,
        replicateUpdatesViaCopy=false, 
    replicateRemovals=true "/>
</cache>

 

切切实实每一个参数代表的意思请参见 EhCache 的手册,此处不再详细表达。

EhCache 的 RMI 集群方式还应该有别的一种节点开采方法,正是通过多播(
multicast
)来维护集群中的全部有效节点。那也是最棒精简而且灵活的艺术,与手工形式区别的是,每种节点上的配备音讯都无差别,大大便利了节点的布署,防止人工的错漏现身。

在上述八个节点的例证中,配置如下:

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

 

内部需求钦点节点开掘形式 peerDiscovery 值为 automatic
自动;同有的时候候组播地址能够钦定 D 类 IP 地址空间,范围从 224.0.1.0 到
238.255.255.255 中的任何多少个地点。


 

Voldemort的布局方式

集群配置文件:

<cluster>
    <!-- The name is just to help users identify this cluster from the gui -->
    <name>mycluster</name>
    <zone>
      <zone-id>0</zone-id>
      <proximity-list>1</proximity-list>
    <zone>
    <zone>
      <zone-id>1</zone-id>
      <proximity-list>0</proximity-list>
    <zone>
    <server>
      <!-- The node id is a unique, sequential id beginning with 0 that identifies each server in the cluster-->
      <id>0</id>
      <host>vldmt1.prod.linkedin.com</host>
      <http-port>8081</http-port>
      <socket-port>6666</socket-port>
      <admin-port>6667</admin-port>
      <!-- A list of data partitions assigned to this server -->
      <partitions>0,1,2,3</partitions>
      <zone-id>0</zone-id>
    </server>
    <server>
      <id>1</id>
      <host>vldmt2.prod.linkedin.com</host>
      <http-port>8081</http-port>
      <socket-port>6666</socket-port>
      <admin-port>6667</admin-port>
      <partitions>4,5,6,7</partitions>
      <zone-id>1</zone-id>
    </server>
  </cluster>

多少存款和储蓄格局铺排文件:

<stores>
      <store>
      <name>test</name>
      <replication-factor>2</replication-factor>
      <preferred-reads>2</preferred-reads>
      <required-reads>1</required-reads>
      <preferred-writes>2</preferred-writes>
      <required-writes>1</required-writes>
      <persistence>bdb</persistence>
      <routing>client</routing>
      <routing-strategy>consistent-routing</routing-strategy>
      <key-serializer>
          <type>string</type>
          <schema-info>utf8</schema-info>
      </key-serializer>
      <value-serializer>
          <type>json</type>
          <schema-info version="1">[{"id":"int32", "name":"string"}]</schema-info>
          <compression>
          <type>gzip<type>
          </compression>
      </value-serializer>
      </store>
  </stores>

4、JBoss Cache – 基于事物的Java缓存框架

  JBoss
Cache是一款基于Java的事务管理缓存系统,它的靶子是创设三个以Java框架为幼功的集群施工方案,能够是服务器应用,也足以是Java
SE应用。

图片 9

  官网:

  集群高可用性

  JBoss
Cache将会自动复制缓存数据,并且在集群中的服务器之间进行缓存数据的一同,那样能够确定保障别的一台服务珍视启了都不会听得多了就能说的详细缓存的可用性。

  集群缓存可制止系统瓶颈

  JBoss
Cache从名称想到所富含的意义是运用缓存来升高系统扩展性的,当大家的WEB系统蒙受大量的数据库读写时,系统的瓶颈将会现出在数码库端,JBoss
Cache正巧能够解决数据库的频繁读取难点,化解那一个瓶颈。

  此外,由于JBoss
Cache的缓存是在集群中的每多少个劳动器间同步的,由此也不会因为一台缓存服务器蒙受质量难题而影响全部系列。

  JBoss Cache的standalone用法

  首先是开端化TreeCache

TreeCache tree = new TreeCache();

  然后是读进配置文件

PropertyConfigurator config = new PropertyConfigurator();
config.configure("配置文件.xml");

  然后最初服务

Tree.startService();

  因为Tree的布局是用NODE来Access的,TreeCache这里就很简短的用:

  /level1/level2/node1 来表示两级Tree上边包车型地铁Node1。

  现在我们增加多少个要Cache的对象。

Tree.put("/level1/level2/node1", "key1", "value1");
String[] array = { "1", "2", "3", "4" }
Tree.put("/level3/array/", "myarray", array);

  大家能够看出,TreeCache里面能够积累任何类型的指标,包罗持有复杂对象。

  读取对象就很有益了,

String s = (String)Tree.get("/level1/level2/node1/", "key1");

  value1就读出来了。

  同理:

String[] sarr = (String[]) Tree.get("/level3/array/","myarray");

  System.out.println(sarr[1]) 会显示2

  最终甘休服务:

Tree.stopService();

  JBoss Cache的FileCacheLoader示例

  首先创制三个FileCache类封装JBoss Cache的相干操作,如下:

package com.javaeye.terrencexu.jbosscache;  

import java.io.File;  
import java.util.Map;  

import org.jboss.cache.Cache;  
import org.jboss.cache.DefaultCacheFactory;  
import org.jboss.cache.Fqn;  
import org.jboss.cache.Node;  
import org.jboss.cache.config.CacheLoaderConfig;  
import org.jboss.cache.config.Configuration;  
import org.jboss.cache.loader.FileCacheLoader;  
import org.jboss.cache.loader.FileCacheLoaderConfig;  

/** 
 * <p> 
 * This is demo to illustrate how to use the JBoss Cache to cache your 
 * frequently accessed Java objects in order to dramatically improve 
 * the performance of your applications. This makes it easy to remove 
 * data access bottlenecks, such as connecting to a database. 
 * </p> 
 * <p> 
 * As a rule of thumb, it is recommended that the FileCacheLoader not  
 * be used in a highly concurrent, transactional or stressful environment, 
 * ant its use is restricted to testing. 
 * </p> 
 *  
 * @author TerrenceX 
 * 
 * @param <T> 
 */  
public class FileCache<T> {  

    /** 
     * The JBoss Cache, used to cache frequently accessed Java objects. 
     */  
    private Cache<String, T> cache;  

    /** 
     * @constructor 
     * @param fsCacheLoaderLocation The file system location to store the cache 
     */  
    public FileCache(File fsCacheLoaderLocation) {  
        cache = initCache(fsCacheLoaderLocation);  
    }  

    /** 
     * Create a Cache and whose cache loader type is File Cache Loader 
     *  
     * @param fsCacheLoaderLocation The file position used to store the cache. 
     *  
     * @return Cache 
     */  
    public Cache<String, T> initCache(File fsCacheLoaderLocation) {  
        // initiate a FileCacheLoader instance  
        FileCacheLoader fsCacheLoader = new FileCacheLoader();  

        // prepare the file cache loader configuration file for File Cache Loader  
        FileCacheLoaderConfig fsCacheLoaderConfig = new FileCacheLoaderConfig();  
        fsCacheLoaderConfig.setLocation(fsCacheLoaderLocation.toString());  
        fsCacheLoaderConfig.setCacheLoader(fsCacheLoader);  

        // set configuration to File Cache Loader  
        fsCacheLoader.setConfig(fsCacheLoaderConfig);  

        // prepare the configuration for Cache  
        Configuration config = new Configuration();  
        config.setCacheLoaderConfig(new CacheLoaderConfig());  
        config.getCacheLoaderConfig().addIndividualCacheLoaderConfig(fsCacheLoaderConfig);  

        // create a Cache through the default cache factory  
        return new DefaultCacheFactory<String, T>().createCache(config);  
    }  

    /** 
     * Add a new node into the tree-node hierarchy 
     *  
     * @param fqn Full Qualified Name for the new node 
     * @return 
     */  
    public Node<String, T> addNode(Fqn<String> fqn) {  
        return cache.getRoot().addChild(fqn);  
    }  

    /** 
     * Remove a specified node from the tree-node hierarchy 
     *  
     * @param fqn Full Qualified Name for the specified node 
     */  
    public void removeNode(Fqn<String> fqn) {  
        cache.removeNode(fqn);  
    }  

    /** 
     * Add node information to the specified node. 
     *  
     * @param fqn Full Qualified Name for the specified node 
     * @param key The key of the node information 
     * @param value The value of the node information 
     */  
    public void addNodeInfo(Fqn<String> fqn, String key, T value) {  
        cache.put(fqn, key, value);  
    }  

    /** 
     * Batch add node information to the specified node. 
     *  
     * @param fqn Full Qualified Name for the specified node 
     * @param infos Node informations map 
     */  
    public void addNodeInfos(Fqn<String> fqn, Map<String, T> infos) {  
        cache.put(fqn, infos);  
    }  

    /** 
     * Get node information from the specified node. 
     *  
     * @param fqn Full Qualified Name for the specified node 
     * @param key The key of the node information 
     * @return 
     */  
    public T getNodeInfo(Fqn<String> fqn, String key) {  
        return cache.get(fqn, key);  
    }  

    /** 
     * Remove node information from the specified node. 
     *  
     * @param fqn Full Qualified Name for the specified node 
     * @param key The key of the node information 
     */  
    public void removeNodeInfo(Fqn<String> fqn, String key) {  
        cache.remove(fqn, key);  
    }  
}

 

  上边是三个测量检验案例:

package com.javaeye.terrencexu.jbosscache;  

import java.io.File;  

import org.jboss.cache.Fqn;  

public class Main {  

    public static void main(String[] args) {  
        FileCache<String> fileCache = new FileCache<String>(new File("d:\tmp"));  

        Fqn<String> jimmyFqn = Fqn.fromString("/com/manager/jimmy");  
        Fqn<String> hansonFqn = Fqn.fromString("/com/developer/hanson");  

        fileCache.addNode(jimmyFqn);  
        fileCache.addNode(hansonFqn);  

        fileCache.addNodeInfo(jimmyFqn, "en-name", "Jimmy Zhang");  
        fileCache.addNodeInfo(jimmyFqn, "zh-name", "Zhang Ji");  
        fileCache.addNodeInfo(hansonFqn, "en-name", "Hanson Yang");  
        fileCache.addNodeInfo(hansonFqn, "zh-name", "Yang Kuo");  

        String enName = fileCache.getNodeInfo(hansonFqn, "en-name");  
        System.out.println(enName);  
    }  

}

 

  运维结果如下:

- JBossCache MBeans were successfully registered to the platform mbean server.  
- JBoss Cache version: JBossCache 'Malagueta' 3.2.5.GA  
Hanson Yang

  生成的缓存文件目录构造如下:

D:/tmp/com.fdb/manage.fdb/jimmy.fdb/data.dat
D:/tmp/com.fdb/developer.fdb/hanson.fdb/data.dat

  总结

  JBoss
Cache还或者有越多的用法,倘若您的系统碰着数据库瓶颈难题,能够构思动用JBoss
Cache来解决。

 

JGroups 集群方式

EhCache 从 1.5. 本子起始扩展了 JGroups 的布满式集群形式。与 RMI
方式绝相比, JGroups
提供了贰个极其灵活的公约栈、可信的单播和多播音讯传输,主要的老毛病是布署复杂甚至一些批评栈对第三方包的依赖。

JGroups 也提供了基于 TCP 的单播 ( Unicast 卡塔尔国 和根据 UDP 的多播 (
Multicast 卡塔尔国 ,对应 RMI
的手工业配置和自行发掘。使用单播格局须要钦赐别的节点的主机地址和端口,上面是四个节点,并应用了单播形式的配备:

<cacheManagerPeerProviderFactory
    class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
    properties="connect=TCP(start_port=7800):
        TCPPING(initial_hosts=host1[7800],host2[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="::" />

 

接受多播情势计划如下:

<cacheManagerPeerProviderFactory
    class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
    properties="connect=UDP(mcast_addr=231.12.21.132;mcast_port=45566;):PING:
    MERGE2:FD_SOCK:VERIFY_SUSPECT:pbcast.NAKACK:UNICAST:pbcast.STABLE:FRAG:pbcast.GMS"
    propertySeparator="::"
/>

 

从上边的配备来看,JGroups 的安插要比 RMI
复杂得多,但也提供更加多的微调参数,有利于提高缓存数据复制的性质。详细的
JGroups 配置参数的具体意思可参考 JGroups 的安顿手册。

JGroups 情势对应缓存节点的铺排音讯如下:

<cache name="sampleCache2"
    maxElementsInMemory="10"
    eternal="false"
    timeToIdleSeconds="100"
    timeToLiveSeconds="100"
    overflowToDisk="false">
    <cacheEventListenerFactory
        class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
        properties="replicateAsynchronously=true, replicatePuts=true,
        replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true" />
</cache>

 

Voldemort的使用示例

value = store.get(key)
store.put(key, value)
store.delete(key)

5、Voldemort – 基于键-值(key-value)的缓存框架

  Voldemort是一款基于Java开荒的分布式键-值缓存系统,像JBoss
Cache相近,Voldemort同样支撑多台服务器之间的缓存同步,以增长系统的可信赖性和读取质量。

图片 10

  官网:

  Voldemort的特点

  • 缓存数据能够活动在相继服务器节点之间联合复制。
  • 每贰个服务器的缓存数据被横向分割,因而是总缓存的多个子集。
  • 从严保持缓存的一致性。
  • 提供服务器宕机快捷复苏方案。
  • 可安插的数据存款和储蓄引擎。
  • 可布置的多少种类化方式。
  • 每三个数额项都有版本标记,用来保障数据的完整性和可用性。
  • 每二个缓存节点都是单独的,因而任何二个节点的故障都不会耳濡目染系统的健康运维。

  Voldemort键-值原理图

图片 11

Voldemort逻辑结构图

图片 12

Voldemort物理布局图

  Voldemort的配置方式

  集群配置文件:

<cluster>
    <!-- The name is just to help users identify this cluster from the gui -->
    <name>mycluster</name>
    <zone>
      <zone-id>0</zone-id>
      <proximity-list>1</proximity-list>
    <zone>
    <zone>
      <zone-id>1</zone-id>
      <proximity-list>0</proximity-list>
    <zone>
    <server>
      <!-- The node id is a unique, sequential id beginning with 0 that identifies each server in the cluster-->
      <id>0</id>
      <host>vldmt1.prod.linkedin.com</host>
      <http-port>8081</http-port>
      <socket-port>6666</socket-port>
      <admin-port>6667</admin-port>
      <!-- A list of data partitions assigned to this server -->
      <partitions>0,1,2,3</partitions>
      <zone-id>0</zone-id>
    </server>
    <server>
      <id>1</id>
      <host>vldmt2.prod.linkedin.com</host>
      <http-port>8081</http-port>
      <socket-port>6666</socket-port>
      <admin-port>6667</admin-port>
      <partitions>4,5,6,7</partitions>
      <zone-id>1</zone-id>
    </server>
  </cluster>

 

  数据存款和储蓄方式布置文件:

<stores>
      <store>
      <name>test</name>
      <replication-factor>2</replication-factor>
      <preferred-reads>2</preferred-reads>
      <required-reads>1</required-reads>
      <preferred-writes>2</preferred-writes>
      <required-writes>1</required-writes>
      <persistence>bdb</persistence>
      <routing>client</routing>
      <routing-strategy>consistent-routing</routing-strategy>
      <key-serializer>
          <type>string</type>
          <schema-info>utf8</schema-info>
      </key-serializer>
      <value-serializer>
          <type>json</type>
          <schema-info version="1">[{"id":"int32", "name":"string"}]</schema-info>
          <compression>
          <type>gzip<type>
          </compression>
      </value-serializer>
      </store>
  </stores>

 

  Voldemort的使用示例

value = store.get(key)
store.put(key, value)
store.delete(key)

  总结

  Voldemort是分布式缓存系统,由此能够动用在中大型的软件项目中,质量方面也都免强能够。

运用组播情势的注意事项

应用 JGroups 供给引进 JGroups 的 Jar 包以至 EhCache 对 JGroups 的封装包
ehcache-jgroupsreplication-xxx.jar 。

在有的启用了 IPv6 的计算机中,平日起步的时候报如下错误消息:

java.lang.RuntimeException: the type of the stack (IPv6) and the user
supplied addresses (IPv4) don’t match: /231.12.21.132.

缓和的措施是扩展 JVM 参数:-Djava.net.preferIPv4Stack=true。假若是
汤姆cat 服务器,可在 catalina.bat 可能 catalina.sh
中追加如下境况变量就能够:

 SET CATALINA_OPTS=-Djava.net.preferIPv4Stack=true

经超过实际际测量检验发现,集群形式下的缓存数据都能够在 1
分钟以内完结到其节点的复制。


 

总结

Voldemort是布满式缓存系统,由此得以接受在中山大学型的软件项目中,品质方面也都还不易。

EhCache Server

与前边介绍的二种集群方案分歧的是, EhCache Server
是一个独门的缓存服务器,此中间使用 EhCache
做为缓存系统,可应用后边提到的三种艺术举办之中集群。对外提供编制程序语言毫无干系的基于
HTTP 的 RESTful 或然是 SOAP 的数目缓存操作接口。

上边是 EhCache Server 提供的对缓存数据实行操作的不二等秘书籍:

OPTIONS /{cache}}

获得有些缓存的可用操作的消息。

HEAD /{cache}/{element}

收获缓存中某个成分的 HTTP 头消息,比方:

curl --head  http://localhost:8080/ehcache/rest/sampleCache2/2

EhCache Server 再次回到的音讯如下:

HTTP/1.1 200 OK 
X-Powered-By: Servlet/2.5 
Server: GlassFish/v3 
Last-Modified: Sun, 27 Jul 2008 08:08:49 GMT 
ETag: "1217146129490"
Content-Type: text/plain; charset=iso-8859-1 
Content-Length: 157 
Date: Sun, 27 Jul 2008 08:17:09 GMT

GET /{cache}/{element}

读取缓存中有个别数据的值。

PUT /{cache}/{element}

写缓存。

出于那么些操作都是依照 HTTP
左券的,因而你能够在别的一种编程语言中利用它,比方 Perl、PHP 和 Ruby
等等。

下图是 EhCache Server 在使用中的构造:

图 3. EhCache Server 施用构造图

图片 13

EhCache Server
同一时间也提供强盛的平安机制、监察和控制功能。在数额存款和储蓄方面,最大的 Ehcache
单实例在内存中能够缓存 20GB。最大的磁盘能够缓存
100GB。通过将节点整合在同步,那样缓存数据就可以超越节点,以此博得更加大的体积。将缓存
20GB 的 50 个节点整合在合作正是 1TB 了。


 

总结

上述大家介绍了二种 EhCache
的集群方案,除了第三种跨编制程序语言的方案外,EhCache
的集群对应用程序的代码编写都以晶莹的,程序人士没有必要考虑缓存数据是什么复制到其余节点上。既保持了代码的轻量级,同不常候又扶助庞大的数额集群。EhCache
可谓是烜赫不常。

二〇〇九 年年中,Terracotta 发表收购 EhCache 产物。Terracotta 公司的产品Terracotta 是二个 JVM 级的开源集结框架,提供 HTTP Session
复制、布满式缓存、POJO 集结、凌驾集群的 JVM
来促成分布式应用程序谐和。前段时间 EhCache 重要的精雕细琢都集聚在跟 Terracotta
框架的合併上,那是三个的确含义上的市廛级缓存建设方案。

正文转发自 

发表评论

电子邮件地址不会被公开。 必填项已用*标注