BlogJava-Terry.Li-彬-文章分类-cache

Ehcache详细解读

礼物 — Wed, 20 Nov 2013 04:53:00 GMT

摘要: Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大，最初知道它，是从Hibernate的缓存开始的。网上中文的EhCache材料以简单介绍和配置方法居多，如果你有这方面的问题，请自行google；对于API，官网上介绍已经非常清楚，请参见官网；但是很少见到特性说明和对实现原理的分析，因此在这篇文章里面，我会详细介绍和分析EhCache的特性，加上一些自己... 阅读全文

礼物 2013-11-20 12:53 发表评论

ehcache 配置参数说明

礼物 — Mon, 16 Sep 2013 02:43:00 GMT

< ehcache xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"        xsi:noNamespaceSchemaLocation = "ehcache.xsd" >
   < diskStore path = "java.io.tmpdir" />
   < defaultCache
     maxElementsInMemory = "10000"
     maxElementsOnDisk = "0"
     eternal = "true"
     overflowToDisk = "true"
     diskPersistent = "false"
     timeToIdleSeconds = "0"
     timeToLiveSeconds = "0"
     diskSpoolBufferSizeMB = "50"
     diskExpiryThreadIntervalSeconds = "120"
     memoryStoreEvictionPolicy = "LFU"
     />
   < cache name = "myCache"
     maxElementsInMemory = "100"
     maxElementsOnDisk = "0"
     eternal = "false"
     overflowToDisk = "false"
     diskPersistent = "false"
     timeToIdleSeconds = "120"
     timeToLiveSeconds = "120"
     diskSpoolBufferSizeMB = "50"
     diskExpiryThreadIntervalSeconds = "120"
     memoryStoreEvictionPolicy = "FIFO"
     />
ehcache >

diskStore ：指定数据存储位置，可指定磁盘中的文件夹位置
defaultCache ：默认的管理策略

以下属性是必须的：

name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)。
maxElementsInMemory： 在内存中缓存的element的最大数目。
maxElementsOnDisk： 在磁盘上缓存的element的最大数目，默认值为0，表示不限制。
eternal： 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断。
overflowToDisk： 如果内存中数据超过内存限制，是否要缓存到磁盘上。

以下属性是可选的：

timeToIdleSeconds： 对象空闲时间，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问。
timeToLiveSeconds： 对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问。
diskPersistent： 是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false。
diskExpiryThreadIntervalSeconds： 对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次。
diskSpoolBufferSizeMB： DiskStore使用的磁盘大小，默认值30MB。每个cache使用各自的DiskStore。
memoryStoreEvictionPolicy： 如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU。

缓存的3 种清空策略 ：
FIFO ，first in first out (先进先出).

LFU ， Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。

LRU ，Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

礼物 2013-09-16 10:43 发表评论

xmemcached

礼物 — Mon, 18 Oct 2010 04:07:00 GMT

