001--jcs入门

jcs入门

1、概要

 　　JCS是Jakarta的项目Turbine的子项目，它是复合式的缓冲工具，具有配置灵活的特点。JCS提供内存、硬盘、分布式架构、构建缓存服务器四种方式来实现对象缓存；能够很方便的实现缓存的差异化定制。缓冲工具对于读操作远远多于写操作的应用性能提高非常显著。

2、 jcs架构图

 　　在这里面涉及到三个核心概念：elements、regions、auxiliaries。一个JCS可以定义多个region，每个region的存活时间、存储方式、对象的容纳数量都可以有自己的定义。Region是JCS中进行对象缓存的单元。与Region对应的是auxiliary。每个region的存储方式以及一些属性，如存活时间等都是由auxiliary定义。Default用来定义默认值，当auxiliary中某个属性没有定义时，就采用default设定的默认值。Region有一个个hashTable组成，存放需要缓存的对象以及对应的key。Elements对应hashTables。

 

3、功能

3.1、算法

　　JCS现在支持两种内存缓冲算法LRU和MRU。通常都是使用LRU算法。

3.2、时间过期

　　JCS对于缓冲的对象，可以设定缓冲过期时间，一个对象在缓冲区中停留的时间超过这个时间，就会被认为是“不新鲜”而被放弃。

3.3、索引式硬盘缓冲

　　使用内存缓冲区需要定义缓冲区大小，当超过缓冲区限制时，会将缓冲内容抛弃掉。如果有配硬盘缓冲，则将挤出来的缓冲内容写入硬盘缓冲区。

 　　硬盘缓冲将缓冲对象的内容写到文件上，但是将访问索引保存在内存中，因此也能够达到尽可能高的访问效率。

3.4、并行式的分布缓冲(Lateral)

　　将几台服务器配成一个缓冲组，组内每台服务器上有数据更新，会横向将更新的内容通过TCP/IP协议传输到其他服务器的缓冲层，这样就可以保证每个服务器缓冲一致性。

　　缺点：如果组内的并行的服务器数量增大后，组内的数据传输量将会迅速上升。这种方案适合并行服务器的数量比较少的情况。

3.5、Client/Server式的缓冲(Remote)

　　客户/服务端式的缓冲集群。这种方式支持一个主服务器和最高达到256个客户端。客户端的缓冲层会尝试连接主服务器，如果连接成功，就会在主服务器上注册。每个客户端有数据更新，就会通知到主服务器，主服务器会将更新通知到除消息来源的客户端以外的所有的客户端。

　　每个客户端可以配置超过一个服务器，第一个服务器是主服务器，如果与第一个服务器连接失败，客户端会尝试与备用的服务器连接，如果连接成功，就会通过备用服务器与其他客户端对话，同时会定期继续尝试与主服务器取得连接。如果备用服务器也连接失败，就会按照配置顺序尝试与下一个备用服务器连接。

 　　 这种方式下，更新通知是一种轻量级的，一个机器上的数据更新，不会把整个数据传输出去，而只是通知一个ID，当远程的其他机器收到更新通知后，就会把对应ID的缓冲对象从本地的内存缓冲区中移除，以保证不会在缓冲区内出现错误数据。

 　　 这种构造需要分别配置客户端和服务器，配置比较麻烦。

4、配置

　　JCS的好处之一，就是应用在开发的时候，可以不用去构思底层的缓冲配置构架。同一个应用，只需要修改配置，就可以改变缓冲构架，不需要修改应用的源代码。配置方法也比较简单，就是修改配置文件cache.ccf。这个文件放置在WEB-INF/classes目录下。配置格式类似log4j的配置文件格式。下面介绍一下使用各种缓冲结构的配置方法。

 

一个应用中，由于对象类型的不同，可能会使用多个缓冲区，每个缓冲区都会有一个名字，如果在配置文件中没有指明特定的缓冲区的属性，所有的缓冲区都会根据默认属性来构建。

默认缓冲配置：

#WEB-INF/classes/cache.ccf(以下内容不要换行)
#不用辅助缓冲  
jcs.default=   
#cache属性类别
jcs.default.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes   
#缓冲容量
jcs.default.cacheattributes.MaxObjects=1000 
#使用LRU算法  
jcs.default.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache

冗余内存清除配置：

#对象使用时间过期清除
jcs.default.cacheattributes.cacheattributes.UseMemoryShrinker=true
#对象最大存活时间
jcs.default.cacheattributes.cacheattributes.MaxMemoryIdleTimeSeconds=3600
#每隔多长时间检查对象是否超过最大存活时间
jcs.default.cacheattributes.cacheattributes.ShrinkerIntervalSeconds=60

#element属性类别
jcs.default.elementattributes=org.apache.jcs.engine.ElementAttributes
#element不是长期有效
jcs.default.elementattributes.IsEternal=false 
#element存活时间
jcs.default.elementattributes.MaxLifeSeconds=21600
#element闲着时间
jcs.default.elementattributes.IdleTime=1800

辅助缓冲配置：

#开启硬盘缓冲
jcs.default.elementattributes.IsSpool=true 
#开启Client/Server式的缓冲
jcs.default.elementattributes.IsRemote=true
#开启横向并行缓存  
jcs.default.elementattributes.IsLateral=true

