关于定制oscache页面缓存

背景：

oscache作为jsp页面缓存，提供了两种模式：

1、缓存整个页面；

2、缓存局部页面。

或许是我本人的了解不足，我发现oscache存在以下问题：

第一种方式使用简单，但是问题就是不能及时刷新，刷新策略不灵活。

而第二种方式虽然灵活，但是修改的jsp文件太多，侵入太大，可读性变差，并且，根据我的理解, 请求从servlet转发到jsp的时候，jsp所需要的一些值已经查出来了，所以就算做了缓存也是没用的。

这个有点难以理解，举个例子来说：

show.jsp

${ request.someMap }

比如上面的jsp，jsp页面需要一个map，而这个map是从数据库查询的。我们肯定希望oscache可以省略这个查询，但是大家都知道，一个请求过来的流程：

请求--→ tomcat容器-→ servlet （servlet组织数据，放入request attribute）--→jsp --→ tomcat容器，也就是请求出来servlet 之后，转到jsp 之前，jsp锁需要的数据已经在servlet中查询出来了，所以jsp 的局部cache 是没有任何意义的。（我不知道其他人是如何做的）

由于以上问题，我决定采用oscache的整个页面缓存，但是定制他的更新时间。

基本思路：

1、自定义配置文件，定义哪些url需要缓存，缓存范围（session、application），过

期时间。如：

2、自定义filter重写CacheFilter，初始化的时候读取配置文件并解析缓存。

3、在doFilter的方法里面，如果请求的uri匹配上了配置文件里面的配置，则调用

CacheFilter的doFilter 走缓存，否则直接放过去，没有缓存。

4、为了能动态刷新缓存，需要判断缓存的最后更新时间与当前时间差是否超出了配置

文件中配置的时间，是的话就刷新，否则不刷新。这个需要自定义刷新策略：写一

个类实现EntryRefreshPolicy接口，并在我们自己的filter初始化的时候，调用

cacheFilter的setExpiresRefreshPolicy设置新的更新策略。EntryRefreshPolicy的

needsRefresh方法传入一个CacheEntry对象，为了将此对象与配置文件中配置的对

应起来，我们需要自定义CacheEntry的key，使key 中包含我们在配置文件中配置

的id。自定义key的生成规则需要重写cacheFilter的createCacheKey方法。具体参

考下面的代码。

5、动态更新的问题：我们在进行了操作之后，希望能刷新相关的缓存资源。比如我

评论了文章，那么可能需要刷新文章这个页面的缓存。这个时候需要手动调用一

下刷新接口，ServletCacheAdministrator. flushGroup(String group), 而如何获取我们已

知的uri的对应的groupName又成了问题，为此还需要自定义group生成的策略：ICacheGroupsProvider接口，并在我们的filter里面调用cacheFilter的

setCacheGroupsProvider方法设置新的组名生成策略。

6、这样一切问题都做好了，只要评论了一个文章，我们只要调用一下刷新的方法

就好了。

详细代码示例：

1、关于配置文件的东东：

import javax.servlet.jsp.PageContext;

/**

* 配置文件的模型

* @author wupeng

*

*/

