oscache 集群和数据同步

最新推荐文章于 2025-08-18 22:47:43 发布
最新推荐文章于 2025-08-18 22:47:43 发布
阅读量149 收藏
点赞数
分类专栏： java 文章标签： java 网络
本文详细解释了如何使用JavaGroupsBroadcastingListener在OSCache集群中实现数据同步，包括实现关键方法以同步属性的添加、删除和更新，并通过配置文件映射监听类路径。同时，解决了一个Tomcat6.0与Tomcat7.0环境下缓存同步失败的问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

cache.event.listeners=com.test.JavaGroupsBroadcastingListenerImpl
cache.cluster.properties=UDP(mcast_addr=231.12.21.132;mcast_port=45566;ip_ttl=32;\
mcast_send_buf_size=150000;mcast_recv_buf_size=80000):\
PING(timeout=2000;num_initial_members=3):\
MERGE2(min_interval=5000;max_interval=10000):\
FD_SOCK:VERIFY_SUSPECT(timeout=1500):\
pbcast.NAKACK(gc_lag=50;retransmit_timeout=300,600,1200,2400,4800;max_xmit_size=8192):\
UNICAST(timeout=300,600,1200,2400):\
pbcast.STABLE(desired_avg_gossip=20000):\
FRAG(frag_size=8096;down_thread=false;up_thread=false):\
pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;print_local_addr=true)
cache.cluster.multicast.ip=231.12.21.132

 oscache 集群同步数据需要使用到JavaGroupsBroadcastingListener，但是JavaGroupsBroadcastingListener 具体没有实现同步的功能，JavaGroupsBroadcastingListener：

 public void handleNotification(Serializable serializable) {
        if (!(serializable instanceof ClusterNotification)) {
            log.error("An unknown cluster notification message received (class=" + serializable.getClass().getName() + "). Notification ignored.");

            return;
        }

        handleClusterNotification((ClusterNotification) serializable);
    }

 handleNotification该方法调用 handleClusterNotification((ClusterNotification) serializable)后，进入AbstractBoardcasting类，改方法只执行刷新当前缓存的内容，对集群数据同步没有实现。

/*
 * Copyright (c) 2002-2003 by OpenSymphony
 * All rights reserved.
 */
package com.opensymphony.oscache.plugins.clustersupport;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.Date;

/**
 * Implementation of a CacheEntryEventListener. It broadcasts the flush events
 * across a cluster to other listening caches. Note that this listener cannot
 * be used in conjection with session caches.
 *
 * @version        $Revision: 254 $
 * @author <a href="&#109;a&#105;&#108;&#116;&#111;:chris&#64;swebtec.&#99;&#111;&#109;">Chris Miller</a>
 */
public abstract class AbstractBroadcastingListener implements CacheEntryEventListener, LifecycleAware {
    private final static Log log = LogFactory.getLog(AbstractBroadcastingListener.class);

    /**
     * The name to use for the origin of cluster events. Using this ensures
     * events are not fired recursively back over the cluster.
     */
    protected static final String CLUSTER_ORIGIN = "CLUSTER";
    protected Cache cache = null;

    public AbstractBroadcastingListener() {
        if (log.isInfoEnabled()) {
            log.info("AbstractBroadcastingListener registered");
        }
    }

