5個強大的Java分布式緩存框架推薦

在開發中大型Java軟件項目時，很多Java架構師都會遇到數據庫讀寫瓶頸，如果你在系統架構時並沒有將緩存策略考慮進去，或者並沒有選擇更優的 緩存策略，那么到時候重構起來將會是一個噩夢。本文主要是分享了5個常用的Java分布式緩存框架，這些緩存框架支持多台服務器的緩存讀寫功能，可以讓你 的緩存系統更容易擴展。

　1、Ehcache – Java分布式緩存框架

　　Ehcache是一個Java實現的開源分布式緩存框架，EhCache 可以有效地減輕數據庫的負載，可以讓數據保存在不同服務器的內存中，在需要數據的時候可以快速存取。同時EhCache 擴展非常簡單，官方提供的Cache配置方式有好幾種。你可以通過聲明配置、在xml中配置、在程序里配置或者調用構造方法時傳入不同的參數。

　　官方網站：http://ehcache.org/

　　Ehcache有以下特點：

• 存取速度非常快，性能很不錯。
• 可以應用多種緩存策略。
• 分級緩存，用戶可以指定哪些數據在硬盤中緩存，哪些數據在內存中緩存。
• 可以通過RMI、可插入API等方式進行分布式緩存。
• 具有緩存和緩存管理器的偵聽接口。
• 支持多緩存管理器實例，以及一個實例的多個緩存區域。
• 默認提供Hibernate的緩存實現。

　　Ehcache的配置示例代碼：

總結　　

在同類的Java緩存框架中，Ehcache配置相對簡單，也比較容易上手，最大的優勢是它支持分布式緩存

 

2、Cacheonix – 高性能Java分布式緩存系統

　　Cacheonix同樣也是一個基於Java的分布式集群緩存系統，它同樣可以幫助你實現分布式緩存的部署。

　　官方網站：http://www.cacheonix.com/

　　Cacheonix的特點

• 可靠的分布式 Java 緩存
• 通過復制實現高可用性
• 支持泛型的緩存 API
• 可與 ORM 框架集成
• 使用數據分區實現負載均衡
• 支持非多播網絡
• 高性能計算
• 快速的本地 Java 緩存
• 分布式鎖機制

　　Cacheonix的架構圖

　　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作為一款開源的分布式緩存框架，可以滿足中型企業規模的系統架構，對提升系統性能有非常棒的作用。

 

3、ASimpleCache – 輕量級Android緩存框架

　　ASimpleCache是一款基於Android的輕量級緩存框架，它只有一個Java文件，ASimpleCache基本可以緩存常用的Android對象，包括普通字符串、JSON對象、經過序列化的Java對象、字節數組等。

　　官方網站：https://github.com/yangfuhai/ASimpleCache

　　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的同學可以分享一下使用心得，為開源事業貢獻一份力量。

 

4、JBoss Cache – 基於事物的Java緩存框架

　　JBoss Cache是一款基於Java的事務處理緩存系統，它的目標是構建一個以Java框架為基礎的集群解決方案，可以是服務器應用，也可以是Java SE應用。

　　官方網站：http://jbosscache.jboss.org/

　　集群高可用性

　　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來解決。

 

5、Voldemort – 基於鍵-值（key-value）的緩存框架

　　Voldemort是一款基於Java開發的分布式鍵-值緩存系統，像JBoss Cache一樣，Voldemort同樣支持多台服務器之間的緩存同步，以增強系統的可靠性和讀取性能。

　　官方網站：http://www.project-voldemort.com/voldemort/

　　Voldemort的特點

• 緩存數據可以自動在各個服務器節點之間同步復制。
• 每一個服務器的緩存數據被橫向分割，因此是總緩存的一個子集。
• 嚴格保持緩存的一致性。
• 提供服務器宕機快速恢復方案。
• 可配置的數據存儲引擎。
• 可配置的數據序列化方式。
• 每一個數據項都有版本標識，用來保證數據的完整性和可用性。
• 每一個緩存節點都是獨立的，因此任何一個節點的故障都不會影響系統的正常運行。

　　Voldemort鍵-值原理圖

Voldemort邏輯架構圖

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是分布式緩存系統，因此可以應用在中大型的軟件項目中，性能方面也都還不錯。