public class CachedUrl {

private String id;

private String uri;

private Pattern pattern;

private int scope;

private long expires;//过期时间,单位分钟

private long expiresInMillis;//过期时间，毫秒private boolean needRefresh;

public CachedUrl(){

scope = PageContext.APPLICATION_SCOPE; needRefresh =false;

expires =60;

}

public String getId(){

return id;

}

public void setId(String id){

this.id = id;

}

public String getUri(){

return uri;

}

public void setUri(String uri){

this.uri = uri;

pattern = https://www.360docs.net/doc/e417129959.html,pile(uri);

}

public int getScope(){

return scope;

}

public void setScope(int scope){

if(scope == PageContext.SESSION_SCOPE || scope == PageContext.APPLICATION_SCOPE){

this.scope = scope;

}

}

public boolean isNeedRefresh(){

return needRefresh;

}

public void setNeedRefresh(boolean needRefresh){

this.needRefresh = needRefresh;

}

public long getExpires(){

return expires;

}

public void setExpires(long expires){

this.expires = expires;

this.expiresInMillis = expires *60*1000;

}

public void setExpires(String expiresString){

try{

if(expiresString !=null&&!"".equals(expiresString)){ long time = Long.parseLong(expiresString);

this.setExpires(time);

}

}catch(Exception e){

e.printStackTrace();

}

}

public long getExpiresInMillis(){

return expiresInMillis;

}

public void setExpiresInMillis(long expiresInMillis){ this.expiresInMillis = expiresInMillis;

}

public Pattern getPattern(){

return pattern;

CacheUrlParser 解析一下配置

package com.ttyc.sns.utils.cache;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.servlet.jsp.PageContext;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

/**

* 解析配置文件

* @author wupeng

*

*/

public class CacheUrlParser {

/**

*

* @param files

* @return uri - CachedUrl

*/

public static Map parseCachedUrlFromXML(Collection files){

SAXReader sax =new SAXReader();

Map map =new HashMap();

try{

for(String file : files){

Document xmlDoc = sax.read(new File(file)); map.putAll(parse(xmlDoc.getRootElement()));

}

}catch(DocumentException e){

e.printStackTrace();

}

return map;

}

/**

*

* @param files

* @return uri - CachedUrl

*/

public static Map

parseCachedUrlFromXML(InputStream is){

SAXReader sax =new SAXReader();

Map map =new HashMap();

try{

Document xmlDoc = sax.read(is);

map.putAll(parse(xmlDoc.getRootElement()));

}catch(DocumentException e){

e.printStackTrace();

}finally{

try{

if(is !=null){

is.close();

}

}catch(IOException e){

e.printStackTrace();

}

}

return map;

}

@SuppressWarnings("unchecked")

public static Mapparse(Element element){ Map map =new HashMap();

List elements =new ArrayList();

if(element.isRootElement()){

elements.addAll(element.elements("cache"));

}else{

elements.add(element);

}

for(Element e :elements){

CachedUrl url =new CachedUrl();

url.setId(e.attributeValue("id"));

url.setUri(e.attributeValue("url"));

String scope = e.attributeValue("scope");

if("session".equalsIgnoreCase(scope)){

url.setScope(PageContext.SESSION_SCOPE);

}else if("application".equalsIgnoreCase(scope)){ url.setScope(PageContext.APPLICATION_SCOPE);

}

url.setNeedRefresh(false);

url.setExpires(e.attributeValue("expires"));

map.put(url.getUri(), url);

}

return map;

}

}

*

*/

public class OSCacheStaticVariables {

private static final Map URI_CACHEDURL = new ConcurrentHashMap();

private static ServletCacheAdministrator admin =null;

private static ServletContext servletContext =null;

private static FilterConfig config =null;

private static Properties osCacheProps =null;

private static final MapID_CACHEDURL =new ConcurrentHashMap();

static void addURI_CACHEDURL(Map

uRI_CACHEDURL){

if(uRI_CACHEDURL !=null&& uRI_CACHEDURL.size()>0){ URI_CACHEDURL.putAll(uRI_CACHEDURL);

for(Map.Entry entry :

URI_CACHEDURL.entrySet()){

CachedUrl url = entry.getValue();

if(url !=null){

ID_CACHEDURL.put(url.getId(), url);

}

}

}

}

public static Set getCachedURISet(){

return URI_CACHEDURL.keySet();

}

public static CachedUrl getCachedUrlByURI(String uri){

CachedUrl result =null;

if(URI_CACHEDURL.containsKey(uri)){

result = URI_CACHEDURL.get(uri);

}else{

for(String tmp : URI_CACHEDURL.keySet()){

if(Pattern.matches(tmp, uri)){

result = URI_CACHEDURL.get(tmp);

if(result !=null){

break;

}

}

}

}

return result;

}

public static CachedUrl getCachedUrlByID(String id){ return ID_CACHEDURL.get(id);

}

static void setAdmin(ServletCacheAdministrator admins){

OSCacheStaticVariables.admin = admins;

}

static void setServletContext(ServletContext servletContext) {

OSCacheStaticVariables.servletContext = servletContext;

}

public static ServletCacheAdministrator getAdmin(){ return admin;

}

public static ServletContext getServletContext(){ return servletContext;

}

public static FilterConfig getConfig(){

return config;

}

public static Properties getOsCacheProps(){

return osCacheProps;

}

static void setOsCacheProps(Properties osCacheProps){

OSCacheStaticVariables.osCacheProps = osCacheProps;

}

static void setConfig(FilterConfig config){

OSCacheStaticVariables.config = config;

}

JspPageCacheFilter 主filter

package com.ttyc.sns.utils.cache;

import java.io.IOException;

import https://www.360docs.net/doc/e417129959.html,ng.reflect.Field;

import java.util.regex.Pattern;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.jsp.PageContext;

import org.apache.log4j.Logger;

import com.opensymphony.oscache.base.Cache;

import com.opensymphony.oscache.web.ServletCacheAdministrator; import com.opensymphony.oscache.web.filter.CacheFilter;

/**

*

* @author wupeng

*

*/

public class JspPageCacheFilter extends CacheFilter{

private static Logger logger =

Logger.getLogger(JspPageCacheFilter.class);

private boolean openCache =true;

@Override

public void init(FilterConfig filterConfig){

try{

//解析xml

OSCacheStaticVariables.addURI_CACHEDURL(CacheUrlParser.parseCa chedUrlFromXML

(Thread.currentThread().getContextClassLoader().getResourceAsS

tream("jspcache.xml")));

}catch(Exception e){

e.printStackTrace();

}

//缓存FilterConfig

OSCacheStaticVariables.setConfig(filterConfig);

openCache

=!"false".equals(filterConfig.getInitParameter("openCache"));

super.init(filterConfig);//父类初始化

try{

Class clazz = CacheFilter.class;

Field adminField = clazz.getDeclaredField("admin");

if(adminField !=null){

adminField.setAccessible(true);

Object obj =adminField.get(this);//获取到这个东西后面要用

OSCacheStaticVariables.setAdmin((ServletCacheAdministrator) obj);

}

}catch(Exception e){

e.printStackTrace();

logger.error(e);

}

//设置缓存更新策略

this.setExpiresRefreshPolicy(new

SnsPageEntryRefreshPolicy());

//设置组名提供策略

this.setCacheGroupsProvider(new

MyICacheGroupsProvider());

OSCacheStaticVariables.setServletContext(filterConfig.getServl etContext());

}

@Override

public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)throws ServletException,IOException {

if(openCache){

try{

HttpServletRequest httpRequest = (HttpServletRequest) request;

String realuri =this.getURI(httpRequest);

logger.debug("jspcachefilter processing uri : "+ realuri);

boolean matched =false;

if(OSCacheStaticVariables.getCachedURISet().contains(realuri)) {

matched =true;

}else{

for(String uri :

OSCacheStaticVariables.getCachedURISet()){

if(Pattern.matches(uri, realuri)){

logger.debug("matched key : "+ uri); matched =true;

break;

}

}

}

if(matched){

logger.debug(" this uri need to be cached, processing oscache filter : "+ realuri);

int scope = PageContext.APPLICATION_SCOPE;

CachedUrl url =

OSCacheStaticVariables.getCachedUrlByURI(realuri);

if(url !=null){

scope = url.getScope();

}

this.setCacheScope(scope);//设置缓存范围

super.doFilter(httpRequest, response,

chain);//走缓存的filter

}else{

chain.doFilter(request, response);

}

}catch(Exception e){

e.printStackTrace();

chain.doFilter(request, response);

}

}else{

chain.doFilter(request, response);

}

}

@Override

public void destroy(){

super.destroy();

}

private String getURI(HttpServletRequest httpRequest){

String uri = httpRequest.getRequestURI();

String realuri =null;

if(uri.indexOf("?")>0){

realuri = uri.substring(0, uri.indexOf("?"));

}else{

realuri = uri;

}

return realuri;

}

/**

* 自定义key的生成规则, 让key包含我们配置的id

* 生成key：[/前缀][/服务名]{([/key])|([/uri_method_][_md5(后缀)])}[后缀]

*/

@Override

public String createCacheKey(HttpServletRequest request, ServletCacheAdministrator scAdmin, Cache cache){

String uri =this.getURI(request);

CachedUrl url =

OSCacheStaticVariables.getCachedUrlByURI(uri);

String sufix =null;

if(url.getScope()== PageContext.SESSION_SCOPE){//如果是session有效的，那么这个key需要加上sessionID

sufix = request.getSession().getId();

}

String key = scAdmin.generateEntryKey(null, request, url.getScope(), url.getId()+"#", sufix);

logger.debug("generate oscache cache entry key : "+key);

return key;

}

SnsPageEntryRefreshPolicy缓存的刷新策略

package com.ttyc.sns.utils.cache;

import com.opensymphony.oscache.base.CacheEntry;

import com.opensymphony.oscache.base.EntryRefreshPolicy;

import com.opensymphony.oscache.base.NeedsRefreshException; import com.opensymphony.oscache.web.filter.ResponseContent;

public class SnsPageEntryRefreshPolicy implements EntryRefreshPolicy{

private static final long serialVersionUID = 6234071763160649441L;

/**

* Indicates whether the supplied CacheEntry needs to be refreshed.

* This will be called when retrieving an entry from the cache - if this method

* returns true then a

NeedsRefreshException will be

* thrown.

*

* @param entry The cache entry which is ignored.

* @return true if the content needs refreshing, false otherwise.

*

* @see NeedsRefreshException

* @see CacheEntry

*/

public boolean needsRefresh(CacheEntry entry){

long currentTimeMillis = System.currentTimeMillis();

long refreshPeriod =-1;

String uri = entry.getKey();

uri = uri.substring(1, uri.indexOf("#"));

CachedUrl cache =

OSCacheStaticVariables.getCachedUrlByID(uri);

if(cache !=null){

if(cache.isNeedRefresh()){//如果已经人为标记了需要更新，那么直接返回了，不判断时间了

}

refreshPeriod = cache.getExpiresInMillis();

}

if((refreshPeriod >=0)&&(currentTimeMillis >= (entry.getLastUpdate()+ refreshPeriod))){

return true;

}else if(entry.getContent()instanceof ResponseContent) {

ResponseContent responseContent =(ResponseContent) entry.getContent();

return currentTimeMillis >=

responseContent.getExpires();

}else{

return false;

}

}

}

return getGroupByURI(uri);

}

public static String[] getGroupByURI(String uri){

CachedUrl url =

OSCacheStaticVariables.getCachedUrlByURI(uri);

if(url !=null){

String group = url.getId();

return new String[]{group};

}

return null;

}

private String getURI(HttpServletRequest httpRequest){ String uri = httpRequest.getRequestURI();

String realuri =null;

if(uri.indexOf("?")>0){

realuri = uri.substring(0, uri.indexOf("?"));

}else{

realuri = uri;

}

return realuri;

}

}

public class OSCacheRefreshUtil {

/**

* 刷新缓存,自动判断刷新范围

* @param request

* @param group

*/

public static void refershCache(HttpServletRequest request, String[] groups){

ServletCacheAdministrator admin =

OSCacheStaticVariables.getAdmin();

ServletContext servletContext =

OSCacheStaticVariables.getServletContext();

if(groups !=null&& groups.length >0&& admin !=null){ for(String group : groups){

CachedUrl url =

OSCacheStaticVariables.getCachedUrlByID(group);

if(url !=null){

Cache cache =null;

if(url.getScope()==

PageContext.SESSION_SCOPE){

cache =

admin.getSessionScopeCache(request.getSession(true));

}else if(url.getScope()==

PageContext.APPLICATION_SCOPE && servletContext !=null){

cache =

admin.getAppScopeCache(servletContext);

}

if(cache !=null){

cache.flushGroup(group);

}

}

}

}

}

/**

* 刷新所有session缓存

* @param session

*/

public static void refreshAllSessionCache(HttpSession

session){

ServletCacheAdministrator admin =

OSCacheStaticVariables.getAdmin();

if(admin !=null){

Cache cache = admin.getSessionScopeCache(session);

if(cache !=null){

cache.flushAll(new Date());

}

}

// clearSessionCache(session);

}

@Deprecated

public static void clearSessionCache(HttpSession session){ ServletCacheAdministrator admin =

OSCacheStaticVariables.getAdmin();

if(admin !=null){

Cache cache = admin.getSessionScopeCache(session);

if(cache !=null){

Class clazz = cache.getClass();

try{

Method clearMethod = getMethod(clazz,"clear", null);

if(clearMethod !=null){

clearMethod.setAccessible(true);

clearMethod.invoke(cache,null);

}

}catch(SecurityException e){

e.printStackTrace();

}catch(IllegalArgumentException e){

e.printStackTrace();

}catch(IllegalAccessException e){

e.printStackTrace();

}catch(InvocationTargetException e){

e.printStackTrace();

}

}

}

}

public static Method getMethod(Class clazz, String methodName, Class...parameterTypes){

Method method =null;

try{

method = clazz.getDeclaredMethod(methodName, parameterTypes);

}catch(SecurityException e){

e.printStackTrace();

}catch(NoSuchMethodException e){

e.printStackTrace();

Class superClazz = clazz.getSuperclass();

if(superClazz !=null

&&!superClazz.getName().equals("https://www.360docs.net/doc/e417129959.html,ng.Object")){

method = getMethod(superClazz, methodName, parameterTypes);

}

}

return method;

}

/**

* 刷新session缓存

* @param gropus

* @param session

*/

public static void refreshSessionCacheByGroups(String[] groups, HttpSession session){

ServletCacheAdministrator admin =

OSCacheStaticVariables.getAdmin();

if(admin !=null){

Cache cache = admin.getSessionScopeCache(session);

refresh(groups, cache);

}

}

/**

* 刷新应用缓存

* @param groups

* @param context

*/

public static void refreshAppCacheByGroups(String[]groups){ ServletCacheAdministrator admin =

OSCacheStaticVariables.getAdmin();

ServletContext servletContext =

OSCacheStaticVariables.getServletContext();

SimpleStatisticListenerImpl 一个统计缓存命中率的东西要不要无所谓

/*

* Copyright (c) 2002-2007 by OpenSymphony

* All rights reserved.

*/

package com.ttyc.sns.utils.cache;

import https://www.360docs.net/doc/e417129959.html,mons.logging.Log;

import https://www.360docs.net/doc/e417129959.html,mons.logging.LogFactory;

import com.opensymphony.oscache.base.Cache;

import com.opensymphony.oscache.base.events.CacheEntryEvent; import

com.opensymphony.oscache.base.events.CacheEntryEventListener; import com.opensymphony.oscache.base.events.CacheGroupEvent; import

com.opensymphony.oscache.base.events.CacheMapAccessEvent; import

com.opensymphony.oscache.base.events.CacheMapAccessEventListen er;

import

com.opensymphony.oscache.base.events.CacheMapAccessEventType; import com.opensymphony.oscache.base.events.CachePatternEvent; import com.opensymphony.oscache.base.events.CachewideEvent; import com.opensymphony.oscache.base.events.ScopeEvent;

import