创建值对象如下：

package com.genericbookstore.data;

import java.io.Serializable;
import java.util.Date;

public class BookVObj implements Serializable
{
    public int bookId = 0;
    public String title;
    public String author;
    public String ISBN;
    public String price;
    public Date publishDate;

    public BookVObj()
    {
    }
}
        

package com.genericbookstore.data;

import org.apache.jcs.JCS;
// in case we want to set some special behavior
import org.apache.jcs.engine.behavior.IElementAttributes;

public class BookVObjManager
{
    private static BookVObjManager instance;
    private static int checkedOut = 0;
    public static JCS bookCache;

    private BookVObjManager()//构造函数
    {
        try
        {
            bookCache = JCS.getInstance("bookCache");
        }
        catch (Exception e)
        {
            // Handle cache region initialization failure
        }

        // Do other initialization that may be necessary, such as getting
        // references to any data access classes we may need to populate
        // value objects later
    }

    /**
     * Singleton access point to the manager.
     */
    public static BookVObjManager getInstance()
    {
        synchronized (BookVObjManager.class)
        {
            if (instance == null)
            {
                instance = new BookVObjManager();
            }
        }

        synchronized (instance)
        {
            instance.checkedOut++;
        }

        return instance;
    }


 /**
     * Retrieves a BookVObj.  Default to look in the cache.
     */
    public BookVObj getBookVObj(int id)
    {
        return getBookVObj(id, true);
    }

    /**
     * Retrieves a BookVObj. Second argument decides whether to look
     * in the cache. Returns a new value object if one can't be
     * loaded from the database. Database cache synchronization is
     * handled by removing cache elements upon modification.
     */
    public BookVObj getBookVObj(int id, boolean fromCache)
    {
        BookVObj vObj = null;

        // First, if requested, attempt to load from cache

        if (fromCache)
        {
            vObj = (BookVObj) bookCache.get("BookVObj" + id);
        }

        // Either fromCache was false or the object was not found, so
        // call loadBookVObj to create it

        if (vObj == null)
        {
            vObj = loadBookVObj(id);
        }

        return  vObj;
    }

    /**
     * Creates a BookVObj based on the id of the BOOK table.  Data
     * access could be direct JDBC, some or mapping tool, or an EJB.
     */
    public BookVObj loadBookVObj(int id)
    {
        BookVObj vObj = new BookVObj();

        vObj.bookId = id;

        try
        {
            boolean found = false;

            // load the data and set the rest of the fields
            // set found to true if it was found

            found = true;

            // cache the value object if found

            if (found)
            {
                // could use the defaults like this
                // bookCache.put( "BookVObj" + id, vObj );
                // or specify special characteristics

                // put to cache

                bookCache.put("BookVObj" + id, vObj);
            }

        }
        catch (Exception e)
        {
            // Handle failure putting object to cache
        }

        return vObj;
    }

    /**
     * Stores BookVObj's in database.  Clears old items and caches
     * new.
     */
    public void storeBookVObj(BookVObj vObj)
    {
        try
        {
            // since any cached data is no longer valid, we should
            // remove the item from the cache if it an update.

            if (vObj.bookId != 0)
            {
                bookCache.remove("BookVObj" + vObj.bookId);
            }

            // put the new object in the cache

            bookCache.put("BookVObj" + vObj.bookId, vObj);
        }
        catch (Exception e)
        {
            // Handle failure removing object or putting object to cache.
        }
    }
}
        

jcs.default.cacheattributes.UseMemoryShrinker=true
jcs.default.cacheattributes.MaxMemoryIdleTimeSeconds=3600
jcs.default.cacheattributes.ShrinkerIntervalSeconds=60
jcs.default.cacheattributes.MaxSpoolPerRun=500
jcs.default.elementattributes=org.apache.jcs.engine.ElementAttributes
jcs.default.elementattributes.IsEternal=false

<%

BookVObjManager cache = BookVObjManager.getInstance();

BookVObj bv1=cache.getBookVObj(8,true);

out.println(bv1.bookId);
%>

五、测试：http://127.0.0.1:8080/jcs/testjcs.jsp

所有源文件请下载。

作者：小红帽

概述
JCS是Jakarta的项目Turbine的子项目。它是一个复合式的缓冲工具。可以将对象缓冲到内存、硬盘。具有缓冲对象时间过期设定。还可以通过JCS构建具有缓冲的分布式构架，以实现高性能的应用。
对于一些需要频繁访问而每访问一次都非常消耗资源的对象，可以临时存放在缓冲区中，这样可以提高服务的性能。而JCS正是一个很好的缓冲工具。缓冲工具对于读操作远远多于写操作的应用性能提高非常显著。
JCS的详细说明在 http://jakarta.apache.org/turbine/jcs/

