`

oscache对象缓存

 
阅读更多

五、缓存对象 
一、对象缓存 

1、Cache操作类 

Java代码  收藏代码
  1.    import java.util.Date;  
  2.   
  3. import com.opensymphony.oscache.base.NeedsRefreshException;  
  4.   
  5. import com.opensymphony.oscache.general.GeneralCacheAdministrator;  
  6.   
  7. public class BaseCache extends GeneralCacheAdministrator {       
  8.   
  9.     private int refreshPeriod; //过期时间(单位为秒);           
  10.   
  11.     private String keyPrefix; //关键字前缀字符;              
  12.   
  13.     private static final long serialVersionUID = -4397192926052141162L;          
  14.   
  15.     public BaseCache(String keyPrefix,int refreshPeriod){      
  16.   
  17.         super();      
  18.   
  19.         this.keyPrefix = keyPrefix;      
  20.   
  21.         this.refreshPeriod = refreshPeriod;      
  22.   
  23.     }      
  24.   
  25.     //添加被缓存的对象;      
  26.   
  27.     public void put(String key,Object value){      
  28.   
  29.         this.putInCache(this.keyPrefix+"_"+key,value);      
  30.   
  31.     }      
  32.   
  33.     //删除被缓存的对象;      
  34.   
  35.     public void remove(String key){      
  36.   
  37.         this.flushEntry(this.keyPrefix+"_"+key);      
  38.   
  39.     }      
  40.   
  41.     //删除所有被缓存的对象;      
  42.   
  43.     public void removeAll(Date date){      
  44.   
  45.         this.flushAll(date);      
  46.   
  47.     }             
  48.   
  49.     public void removeAll(){      
  50.   
  51.         this.flushAll();      
  52.   
  53.     }      
  54.   
  55.     //获取被缓存的对象;      
  56.   
  57.     public Object get(String key) throws Exception{      
  58.   
  59.         try{      
  60.   
  61.             return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);      
  62.   
  63.         } catch (NeedsRefreshException e) {      
  64.   
  65.             this.cancelUpdate(this.keyPrefix+"_"+key);      
  66.   
  67.             throw e;      
  68.   
  69.         }        
  70.   
  71.     }              
  72.   
  73. }     


2、Cache管理类 

Java代码  收藏代码
  1. public class CacheManager {          
  2.   
  3.     private BaseCache newsCache;              
  4.   
  5.     private static CacheManager instance;      
  6.   
  7.     private static Object lock = new Object();             
  8.   
  9.     private CacheManager() {      
  10.   
  11.         //这个根据配置文件来,初始BaseCache而已;      
  12.   
  13.         newsCache = new BaseCache("news",120);           
  14.   
  15.     }              
  16.   
  17.     public static CacheManager getInstance(){      
  18.   
  19.         if (instance == null){      
  20.   
  21.             synchronized( lock ){      
  22.   
  23.                 if (instance == null){      
  24.   
  25.                     instance = new CacheManager();      
  26.   
  27.                 }      
  28.   
  29.             }      
  30.   
  31.         }      
  32.   
  33.         return instance;      
  34.   
  35.     }         
  36.   
  37.   
  38.    
  39.   
  40.   
  41.     public void removeAllNews() {      
  42.   
  43.         newsCache.removeAll();      
  44.   
  45.     }         
  46.   
  47.     public void putUser(User news) { newsCache.put(news.getId()+"",news);      }         
  48.   
  49.     public void removeUser(String newsID) {  newsCache.remove(newsID);       }         
  50.   
  51.     public User getUser(int newsID) {      
  52.   
  53.         try {      
  54.   
  55.             return (User) newsCache.get(newsID+"");      
  56.   
  57.         } catch (Exception e) {      
  58.   
  59.             System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage());      
  60.   
  61.             User news = new User(newsID);      
  62.   
  63.             this.putUser(news);      
  64.   
  65.             return news;      
  66.   
  67.         }      
  68.   
  69.     }         
  70. }  


3、对象Bean 

Java代码  收藏代码
  1. public class User {  
  2.   
  3.     private int id;  
  4.   
  5.     private String name;  
  6.   
  7.     private String sex;  
  8.   
  9.     private int age;  
  10.   
  11.     private Date accessTime; public User(int id) {  
  12.   
  13.        super();  
  14.   
  15.        this.id = id;  
  16.   
  17.        this.accessTime = new Date(System.currentTimeMillis());  
  18.   
  19.     }  
  20.   
  21.     public String toString() {  
  22.   
  23.        return "User info is : id=" + id + "  accessTime="  
  24.   
  25.               + accessTime.toString();  
  26.   
  27.     }  
  28.   
  29.     public User(String name, String sex, int age) {  
  30.   
  31.        super();  
  32.   
  33.        this.name = name;  
  34.   
  35.        this.sex = sex;  
  36.   
  37.        this.age = age;  
  38.   
  39.     }  
  40.   
  41.     public User() {  
  42.   
  43.     }  
  44.   
  45.     public int getAge() {  
  46.   
  47.        return age;  
  48.   
  49.     }  
  50.   
  51.     public void setAge(int age) {  
  52.   
  53.        this.age = age;  
  54.   
  55.     }  
  56.   
  57.     public String getName() {  
  58.   
  59.        return name;  
  60.   
  61.     }  
  62.   
  63.     public void setName(String name) {  
  64.   
  65.        this.name = name;  
  66.   
  67.     }  
  68.   
  69.     public String getSex() {  
  70.   
  71.        return sex;  
  72.   
  73.     }  
  74.   
  75.     public void setSex(String sex) {  
  76.   
  77.        this.sex = sex;  
  78.   
  79.     }  
  80.   
  81.     public int getId() {  
  82.   
  83.        return id;  
  84.   
  85.     }  
  86.   
  87.     public void setId(int id) {  
  88.   
  89.        this.id = id;  
  90.   
  91.     }  
  92.   
  93.     public Date getAccessTime() {  
  94.   
  95.        return accessTime;  
  96.   
  97.     }  
  98.   
  99.     public void setAccessTime(Date accessTime) {  
  100.   
  101.        this.accessTime = accessTime;  
  102.   
  103.     }  
  104.   
  105. }  


4、测试类 

Java代码  收藏代码
  1. public class TestObjectCache {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.        CacheManager cm=CacheManager.getInstance();  
  6.   
  7.          
  8.   
  9.        TestObjectCache test=new TestObjectCache();  
  10.   
  11.        test.print(cm);  
  12.   
  13.     }  
  14.   
  15.       
  16.   
  17.     public void print(CacheManager cm){  
  18.   
  19.        User user=null;  
  20.   
  21.        for (int i = 0; i < 1000; i++) {  
  22.   
  23.            user=cm.getUser(100);  
  24.   
  25.            System.out.println("<<"+i+">>: "+user);            
  26.   
  27.            if(i==10){  
  28.   
  29.               //删除缓存id的对象  
  30.   
  31.               cm.removeUser(100+"");  
  32.   
  33.            }            
  34.   
  35.            if(i==20){  
  36.   
  37.               //删除所有缓存的对象  
  38.   
  39.               cm.removeAllNews();  
  40.   
  41.            }            
  42.   
  43.            // 睡眠部分  
  44.   
  45.            try {  
  46.   
  47.               Thread.sleep(30000);  
  48.   
  49.            } catch (Exception e) {  
  50.   
  51.            }  
  52.   
  53.        }  
  54.   
  55.     }  
  56.   
  57. }  



CacheManager 类 

Java代码  收藏代码
  1. public class CacheManager {  
  2.   
  3.     private BaseCache newsCache;  
  4.   
  5.     private static CacheManager instance;  
  6.   
  7.     private static Object lock = new Object();  
  8.   
  9.    
  10.   
  11.     private CacheManager() {  
  12.   
  13.        // 这个根据配置文件来,初始BaseCache而已;  
  14.   
  15.        newsCache = new BaseCache("hrms"300);  
  16.   
  17.     }  
  18.   
  19.    
  20.   
  21.     public static CacheManager getInstance() {  
  22.   
  23.        if (instance == null) {  
  24.   
  25.            synchronized (lock) {  
  26.   
  27.               if (instance == null) {  
  28.   
  29.                   instance = new CacheManager();  
  30.   
  31.               }  
  32.   
  33.            }  
  34.   
  35.        }  
  36.   
  37.        return instance;  
  38.   
  39.     }  
  40.   
  41.    
  42.   
  43.     public void put(Object news,String key,String[] groups) {  
  44.   
  45.        newsCache.put(key, news,groups);  
  46.   
  47.     }  
  48.   
  49.     public void remove(String key) {  
  50.   
  51.        newsCache.remove(key);  
  52.   
  53.     }  
  54.   
  55.     public Object get(String key) {  
  56.   
  57.        try {  
  58.   
  59.            return newsCache.get(key);  
  60.   
  61.        } catch (Exception e) {  
  62.   
  63.            return null;  
  64.   
  65.        }  
  66.   
  67.     }  
  68.   
  69.     public void removeAll() {  
  70.   
  71.        newsCache.removeAll();  
  72.   
  73.     }     
  74.   
  75.     public void removeObjectByGroup(String group){  
  76.   
  77.        newsCache.removeObjectByGroup(group);  
  78.   
  79.     }  
  80.   
  81. }  



BaseCache 类增加的2个方法如下: 

    // 添加被缓存的对象; 

    public void put(String key, Object value,String[] groups) { 

       this.putInCache(this.keyPrefix + "_" + key, value,groups); 

    } 

    //删除该组的缓存对象 

    public void removeObjectByGroup(String group){ 

       this.flushGroup(group); 

    } 

第六部分:小结及其引申 



缓存是在提升系统响应时常用的一种技术,在系统缓存上通常采用的是有页面缓存、处理缓存和数据缓存这三种具体的类别,应该说这三种缓存在实现上还是稍有不同,尽管底层的缓存实现是一样的。 

页面缓存 

页面缓存是指对页面中的内容片断进行缓存的方案。比如页面中有一个部分是显示栏目中的内容的,那么就可以缓存这个部分,在进行第二次请求的时候就直接从缓存中取出这部分的内容(其实就是这部分的html了),这种情况下,缓存的作用其实非常明显,在典型的action+service+dao这样的结构中,在采用页面缓存后就意味着不需要经过action、service、dao这些层次的处理了,而是直接就返回了,对于系统响应速度的提升来说是非常明显的。 

页面缓存通常采用oscache来进行实现,oscache提供了一个jsp  tag,可通过这个tag来包含需要缓存的内容部分,当然,缓存的这个内容部分需要有对服务器的请求或逻辑计算等的,可想而知,去缓存一段静态html是没有意义的。 

其次需要定义缓存的这段内容的key,例如我们要去缓存页面中某个栏目的某页的内容,对于这段内容而言唯一的key就是栏目ID以及当前页数,这样就组成了这段缓存的key了,其实这个部分看起来好像是很简单,但有些时候会很麻烦,要仔细的想清楚这段内容的唯一的标识的key到底是什么,^_^,通常的做法其实可以从action中需要获取的参数或service接口的参数来决定.... 

页面缓存中还需要做的一个步骤就是通知缓存需要更新,页面缓存和其他缓存稍有不同,需要告诉它,这个时候不能再使用缓存中的内容了,需要从后台再重新获取来生成新的缓存内容,这个其实很简单,因为很难在后台发生变化的时候自己来更新缓存的内容,只能是去通知它,然后让它再次发起请求来生成新的内容放入缓存中。 

页面的缓存的使用对于系统的响应速度确实会有很大的提升,在实现页面缓存时最麻烦的主要是缓存的key的定义以及缓存更新的通知,缓存key的定义这个自然框架是没法解决的,不过缓存更新的通知其实在框架中可以考虑一种通知模型的,^_^,就像事件通知那样........在实际的项目中,可以自己去实现一个这样的通知模型或者就是简单的采用单例方式来标识某个key是否需要更新。 

页面缓存在实际的项目中使用非常的多。 

处理缓存 

处理缓存是指对于action、service、dao或者系统层次中的某方法进行缓存,说直接点,就是对某个类的某个方法的结果做缓存,这样在下次进行完全相同的请求的时候就可以直接取缓存了,这种响应速度的提升也是非常明显的。 

处理缓存在现在的情况下其实采用任务的缓存工具包都可以实现,如oscache、ehcache、jbosscache等,但目前还没有处理缓存框架的出现,这个和处理缓存是否应该存在的意义也是有关系的,处理缓存框架要做到的其实就像拦截一样的方式,和oscache  tag类似。 

同样,处理缓存的麻烦也在于怎么样去定义这个key,很多情况下可以根据方法的输入作为key,方法的输出作为key的值,但也会有其他一些复杂的情况,这个时候定义key就会变得复杂些了。 

处理缓存同样有通知更新缓存的情况,和页面缓存基本是一样的。 

应该说,处理缓存和页面缓存非常的相似,从实现上来说基本是完全一致的,在使用上来讲处理缓存使用的好像不多。 

数据缓存 

数据缓存估计大家都很熟悉,就是对系统的数据进行缓存的方式,典型的就是Hibernate的一级、二级数据缓存。 

数据缓存在实现上如果是用hibernate的话更多的是直接使用hibernate的一级、二级以及查询缓存,如果自己要实现的话可以去参考hibernate的实现机制。 

数据缓存的key在一级、二级缓存中采用的都是数据的标识键的值的方式,查询缓存采用的是查询参数、查询语句的方式。 

数据缓存的更新则是hibernate在进行存储时直接更新缓存的内容,而对于查询缓存则是采用全部直接清除的方式,这样在下次进行查询时自然会重新去查询,^_^,大家可能会想,为什么页面缓存和处理缓存不采用这样的方式来实现缓存的更新,稍微想想就知道了,在后台发生改变的时候其实是不知道需要移除哪些key的,所以hibernate为了避免这个麻烦,采用的就是当数据一旦发生改变的时候就清除全部的查询缓存,而不是只去清除相关的缓存,其实这里可以采用一种订阅式的模型,呵呵,当然,也增加了框架的复杂度。 

数据缓存使用的应该是最多的,效果也是很明显的。 

以上三种缓存是目前缓存实现时通常碰到的三种状况,里面按使用的多少来排序应该是:数据缓存、页面缓存和处理缓存;实现的难度上从难到易的顺序应该是:处理缓存、页面缓存、数据缓存;对于系统响应速度提升的效果来说从最好到好的顺序应该是:页面缓存、处理缓存、数据缓存。 

分享到:
评论

相关推荐

    用OSCache进行缓存对象

    1、OSCache是什么? 2、OSCache的特点 3、有关“用OSCache进行缓存对象”的研究

    OsCache缓存框架使用示例

    3. 创建缓存对象:在需要缓存数据的地方,创建OsCache实例并指定缓存名称。例如,可以创建一个名为`weatherCache`的缓存,用于存储天气信息。 4. 存储数据:当获取到新的天气信息时,将其存储到OsCache中,键为城市...

    oscache缓存技术

    osCache的核心功能包括缓存对象、缓存区域管理、缓存过期策略以及支持分布式缓存等。 ### 1. osCache的基本概念 - **缓存对象**:osCache允许开发者将任何Java对象存储到缓存中,以便后续请求可以直接从内存中获取...

    OSCache 缓存对象的总结

    OSCache 是一个开源的缓存解决方案,主要用于Java应用程序,它提供了高效的对象缓存功能,能够显著提高应用的性能。在本文中,我们将深入探讨OSCache的核心特性、工作原理以及如何在实际项目中有效利用它。 OSCache...

    SSM的整合+OScache页面缓存+freemark模板

    OScache是Java的一个开源缓存框架,它可以用来缓存任何Java对象,包括页面。在SSM项目中引入OScache,可以在服务器端对经常访问的页面进行缓存,提高页面加载速度,减轻服务器压力。配置OScache主要包括设置缓存策略...

    oscache-java缓存框架

    - **对象缓存**:osCache允许开发者将Java对象直接放入缓存,便于快速检索。 - **内存管理**:自动管理内存,当内存不足时,可基于LRU(Least Recently Used)策略进行对象的淘汰。 - **持久化**:支持缓存数据的...

    osCache,缓存

    它由OpenSymphony开源组织开发,旨在提供内存中的对象缓存服务,以提升应用性能并减轻数据库负载。osCache的核心功能是将频繁访问的数据存储在内存中,避免了反复从数据库读取,从而显著提高了应用程序的响应速度。 ...

    oscache缓存技术入门实例

    它支持缓存对象、集合、Map等各种数据类型,并提供了缓存过期、刷新策略等高级特性。 二、osCache工作原理 1. 数据存储:osCache将数据存储在内存中的缓存区域,这些区域可以被细分为多个缓存,每个缓存有自己的...

    OSCache缓存技术(6)【实例】

    OSCache支持对象级别的缓存,也就是说,它可以缓存任何Java对象,并提供了自动过期和更新策略,确保数据的实时性。 在OSCache中,缓存管理主要通过`Cache`接口实现。开发者可以创建并初始化一个`Cache`实例,然后将...

    oscache缓存配置

    osCache的核心功能是提供了一个内存中的对象缓存系统,通过将常用数据暂存到内存中,避免了频繁的数据库查询,从而显著提升应用程序的性能。 在开始配置osCache之前,我们需要了解其基本概念和工作原理。osCache...

    oscache-JSP缓存

    osCache是一个基于Java的缓存框架,主要针对JSP页面和Java对象的缓存。它通过将常用的数据存储在内存中,避免了频繁的数据库查询或计算,从而降低了服务器负载,提高了响应速度。osCache支持缓存页面片段、整个页面...

    OSCache缓存框架的简单用法

    OSCache的核心特性包括缓存对象的自动过期、内存管理策略、缓存同步以及丰富的API。 **2. 安装与依赖** 首先,你需要将OSCache的JAR文件添加到项目的类路径中。你可以从OpenSymphony的官方网站或者Maven仓库下载...

    OSCache缓存jsp例子

    OSCache 提供了对Java对象的缓存管理功能,包括缓存对象的存储、检索、更新和过期策略等。它支持多种缓存策略,如LRU(Least Recently Used)最近最少使用、FIFO(First In First Out)先进先出等。在JSP页面缓存中...

    oscache缓存

    osCache是Java平台上的一个高效的缓存解决方案,主要用于在应用程序中缓存数据,以提高性能和减少数据库的负载。这个工具特别适用于那些需要频繁访问但更新不频繁的数据,例如经常查询但很少更改的数据库记录。...

    一个OSCache缓存技术的关键zip包

    OSCache 是一款开源的缓存解决方案,主要用于Java应用程序,它能显著提高应用性能,通过缓存数据、对象和查询结果来减少对数据库的访问。这个关键的zip包包含了一些核心的OSCache组件和相关的文档,下面我们将深入...

    Hibernate OSCache缓存

    **Hibernate OSCache缓存详解** Hibernate 是一个流行的Java ORM(对象关系映射)框架,它允许开发者以面向对象的方式操作数据库。为了提高性能,Hibernate 提供了缓存机制,其中 OSCache 是一种广泛使用的二级缓存...

    hibernate+oscache实现二级缓存实例

    为了提高系统性能,通常会采用缓存技术来减少对数据库的直接访问,而OSCache就是一种广泛使用的开源缓存解决方案。本实例将介绍如何结合Hibernate和OSCache实现二级缓存,以优化应用程序的性能。 一级缓存是...

Global site tag (gtag.js) - Google Analytics