Getting_Started_zh 简单介绍依赖包简单例子设置权重使用二进制协议使用Kestrel 动态增删节点 Nio连接池使用CAS原子更新简单介绍 Xmemcached支持memcached所有的二进制协议（从1.2.0开始）和文本协议，并且支持对Kestrel(一个scala写的MQ)的兼容访问。更多信息请参考用户指南依赖包 Xmemcached 1.x 需要依赖common-logging和yanf4j-0.70http://code.google.com/p/yanf4j/downloads/list) Xmemcached 1.2.0-stable开始及以后版本需要依赖slf4j(http://www.slf4j.org/)和yanf4j-1.0.1 memcached 1.2.0 and 1.2.1 依赖 yanf4j 1.0.1 memcached 1.2.2 依赖 yanf4j 1.1.0 memcached 1.2.3 and 1.2.4 依赖 yanf4j 1.1.1 Xmemcached 1.2.5 不再依赖yanf4j 如果您使用maven构建，只需要添加依赖即可使用xmemcached: com.googlecode.xmemcachedxmemcached1.2.5 简单例子 MemcachedClient client=new XMemcachedClient("host",11211); //同步存储value到memcached client.set("key",3600,someObject); //从memcached获取key对应的value Object someObject=client.get("key"); //从memcached获取key对应的value,操作超时2秒 someObject=client.get("key",2000); //删除value client.delete("key"); 设置权重 MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:12000 localhost:12001"),new int[]{1,3}); MemcachedClient memcachedClient=builder.build(); 上面的例子将"localhost:12000"节点的权重设置为1，而将"localhost:12001"节点的权重设置为3.当然，你也可以通过JMX调用MBean动态修改权重： public interface XMemcachedClientMBean{ .... /** * Set a memcached server's weight * * @param server * @param weight */ public void setServerWeight(String server, int weight); } 使用二进制协议 Xmemcached默认使用成熟的文本协议，memcached 1.4.0正式支持启用二进制协议，如果你想使用二进制协议，你只要添加一行代码，设置BinaryCommandFactory即可： MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:12000 localhost:12001"),new int[]{1,3}); builder.setCommandFactory(new BinaryCommandFactory());//use binary protocol MemcachedClient memcachedClient=builder.build(); 使用Kestrel Kestrel是twitter开源的一个scala写的简单高效MQ，它支持memcached文本协议，但是并不完全兼容，例如它不支持flag，导致很多利用flag做序列化的客户端无法正常运作。因此Xmemcached特意提供了KestrelCommandFactory用于支持Kestrel。使用KestrelCommandFactory即可拥有如下好处：默认关闭get优化，因为kestrel不支持bulk get；支持kestrel的阻塞获取和可靠获取；允许向kestrel存储任意java序列化类型。设置KestrelCommandFactory: MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:12000 localhost:12001"),new int[]{1,3}); builder.setCommandFactory(new KestrelCommandFactory()); MemcachedClient memcachedClient=builder.build(); 关于最后一点需要补充说明，由于kestrel不支持flag，因此xmemcached在存储的数据之前加了4个字节的flag，如果你的全部应用都使用xmemcached，那么没有问题，如果使用其他clients，会有兼容性的问题，因此Xmemcached还允许关闭这个功能，通过 client.setPrimitiveAsString(true); 设置为true后，原生类型都将存储为字符串，而序列化类型将无法存储了。动态增删节点你可以通过编程或者JMX来动态增加或者移除memcached节点： MemcachedClient client=new XMemcachedClient(AddrUtil.getAddresses("server1:11211 server2:11211")); //Add two new memcached nodes client.addServer("server3:11211 server4:11211"); //Remove memcached servers client.removeServer("server1:11211 server2:11211"); Nio连接池 Xmemcached是基于java nio的client实现，默认对一个memcached节点只有一个连接，这在通常情况下已经有非常优异的表现。但是在典型的高并发环境下,nio的单连接也会遇到性能瓶颈。因此XMemcached支持设置nio的连接池，允许建立多个连接到同一个memcached节点，但是请注意，这些连接之间是不同步的，因此你的应用需要自己保证数据更新的同步，启用连接池可以通过下面代码： MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:12000")); builder.setConnectionPoolSize(5); 使用CAS原子更新典型的CAS操作需要先通过gets得到cas值，然后进行cas替换，用起来相当麻烦。XMemcached提供了CASOperation封装了这两个操作，提供给用户统一的使用接口，并且允许设置最多重试次数。详见下面的例子，启动N个线程原子更新同一个key的value。 class CASThread extends Thread { static final class IncrmentOperation implements CASOperation { /* *Max repeat times.if repeat times is great than this value, *xmemcached will throw a TimeoutException. */ @Override public int getMaxTries() { return Integer.MAX_VALUE; } //increase current value @Override public Integer getNewValue(long currentCAS, Integer currentValue) { return currentValue + 1; // 当前值+1 } } private XMemcachedClient mc; private CountDownLatch cd; public CASThread(XMemcachedClient mc, CountDownLatch cdl) { super(); this.mc = mc; this.cd = cdl; } public void run() { try { //do the cas operation if (mc.cas("a", 0, new IncrmentOperation())) this.cd.countDown(); } catch (Exception e) { e.printStackTrace(); } } } public class CASTest { public static void main(String[] args) throws Exception { if (args.length < 2) { System.err.println("Usage:java CASTest [threadNum] [server]"); System.exit(1); } //threads num int NUM = Integer.parseInt(args[0]); XMemcachedClient mc = new XMemcachedClient(AddrUtil.getAddresses(args[1])); //initial value is 0 mc.set("a", 0, 0); CountDownLatch cdl = new CountDownLatch(NUM); long start = System.currentTimeMillis(); //start NUM threads to increment the value for (int i = 0; i < NUM; i++) new CASThread(mc, cdl).start(); cdl.await(); System.out.println("test cas,timed:" + (System.currentTimeMillis() - start)); System.out.println("result=" + mc.get("a")); mc.shutdown(); } }

