討論一下java的緩存機制，可以看看例子。

緩存機制應該可以瞭解爲：

 1.通對JAVA類中使用static聲明一個成員變量,使其多用戶併發訪問這個類時,多個類對象共享這一個靜態成員變量,以達到併發時緩存對象.  
  2.通過java.util.Timer或後臺運行的多線程代碼,同樣類中使用1中所說的static變量,訪問情況同1,只是在這種方法中,類對象始終運行,新建類對象可能更快.

以上的所述的可以通過設計模式中Singleton模式，Prototype模式來分析一下，下面的例子也可以幫助瞭解這種說法。

 

1、CacheData.java 存放緩存數據的Bean
/** *//**
*
*/
package com.cari.web.cache;

/** *//**
* @author zsy
*
*/
public class CacheData ...{
    private Object data;
    private long time;
    private int count;
   
    public CacheData() ...{
       
    }
   
    public CacheData(Object data, long time, int count) ...{
        this.data = data;
        this.time = time;
        this.count = count;
    }
   
    public CacheData(Object data) ...{
        this.data = data;
        this.time = System.currentTimeMillis();
        this.count = 1;
    }
   
    public void addCount() ...{
        count++;
    }
   
    public int getCount() ...{
        return count;
    }
    public void setCount(int count) ...{
        this.count = count;
    }
    public Object getData() ...{
        return data;
    }
    public void setData(Object data) ...{
        this.data = data;
    }
    public long getTime() ...{
        return time;
    }
    public void setTime(long time) ...{
        this.time = time;
    }
}

2、CacheOperation.java 緩存處理類

package com.cari.web.cache;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/** *//**
* @author zsy
*/
public class CacheOperation ...{
    private static final Log log = LogFactory.getLog(CacheOperation.class);
    private static CacheOperation singleton = null;
   
    private Hashtable cacheMap;//存放緩存數據
   
    private ArrayList threadKeys;//處於線程更新中的key值列表
   
    public static CacheOperation getInstance() ...{
        if (singleton == null) ...{
            singleton = new CacheOperation();
        }
        return singleton;
    }
   
    private CacheOperation() ...{
        cacheMap = new Hashtable();
        threadKeys = new ArrayList();
    }
   
    /** *//**
    * 添加數據緩存
    * 與方法getCacheData(String key, long intervalTime, int maxVisitCount)配合使用
    * @param key
    * @param data
    */
    public void addCacheData(String key, Object data) ...{
        addCacheData(key, data, true);
    }
   
    private void addCacheData(String key, Object data, boolean check) ...{
        if (Runtime.getRuntime().freeMemory() < 5L*1024L*1024L) ...{//虛擬機內存小於10兆，則清除緩存
            log.warn("WEB緩存：內存不足，開始清空緩存！");
            removeAllCacheData();
            return;
        } else if(check && cacheMap.containsKey(key)) ...{
            log.warn("WEB緩存：key值= " + key + " 在緩存中重複, 本次不緩存！");
            return;
        }
        cacheMap.put(key, new CacheData(data));
    } 
    
3、緩存數據的操作    

/**
    * 取得緩存中的數據
    * 與方法addCacheData(String key, Object data)配合使用
    * @param key
    * @param intervalTime 緩存的時間週期，小於等於0時不限制
    * @param maxVisitCount 訪問累積次數，小於等於0時不限制
    * @return
    */
    public Object getCacheData(String key, long intervalTime, int maxVisitCount) ...{
        CacheData cacheData = (CacheData)cacheMap.get(key);
        if (cacheData == null) ...{
            return null;
        }
        if (intervalTime > 0 && (System.currentTimeMillis() - cacheData.getTime()) > intervalTime) ...{
            removeCacheData(key);
            return null;
        }
        if (maxVisitCount > 0 && (maxVisitCount - cacheData.getCount()) <= 0) ...{
            removeCacheData(key);
            return null;
        } else ...{
            cacheData.addCount();
        }
        return cacheData.getData();
    }
   
