|
能夠實現不等待，線程自動更新緩存
java動態緩存jar包請下載。
源代碼：
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;
}
}
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));
}
/** *//**
* 取得緩存中的數據
* 與方法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();
}
}
用法：
例1：代碼片斷以下：
public class Test {
String rulStr=....;
String encoding=....;
public void getData() {
DataCreator c = new DataCreator();
String result = c.initUrlData(urlStr,encoding);
System.out.println(result);
}
}
每次執行上面代碼時都要經過調用 initUrlData方法取得數據，假設此方法很耗資源而耗時間，但對數據時實性要求不高，就是能夠用如下方式進行緩存處理，保證很快地取得數據，並根據設置的參數自動更新緩存中數據
注意：initUrlData方法參數值同樣時才屬於同一個緩存，不然會生成一個新的緩存，也就是說從緩存中取數據與initUrlData方法參數值有關
......
public void getData() {
DataCreator data = new DataCreator();
CacheOperation co = CacheOperation.getInstance();
String str = (String)co.getCacheData(data, "initUrlData",new Object[]{urlStr, encoding}, 120000, 100);
System.out.println(result);
}
......
getCacheData方法返回值與initUrlData方法返回類型同樣，參數說明：
data：調用initUrlData方法的實列，若是該方法是靜態的，則傳類的類型，如（DataCreator .class）；
"initUrlData"：方法名稱；
new Object[]{urlStr, encoding}：initUrlData方法的參數數組，若是某一參數爲空則傳該參數的類型，若encoding 爲空，則爲new Object[]{urlStr, String.class}或new Object[]{urlStr, ""}；
120000：緩存時間，單位：豪秒，即過兩分鐘更新一次緩存；值爲0時爲不限，即不更新緩存；
100：訪問次數，當緩存中數據被訪問100次時更新一次緩存；值爲0時爲不限，即不更新緩存；
例2：代碼片斷以下：
......
String province = request.getParameter("province");
String city= request.getParameter("city");
String county= request.getParameter("county");
Document doc = XMLBuilder.buildLatelyKeyword(kwm.latelyKeyword(province, city, county));
out.write(doc);
......
作緩存並兩分鐘更新一次,以下：
......
String province = request.getParameter("province");
String city= request.getParameter("city");
String county= request.getParameter("county");
CacheOperation co = CacheOperation.getInstance();
MethodInfo mi = co.new MethodInfo(kwm, "latelyKeyword", new Object[]{province, city, county});
Document doc = (Document )co.getCacheData(XMLBuilder.class,"buildLatelyKeyword",new Object[]{mi}, 120000, 0);
out.write(doc);
......
以上方法是嵌套調用， 要先定義內部方法說明即MethodInfo，此類是CacheOperation 的一個內部類。
說明的不是很清楚，具體實現過程看源程序。。
|
