`
wendy_wxie
  • 浏览: 117799 次
  • 性别: Icon_minigender_1
  • 来自: 长沙
社区版块
存档分类
最新评论

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

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

分享到:
评论
3 楼 w245814 2014-02-20  
多线程下,漏洞百出。。。还有map的实例化的位置有问题,不应该放在构造器中。。而应该是在类加载的时候就初始化。。
2 楼 sanfeng_chow 2013-03-05  
谢文,谢文
1 楼 janzxx 2013-01-09  
有没考虑过线程安全的问题

相关推荐

    JAVA缓存技术_深入了解

    JAVA缓存技术_深入了解,多个缓存技术介绍

    Java缓存技术的使用实例

    Java缓存技术是提高应用程序性能的关键工具,尤其是在处理大量数据时。它通过存储频繁访问的数据在内存中,避免了重复的数据库查询,显著提升了响应速度。在这个“Java缓存技术的使用实例”中,我们将深入探讨Java...

    java map 实现缓存技术

    本文将深入探讨如何使用Java Map实现缓存技术,以及其中的关键知识点。 首先,让我们理解什么是缓存。缓存是一种存储技术,用于暂时保存经常访问的数据,以便于快速检索。在Java中,我们通常使用HashMap、...

    JAVA缓存技术深入了解

    深入理解Java缓存技术可以帮助我们设计出更加高效、响应迅速的系统。在这个主题下,我们将探讨Java缓存的基本概念、常用框架以及实现策略。 首先,让我们了解什么是缓存。缓存是一种存储技术,它允许我们在短时间内...

    Java缓存技术深入了解

    **Java缓存技术深入了解** Java缓存技术是提高应用程序性能的关键技术之一,它通过存储经常访问的数据,减少了对数据库或其他慢速数据源的依赖,从而加快了数据的获取速度。本篇文章将深入探讨Java中的缓存实现,...

    java 缓存技术

    java 缓存技术 oscache 和 JCS 的说明

    Java缓存技术

    ### Java缓存技术详解 #### 一、引言 随着计算机技术的快速发展,Java作为一种流行的编程语言,在多个领域内得到广泛应用。特别是在互联网开发领域,Java因其卓越的通用性、高效性、平台移植性和安全性,成为了不...

    java缓存技术

    下面我们将深入探讨Java缓存技术,特别是Ehcache的使用。 首先,理解缓存的基本原理至关重要。缓存是一种存储技术,用于临时存储最近或最常访问的数据,以便快速访问。在Java应用中,缓存可以减少对远程服务(如...

    清楚Java Applet缓存

    在高级选项中,还可以配置更多关于Java缓存的设置,比如缓存大小、更新策略等。 总的来说,理解并掌握如何管理Java Applet缓存对于开发者来说至关重要,尤其是在迭代开发和调试过程中,能够及时清除缓存以确保始终...

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

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

    JAVA_WEB_缓存技术

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

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

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

    java中的缓存技术

    3. Ehcache:Ehcache是另一个流行的Java缓存解决方案,它既可以作为本地缓存使用,也可以作为分布式缓存。Ehcache支持磁盘存储、缓存分区、缓存预热等功能,并且与Spring框架集成良好。 4. caffeine:Caffeine是一...

    java缓存技术.ppt

    java缓存技术.ppt

    Java缓存技术总结初见

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

    java缓存技术深入剖析

    Java缓存技术是提高应用程序性能的关键所在,尤其是在处理大量数据时。Javaeye创始人分享的这份“java缓存技术深入剖析”旨在帮助开发者更好地理解和应用缓存机制。以下是对该主题的详细阐述: 一、缓存的基本概念 ...

    详解java缓存ppt讲义

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

    Java_ibatis缓存技术

    本文将深入探讨Java_iBatis缓存技术,包括它的概念、类型、配置以及在实际应用中的注意事项。 首先,缓存是一种存储机制,用于临时存放频繁访问的数据,减少数据库的读取次数,从而提高系统响应速度。在iBatis中,...

Global site tag (gtag.js) - Google Analytics