    /** *//**
    * 當緩存中數據失效時，用不給定的方法線程更新數據
    * @param o 取得數據的對像(該方法是靜態方法是不用實例，則傳Class實列)
    * @param methodName 該對像中的方法
    * @param parameters 該方法的參數列表(參數列表中對像都要實現toString方法,若列表中某一參數爲空則傳它所屬類的Class)
    * @param intervalTime 緩存的時間週期，小於等於0時不限制
    * @param maxVisitCount 訪問累積次數，小於等於0時不限制
    * @return
    */
    public Object getCacheData(Object o, String methodName,Object[] parameters,
            long intervalTime, int maxVisitCount) ...{
        Class oc = o instanceof Class ? (Class)o : o.getClass();
        StringBuffer key = new StringBuffer(oc.getName());//生成緩存key值
        key.append("-").append(methodName);
        if (parameters != null) ...{
            for (int i = 0; i < parameters.length; i++) ...{
                if (parameters[i] instanceof Object[]) ...{
                    key.append("-").append(Arrays.toString((Object[])parameters[i]));
                } else ...{
                    key.append("-").append(parameters[i]);
                }
            }
        }
       
        CacheData cacheData = (CacheData)cacheMap.get(key.toString());
        if (cacheData == null) ...{//等待加載並返回
            Object returnValue = invoke(o, methodName, parameters, key.toString());
            return returnValue instanceof Class ? null : returnValue;
        }
        if (intervalTime > 0 && (System.currentTimeMillis() - cacheData.getTime()) > intervalTime) ...{
            daemonInvoke(o, methodName, parameters, key.toString());//緩存時間超時,啓動線程更新數據
        } else if (maxVisitCount > 0 && (maxVisitCount - cacheData.getCount()) <= 0) ...{//訪問次數超出,啓動線程更新數據
            daemonInvoke(o, methodName, parameters, key.toString());
        } else ...{
            cacheData.addCount();
        }
        return cacheData.getData();
    }
   
    /** *//**
    * 遞歸調用給定方法更新緩存中數據據
    * @param o
    * @param methodName
    * @param parameters
    * @param key
    * @return 若反射調用方法返回值爲空則返回該值的類型
    */
    private Object invoke(Object o, String methodName,Object[] parameters, String key) ...{
        Object returnValue = null;
        try ...{
            Class[] pcs = null;
            if (parameters != null) ...{
                pcs = new Class[parameters.length];
                for (int i = 0; i < parameters.length; i++) ...{
                    if (parameters[i] instanceof MethodInfo) ...{//參數類型是MethodInfo則調用該方法的返回值做這參數
                        MethodInfo pmi = (MethodInfo)parameters[i];
                        Object pre = invoke(pmi.getO(), pmi.getMethodName(), pmi.getParameters(), null);
                        parameters[i] = pre;
                    }
                    if (parameters[i] instanceof Class) ...{
                        pcs[i] = (Class)parameters[i];
                        parameters[i] = null;
                    } else ...{
                        pcs[i] = parameters[i].getClass();
                    }
                }
            }
            Class oc = o instanceof Class ? (Class)o : o.getClass();
        //    Method m = oc.getDeclaredMethod(methodName, pcs);
            Method m = matchMethod(oc, methodName, pcs);
            returnValue = m.invoke(o, parameters);
            if (key != null && returnValue != null) ...{
                addCacheData(key, returnValue, false);
            }
            if (returnValue == null) ...{
                returnValue = m.getReturnType();
            }
        } catch(Exception e) ...{
            log.error("調用方法失敗,methodName=" + methodName);
            if (key != null) ...{
                removeCacheData(key);
                log.error("更新緩存失敗，緩存key=" + key);
            }
            e.printStackTrace();
        }
        return returnValue;
    }

/** *//**
    * 找不到完全匹配的方法時,對參數進行向父類匹配
    * 因爲方法aa(java.util.List) 與 aa(java.util.ArrayList)不能自動匹配到
    *
    * @param oc
    * @param methodName
    * @param pcs
    * @return
    * @throws NoSuchMethodException
    * @throws NoSuchMethodException
    */
    private Method matchMethod(Class oc, String methodName, Class[] pcs
            ) throws NoSuchMethodException, SecurityException ...{
        try ...{
            Method method = oc.getDeclaredMethod(methodName, pcs);
            return method;
        } catch (NoSuchMethodException e) ...{
            Method[] ms = oc.getDeclaredMethods();
            aa:for (int i = 0; i < ms.length; i++) ...{
                if (ms[i].getName().equals(methodName)) ...{
                    Class[] pts = ms[i].getParameterTypes();
                    if (pts.length == pcs.length) ...{
                        for (int j = 0; j < pts.length; j++) ...{
                            if (!pts[j].isAssignableFrom(pcs[j])) ...{
                                break aa;
                            }
                        }
                        return ms[i];
                    }
                }
            }
            throw new NoSuchMethodException();
        }
    }
   