    /**
     * Event fired when an entry is flushed from the cache. This broadcasts
     * the flush message to any listening nodes on the network.
     */
    public void cacheEntryFlushed(CacheEntryEvent event) {
        if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
            if (log.isDebugEnabled()) {
                log.debug("cacheEntryFlushed called (" + event + ")");
            }

            sendNotification(new ClusterNotification(ClusterNotification.FLUSH_KEY, event.getKey()));
        }
    }

    /**
     * Event fired when an entry is removed from the cache. This broadcasts
     * the remove method to any listening nodes on the network, as long as
     * this event wasn't from a broadcast in the first place.
     */
    public void cacheGroupFlushed(CacheGroupEvent event) {
        if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
            if (log.isDebugEnabled()) {
                log.debug("cacheGroupFushed called (" + event + ")");
            }

            sendNotification(new ClusterNotification(ClusterNotification.FLUSH_GROUP, event.getGroup()));
        }
    }

    public void cachePatternFlushed(CachePatternEvent event) {
        if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
            if (log.isDebugEnabled()) {
                log.debug("cachePatternFushed called (" + event + ")");
            }

            sendNotification(new ClusterNotification(ClusterNotification.FLUSH_PATTERN, event.getPattern()));
        }
    }

    public void cacheFlushed(CachewideEvent event) {
        if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
            if (log.isDebugEnabled()) {
                log.debug("cacheFushed called (" + event + ")");
            }

            sendNotification(new ClusterNotification(ClusterNotification.FLUSH_CACHE, event.getDate()));
        }
    }

    // --------------------------------------------------------
    // The remaining events are of no interest to this listener
    // --------------------------------------------------------
    public void cacheEntryAdded(CacheEntryEvent event) {
    }

    public void cacheEntryRemoved(CacheEntryEvent event) {
    }

    public void cacheEntryUpdated(CacheEntryEvent event) {
    }

    public void cacheGroupAdded(CacheGroupEvent event) {
    }

    public void cacheGroupEntryAdded(CacheGroupEvent event) {
    }

    public void cacheGroupEntryRemoved(CacheGroupEvent event) {
    }

    public void cacheGroupRemoved(CacheGroupEvent event) {
    }

    public void cacheGroupUpdated(CacheGroupEvent event) {
    }

    /**
     * Called by the cache administrator class when a cache is instantiated.
     *
     * @param cache the cache instance that this listener is attached to.
     * @param config The cache's configuration details. This allows the event handler
     * to initialize itself based on the cache settings, and also to receive <em>additional</em>
     * settings that were part of the cache configuration but that the cache
     * itself does not care about. If you are using <code>cache.properties</code>
     * for your configuration, simply add any additional properties that your event
     * handler requires and they will be passed through in this parameter.
     *
     * @throws InitializationException thrown when there was a problem initializing the
     * listener. The cache administrator will log this error and disable the listener.
     */
    public void initialize(Cache cache, Config config) throws InitializationException {
        this.cache = cache;
    }

    /**
     * Handles incoming notification messages. This method should be called by the
     * underlying broadcasting implementation when a message is received from another
     * node in the cluster.
     *
     * @param message The incoming cluster notification message object.
     */
    public void handleClusterNotification(ClusterNotification message) {
        if (cache == null) {
            log.warn("A cluster notification (" + message + ") was received, but no cache is registered on this machine. Notification ignored.");

            return;
        }

        if (log.isInfoEnabled()) {
            log.info("Cluster notification (" + message + ") was received.");
        }

        switch (message.getType()) {
            case ClusterNotification.FLUSH_KEY:
                cache.flushEntry((String) message.getData(), CLUSTER_ORIGIN);
                break;
            case ClusterNotification.FLUSH_GROUP:
                cache.flushGroup((String) message.getData(), CLUSTER_ORIGIN);
                break;
            case ClusterNotification.FLUSH_PATTERN:
                cache.flushPattern((String) message.getData(), CLUSTER_ORIGIN);
                break;
            case ClusterNotification.FLUSH_CACHE:
                cache.flushAll((Date) message.getData(), CLUSTER_ORIGIN);
                break;
            default:
                log.error("The cluster notification (" + message + ") is of an unknown type. Notification ignored.");
        }
    }

    /**
     * Called when a cluster notification message is to be broadcast. Implementing
     * classes should use their underlying transport to broadcast the message across
     * the cluster.
     *
     * @param message The notification message to broadcast.
     */
    abstract protected void sendNotification(ClusterNotification message);
}

 
所以我们要集群式同步数据，必须实现这三个方法：

public void cacheEntryAdded(CacheEntryEvent event) {
    }

    public void cacheEntryRemoved(CacheEntryEvent event) {
    }

    public void cacheEntryUpdated(CacheEntryEvent event) {
    }

 这个实现类实现了以上的三个方法，就可以同步数据了：