礼物 2010-10-18 12:07 发表评论

用OSCache进行缓存对象

礼物 — Mon, 09 Aug 2010 07:57:00 GMT

1、OSCache是什么?
     OSCache标记库由OpenSymphony设计，它是一种开创性的缓存方案，它提供了在现有JSP页面之内实现内存缓存的功能。OSCache是个一个被广泛采用的高性能的J2EE缓存框架，OSCache还能应用于任何Java应用程序的普通的缓存解决方案。
2、OSCache的特点
    (1) 缓存任何对象：你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。
    (2) 拥有全面的API：OSCache API允许你通过编程的方式来控制所有的OSCache特性。
    (3) 永久缓存：缓存能被配置写入硬盘，因此允许在应用服务器的多次生命周期间缓存创建开销昂贵的数据。
    (4) 支持集群：集群缓存数据能被单个的进行参数配置，不需要修改代码。
    (5) 缓存过期：你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略（如果默认性能不能满足需要时）。
3、OSCache的安装与配置
    网上已经有一个不错的使用教程：http://blog.csdn.net/ezerg/archive/2004/10/14/135769.aspx
4、有关“用OSCache进行缓存对象”的研究
    这个是我今天要说的东西。网上对于OSCache缓存Web页面很多说明和例子，但对于缓存对象方面说得不多，我就把自已写得一些东西放出来，让大家看一看是怎样缓存对象的!
    我基于GeneralCacheAdministrator类来写的BaseCache类

view plain copy to clipboard print ?

package com.klstudio.cache;
import java.util.Date;
import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
public class BaseCache extends GeneralCacheAdministrator {
//过期时间(单位为秒);
private int refreshPeriod;
//关键字前缀字符;
private String keyPrefix;
private static final long serialVersionUID = -4397192926052141162L;
public BaseCache(String keyPrefix, int refreshPeriod){
super ();
this .keyPrefix = keyPrefix;
this .refreshPeriod = refreshPeriod;
}
//添加被缓存的对象;
public void put(String key,Object value){
this .putInCache( this .keyPrefix+ "_" +key,value);
}
//删除被缓存的对象;
public void remove(String key){
this .flushEntry( this .keyPrefix+ "_" +key);
}
//删除所有被缓存的对象;
public void removeAll(Date date){
this .flushAll(date);
}
public void removeAll(){
this .flushAll();
}
//获取被缓存的对象;
public Object get(String key) throws Exception{
try {
return this .getFromCache( this .keyPrefix+ "_" +key, this .refreshPeriod);
} catch (NeedsRefreshException e) {
this .cancelUpdate( this .keyPrefix+ "_" +key);
throw e;
}
}
}

Java代码

