`

java动态缓存技术:WEB缓存应用

 
阅读更多

可以实现不等待,线程自动更新缓存

 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 的一个内部类。

说明的不是很清楚,具体实现过程看源程序。。

分享到:
评论

相关推荐

    JAVA_WEB_缓存技术

    在Java Web开发中,缓存技术是提高应用程序性能的关键手段之一。它通过存储常用的数据或计算结果,避免了每次请求时都直接从数据库或其他慢速存储中获取数据,从而显著提升了响应速度。在这个场景中,我们看到两个...

    JAVA缓存技术_深入了解.ppt

    Java缓存技术是提高应用程序性能的关键技术之一,它通过存储频繁访问的数据,减少了对慢速资源(如磁盘或远程服务)的依赖,从而提升了系统的响应速度。本篇将深入探讨Java缓存技术的原理、分类以及在不同层次的应用...

    Java Web应用开发--J2EE和Tomcat第2版

    7. **安全性和性能优化**:探讨Java Web应用的安全性问题,如身份验证、授权、加密等,以及如何通过缓存、负载均衡等技术提高应用的性能。 8. **最佳实践与案例研究**:通过实际案例分析,展示如何将上述知识点应用...

    缓存技术详解

    ### 缓存技术详解 #### 一、缓存的基本概念及作用 缓存技术是一种用于提高...通过以上介绍可以看出,缓存技术在Web开发和移动开发中扮演着极其重要的角色,合理地设计和使用缓存可以极大地提高系统的性能和用户体验。

    详解java缓存ppt讲义

    Java缓存技术在企业级开发中扮演着至关重要的角色,主要目的是提高系统性能,减少不必要的计算和I/O操作。本文将深入探讨缓存的概念、作用、类型以及在Java环境下的应用。 缓存,简单来说,就是高速缓冲存储器,它...

    Java缓存技术总结初见

    【Java缓存技术总结初见】 缓存技术在IT领域中扮演着至关重要的角色,尤其在高并发和大数据量的应用场景下,缓存能够显著提升系统性能,减轻服务器压力。本文将简要介绍缓存的基本概念,分析其优缺点,并探讨几种...

    web缓存技术精品课程

    Web缓存技术是Java Web应用中不可或缺的部分,其主要作用是减少数据在不同软硬件之间的传输延迟,优化数据读取速度。缓存可以理解为一种特殊的存储器子系统,它复制了频繁使用的数据,以便快速访问。Web应用系统中...

    零基础学Java.Web开发:JSP.Servlet.Struts.Spring.Hibernate.Ajax(PPT).

    Java Web开发是构建基于互联网应用程序的关键技术,涵盖了多种框架和工具。这个压缩包中的资源,"零基础学Java.Web开发:JSP Servlet Struts Spring Hibernate Ajax(PPT)",旨在为初学者提供一个全面的学习路径,从...

    Tomcat与Java_Web开发技术详解3.pdf

    综上所述,《Tomcat与Java Web开发技术详解》这本书不仅全面覆盖了Tomcat的基本使用方法,还深入探讨了Java Web开发中的高级技术,对于希望深入了解Tomcat及其在Java Web开发中应用的读者来说,是一本非常有价值的...

    Java图像处理的双缓存技术演示

    Web应用中的图像处理是非常重要的,Java使用Applet扩展了标签,让程序要可程序控制图像的显示,这给实际开B/S应用带来多一种图像技术,该例子演示了图像处理的双缓存技术处理图像抖动的问题。双缓存技术是Java完成...

    java web 技术文章

    在Java Web领域,开发者可以利用一系列技术和工具来创建动态、交互式的网站和应用。以下是一些关键的知识点: 1. **Servlet与JSP**:Servlet是Java EE中的核心组件,用于处理HTTP请求和响应。它们提供了服务器端的...

    JAVA WEB编程从入门到实践.3

    在Java Web编程的世界里,开发者们使用一系列技术和框架来创建动态、交互式的Web应用程序。"JAVA WEB编程从入门到实践"这一主题涵盖了从基础概念到实际应用的全面学习路径,旨在帮助初学者逐步掌握这个领域。 一、...

    Java.Web Java.Web

    对于Java Web应用来说,可以通过多种方式来进行性能优化,比如使用缓存技术减少数据库访问次数、使用异步处理提高响应速度、采用CDN加速静态资源加载等。 综上所述,Java Web开发涉及到许多关键技术点和实践技巧。...

    J2EE WEB缓存技术详解.doc

    标题和描述中的“J2EE WEB缓存技术详解”指向了一篇关于在Java Web应用程序中使用缓存技术的深入分析文章。文章由作者夏俊于2011年撰写,主要探讨了在处理大量数据时,如何通过实施缓存策略来优化系统性能,特别是...

    Java Web开发技术大全(电子书)

    Java Web开发技术是构建互联网应用程序的关键领域,涵盖了服务器端编程、网页交互以及数据库管理等多个方面。本书《Java Web开发技术大全》无疑是深入学习这一领域的宝贵资源。以下将详细阐述Java Web开发中的核心...

    oscache缓存技术应用

    **oscache缓存技术应用** **一、OSCache简介与应用** Cache技术是提升系统响应速度和性能的关键手段,尤其在Web应用中,通过缓存页面的输出结果,能够显著提高系统性能。OSCache是由OpenSymphony开发的一种创新...

    art of java web development

    9. **性能优化**:如何通过缓存、负载均衡、代码优化等手段提高Java Web应用的性能,可能也是书中讨论的重点。 10. **开发工具**:Eclipse、IntelliJ IDEA等Java开发工具的使用技巧,以及版本控制系统如Git的配合,...

    swi-205基于JAVA技术的WEB应用开发pdf.rar

    《基于JAVA技术的WEB应用开发》是一份详细深入的学习资料,专为准备SWI-205认证考试的学员提供。这份PDF文档涵盖了JAVA技术在构建Web应用程序中的核心概念、技术和实践方法。以下是对这份资料中关键知识点的详细解读...

Global site tag (gtag.js) - Google Analytics