package com.test;
import com.opensymphony.oscache.base.events.CacheEntryEvent;
import com.opensymphony.oscache.plugins.clustersupport.ClusterNotification;
import com.opensymphony.oscache.plugins.clustersupport.JavaGroupsBroadcastingListener;

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.flushEntry(event.getKey());
				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);
		System.out.println("属性添加");
		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) {
		System.out.println("属性移除");
		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) {
		System.out.println("属性更新");
		super.cacheEntryUpdated(event);
		if(!CLUSTER_ORIGIN.equals(event.getOrigin())) {
			sendNotification(new ClusterNotification(CacheConstants.CLUSTER_ENTRY_UPDATE, new QflagCacheEvent(event.getMap(),event.getEntry(),CLUSTER_ORIGIN)));
		}
	}
	
}

 

然后修改配置文件，映射cache.event.listeners类的路径：

cache.event.listeners=com.test.JavaGroupsBroadcastingListenerImpl
cache.cluster.properties=UDP(mcast_addr=231.12.21.132;mcast_port=45566;ip_ttl=32;\
mcast_send_buf_size=150000;mcast_recv_buf_size=80000):\
PING(timeout=2000;num_initial_members=3):\
MERGE2(min_interval=5000;max_interval=10000):\
FD_SOCK:VERIFY_SUSPECT(timeout=1500):\
pbcast.NAKACK(gc_lag=50;retransmit_timeout=300,600,1200,2400,4800;max_xmit_size=8192):\
UNICAST(timeout=300,600,1200,2400):\
pbcast.STABLE(desired_avg_gossip=20000):\
FRAG(frag_size=8096;down_thread=false;up_thread=false):\
pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;shun=false;print_local_addr=true)
cache.cluster.multicast.ip=231.12.21.132

 具体源码可以参考 oscache集群功能  http://rwl6813021.iteye.com/blog/246473，我已经实现了整合。

测试使用两个tomcat6.0，无问题，但是一个tomca6.0，一个tomcat7.0时发现缓存没有同步。。。

