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

图片 1

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

  JBoss
Cache是一款基于Java的事务管理缓存系统,它的指标是创设八个以Java框架为底子的集群实施方案,能够是服务器应用,也可以是Java
SE应用。

图片 2

  官方网站:

  集群高可用性

  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来消除。

 

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

Ehcache是二个Java完毕的开源布满式缓存框架,EhCache
能够使得地缓慢解决数据库的负荷,能够让数据保存在分歧服务器的内存中,在须求多少的时候能够飞速存取。同时EhCache
扩大特别轻松,官方提供的Cache配置方式有几许种。你能够经过表明配置、在xml中构造、在程序里陈设或许调用布局方法时传出不一样的参数。

图片 3

官方网站:

使用教程:

本文由码农网 –
小峰原创,转发请看清文末的转发供给,款待参加大家的付费投稿安顿!

2、Cacheonix – 高品质Java遍及式缓存系统

  Cacheonix相似也是贰个基于Java的布满式集群缓存系统,它同样能够匡助您兑现布满式缓存的计划。

图片 4

  官方网站:

  Cacheonix的特点

  • 保障的遍布式 Java 缓存
  • 通过复制达成高可用性
  • 扶植泛型的缓存 API
  • 可与 ORM 框架集成
  • 采纳数据分区实现负载均衡
  • 支撑非多播互连网
  • 高品质总计
  • 相当慢的本土 Java 缓存
  • 分布式锁机制

  Cacheonix的布局图

图片 5

  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作为一款开源的遍布式缓存框架,能够满意中型公司规模的系统结构,对晋级系统质量有那个棒的法力。

 

在付出中山高校型Java软件项目时,超多Java布局师都会超越数据库读写瓶颈,假设你在系统构造时并不曾将缓存战略思谋进来,也许并从未采取更优的缓存攻略,那么届时候重构起来将会是一个恐怖的梦。本文首若是享受了5个常用的Java布满式缓存框架,这个缓存框架扶助多台服务器的缓存读写功效,能够让您的缓存系统更便于扩展。

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();

在付出中山大学型Java软件项目时,非常多Java布局师都会蒙受数据库读写瓶颈,倘若您在系统布局时并未将缓存计策思考进来,大概并不曾接收更优的
缓存攻略,那么届时候重构起来将会是多少个梦魇。本文首假设享受了5个常用的Java遍及式缓存框架,那个缓存框架支持多台服务器的缓存读写成效,能够让你的缓存系统更便于扩张。

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

Voldemort是一款基于Java开辟的遍及式键-值缓存系统,像JBoss
Cache平等,Voldemort雷同支撑多台服务器之间的缓存同步,以增加系统的可靠性和读取质量。

图片 6

官方网站:

应用教程:

各位假诺还恐怕有越来越好的布满式Java缓存框架,接待在商量中留言推荐,本文将不仅开展立异。

JBoss
Cache是一款基于Java的事务管理缓存系统,它的指标是营造二个以Java框架为底工的集群设计方案,能够是服务器应用,也得以是Java
SE应用。

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

  Ehcache是叁个Java达成的开源分布式缓存框架,EhCache
能够使得地缓慢解决数据库的负载,能够让多大将军存在分裂服务器的内部存储器中,在供给多少的时候能够快速存取。同时EhCache
扩大特别轻易,官方提供的Cache配置方式有有个别种。你能够通过申明配置、在xml中布局、在程序里安顿大概调用布局方法时传出不一样的参数。

图片 7

  官方网址:

  Ehcache有以下特点:

  • 存取速度一点也超级快,品质特别不利。
  • 能够采取三种缓存计谋。
  • 各自缓存,顾客能够钦定哪些数据在硬盘中缓存,哪些数据在内部存款和储蓄器中缓存。
  • 能够通过RMI、可插入API等办法开展示公布满式缓存。
  • 全部缓存和缓存微处理器的侦听接口。
  • 扶助多缓存微电脑实例,以至叁个实例的多少个缓存区域。
  • 默许提供Hibernate的缓存达成。

  Ehcache的陈设示范代码:

总结  

在同类的Java缓存框架中,Ehcache配置绝对简便易行,也正如轻巧上手,最大的优势是它帮衬布满式缓存

 

本文由码农网 –
小峰原创,转发请看清文末的转发必要,款待参预大家的付费投稿陈设!

集群高可用性

JBoss
Cache将会活动复制缓存数据,况且在集群中的服务器之间举行缓存数据的同步,那样能够保证其余一台服务重视启了都不会影响缓存的可用性。

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

  Voldemort是一款基于Java开拓的布满式键-值缓存系统,像JBoss
Cache相同,Voldemort同样支撑多台服务器之间的缓存同步,以加强系统的可相信性和读取品质。

图片 8

  官网:

  Voldemort的特点

  • 缓存数据能够自行在依次服务器节点之间联合复制。
  • 每二个服务器的缓存数据被横向分割,因而是总缓存的三个子集。
  • 严厉保持缓存的一致性。
  • 提供服务器宕机飞速恢复生机方案。
  • 可计划的数据存款和储蓄引擎。
  • 可计划的数额体系化形式。
  • 每二个数量项都有版本标志,用来保障数据的完整性和可用性。
  • 每多个缓存节点都以独自的,因而任何叁个节点的故障都不会影响系统的平时化运作。

  Voldemort键-值原理图

图片 9

Voldemort逻辑结构图

图片 10

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是遍及式缓存系统,因而得以行使在中山大学型的软件项目中,性能方面也都还不易。

2、Cacheonix – 高品质Java遍及式缓存系统

Cacheonix相近也是叁个基于Java的遍及式集群缓存系统,它同样能够援救您达成布满式缓存的陈设。

图片 11

官方网站:

运用教程:

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

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

  ASimpleCache是一款基于Android的轻量级缓存框架,它独有多少个Java文件,ASimpleCache基本能够缓存常用的Android对象,包蕴见怪不怪字符串、JSON对象、经过系列化的Java对象、字节数组等。

图片 12

  官方网站:

  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的同室能够享受一下用到体验,为开源工作贡献一份力量。

 

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

ASimpleCache是一款基于Android的轻量级缓存框架,它唯有三个Java文件,ASimpleCache基本得以缓存常用的Android对象,包蕴普通字符串、JSON对象、经过种类化的Java对象、字节数组等。

图片 13

官网:

采取教程:

集群缓存可避免系统瓶颈

JBoss
Cache从名称想到所包蕴的意义是使用缓存来抓牢系统扩张性的,当大家的WEB系统遇到大批量的数据库读写时,系统的瓶颈将会产出在数量库端,JBoss
Cache正巧能够解决数据库的累累读取难点,杀绝那个瓶颈。

其它,由于JBoss
Cache的缓存是在集群中的每一个劳动器间同步的,因而也不会因为一台缓存服务器遇到质量难题而影响全体系列。

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

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

图片 1

官方网站:

应用教程:

总结

JBoss
Cache还应该有越来越多的用法,假使你的连串碰着数据库瓶颈难题,能够设想使用JBoss
Cache来缓慢解决。

发表评论

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