`
javaeyetodj
  • 浏览: 431394 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

OSCACHE集群功能 转

CacheBlog 
阅读更多

转自 http://benx.iteye.com/blog/606083

Oscache的集群功能没有完全实现，只是实现了flush的接口，需要用户自己去实现它的其它集群接口(不知道他是出于什么考虑). 如果采用Jgroups组件，则需要继承自JavaGroupsBroadcastingListener抽象类，继承它的handleClusterNotification方法，完成集群其它功能的实现：
注意：集群中传递的对象必须实现Serializable接口。

Java代码 复制代码
  1. public class JavaGroupsBroadcastingListenerImpl extends     
  2.         JavaGroupsBroadcastingListener {     
  3.     public void handleClusterNotification(ClusterNotification message) {     
  4.              
  5.         switch (message.getType()) {     
  6.         case CacheConstants.CLUSTER_ENTRY_ADD:     
  7.             System.out.println("集群新增:" + message.getData());     
  8.             if(message.getData() instanceof QflagCacheEvent) {     
  9.                 QflagCacheEvent event = (QflagCacheEvent)message.getData();     
  10.                 cache.putInCache(event.getKey(), event.getEntry().getContent(),null,null,CLUSTER_ORIGIN);     
  11.             }     
  12.             break;     
  13.         case CacheConstants.CLUSTER_ENTRY_UPDATE:     
  14.             System.out.println("集群更新:" + message.getData());     
  15.             if(message.getData() instanceof QflagCacheEvent) {     
  16.                 QflagCacheEvent event = (QflagCacheEvent)message.getData();     
  17.                 cache.putInCache(event.getKey(), event.getEntry().getContent(),null,null,CLUSTER_ORIGIN);     
  18.             }     
  19.             break;     
  20.         case CacheConstants.CLUSTER_ENTRY_DELETE:     
  21.             System.out.println("集群删除:" + message.getData());     
  22.             if(message.getData() instanceof QflagCacheEvent) {     
  23.                 QflagCacheEvent event = (QflagCacheEvent)message.getData();     
  24. //              cache.removeEntry(event.getKey(),event.getOrigin());     
  25.                 cache.removeEntry(event.getKey());     
  26.             }     
  27.             break;     
  28.         }     
  29.      
  30.     }     
  31.          
  32.     public void cacheEntryAdded(CacheEntryEvent event) {     
  33.         super.cacheEntryAdded(event);     
  34.         if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {     
  35.             sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_ADD, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));     
  36.         }     
  37.     }     
  38.      
  39. //  @Override     
  40. //  public void cacheEntryFlushed(CacheEntryEvent event) {     
  41. //           
  42. //      super.cacheEntryFlushed(event);     
  43. //      if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {     
  44. //          sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_ADD, new UcallCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));     
  45. //      }     
  46. //  }     
  47.      
  48.     @Override     
  49.     public void cacheEntryRemoved(CacheEntryEvent event) {     
  50.              
  51.         super.cacheEntryRemoved(event);     
  52.         if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {     
  53.             sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_DELETE, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));     
  54.         }     
  55.     }     
  56.      
  57.     @Override     
  58.     public void cacheEntryUpdated(CacheEntryEvent event) {     
  59.              
  60.         super.cacheEntryUpdated(event);     
  61.         if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {     
  62.             sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_UPDATE, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));     
  63.         }     
  64.     }     
  65.          
  66. }    
public class JavaGroupsBroadcastingListenerImpl extends  
        JavaGroupsBroadcastingListener {  
    public void handleClusterNotification(ClusterNotification message) {  
          
        switch (message.getType()) {  
        case CacheConstants.CLUSTER_ENTRY_ADD:  
            System.out.println("集群新增:" + message.getData());  
            if(message.getData() instanceof QflagCacheEvent) {  
                QflagCacheEvent event = (QflagCacheEvent)message.getData();  
                cache.putInCache(event.getKey(), event.getEntry().getContent(),null,null,CLUSTER_ORIGIN);  
            }  
            break;  
        case CacheConstants.CLUSTER_ENTRY_UPDATE:  
            System.out.println("集群更新:" + message.getData());  
            if(message.getData() instanceof QflagCacheEvent) {  
                QflagCacheEvent event = (QflagCacheEvent)message.getData();  
                cache.putInCache(event.getKey(), event.getEntry().getContent(),null,null,CLUSTER_ORIGIN);  
            }  
            break;  
        case CacheConstants.CLUSTER_ENTRY_DELETE:  
            System.out.println("集群删除:" + message.getData());  
            if(message.getData() instanceof QflagCacheEvent) {  
                QflagCacheEvent event = (QflagCacheEvent)message.getData();  
//              cache.removeEntry(event.getKey(),event.getOrigin());  
                cache.removeEntry(event.getKey());  
            }  
            break;  
        }  
  
    }  
      
    public void cacheEntryAdded(CacheEntryEvent event) {  
        super.cacheEntryAdded(event);  
        if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {  
            sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_ADD, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));  
        }  
    }  
  
//  @Override  
//  public void cacheEntryFlushed(CacheEntryEvent event) {  
//        
//      super.cacheEntryFlushed(event);  
//      if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {  
//          sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_ADD, new UcallCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));  
//      }  
//  }  
  
    @Override  
    public void cacheEntryRemoved(CacheEntryEvent event) {  
          
        super.cacheEntryRemoved(event);  
        if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {  
            sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_DELETE, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));  
        }  
    }  
  
    @Override  
    public void cacheEntryUpdated(CacheEntryEvent event) {  
          
        super.cacheEntryUpdated(event);  
        if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {  
            sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_UPDATE, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));  
        }  
    }  
      
}

 

Java代码 复制代码
  1. package qflag.ucall.cache;     
  2. public class CacheConstants {     
  3.     /**   
  4.      * 添加缓存对象操作   
  5.      */     
  6.     public final static int ACTION_ADD_OBJ = 1;     
  7.     /**   
  8.      * 更新缓存对象操作   
  9.      */     
  10.     public final static int ACTION_UPDATE_OBJ = 2;     
  11.     /**   
  12.      * 删除缓存对象操作   
  13.      */     
  14.     public final static int ACTION_DELETE_OBJ = 3;     
  15.     /**   
  16.      * 刷新缓存对象   
  17.      */     
  18.     public final static int ACTION_FLUSH_OBJ = 4;     
  19.          
  20.          
  21.     /**   
  22.      * 集群entry add处理   
  23.      */     
  24.     public final static int CLUSTER_ENTRY_ADD = 20;     
  25.          
  26.     /**   
  27.      * 集群entry update处理   
  28.      */     
  29.     public final static int CLUSTER_ENTRY_UPDATE = 21;     
  30.          
  31.     /**   
  32.      * 集群entry delete处理   
  33.      */     
  34.     public final static int CLUSTER_ENTRY_DELETE = 22;     
  35. }    
package qflag.ucall.cache;  
public class CacheConstants {  
    /** 
     * 添加缓存对象操作 
     */  
    public final static int ACTION_ADD_OBJ = 1;  
    /** 
     * 更新缓存对象操作 
     */  
    public final static int ACTION_UPDATE_OBJ = 2;  
    /** 
     * 删除缓存对象操作 
     */  
    public final static int ACTION_DELETE_OBJ = 3;  
    /** 
     * 刷新缓存对象 
     */  
    public final static int ACTION_FLUSH_OBJ = 4;  
      
      
    /** 
     * 集群entry add处理 
     */  
    public final static int CLUSTER_ENTRY_ADD = 20;  
      
    /** 
     * 集群entry update处理 
     */  
    public final static int CLUSTER_ENTRY_UPDATE = 21;  
      
    /** 
     * 集群entry delete处理 
     */  
    public final static int CLUSTER_ENTRY_DELETE = 22;  
}

 

Java代码 复制代码
  1.   
  2. package qflag.ucall.cache.event;     
  3.      
  4. import java.io.Serializable;     
  5.      
  6. import com.opensymphony.oscache.base.Cache;     
  7. import com.opensymphony.oscache.base.CacheEntry;     
  8. import com.opensymphony.oscache.base.events.CacheEntryEvent;     
  9. import com.opensymphony.oscache.base.events.CacheEvent;     
  10.      
  11. public class QflagCacheEvent extends CacheEvent implements Serializable {     
  12.     /**   
  13.      * The cache where the entry resides.   
  14.      */     
  15.     private Cache map = null;     
  16.      
  17.     /**   
  18.      * The entry that the event applies to.   
  19.      */     
  20.     private CacheEntry entry = null;     
  21.      
  22.     /**   
  23.      * Constructs a cache entry event object with no specified origin   
  24.      *    
  25.      * @param map   
  26.      *            The cache map of the cache entry   
  27.      * @param entry   
  28.      *            The cache entry that the event applies to   
  29.      */     
  30.     public QflagCacheEvent(Cache map, CacheEntry entry) {     
  31.         this(map, entry, null);     
  32.     }     
  33.      
  34.     /**   
  35.      * Constructs a cache entry event object   
  36.      *    
  37.      * @param map   
  38.      *            The cache map of the cache entry   
  39.      * @param entry   
  40.      *            The cache entry that the event applies to   
  41.      * @param origin   
  42.      *            The origin of this event   
  43.      */     
  44.     public QflagCacheEvent(Cache map, CacheEntry entry, String origin) {     
  45.         super(origin);     
  46.         this.map = map;     
  47.         this.entry = entry;     
  48.     }     
  49.      
  50.     /**   
  51.      * Retrieve the cache entry that the event applies to.   
  52.      */     
  53.     public CacheEntry getEntry() {     
  54.         return entry;     
  55.     }     
  56.      
  57.     /**   
  58.      * Retrieve the cache entry key   
  59.      */     
  60.     public String getKey() {     
  61.         return entry.getKey();     
  62.     }     
  63.      
  64.     /**   
  65.      * Retrieve the cache map where the entry resides.   
  66.      */     
  67.     public Cache getMap() {     
  68.         return map;     
  69.     }     
  70.      
  71.     public String toString() {     
  72.         return "key=" + entry.getKey();     
  73.     }     
  74. }    
package qflag.ucall.cache.event;  
  
import java.io.Serializable;  
  
import com.opensymphony.oscache.base.Cache;  
import com.opensymphony.oscache.base.CacheEntry;  
import com.opensymphony.oscache.base.events.CacheEntryEvent;  
import com.opensymphony.oscache.base.events.CacheEvent;  
  
public class QflagCacheEvent extends CacheEvent implements Serializable {  
    /** 
     * The cache where the entry resides. 
     */  
    private Cache map = null;  
  
    /** 
     * The entry that the event applies to. 
     */  
    private CacheEntry entry = null;  
  
    /** 
     * Constructs a cache entry event object with no specified origin 
     *  
     * @param map 
     *            The cache map of the cache entry 
     * @param entry 
     *            The cache entry that the event applies to 
     */  
    public QflagCacheEvent(Cache map, CacheEntry entry) {  
        this(map, entry, null);  
    }  
  
    /** 
     * Constructs a cache entry event object 
     *  
     * @param map 
     *            The cache map of the cache entry 
     * @param entry 
     *            The cache entry that the event applies to 
     * @param origin 
     *            The origin of this event 
     */  
    public QflagCacheEvent(Cache map, CacheEntry entry, String origin) {  
        super(origin);  
        this.map = map;  
        this.entry = entry;  
    }  
  
    /** 
     * Retrieve the cache entry that the event applies to. 
     */  
    public CacheEntry getEntry() {  
        return entry;  
    }  
  
    /** 
     * Retrieve the cache entry key 
     */  
    public String getKey() {  
        return entry.getKey();  
    }  
  
    /** 
     * Retrieve the cache map where the entry resides. 
     */  
    public Cache getMap() {  
        return map;  
    }  
  
    public String toString() {  
        return "key=" + entry.getKey();  
    }  
}

 

分享到：
| Hibernate和 OsCache的使用 转
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    oscache 集群和数据同步

    《osCache集群与数据同步详解》 osCache是一款开源的Java缓存框架，它提供了高效、易用的缓存管理方案，广泛应用于大型分布式系统中，以提高应用程序的性能和响应速度。osCache的核心功能包括缓存管理、缓存同步...

    oscache-2.1.1-full.zip_full_oscache_oscache 2_oscache2

    结合集群功能，可以构建高可用、高性能的分布式缓存系统。 总的来说，osCache 2.1.1 是一个强大且灵活的缓存解决方案，尤其适合需要高效缓存管理及分布式支持的Java项目。通过理解其核心特性和使用方法，开发者可以...

    oscache的例子

    OSCache标记库由OpenSymphony设计，它是一种开创性的缓存方案，它提供了在现有JSP页面之内实现内存缓存的功能。OSCache是个一个被广泛采用的高性能的J2EE缓存框架，OSCache还能应用于任何Java应用程序的普通的缓存...

    oscache-java缓存框架

    osCache不仅可以用于Web应用，也可以用于任何Java应用程序，支持集群环境，提供了丰富的功能和配置选项。 1. **osCache的基本概念** - **缓存**：缓存是一种技术，用于临时存储频繁访问的数据，以便快速响应用户的...

    oscache详细配置文档

    为了在 JSP 页面中使用 OSCache 功能，需要将 `soscache.tld` 文件添加到 CLASSPATH 中，通常放在 `src/webapp/WEB-INF/classes` 或 `etc` 目录下。然后在 `web.xml` 文件中添加标签库定义，如下所示： ```xml ...

    OSCache配置说明文档

    本文档的主要目的是阐述OSCache的核心功能、配置方法以及实际应用中的操作步骤，帮助开发者理解和有效地利用OSCache提升应用程序性能。 阅读对象： 此文档适合对Java Web开发有一定了解，希望引入缓存机制以优化...

    oscache-2.4.1-full

    虽然主要是单机缓存解决方案，但OSCache也可以扩展到分布式环境，通过集群共享缓存，进一步提高系统可扩展性和可用性。 总之，OSCache-2.4.1是一个强大的缓存解决方案，旨在提高JSP应用的性能，减轻数据库压力，...

    oscache对象缓存

    oscache的主要功能是提供对象级别的缓存，这意味着它可以存储任何Java对象，并且支持多种缓存策略，如LRU（Least Recently Used）和FIFO（First In First Out）。这些策略确保了内存的有效利用，防止缓存溢出。 ...

    oscache文档

    **OSCache**是由**OpenSymphony**设计的一种创新的JSP自定义标签库，主要用于实现现有JSP页面内部的快速内存缓存功能。作为一种广泛应用且高性能的J2EE缓存框架，OSCache能够应用于任何Java应用程序中作为通用缓存...

    oscache.rar

    首先，OSCache的核心功能是内存缓存，它允许我们将频繁访问的数据存储在内存中，避免了每次查询数据库的开销。OSCache支持对缓存进行设置过期时间、大小限制等管理，确保缓存的有效性和可控性。 集群环境下的...

    oscache2.1_ful

    **一、OSCache 的核心功能** 1. **缓存管理**: OSCache 提供了完善的缓存管理机制，允许开发者存储和检索对象，同时支持自动和手动的缓存清理策略，确保内存的有效利用。 2. **缓存预热**: 在应用程序启动时，...

    oscache-2.4.1-full.rar

    OSCache标记库由OpenSymphony设计，它是一种开创性的缓存方案，它提供了在现有JSP页面之内实现内存缓存的功能。OSCache是个一个被广泛采用的高性能的J2EE缓存框架，OSCache还能应用于任何Java应用程序的普通的缓存...

    oscache缓存使用总结.doc

    将`oscache.tld`文件复制到`/WEB-INF/classes`目录，这是OSCache的标签库文件，用于在JSP中使用OSCache的功能。 4. **web.xml配置**： 在`web.xml`文件中添加OSCache的标签库引用，如下所示： ```xml ...

    Oscache-入门教程.doc

    4. **集群支持**：在集群环境中，OSCache 可以配置为共享缓存数据，无需修改代码就能实现数据一致性。 5. **缓存过期策略**：开发者可以自定义缓存对象的过期规则，包括可插入的刷新策略，以适应各种复杂需求。 **...

    oscache-2.3.jar

    本文将深入探讨oscache的核心功能、工作原理及其在实际应用中的价值。 一、oscache简介 oscache全称为OpenSymphony Cache，是一个完全开源的、基于JVM内存的缓存解决方案。它提供了全面的缓存管理功能，包括对象...

    Cache技术--OSCache

    OSCache的使用并不复杂，开发者可以通过官方文档进一步了解详细配置和高级功能，例如缓存预热、缓存同步、缓存锁定等，以充分利用其性能优化潜力。 总结，OSCache作为一款强大的缓存框架，不仅提高了Web应用的性能...

    应用OSCache提升J2EE系统运行性能

    本文将深入解析OSCache的工作原理、主要功能以及如何在实际项目中应用，以帮助开发者理解并有效地利用这个工具。 一、OSCache简介 OSCache是由OpenSymphony开发的一个开源缓存框架，其主要目标是提供高性能、高可用...

    Oscache_入门

    4. **集群支持**：Oscache支持在集群环境中使用，无需额外修改代码即可实现缓存数据的一致性。 5. **缓存过期管理**：用户可以自定义缓存项的有效期，包括支持插件式的刷新策略，以便在默认性能无法满足需求时进行...

Magicbox
Global site tag (gtag.js) - Google Analytics