    /** *//**
    * 新啓線程後臺調用給定方法更新緩存中數據據
    * @param o
    * @param methodName
    * @param parameters
    * @param key
    */
    private void daemonInvoke(Object o, String methodName,Object[] parameters, String key) ...{
        if (!threadKeys.contains(key)) ...{
            InvokeThread t = new InvokeThread(o, methodName, parameters, key);
            t.start();
        }
    }
   
    /** *//**
    * 些類存放方法的主調對像,名稱及參數數組
    * @author zsy
    *
    */
    public class MethodInfo ...{
        private Object o;
        private String methodName;
        private Object[] parameters;
        public MethodInfo(Object o, String methodName,Object[] parameters) ...{
            this.o = o;
            this.methodName = methodName;
            this.parameters = parameters;
        }
        public String getMethodName() ...{
            return methodName;
        }
        public void setMethodName(String methodName) ...{
            this.methodName = methodName;
        }
        public Object getO() ...{
            return o;
        }
        public void setO(Object o) ...{
            this.o = o;
        }
        public Object[] getParameters() ...{
            return parameters;
        }
        public void setParameters(Object[] parameters) ...{
            this.parameters = parameters;
        }
       
        public String toString() ...{
            StringBuffer str = new StringBuffer(methodName);
            if (parameters != null) ...{
                str.append("(");
                for (int i = 0; i < parameters.length; i++) ...{
                    if (parameters[i] instanceof Object[]) ...{
                        str.append(Arrays.toString((Object[])parameters[i])).append(",");
                    } else ...{
                        str.append(parameters[i]).append(",");
                    }
                }
                str.append(")");
            }
            return str.toString();
        }
    }
   
    /** *//**
    * 線程調用方法
    * @author zsy
    *
    */
    private class InvokeThread extends Thread ...{
        private Object o;
        private String methodName;
        private Object[] parameters;
        private String key;
        public InvokeThread(Object o, String methodName,Object[] parameters, String key) ...{
            this.o = o;
            this.methodName = methodName;
            this.parameters = parameters;
            this.key = key;
        }
       
        public void run() ...{
            threadKeys.add(key);
            invoke(o, methodName, parameters, key);
            threadKeys.remove(key);
        }
    }
   
    /** *//**
    * 移除緩存中的數據
    * @param key
    */
    public void removeCacheData(String key) ...{
        cacheMap.remove(key);
    }
   
    /** *//**
    * 移除所有緩存中的數據
    *
    */
    public void removeAllCacheData() ...{
        cacheMap.clear();
    }
   
    public String toString() ...{
        StringBuffer sb = new StringBuffer("************************ ");
        sb.append("正在更新的緩存數據： ");
        for (int i = 0; i < threadKeys.size(); i++) ...{
            sb.append(threadKeys.get(i)).append(" ");
        }
        sb.append("當前緩存大小：").append(cacheMap.size()).append(" ");
        sb.append("************************");
        return sb.toString();
    }
}