JCS的特性
JCS除了简单的将对象缓冲在内存中以外，还具有几个特性，以适应企业级缓冲系统的需要。这些特性包括时间过期、索引式硬盘缓冲、并行式的分布缓冲等。
内存缓冲
JCS现在支持两种内存缓冲算法LRU和MRU。通常都是使用LRU算法。
org.apache.stratum.jcs.engine.memory.lru.LRUMemoryCache
使用内存缓冲区需要定义缓冲区大小，当超过缓冲区限制时，会将缓冲内容抛弃掉。如果有配硬盘缓冲，则将挤出来的缓冲内容写入硬盘缓冲区。

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

索引式硬盘缓冲
一方面，为了避免缓冲区过大，撑爆虚拟机的内存，另一方面又希望能够缓冲更多的对象，JCS可以将超出缓冲区大小的对象缓存到硬盘上。配置上也比较方便，只需要指定缓冲临时文件的存放目录位置。硬盘缓冲将缓冲对象的内容写到文件上，但是将访问索引保存在内存中，因此也能够达到尽可能高的访问效率。

并行式的分布缓冲(Lateral)
通常，将对象缓冲在内存中，一方面提高了应用的性能，而另一方面却使得应用不可以分布式发布。因为假设一个应用配置在两台服务器上并行运行，而两台服务器单独缓冲，则很容易导致两个缓冲区内容出现版本上的不一致而出错。一个机器上修改了数据，这个动作会影响到本地内存缓冲区和数据库服务器，但是却不会通知到另一台服务器，导致另一台上缓冲的数据实际上已经无效了。
并行式的分布缓冲就是解决这个问题。可以通过配置，将几台服务器配成一个缓冲组，组内每台服务器上有数据更新，会横向将更新的内容通过TCP/IP协议传输到其他服务器的缓冲层，这样就可以保证不会出现上述情况。这个的缺点是如果组内的并行的服务器数量增大后，组内的数据传输量将会迅速上升。这种方案适合并行服务器的数量比较少的情况。

Client/Server式的缓冲(Remote)
客户/服务端式的缓冲集群。这种方式支持一个主服务器和最高达到256个客户端。客户端的缓冲层会尝试连接主服务器，如果连接成功，就会在主服务器上注册。每个客户端有数据更新，就会通知到主服务器，主服务器会将更新通知到除消息来源的客户端以外的所有的客户端。
每个客户端可以配置超过一个服务器，第一个服务器是主服务器，如果与第一个服务器连接失败，客户端会尝试与备用的服务器连接，如果连接成功，就会通过备用服务器与其他客户端对话，同时会定期继续尝试与主服务器取得连接。如果备用服务器也连接失败，就会按照配置顺序尝试与下一个备用服务器连接。
这种方式下，更新通知是一种轻量级的，一个机器上的数据更新，不会把整个数据传输出去，而只是通知一个ID，当远程的其他机器收到更新通知后，就会把对应ID的缓冲对象从本地的内存缓冲区中移除，以保证不会在缓冲区内出现错误数据。
这种构造需要分别配置客户端和服务器，配置比较麻烦。

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

内存缓冲
#WEB-INF/classes/cache.ccf(以下内容不要换行)
jcs.default=
jcs.default.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
jcs.default.cacheattributes.MaxObjects=1000
jcs.default.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
上面配置了默认缓冲属性。一个应用中，由于对象类型的不同，可能会使用多个缓冲区，每个缓冲区都会有一个名字，如果在配置文件中没有指明特定的缓冲区的属性，所有的缓冲区都会根据默认属性来构建。上面的内容，指明缓冲区的大小为存放1000个对象，内存缓冲器使用LRUMemoryCache对象。可选的还有MRUMemoryCache，应该可以自定义新的内存缓冲区。1000个缓冲对象这个容量，是指每个缓冲区都缓冲1000个，而不是指所有缓冲区总容量。以上配置，就可以让应用运行起来。

时间过期
如果需要引入时间过期机制，则需要加上
jcs.default.cacheattributes.cacheattributes.UseMemoryShrinker=true
jcs.default.cacheattributes.cacheattributes.MaxMemoryIdleTimeSeconds=3600
jcs.default.cacheattributes.cacheattributes.ShrinkerIntervalSeconds=60
这里指明对象超过3600秒则过期，每隔60秒检查一次。