package com.klstudio.cache;
import java.util.Date;
import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
public class BaseCache extends GeneralCacheAdministrator {
//过期时间(单位为秒);
private int refreshPeriod;
//关键字前缀字符;
private String keyPrefix;
private static final long serialVersionUID = -4397192926052141162L;
public BaseCache(String keyPrefix,int refreshPeriod){
super();
this.keyPrefix = keyPrefix;
this.refreshPeriod = refreshPeriod;
}
//添加被缓存的对象;
public void put(String key,Object value){
this.putInCache(this.keyPrefix+"_"+key,value);
}
//删除被缓存的对象;
public void remove(String key){
this.flushEntry(this.keyPrefix+"_"+key);
}
//删除所有被缓存的对象;
public void removeAll(Date date){
this.flushAll(date);
}
public void removeAll(){
this.flushAll();
}
//获取被缓存的对象;
public Object get(String key) throws Exception{
try{
return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);
} catch (NeedsRefreshException e) {
this.cancelUpdate(this.keyPrefix+"_"+key);
throw e;
}
}
}

package com.klstudio.cache;

import java.util.Date;

import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;

public class BaseCache extends GeneralCacheAdministrator {
	//过期时间(单位为秒);
	private int refreshPeriod;
	//关键字前缀字符;
	private String keyPrefix;
	
	private static final long serialVersionUID = -4397192926052141162L;
	
	public BaseCache(String keyPrefix,int refreshPeriod){
		super();
		this.keyPrefix = keyPrefix;
		this.refreshPeriod = refreshPeriod;
	}
	//添加被缓存的对象;
	public void put(String key,Object value){
		this.putInCache(this.keyPrefix+"_"+key,value);
	}
	//删除被缓存的对象;
	public void remove(String key){
		this.flushEntry(this.keyPrefix+"_"+key);
	}
	//删除所有被缓存的对象;
	public void removeAll(Date date){
		this.flushAll(date);
	}
	
	public void removeAll(){
		this.flushAll();
	}
	//获取被缓存的对象;
	public Object get(String key) throws Exception{
		try{
			return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);
		} catch (NeedsRefreshException e) {
			this.cancelUpdate(this.keyPrefix+"_"+key);
			throw e;
		}

}
	
}

通过CacheManager类来看怎样缓存对象的,这个类中所用的News只是具体功能的类，我就不贴出来了，你可以自己写一个!

view plain copy to clipboard print ?

package com.klstudio;
import com.klstudio.News;
import com.klstudio.cache.BaseCache;
public class CacheManager {
private BaseCache newsCache;
private static CacheManager instance;
private static Object lock = new Object();
public CacheManager() {
//这个根据配置文件来，初始BaseCache而已;
newsCache = new BaseCache("news",1800);
}
public static CacheManager getInstance(){
if (instance == null){
synchronized( lock ){
if (instance == null){
instance = new CacheManager();
}
}
}
return instance;
}
public void putNews(News news) {
// TODO 自动生成方法存根
newsCache.put(news.getID(),news);
}
public void removeNews(String newsID) {
// TODO 自动生成方法存根
newsCache.remove(newsID);
}
public News getNews(String newsID) {
// TODO 自动生成方法存根
try {
return (News) newsCache.get(newsID);
} catch (Exception e) {
// TODO 自动生成 catch 块
System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage());
News news = new News(newsID);
this.putNews(news);
return news;
}
}
public void removeAllNews() {
// TODO 自动生成方法存根
newsCache.removeAll();
}
}

Java代码

