缓存filter及资源池模式

一。缓存过滤器模式

1。概念：缓存过滤器模式是通过使用servlet的filter来动态地缓存生成的页面，从而提高web层的性能和伸缩性。工作原理非常简单，当第一次请求到来时，判断是否可以缓存，可以的话就放在缓存里。当下次请求时，直接从缓存中取出，而不是再次请求。

2。一个简单实现对html页面的缓存：

package cfexample.controller;

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

/**

 *用来替代httpservletreponse的新对象，以提供缓存能力

 */

public class cacheresponsewrapper extends httpservletresponsewrapper {

    private cacheoutputstream outstream;

    //替换outputstream和printwriter

    private servletoutputstream stream;

    private printwriter writer;

    class cacheoutputstream extends servletoutputstream {

        private bytearrayoutputstream bos;

        cacheoutputstream() {

            bos = new bytearrayoutputstream();

        }

        public void write(int param) throws ioexception {

            bos.write(param);

        public void write(byte[] b, int off, int len) throws ioexception {

            bos.write(b, off, len);

        protected byte[] getbytes() {

            return bos.tobytearray();

    }

     public cacheresponsewrapper(httpservletresponse original) {

        super(original);

    protected servletoutputstream createoutputstream() 

        throws ioexception

    {

        outstream = new cacheoutputstream();

        return outstream;

    public servletoutputstream getoutputstream()

        throws ioexception 

        if (stream != null) {

            return stream;

        if (writer != null) {

            throw new ioexception("writer already in use");

        stream = createoutputstream();

        return stream;

     public printwriter getwriter() throws ioexception {

            return writer;

            throw new ioexception("outputstream already in use");

        writer = new printwriter(new outputstreamwriter(createoutputstream()));

        return writer;

    protected byte[] getbytes() throws ioexception {

        if (outstream != null) {

            return outstream.getbytes();

        return null;

}

//cachefilter.java 过滤器：

import java.net.*;

import java.util.*;

import java.text.*;

import javax.servlet.filter;

import javax.servlet.filterchain;

import javax.servlet.filterconfig;

import javax.servlet.servletcontext;

import javax.servlet.servletexception;

import javax.servlet.servletrequest;

import javax.servlet.servletresponse;

public class cachefilter implements filter {

    private filterconfig filterconfig = null;

    //缓存池

    private hashmap cache;

    public cachefilter() {

    public void dofilter(servletrequest request, 

                         servletresponse response,

                         filterchain chain)

        throws ioexception, servletexception

        httpservletrequest req = (httpservletrequest) request;

        httpservletresponse res = (httpservletresponse) response;

        //缓存子中的键uri+查询字符串

        string key = req.getrequesturi() + "?" + req.getquerystring();

        //只缓存get请求的内容

        if (req.getmethod().equalsignorecase("get") && iscacheable(key)) {

            byte[] data = (byte[]) cache.get(key);

           //池中没有，生成并存入

            if (data == null) {

                cacheresponsewrapper crw = new cacheresponsewrapper(res);

                chain.dofilter(request, crw);

                data = crw.getbytes();

                cache.put(key, data);

            } 

            // 如果有的话，直接得到返回

            if (data != null) {

                res.setcontenttype("text/html");

                res.setcontentlength(data.length);

                try {

                    outputstream os = res.getoutputstream();

                    os.write(data);

                    os.flush();

                    os.close();

                } catch(exception ex) {

                    ex.printstacktrace();

                }

            }

        } else {

            // generate the data normally if it was not cacheable

            chain.dofilter(request, response);

    //判断是否可以缓存，考虑一个配置文件配置哪些可以缓存，此处省去

    private boolean iscacheable(string key) {

        return true;

    public void init(filterconfig filterconfig) {

        this.filterconfig = filterconfig;

        cache = new hashmap();

    public void destroy() {

        cache.clear();

        cache = null;

        filterconfig = null;

3.实际应用例子：oscache是很好的解决web层缓存的方案！！准备认真读读它的源代码。

二。资源池模式：

1。概念：一个资源池就是一组预先生成的对象，它们可以被出借以便节省多次chuang创建它们所花费的时间。典型的如：ejb池（service locator一般都有一个ejb的home接口池),数据库连接池。

2。优点：a。提高了应用的可伸缩性，使资源的创建和开销不至于失控。b，产生了一个统一的有效微调点，通过运行时修改池参数来影响应用的性能等因素。

3。简单实现：

（1）首先一个创建对象的工厂：

package pool;

public interface resourcefactory {

    public object createresource();

    //验证返回的资源，并提供还原

    public boolean validateresource(object o);

（2）资源池：

public class resourcepool {

    private resourcefactory factory;

   //参数

    private int maxobjects;

    private int curobjects;

    private boolean quit;

    //出借的资源

    private set outresources;

    //可以使用的资源

    private list inresources;

    public resourcepool(resourcefactory factory, int maxobjects) {

        this.factory = factory;

        this.maxobjects = maxobjects;

        curobjects = 0;

        outresources = new hashset(maxobjects);

        inresources = new linkedlist();

   //从池中取资源

    public synchronized object getresource() throws exception {

        while(!quit) {

             if (!inresources.isempty()) {

                object o = inresources.remove(0);

               if(!factory.validateresource(o))

                    o = factory.createresource();

                outresources.add(o);

                return o;

            //放入出借池

            if(curobjects < maxobjects) {

                object o = factory.createresource();

                curobjects++;

            //没有可用的，等待

            try { wait(); } catch(exception ex) {}

       //池子已经销毁

    //归还资源

    public synchronized void returnresource(object o) {

        if(!outresources.remove(o))

            return;

        inresources.add(o);

        notify();

    public synchronized void destroy() {

        quit = true;

        notifyall();

4.实例：很多开源的数据库连接池，ejb模式中的service locator等等

文章转自庄周梦蝶  ，原文发布5.16