索引式硬盘缓冲
索引式硬盘缓冲是辅助缓冲的一种，使用时需要做以下事情
#定义一个硬盘缓冲区产生器(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.auxiliary.LTCP=org.apache.jcs.auxiliary.lateral.LateralCacheFactory
jcs.auxiliary.LTCP.attributes=org.apache.jcs.auxiliary.lateral.LateralCacheAttributes
jcs.auxiliary.LTCP.attributes.TransmissionTypeName=TCP
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
这里的配置是在41,129,221三台机器上实现并行缓冲的。
大家都在1121端口上监听，同时与另外两台机器连接。如果连接失败，就会等待一个时间后再连接一次，直到连接成功为止。三台机器中任意一台的缓冲区发生更新，比如put和remove动作，就会把更新传递给另外两台。

单独指明某个缓冲区的属性
如果，针对某个缓冲区，比如叫做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

system.GroupIdCache
这个概念我也不是很清楚。不过JCS文档中指出配置以下内容会比较好。
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

来源 ： java学习室

此方法同样可适用Tomcat等服务，只要指定页面和服务名即可。也可以用于Web端重启服务器，不过因该不好用，除非你让Tomcat的启动账号有Administrator的权限。

												import java.io.InputStream;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.net.MalformedURLException;
import java.util.Date;/**
 * <p>Title:IIS服务监护 </p>
 * <p>Description: </p>
 * <p>Copyright: flashman.com.cn Copyright (c) 2005</p>
 * <p>Company: flashman.com.cn</p>
 * @Jeff zhu
 * @version 1.0
 */public class IISMonitor extends Thread{//服务操作成功标识//  private static final String SUCCESS_SIGN = "successfully";//英文系统privatestatic final String SUCCESS_SIGN ="成功";//中文系统//页面检测间隔时间privatestatic final int REFRESH_TIMER = 5 * 60 * 1000;//页面活动时间privatestatic final int MONITOR_TIMER = 10 * 1000;

  Runtime runtime;public IISMonitor(){
    runtime = Runtime.getRuntime();}/**
   * 启动服务
   * @param name 服务名
   * @return
   */public boolean startService(String name){return execute("net start "+ name).indexOf(SUCCESS_SIGN)>= 0;}/**
   * 停止服务
   * @param name 服务名
   * @return
   */public boolean stopService(String name){return execute("net stop "+ name +" /y").indexOf(SUCCESS_SIGN)>= 0;}/**
   * 页面是否活动
   * @param link
   * @return
   */public boolean pageIsAlive(String link){

    boolean result =true;

    PageCheck page =new PageCheck(link);
    page.start();

    long now =System.currentTimeMillis();
    try {while(!page.alive){this.sleep(1000);if(System.currentTimeMillis()- now > MONITOR_TIMER){
          result =false;break;}//        System.out.println(System.currentTimeMillis() - now);}}
    catch (InterruptedException ex){
      ex.printStackTrace();
      result =false;}

    page.stop();return result;}/**
   * 执行命令行
   * @param cmd
   * @return 控制台信息
   */privateString execute(String cmd){String line, message ="";

    try {

      Process process = Runtime.getRuntime().exec(cmd);

      try {
        BufferedReader readIn =new BufferedReader(new InputStreamReader(process.getInputStream()));while((line = readIn.readLine())!=null){
          message += line +"\n";}
        readIn.close();} catch (IOException ex){
        ex.printStackTrace();}}catch (IOException ex){
      message ="";}//System.out.println(message);return message;}/**
   * 启动方法
   * @param args
   */publicstaticvoid main(String[] args){new Thread(){publicvoid run(){

        IISMonitor monitor =new IISMonitor();while(true){
          try {String link, message ="";System.out.print(newDate().toLocaleString()+" checked...");
            link ="http://localhost/iisMonitor.asp";if(monitor.pageIsAlive(link)){System.out.print("the page is Alive!\n");}else{System.out.print("the page is Dead!!!\n");//StopIISSystem.out.print("Stoped IIS...");if(monitor.stopService("iisadmin")){System.out.print("successfully.\n");}else{System.out.print("unsuccessful!!!\n");}//StartIISSystem.out.print("Started IIS...");if(monitor.startService("W3SVC")){System.out.print("successfully.\n");}else{System.out.print("unsuccessful!!!\n");}}System.out.println(message);this.sleep(IISMonitor.REFRESH_TIMER);}
          catch (Exception ex){
            ex.printStackTrace();}}}}.start();}}/**
 * 页面检测类
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */
class PageCheck extends Thread{public boolean alive;privateString link;public PageCheck(String link){this.alive =false;this.link = link;}publicvoid run(){

    try {
      URLConnection urlConnection;String line, result ="";

      urlConnection =new URL(link).openConnection();
      BufferedReader readIn =new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));while((line = readIn.readLine())!=null){
        result += line +"\n";}
      readIn.close();
      alive =true;}
    catch (Exception ex){
      ex.printStackTrace();
      alive =false;}}}

 

下面这段存成iisMonitor.asp放在服务器上

<%
Response.Buffer=false
Response.Write now

'假死测试'For I=1 To 1000000' Response.Write I & "<br>"'Next%>
										

 <servlet>
   <servlet-name>proxool_Admin</servlet-name>
   <servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>
 </servlet>

 <servlet-mapping>
   <servlet-name>proxool_Admin</servlet-name>
   <url-pattern>/proxoolAdmin</url-pattern>
 </servlet-mapping>

学C语言的时候，我们相爱,成为恋人！
学VB的时候，我们分手，成为朋友！
学J2EE的时候，我们决定忘记，成为陌路人！

璐璐：
我原来真的那么差劲吗？
可能我从来都站在自己的角度想问题！
我和我女朋友，也就一个星期见一次！
我还是很忙，正在做J2EE的毕业设计，天天都忙到凌晨三四点，
以至于她告诉我，不如娶个电脑当老婆！
我想实现我的梦，所以我选择深圳，以后再去上海！
但这样又会发生什么样的变化，我不敢去想！
我曾经以为一切的事情都不会发生改变！
后来，我明白了计划赶不上变化！
很常一段时间我在痛苦和自责中活着，我毕竟是人！
说这些，我不得不承认，我现在还爱你，只不过是放在最深处！
忘记,我做不到，时间可以使人忘记一切，但曾经走过的路，去过的地方，哪怕是电视塔下的那片草坪，
我无法忘记，那是因为我还看的见！
我曾试图忘记，但却没有撕毁那张封信的勇气！
时间不会因为我而倒退，地球也不会停止转动，
于是我每天还是要带着微笑活着！
做人累，忘记人更累！
如果桂林是缘分的开始，那么在长沙收到的第一封信就是我判为有期徒刑！
如果温州是缘分的开始，那么从你手中接过的第二封信就已经是判我为无期徒刑！
我曾经想上诉，于是你消失了！
之后我就进了监狱，过了好久猪狗不如的生活后,我越狱了！
但是我还保留着那份相对于人，而不相对于时间的爱情判决书！
几年后，你出现了，但我却因为越狱而终身无法上诉！
如果时间可以GOTO,我愿意在我们的爱情外加装FOR循环
如果时间可以GOTO,我愿意在我们的爱情内加装IF判断
如果时间可以GOTO,我愿意为自己加装垃圾回收机制
如果时间可以GOTO,我甚至可以背叛J2EE,而投靠.NET，不用JAVA，而改用C#
如果时间可以GOTO......
错，我犯过！
而无法挽回的错，我仍然犯过！
犯错时我一点意识都没有，当意识到犯了无法挽回的错时，也就意味着连改的机会都没有了！
曾经说爱你，现在已经没有权利，只能放在内心深处，不为人知！
曾经说对不起，现在已经没有意义，但真心祝你快乐，幸福！
相信你以后的他，一定比我好千百倍，
不会连陪你的时间都可以数的清，
不会三五天消失都不打一个电话，
不会因为要调试代码而晚上让你独自回去，
不会让你伤心，难过，
不会......

璐璐，最后，在执行DELETE 前，让我再看一次吧！

SELECT * FROM MyLove 

ID      Datetime        Address           Forget
1       2000-02-14    电视塔草坪      没有忘记[默认值]
.         ....-.-..                .....                    没有忘记[默认值] 
.         ....-.-..                .....                    没有忘记[默认值] 
.         ....-.-..                .....                    没有忘记[默认值] 
521   2002-02-14  宿舍楼下           没有忘记[默认值]

曾经很少使用INSERT , 却使用UPDATE修改Forget列,但不管怎么修改
到最后都变成默认值，因为曾经我无法忘记！

璐璐，再见了，就像你说的那样，让我们忘记对方吧，珍惜现在所拥有的！

正在删除对方的QQ号码......
删除成功！

正在删除对方的E-mail......
删除成功！

正在删除对方的电话......
删除成功！

删除MyLove表中所有内容，将执行"DELETE MyLove",确认吗?(Y/N):_

Y

重要信息删除，请输入密码:_

if(my!=521&&you!=521)System.out.println("再见了,我的爱人!");

密码正确！

正在删除MyLove表中所有内容......
................................
................................
................................
................................

删除成功！！   

//感言
//程序写累了，就写写自己的程序人生，有些感伤！
//朋友，在为祖国软件业做贡献的同时，别忘了你的她！