package com.klstudio;
import com.klstudio.News;
import com.klstudio.cache.BaseCache;
public class CacheManager {
private BaseCache newsCache;
private static CacheManager instance;
private static Object lock = new Object();
public CacheManager() {
//这个根据配置文件来，初始BaseCache而已;
newsCache = new BaseCache("news",1800);
}
public static CacheManager getInstance(){
if (instance == null){
synchronized( lock ){
if (instance == null){
instance = new CacheManager();
}
}
}
return instance;
}
public void putNews(News news) {
// TODO 自动生成方法存根
newsCache.put(news.getID(),news);
}
public void removeNews(String newsID) {
// TODO 自动生成方法存根
newsCache.remove(newsID);
}
public News getNews(String newsID) {
// TODO 自动生成方法存根
try {
return (News) newsCache.get(newsID);
} catch (Exception e) {
// TODO 自动生成 catch 块
System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage());
News news = new News(newsID);
this.putNews(news);
return news;
}
}
public void removeAllNews() {
// TODO 自动生成方法存根
newsCache.removeAll();
}
}

礼物 2010-08-09 15:57 发表评论

Hibernate ehcache配置二级缓存

礼物 — Sun, 08 Aug 2010 08:40:00 GMT

摘要: Hibernate ehcache配置二级缓存 1、首先设置EhCache，建立配置文件ehcache.xml，默认的位置在class-path，可以放到你的src目录下：　阅读全文

礼物 2010-08-08 16:40 发表评论

Freemarker中使用OSCache

礼物 — Sat, 07 Aug 2010 07:53:00 GMT

可以使用maven加入oscache依赖，然后在需要使用oscache的freemarker页面上引入标签<#assign oscache=JspTaglibs['http://www.opensymphony.com/oscache']/>，中括号中可以使用路径方式，然后再页面上需要加入oscache的地方使用<@oscache:标记

例如：
<#assign oscache=JspTaglibs['http://www.opensymphony.com/oscache']/>

<#assign fowUrlaa="">
<#if RequestParameters.fowUrl?exists>
<#assign fowUrlaa="${RequestParameters.fowUrl}">

<@oscache.cache key="__oscache_categories" time=300>
${fowUrlaa}

然后再URL上添加参数测试：?fowUrl=12fas11

礼物 2010-08-07 15:53 发表评论

(转载)在J2EE系统中应用OSCache

礼物 — Thu, 26 Feb 2009 01:09:00 GMT

本文来自：http://www.blogjava.net/zhongli/archive/2009/02/22/256033.html

文章摘要

Cache是一种用于提高系统响应速度、改善系统运行性能的技术。尤其是在Web应用中，通过缓存页面的输出结果，可以很显著的改善系统运行性能。本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。通过应用OSCache，我们不但可以实现通常的Cache功能，还能够改善系统的稳定性。

1 面临的问题

1.1 需要处理的特殊动态内容

在信息系统建设过程中我们通常会遇到这样的问题：

1. 基础数据的变更问题

信息系统中需要处理的基础数据的内容短时间内是不会发生变化的，但是在一个相对长一些的时间里，它却可能是动态增加或者减少的。

举个例子：电子商务中关于送货区域的定义，可能短时间内不会发生变化，但是随着电子商务企业业务的扩大，系统中需要处理的送货区域就可能增加。所以我们的系统中不得不在每次向客户展示送货区域信息的时候都和数据库（假设送货区域信息保存在数据库中，这也是通常采用的处理方法）进行交互。

2. 统计报表（不仅限于统计报表）的问题

一般来说，统计报表是一个周期性的工作，可能是半个月、一个月或者更长的时间才会需要更新一次，然而统计报表通常是图形显示或者是生成pdf、word、excel等格式的文件，这些图形内容、文件的生成通常需要消耗很多的系统资源，给系统运行造成很大的负担。

1.2 问题的共同点

通过比较分析，不难发现这两类问题有一些共同点：

1、被处理的内容短时间不变，所以短时间内可以作为静态内容进行处理

2、在一个不太长的时间内，被处理的内容可能或者必定产生变化，所以必须将他们作为动态内容进行处理

3、在合理的时间区段内可以忽略被处理内容变化后带来的影响

4、对这些内容的处理动作比较消耗系统性能，影响系统响应时间

1.3 解决方法

缓存技术可以帮助我们很好的解决这个问题：

