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

在开发中大型Java软件项目时，很多Java架构师都会遇到数据库读写瓶颈，如果你在系统架构时并没有将缓存策略考虑进去，或者并没有选择更优的缓存策略，那么到时候重构起来将会是一个噩梦。本文主要是分享了5个常用的Java分布式缓存框架，这些缓存框架支持多台服务器的缓存读写功能，可以让你的缓存系统更容易扩展。

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

Ehcache是一个Java实现的开源分布式缓存框架，EhCache 可以有效地减轻数据库的负载，可以让数据保存在不同服务器的内存中，在需要数据的时候可以快速存取。同时EhCache 扩展非常简单，官方提供的Cache配置方式有好几种。你可以通过声明配置、在xml中配置、在程序里配置或者调用构造方法时传入不同的参数。

Ehcache有以下特点：

• 存取速度非常快，性能很不错。
• 可以应用多种缓存策略。
• 分级缓存，用户可以指定哪些数据在硬盘中缓存，哪些数据在内存中缓存。
• 可以通过RMI、可插入API等方式进行分布式缓存。
• 具有缓存和缓存管理器的侦听接口。
• 支持多缓存管理器实例，以及一个实例的多个缓存区域。
• 默认提供Hibernate的缓存实现。
• Spring默认配置缓存

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

Ehcache的配置示例代码：

<ehcache>
<diskStore path=”java.io.tmpdir”/>
<defaultCache
maxElementsInMemory=”10000″
eternal=”false”
timeToIdleSeconds=”120″
timeToLiveSeconds=”120″
overflowToDisk=”true”
maxElementsOnDisk=”10000000″
diskPersistent=”false”
diskExpiryThreadIntervalSeconds=”120″
memoryStoreEvictionPolicy=”LRU”
/>
</ehcache>

<!-- 配置自定义缓存

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

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

timeToIdleSeconds：缓存数据的钝化时间，也就是在一个元素消亡之前，

两次访问时间的最大时间间隔值，这只能在元素不是永久驻留时有效，

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

timeToLiveSeconds：缓存数据的生存时间，也就是一个元素从构建到消亡的最大时间间隔值，

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

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

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

-->

在同类的Java缓存框架中，Ehcache配置相对简单，也比较容易上手，最大的优势是它支持分布式缓存。

2、Cacheonix – 高性能Java分布式缓存系统

Cacheonix同样也是一个基于Java的分布式集群缓存系统，它同样可以帮助你实现分布式缓存的部署。

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

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

ASimpleCache是一款基于Android的轻量级缓存框架，它只有一个Java文件，ASimpleCache基本可以缓存常用的Android对象，包括普通字符串、JSON对象、经过序列化的Java对象、字节数组等。

官方网站：https://github.com/yangfuhai/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.javacache.steven.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 steven
 *
 * @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.javacache.steven.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("f:\\tmp"));  

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

        fileCache.addNode(jimmyFqn);
        fileCache.addNode(jackFqn);  

        fileCache.addNodeInfo(jimmyFqn, "en-name", "Jimmy Zhang");
        fileCache.addNodeInfo(jimmyFqn, "zh-name", "Zhang Ji");
        fileCache.addNodeInfo(jackFqn, "en-name", "Jack Li");
        fileCache.addNodeInfo(jackFqn, "zh-name", "Li Jie");  

        String enName = fileCache.getNodeInfo(jackFqn, "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
Jack Li

生成的缓存文件目录结构如下：

F:/tmp/com.fdb/manage.fdb/jimmy.fdb/data.dat
F:/tmp/com.fdb/developer.fdb/jack.fdb/data.dat

JBoss Cache还有更多的用法，如果你的系统遇到数据库瓶颈问题，可以考虑使用JBoss Cache来解决。

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

Voldemort是一款基于Java开发的分布式键-值缓存系统，像JBoss Cache一样，Voldemort同样支持多台服务器之间的缓存同步，以增强系统的可靠性和读取性能。

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