#定义一个硬盘缓冲区产生器(Factory)，取名为DC  
jcs.auxiliary.DC=org.apache.stratum.jcs.auxiliary.disk.indexed.IndexedDiskCacheFactory  
jcs.auxiliary.DC.attributes=org.apache.stratum.jcs.auxiliary.disk.indexed.IndexedDiskCacheAttributes  
#缓存文件存放位置
jcs.auxiliary.DC.attributes.DiskPath=g:/dev/jakarta-turbine-stratum/raf  
#缓冲区都会自己使用一个硬盘缓冲区，缓冲文件会以缓冲区的名字来命名。存放在指定的目录下。
#真正使用这个缓存，需要将jcs.default的值改为DC。如：jcs.default=DC
#多种辅助缓冲请用逗号隔开值
  
#横向并行式的配置如下   
jcs.auxiliary.LTCP=org.apache.jcs.auxiliary.lateral.LateralCacheFactory  
jcs.auxiliary.LTCP.attributes=org.apache.jcs.auxiliary.lateral.LateralCacheAttributes  
jcs.auxiliary.LTCP.attributes.TransmissionTypeName=TCP 
# 其他节点的地址及所用端口，请控制节点数不超过4个
jcs.auxiliary.LTCP.attributes.TcpServers=192.168.10.129:1121,192.168.10.222:1121
 
# 本节点为并行分布缓存所用的端口
jcs.auxiliary.LTCP.attributes.TcpListenerPort=1121  
jcs.auxiliary.LTCP.attributes.PutOnlyMode=false 
#上面节点都在1121端口上监听，同时与另外两台机器连接。如果连接失败，就会等待一个时间后再连接一次，直到连接成功为止。三台机器中任意一台的缓冲区发生更新，比如put和remove动作，就会把更新传递给另外两台。
#真正使用这个缓存，需要将jcs.default的值改为DC。如：jcs.default=LTCP
#多种辅助缓冲请用逗号隔开值

#Client/Server式的缓冲配置比较复杂，不在这配置。

单独指明某个缓冲区的属性

如果，针对某个缓冲区，比如叫做TestCache1，需要单独配置属性，可以如下配置。

jcs.region.testCache1=DC,LTCP    
jcs.region.testCache1.cacheattributes=org.apache.stratum.jcs.engine.CompositeCacheAttributes   
jcs.region.testCache1.cacheattributes.MaxObjects=1000    
jcs.region.testCache1.cacheattributes.MemoryCacheName=org.apache.stratum.jcs.engine.memory.lru.LRUMemoryCache    
jcs.region.testCache1.cacheattributes.UseMemoryShrinker=true    
jcs.region.testCache1.cacheattributes.MaxMemoryIdleTimeSeconds=3600    
jcs.region.testCache1.cacheattributes.ShrinkerIntervalSeconds=60 

#这个概念我也不是很清楚。不过JCS文档中指出配置以下内容会比较好。  
system.GroupIdCache 
jcs.system.groupIdCache=DC    
jcs.system.groupIdCache.cacheattributes=org.apache.stratum.jcs.engine.CompositeCacheAttributes  
jcs.system.groupIdCache.cacheattributes.MaxObjects=10000  
jcs.system.groupIdCache.cacheattributes.MemoryCacheName=org.apache.stratum.jcs.engine.memory.lru.LRUMemoryCache  
#这可能是JCS自己的组管理体系上的缓冲区。

Client/Server式的缓冲(Remote)

这种构架需要单独配置客户端和服务端，如果要研究，可以查看http://jakarta.apache.org/turbine/jcs/RemoteAuxCache.html

5、简单操作

package com.cft.util;  
  
import org.apache.jcs.JCS;  
  
public class JCSManagerDTO {  
    private static JCSManagerDTO instance;  
    private static int checkedOut = 0;  
    public static JCS ObjCache;  
  
    private synchronized  JCSManagerDTO() {  
        try {  
            ObjCache = JCS.getInstance("ObjCache");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    public static JCSManagerDTO getInstance() {  
            if (instance == null) {  
                instance = new JCSManagerDTO();  
            }  
        synchronized (instance) {  
            instance.checkedOut++;  
        }  
        return instance;  
    }  
  
    public Object getObj(Object key) {  
        Object obj = null;  
        obj = (Object) ObjCache.get(key);  
        return obj;  
    }  
  
    public void storeObject(Object key, Object obj) {  
        try {  
            if (!key.equals("")) {  
                // ObjCache.remove(key);  
            }  
            ObjCache.put(key, obj);  
  
        } catch (Exception e) {  
        }  
    }  
  
    public void clearObject(Object key) {  
        try {  
            ObjCache.remove(key);  
        } catch (Exception e) {  
        }  
    }  
  
    public void clear() {  
        try {  
            ObjCache.clear();  
        } catch (Exception e) {  
        }  
    }  
  
    public void clearMatchObject(String key) {  
  
        // CacheAccess access1=CacheAccess.getAccess("DC");  
        // java.util.Map map=access1.get.getMatchingCacheElements(key);  
    }  
  
    public static void main(String[] args) {  
        JCSManagerDTO dto = JCSManagerDTO.getInstance();  
        dto.storeObject("test1", "111");  
        dto.storeObject("test2", "222");  
        dto.storeObject("test3", "333");  
        dto.storeObject("test4", "444");  
  
        System.out.println("test1 is  " + dto.getObj("test1"));  
        System.out.println("test2 is  " + dto.getObj("test2"));  
        System.out.println("test3 is  " + dto.getObj("test3"));  
        System.out.println("test4 is  " + dto.getObj("test4"));  
    }  
  
}

 6、涉及包

依赖jar包

jcs-1.3.jar

commons-lang-2.3.jar

commons-collections-2.1.1.jar

concurrent-1.3.4.jar