1、缓存信息

当上述的基础数据或者统计报表第一次被访问时，被处理的内容被当作动态信息，基础数库从数据库中获得，统计报表也会被生成符合要求的图形、文件，然后这些信息都会被放入缓存信息中。

2、响应信息由缓存提供

当上述的基础数据或者统计报表继续被访问时，系统将会首先检查缓存信息中是否有对应的内容和我们设定的缓存规则，如果符合缓存信息存在而且符合缓存规则，给出的响应将来自于缓存信息，如果没有或者缓存信息已经不符合设定的要求，系统将重复上一步的动作。

很显然，上面的步骤2中，多数情况下，当用户请求到达时，被处理的内容将来自于缓存，所以大大的减少了与数据库的交互，或者不再需要为每个请求都生成一次报表图形或者文件，这部分工作的减少对于降低系统性能消耗、提高系统稳定性和并发处理能力是非常有益的。

2 OSCache简介

OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件，它的出现解决了我们面临的问题。 OSCache目前最新的稳定版本是2.0，本文中的例子都是基于这个版本的，如果大家运行例子的过程中发生问题，请首先确认是否采用了正确的软件版本。

2.1 主要特征

1. 兼容多种支持JSP的web服务器

已经通过兼容测试的web服务器包括OrionServer (1.4.0或者以上版本) 、Macromedia JRun (3.0或者以上版本) 、BEA Weblogic (7.x或者以上版本) 、IBM Websphere (5.0版本)、Silverstream (3.7.4版本)、Caucho Resin (1.2.3或者以上版本)、Tomcat (4.0或者以上版本) ，其他支持servlet2.3、jsp1.2的web服务器应该都是完全兼容OSCache的。

2. 可选的缓存区

你可以使用内存、硬盘空间、同时使用内存和硬盘或者提供自己的其他资源（需要自己提供适配器）作为缓存区。

使用内存作为缓存区将可以提供更好的性能
使用硬盘作为缓存区可以在服务器重起后迅速恢复缓存内容
同时使用内存和硬盘作为缓存区则可以减少对内存的占用

3. 灵活的缓存系统

OSCache支持对部分页面内容或者对页面级的响应内容进行缓存，编程者可以根据不同的需求、不同的环境选择不同的缓存级别。

4. 容错

在一般的web应用中，如果某个页面需要和数据库打交道，而当客户请求到达时，web应用和数据库之间无法进行交互，那么将返回给用户"系统出错"或者类似的提示信息，如果使用了OSCache的话，你可以使用缓存提供给用户，给自己赢得维护系统或者采取其他补救的时间。

其它特性还包括对集群的支持、缓存主动刷新等特性，大家可以参考OpenSymphony网站上的其他资源获取更多的信息。

3 OSCache组件的安装

OSCache是一个基于web应用的组件，他的安装工作主要是对web应用进行配置，大概的步骤如下：

1. 下载、解压缩OSCache

请到OSCache的主页http://www.opensymphony.com/oscache/download.html http://www.bt285.cn/content.php?id=1196863 http://www.5a520.cn

下载Oscache的最新版本，作者下载的是OSCache的最新稳定版本2.0。

将下载后的。Zip文件解压缩到c:oscache（后面的章节中将使用%OSCache_Home%来表示这个目录）目录下

2. 新建立一个web应用

3. 将主要组件%OSCache_Home%oscache.jar放入WEB-INFlib目录

4. commons-logging.jar、commons-collections.jar的处理

OSCache组件用Jakarta Commons Logging来处理日志信息，所以需要commons-logging.jar的支持，请将%OSCache_Home%libcorecommons-logging.jar放入classpath（通常意味着将这个文件放入WEB- INFlib目录）
如果使用JDK1.3,请将%OSCache_Home%libcorecommons-collections.jar放入classpath，如果使用JDK1.4或者以上版本，则不需要了

