緩存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