oscache-2.1.1-full.zip_full_oscache_oscache 2_oscache2
09-14
6. **事件监听**: 提供了缓存事件监听器接口，允许开发者在数据的存取过程中进行额外的操作，如数据同步、日志记录等。 **压缩包内容分析** 1. **docs**: 包含osCache的文档，包括用户手册、API参考等，是学习和...
oscache 集群中数据同步问题
心里打结，为了过得舒服点，只好拼命的开结
12-20 183
今天碰到了oscache缓存同步的问题，因为以前没接触这些个问题，所以查了一堆有用的资料，放在上面。下面是前辈整理的一些资料，都是在javaeye上找的： OSCache 集群中数据同步问题， Oscache分布式集群配置总结 OSCache使用指南 下面是自己的一些总结： oscache.properties：文件配置向导 ，在 JavaGroupsBroadc...
OSCache分布式集群配置
All is well ^_^
08-01 1757
OSCache简介 缓存任何对象 永久缓存，缓存持久化处理 缓存记录的过期 支持集群（需要额外配置） OSCache 集群支持介绍 OScache自身不具备集群通信能力，它他需要借助第三方通讯工具来实现集群缓存数据同步。 下图所示是OScache集群相关的Java类，其中类AbstractBroadcastingListener负责缓
[转]Oscache分布式集群配置总结
有为
12-17 209
由于项目需要，需要用到oscache的分布式集群，为了实现分布式环境下消息的通知,目前两种比较流行的做法是使用 JMS和JGROUPS，这两种方式都在底层实现了广播发布消息。 由于JGroups可以提供可靠的广播通信.所以我准备采用JGroups。 需要用的jar包有: oscache.jar 2.4.1（缓存组件），jgroups.jar2.8.GA（IP组播）,commons-loggi...
实现分布式环境下消息的接受和发送
Herry
05-14 487
为了提高应用的性能,我们准备实现分布式cache,所以我特别研究了oscache关于分布式实现的部分. 我们知道为了实现分布式环境下消息的通知,目前两种比较流行的做法是使用JavaGroups[http://www.jgroups.org]和JMS。这两种方式都在底层实现了广播发布消息。 由于JGroups可以提供可靠的广播通信.所以我们准备采用JGroups. ...
oscache集群环境下的数据同步问题
pacer123
01-22 157
在我们的web应用中，大家可能经常会用到oscache来缓存数据。但是当你的应用服务器是集群环境的情况下，通常会有数据不同步的问题。为了解决这样的问题，可以利用IP组播实现集群环境下的节点间缓存数据的同步。 经过在2台PC机上分别启动tomcat，运行库存web应用，调用被缓存的方法，然后在其中一台更改缓存的结果，经测试，另一台的缓存被同步更新了。 这为集群环境下，各节点...
OSCache 集群中数据同步问题
f7536
05-23 151
最近使用oscach集群中，有些问题不甚了解，请各位提些建议。 现有的配置： oscache.properties 中使用默认jgroup配置 cache.event.listeners=com.opensymphony.oscache.plugins.clustersupport.JavaGroupsBroadcastingListener cache.cluster.prope...
oscache集群技术：实现高效数据同步与管理
数据同步通常涉及到实时同步和定期同步两种方式。 4.实现数据同步的工具和技术 实现数据同步的工具有许多，例如数据库的主从复制、分布式文件系统、分布式数据库技术等。一些工具可能基于特定的算法，比如基于...
JAVA缓存框架Oscache集群详解
Oscache集群通过集成JMS（Java Message Service）、RMI（Remote Method Invocation）和Jgroups技术，实现了节点间的通信和数据同步，确保缓存的一致性。例如，在描述中提到的Oscache01、Oscache02和Oscache03可能...
OSCache 2.4.1: 强化JSP快速内存缓存与集群支持
**OSCache** 是一种由 OpenSymphony 设计的 Java 缓存解决方案，旨在为 Java 应用程序提供高性能的数据存储和检索功能。OSCache 被广泛应用于 Web 应用中，尤其在处理大量动态内容生成时，其缓存技术能够显著提升...
Java——琐碎知识点2
2401_88065518的博客
08-15 744
Java基础知识点：Java官方帮助文档、Scanner扫描器、快捷键、“==”做比较、获取代码运行时间、打印对象名时不会出现内存地址的类型、Arrays类常用方法、循环标号的使用、Lambda表达式、异常处理、Java浮点数的精度问题（BigDecimal）、DecimalFormat格式化数字工具、printf格式化输出
08.常见文本处理工具
最新发布
weixin_56408536的博客
08-18 490
查看二进制文件的不同。
JavaScript 核心基础：类型检测、DOM 操作与事件处理
热爱音乐和二次元！
08-15 1326
本文系统梳理 JavaScript 核心知识点，包括数据类型检测规则、遍历方式、DOM操作和事件处理。重点解析 typeof 运算符对不同数据类型的检测结果，数组与对象的遍历方法差异，以及使用 querySelector 获取元素的现代方案。同时详细讲解事件绑定的两种方式（onclick 覆盖 vs addEventListener 多播）和事件冒泡机制，帮助开发者构建扎实的 JS 基础，写出更健壮的代码。
cat本地部署
Chaser______的博客
08-15 721
CAT监控系统部署指南 环境准备：JDK1.8、Tomcat、MySQL 获取CAT包：通过Git克隆源码或下载官网war包 部署步骤： 创建/data目录结构并设置权限 配置client.xml、datasources.xml和server.xml 导入SQL文件创建数据库 将cat.war部署到Tomcat的webapps目录 启动服务：启动Tomcat后访问http://ip:8080/cat 注意事项：将配置文件中的127.0.0.1替换为实际IP地址 （98字）
蓝凌EKP产品：JSP 性能优化和 JSTL/EL要点检查列表
wwwhongxia的专栏
08-17 970
使用或获取 Spring BeanFilter 本身由 Tomcat 管理，但业务逻辑由 Spring 管理支持 Redis 缓存、限流、统计等功能JSP 内置对象作用域优化临时页面变量使用page作用域避免使用 request/session/application 存储短期临时数据提升性能，降低内存压力。
Java集合Map与Stream流：Map实现类特点、遍历方式、Stream流操作及Collections工具类方法
FUYY'S BLOG
08-15 733
Stream流是Java 8引入的处理集合数据的高级工具，它不是数据结构，而是数据处理管道，可以对集合、数组等数据源进行高效的聚合操作（如过滤、排序、统计等）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值