5. 将oscache.properties、oscache.tld放入WEB-INFclass目录

%OSCache_Home%oscache.properties包含了对OSCache运行特征值的设置信息
%OSCache_Home%oscache.tld包含了OSCache提供的标签库的定义内容

6. 修改web.xml文件

在web.xml文件中增加下面的内容，增加对OSCache提供的taglib的支持：



            

            oscache

            

            /WEB-INF/classes/ oscache.tld

4 开始使用OSCache中的缓存组件

OSCache中按照缓存范围的不同分为两种不同的方式：一种是缓存JSP页面中部分或者全部内容，一种是基于整个页面文件的缓存。

4.1 JSP部分内容缓存

4.1.1 Cache-OSCache提供的缓存标签

这是OSCache提供的标签库中最重要的一个标签，包括在标签中的内容将应用缓存机制进行处理，处理的方式将取决于编程者对cache标签属性的设置。

第一次请求到达时，标签中的内容被处理并且缓存起来，当下一个请求到达时，缓存系统会检查这部分内容的缓存是否已经失效，主要是以下几项：

1. 缓存时间超过了cache标签设置的time或者duration属性规定的超时时间
2. cron属性规定的时间比缓存信息的开始时间更晚
3. 标签中缓存的内容在缓存后又被重新刷新过
4. 其他缓存超期设定

如果符合上面四项中的任何一项，被缓存的内容视为已经失效，这时被缓存的内容将被重新处理并且返回处理过后的信息，如果被缓存的内容没有失效，那么返回给用户的将是缓存中的信息。

cache标签的属性说明:

key - 标识缓存内容的关键词。在指定的作用范围内必须是唯一的。默认的key是被访问页面的URI和后面的请求字符串。

你可以在同一个页面中使用很多cache标签而不指定他的key属性，这种情况下系统使用该页面的URI和后面的请求字符串，另外再自动给这些key增加一个索引值来区分这些缓存内容。但是不推荐采用这样的方式。

scope - 缓存发生作用的范围，可以是application或者session

time - 缓存内容的时间段，单位是秒，默认是3600秒，也就是一个小时，如果设定一个负值，那么这部分被缓存的内容将永远不过期。

duration - 指定缓存内容失效的时间，是相对time的另一个选择，可以使用简单日期格式或者符合USO-8601的日期格式。如：duration='PT5M' duration='5s'等

refresh - false 或者true。

如果refresh属性设置为true，不管其他的属性是否符合条件，这部分被缓存的内容都将被更新，这给编程者一种选择，决定什么时候必须刷新。

mode - 如果编程者不希望被缓存的内容增加到给用户的响应中，可以设置mode属性为"silent"

其它可用的属性还包括：cron 、groups、language、refreshpolicyclass、refreshpolicyparam。

上面的这些属性可以单独使用，也可以根据需要组合使用，下面的例子将讲解这些常用属性的使用方式。

4.1.2 Cache标签实例分析:

1. 最简单的cache标签用法

使用默认的关键字来标识cache内容，超时时间是默认的3600秒



            

            <%

            

            //自己的JSP代码内容

            

            %>

2. 用自己指定的字符串标识缓存内容，并且设定作用范围为session。



            

            <%

            

            //自己的JSP代码内容

            

            %>

3.动态设定key值，使用自己指定的time属性设定缓存内容的超时时间，使用动态refresh值决定是否强制内容刷新。

因为OSCache使用key值来标识缓存内容，使用相同的key值将会被认为使用相同的的缓存内容，所以使用动态的key值可以自由的根据不同的角色、不同的要求决定使用不同的缓存内容。



            

            <%

            

            //自己的JSP代码内容

            

            %>

4. 设置time属性为负数使缓存内容永不过期



            

            <%

            

            //自己的JSP代码内容

            

            %>

5. 使用duration属性设置超期时间



            

            <%

            

            //自己的JSP代码内容

            

            %>

6. 使用mode属性使被缓存的内容不加入给客户的响应中



            

            <%

            

            //自己的JSP代码内容

            

            %>

4.2 用CashFilter实现页面级缓存

在OSCache组件中提供了一个CacheFilter用于实现页面级的缓存，主要用于对web应用中的某些动态页面进行缓存，尤其是那些需要生成pdf格式文件/报表、图片文件等的页面，不仅减少了数据库的交互、减少数据库服务器的压力，而且对于减少web服务器的性能消耗有很显著的效果。

这种功能的实现是通过在web.xml中进行配置来决定缓存哪一个或者一组页面，而且还可以设置缓存的相关属性，这种基于配置文件的实现方式对于J2EE来说应该是一种标准的实现方式了。

[注] 只有客户访问时返回http头信息中代码为200（也就是访问已经成功）的页面信息才能够被缓存

1. 缓存单个文件

修改web.xml，增加如下内容，确定对/testContent.jsp页面进行缓存。



            

            CacheFilter

            

            com.opensymphony.oscache.web.filter.CacheFilter

            

            

            

            

            

            CacheFilter

            

            

            

            /testContent.jsp

2. 缓存URL pattern

修改web.xml，增加如下内容，确定对*.jsp页面进行缓存。



            

            CacheFilter

            

            com.opensymphony.oscache.web.filter.CacheFilter

            

            

            

            

            

            CacheFilter

            

            

            

            *.jsp

3. 自己设定缓存属性

在页面级缓存的情况下，可以通过设置CacheFilter的初始属性来决定缓存的一些特性：time属性设置缓存的时间段，默认为3600秒，可以根据自己的需要只有的设置，而scope属性设置，默认为application，可选项包括application、session



            

            CacheFilter

            

            com.opensymphony.oscache.web.filter.CacheFilter

            

            

            

            time

            

            600

            

            

            

            

            

            scope

            

            session

            

            

            

            

            

            

            

            CacheFilter

            

            

            

            *.jsp

5 性能测试结果

5.1 测试环境

系统平台：windows 2000 高级服务器/ P3 800 /512M内存

web服务器：websphere 5.0

数据库服务器：mysql 4.0.18-nt

性能测试用工具：apache Jmeter

5.2 测试计划

这次性能测试对比方为使用缓存和不使用缓存两种，他们的访问代码都是一样的：通过数据源从本地mysql数据库中获取person表的所有记录，然后显示在页面上。

测试中将模仿10个用户，每个用户发起5次请求，然后统计所有访问花费的时间。

5.3 测试结果

使用缓存后的测试结果不使用缓存时的测试结果

所有请求花费的总时间(毫秒) 20569 22870

性能测试的详细结果请大家查看下载内容中的《不使用cache时的系统性能测试结果.txt》和《使用cache后系统性能测试结果.txt》

6 总结

在J2EE系统中，我们经常需要处理一些特殊的动态内容，这些内容在一个时间段内的变更非常有限，但是又不得不将他们确定为动态内容进行输出，而且非常消耗数据库系统资源或者web服务器的资源，这时我们就可以采用Cache----一种用于提高系统响应速度、改善系统运行性能的技术----来优化我们的系统。尤其是在Web应用中，这种处理可以很显著的改善系统运行性能。

本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。它提供了在J2EE系统中实现缓存需要的丰富的功能。通过应用OSCache，我们不但可以实现通常的Cache功能、自由的设定cache的相关特性比如缓存时间段/缓存内容等，提升系统性能，而且还能有效的改善系统的稳定性。除此之外，OSCache组件还提供了更多的特性比如集群、容错、灵活的缓存区选择等。

作者根据自己的使用经验给大家提供了一些简单的例子，他们部分演示了如何使用OSCache组件提供的丰富特性，OSCache提供的特性远不止这些，需要大家在今后的时间里深入的研究

礼物 2009-02-26 09:09 发表评论