[Curator] Node Cache 的使用与分析

最新推荐文章于 2024-06-06 09:32:11 发布
最新推荐文章于 2024-06-06 09:32:11 发布
阅读量2k 收藏
点赞数 1
文章标签： java
原文链接：https://my.oschina.net/roccn/blog/918458
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

Node Cache

使用节点数据作为本地缓存使用。这个类可以对节点进行监听，能够处理节点的增删改事件，数据同步等。 还可以通过注册自定义监听器来更细节的控制这些数据变动操作。

1. 关键 API

org.apache.curator.framework.recipes.cache.NodeCache

org.apache.curator.framework.recipes.cache.NodeCacheListener

org.apache.curator.framework.recipes.cache.ChildData

2. 机制说明

  • 仅仅是单个数据的缓存
  • 内部使用状态机作为不同操作的处理控制

3. 用法

3.1 创建

public NodeCache(CuratorFramework client,
                         String path)

3.2 使用

还是一样的套路，在使用前需要调用start()；用完之后需要调用close()方法。

随时都可以调用getCurrentData()获取当前缓存的状态和数据。

也可以通过getListenable()获取监听器容器，并在此基础上增加自定义监听器：

public void addListener(NodeCacheListener listener)

4. 错误处理

NodeCache实例已经自带一个ConnectionStateListener处理链接状态的变化。

5. 源码分析

5.1 类定义

public class NodeCache implements Closeable{}
  • 实现了java.io.Closeable

5.2 成员变量

public class NodeCache implements Closeable
{
    private final Logger log = LoggerFactory.getLogger(getClass());
    private final CuratorFramework client;
    private final String path;
    private final boolean dataIsCompressed;
    private final AtomicReference<ChildData> data = new AtomicReference<ChildData>(null);
    private final AtomicReference<State> state = new AtomicReference<State>(State.LATENT);
    private final ListenerContainer<NodeCacheListener> listeners = new ListenerContainer<NodeCacheListener>();
    private final AtomicBoolean isConnected = new AtomicBoolean(true);
    private ConnectionStateListener connectionStateListener = new ConnectionStateListener()
    {
        @Override
        public void stateChanged(CuratorFramework client, ConnectionState newState)
        {
            if ( (newState == ConnectionState.CONNECTED) || (newState == ConnectionState.RECONNECTED) )
            {
                if ( isConnected.compareAndSet(false, true) )
                {
                    try
                    {
                        reset();
                    }
                    catch ( Exception e )
                    {
                        ThreadUtils.checkInterrupted(e);
                        log.error("Trying to reset after reconnection", e);
                    }
                }
            }
            else
            {
                isConnected.set(false);
            }
        }
    };

    private Watcher watcher = new Watcher()
    {
        @Override
        public void process(WatchedEvent event)
        {
            try
            {
                reset();
            }
            catch(Exception e)
            {
                ThreadUtils.checkInterrupted(e);
                handleException(e);
            }
        }
    };

    private enum State
    {
        LATENT,
        STARTED,
        CLOSED
    }

    private final BackgroundCallback backgroundCallback = new BackgroundCallback()
    {
        @Override
        public void processResult(CuratorFramework client, CuratorEvent event) throws Exception
        {
            processBackgroundResult(event);
        }
    };
}
  • log
  • client
  • path
    • 节点路径
  • dataIsCompressed
    • 数据是否压缩
  • data
    • AtomicReference
    • 存放着本地缓存数据
    • 缓存数据被封装成ChildData
  • state
    • AtomicReference
    • 状态
    • 内部枚举
      • LATENT （默认）
      • STARTED
      • CLOSED
  • listeners
    • org.apache.curator.framework.listen.ListenerContainer
    • 监听器容器
  • isConnected
    • 是否已连接ZK
    • AtomicBoolean
  • connectionStateListener
    • 自带的链接状态监听器
  • watcher
    • 自带的节点监听器
    • 一旦节点变动，则调用reset()重置
  • backgroundCallback
    • 节点数据回调操作
    • 避免线程阻塞

5.3 构造器

public NodeCache(CuratorFramework client, String path)
{
    this(client, path, false);
}

public NodeCache(CuratorFramework client, String path, boolean dataIsCompressed)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    this.dataIsCompressed = dataIsCompressed;
}

构造器很简单，就是赋值处理。 所以，大部分逻辑还是在start()中。

5.4 启动

public void     start() throws Exception
{
    start(false);
}

public void     start(boolean buildInitial) throws Exception
{
    Preconditions.checkState(state.compareAndSet(State.LATENT, State.STARTED), "Cannot be started more than once");

    client.getConnectionStateListenable().addListener(connectionStateListener);

    if ( buildInitial )
    {
        client.checkExists().creatingParentContainersIfNeeded().forPath(path);
        internalRebuild();
    }
    reset();
}

private void     internalRebuild() throws Exception
{
    try
    {
        Stat    stat = new Stat();
        byte[]  bytes = dataIsCompressed ? client.getData().decompressed().storingStatIn(stat).forPath(path) : client.getData().storingStatIn(stat).forPath(path);
        data.set(new ChildData(path, stat, bytes));
    }
    catch ( KeeperException.NoNodeException e )
    {
        data.set(null);
    }
}

private void     reset() throws Exception
{
    if ( (state.get() == State.STARTED) && isConnected.get() )
    {
        client.checkExists().creatingParentContainersIfNeeded().usingWatcher(watcher).inBackground(backgroundCallback).forPath(path);
    }
}

可以看到

  • 默认是不进行缓存数据的初始化的

再来看看启动的过程

  1. 原子操作更新启动状态
  2. 为链接添加connectionStateListener监听器
  3. 如果需要初始化缓存
    1. 创建节点
    2. 调用internalRebuild(),初始数据
      1. 同步节点数据与状态
      2. 写入本地缓存
  4. 调用reset()
    1. 在正常状态时检查缓存节点是否存在
      • 第3步可能是不错初始化动作的
      • 为节点添加了watcher
      • 回调触发backgroundCallback
        • 调用processBackgroundResult()方法（状态机）

5.4.1 processBackgroundResult方法

启动逻辑很大一部分在processBackgroundResult方法中。所以，这里再来看看这个方法：

private void processBackgroundResult(CuratorEvent event) throws Exception
{
    switch ( event.getType() )
    {
        case GET_DATA:
        {
            if ( event.getResultCode() == KeeperException.Code.OK.intValue() )
            {
                ChildData childData = new ChildData(path, event.getStat(), event.getData());
                setNewData(childData);
            }
            break;
        }

        case EXISTS:
        {
            if ( event.getResultCode() == KeeperException.Code.NONODE.intValue() )
            {
                setNewData(null);
            }
            else if ( event.getResultCode() == KeeperException.Code.OK.intValue() )
            {
                if ( dataIsCompressed )
                {
                    client.getData().decompressed().usingWatcher(watcher).inBackground(backgroundCallback).forPath(path);
                }
                else
                {
                    client.getData().usingWatcher(watcher).inBackground(backgroundCallback).forPath(path);
                }
            }
            break;
        }
    }
}

由于启动在先，所以先来看看EXISTS事件：

  1. 如果节点不存在
    1. 调用setNewData(null),设置数据为null
  2. 如果节点存在
    1. 如果数据需要压缩处理
      1. 则解压获取值
    2. 否则直接获取数据
  • 好吧，这里又是通过backgroundCallback来回调获取值，所以，又会以新的新的状态回到processBackgroundResult
    • GET_DATA
    • 状态机

再来看看GET_DATA事件：

  1. 如果读取正常
    1. 构建childData
    2. 调用setNewData，赋值

5.4.2 setNewData方法

如此看来，还需要看看setNewData方法：

private void setNewData(ChildData newData) throws InterruptedException
{
    ChildData   previousData = data.getAndSet(newData);
    if ( !Objects.equal(previousData, newData) )
    {
        listeners.forEach
        (
            new Function<NodeCacheListener, Void>()
            {
                @Override
                public Void apply(NodeCacheListener listener)
                {
                    try
                    {
                        listener.nodeChanged();
                    }
                    catch ( Exception e )
                    {
                        ThreadUtils.checkInterrupted(e);
                        log.error("Calling listener", e);
                    }
                    return null;
                }
            }
        );

        if ( rebuildTestExchanger != null )
        {
            try
            {
                rebuildTestExchanger.exchange(new Object());
            }
            catch ( InterruptedException e )
            {
                Thread.currentThread().interrupt();
            }
        }
    }
}
  1. 本地缓存data赋新值
  2. 如果发现缓存有更新
    1. 触发监听容器中的监听器（同步调用）
    2. rebuildTestExchanger
      • 这个可以基本略过
      • 测试时向其他现场发送一个信号对象
5.4.3 小结

启动过程大致可以分为

  1. 添加链接监听器
  2. 如果需要初始化节点，则创建节点，并拉取缓存数据到本地
  3. 为节点加上节点监听器，并挂载回调方法
  4. 通过回调状态机来同步缓存数据

5.5 获取缓存数据

public ChildData getCurrentData()
{
    return data.get();
}

直接读取缓存数据。 对使用者来说，只需要操作本地缓存。 而本地缓存与ZK节点数据，通过监听器回调状态机来完成同步动作。

5.6 关闭

缓存用完，需要调用close()

public void close() throws IOException
{
    if ( state.compareAndSet(State.STARTED, State.CLOSED) )
    {
        listeners.clear();
        client.clearWatcherReferences(watcher);
        client.getConnectionStateListenable().removeListener(connectionStateListener);

        // TODO
        // From PathChildrenCache
        // This seems to enable even more GC - I'm not sure why yet - it
        // has something to do with Guava's cache and circular references
        connectionStateListener = null;
        watcher = null;
    }        
}
  • 原子操作更新状态
  • 清理监听器容器
  • 清理掉节点上监听器
  • 清理掉链接上的监听器

并没有制空本地缓存数据

6. 小结

与Path Cache比起来，Node Cache要简单很多。

  • Path Cache
    • 更像是一个Cache Manager
    • 在path下管理着多个cache
    • 由于多个cache的存在
      • 同步逻辑复杂
      • 并发问题更为严重
        • 所以内部使用了
          • 命令模式
          • 异步按序执行操作
  • Node Cache
    • 仅仅是单个数据的缓存
    • 而且缓存数据的特性，也无需严格控制并发（脏数据也可以接受）
    • 使用一个回调状态机来处理不同的数据状态

转载于:https://my.oschina.net/roccn/blog/918458

csid_502
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Nodecache最适合国内地区的免备案CDN推荐!
qq_38452232的博客
12-15 1750
自己的一个网站，因为服务器是海外的，虽然速度还不错，但延迟和丢包问题经常困扰着我。尤其是到了晚上，丢包情况就更加严重，所以需要一款免备案、有香港节点的CDN来提升一下访问体验。查了下资料，很多人推荐使用Nodecache，用了一段时间后感觉 Nodecache 确实还不错，下面给大家介绍一下。 Nodecache是GlobalCache Technology Co., Ltd.旗下品牌，致力于为客户提供一站式的在线业务加速服务。Nodecache 主要提供的就是 免备案CDN 加速、SSL证书、DNS
Node学习笔记
卜司的博客
03-22 1318
一、安装node 1、下载node https://www.runoob.com/nodejs/nodejs-install-setup.html 2、安装npm 安装前确认无npm 环境变量里面也没有 C:\Users\bobo\AppData\Roaming下也没有node有关的 有全部删除 参考 https://www.cnblogs.com/aeolian/p/12457284.html https://www.bilibili.com/video/BV1VK4y1v7TK?from=search&
ZooKeeper监听功能实现
天瑕的博客
09-03 1755
ZooKeeper监听功能实现
推荐开源项目：Node.js的高效缓存管理器——cache-manager-redis-store
最新发布
gitblog_00078的博客
06-06 854
推荐开源项目：Node.js的高效缓存管理器——cache-manager-redis-store 项目地址:https://gitcode.com/dabroek/node-cache-manager-redis-store 项目介绍 cache-manager-redis-store 是一个专为 node-cache-manager 设计的Redis缓存存储库。这个简洁的包提供了一个高效的解决...
NodeCache
kongkong的专栏
08-26 930
http://curator.apache.org/curator-recipes/node-cache.html Participating Classes NodeCache NodeCacheListener ChildData Usage Creating a NodeChildrenCache public NodeCache(CuratorFramework client, String path) Parameters: clie
node安装后的设置(node_global和node_cache) - windows
热门推荐
scorpio_meng的博客
10-23 6万+
之前安装node后就进行了demo的测试和学习，从网上拉取包的有时候不知道放在什么地方了，c盘也有，当前项目目录也有，挺乱的。 使用npm安装模块分为本地安装和全局安装。 本地安装：npm install express 会安装到当前项目 全局安装：npm install express -g 会安装到指定的目录(node_global) 另外，如果没有设置全局目录node_glo...
5、zookeeper的java -Curator（服务注册与发现）
05-29
本文介绍使用zookeeper的Curator类库实现服务的注册与发现。 该示例会涉及到本专栏下的其他文章，比如：4、zookeeper的java三种客户端介绍-Curator（crud、事务操作、监听、分布式计数器、分布式锁） 等文章，都是在...
Zookeeper客户端Curator Framework使用代码
05-05
本篇文章将深入探讨Curator Framework的主要功能、使用方法以及示例代码。 1. **Zookeeper基础** Zookeeper是一个分布式协调服务，常用于管理配置信息、命名服务、集群状态同步、分布式锁等场景。它采用的是主从...
使用curator实现zookeeper锁服务的示例分享
09-04
然而，直接使用Zookeeper API进行锁服务的开发较为复杂，这时就需要像Curator这样的客户端库来简化操作。本文将详细介绍如何使用Curator实现Zookeeper的锁服务，并提供一个具体的示例。 首先，我们需要了解Curator...
zk使用curator实现分布式锁
09-20
在分布式系统中，确保数据的一致性和正确性是至关重要的，而ZooKeeper与Curator的结合使用就是解决这一问题的有效方案。ZooKeeper是一个高度可靠的分布式协调服务，它提供了诸如分布式锁、队列和配置管理等核心功能...
zookeeper(java使用curator操作zooke.emmx
07-18
使用mindmaster打开
npm-nodecache:简单而强大的NodeJS缓存模块
05-22
简单而强大的NodeJS缓存模块。 安装方式： npm install nodecache 用法 将数据保存在内存中，仅当当前不在内存中时才调用cache.save的第二个参数。 var cache = require ( 'nodecache' ) ; var myFunction = function ( ) { ... return 'Some Data' ; } ; var myData = cache . save ( 'myData' , myFunction ) ; // This will call myFunction() and return 'Some Data'. var myCachedData = cache . save ( 'myData' , myFunction ) ; // This will return 'Some Dat
node-cache：一个简单的针对nodejs的内存中缓存
02-28
内存缓存 一个简单的针对node.js的内存缓存 安装 npm install memory-cache --save 用法 var cache = require ( 'memory-cache' ) ; // now just use the cache cache . put ( 'foo' , 'bar' ) ; console . log ( cache . get ( 'foo' ) ) ; // that wasn't too interesting, here's the good part cache . put ( 'houdini' , 'disappear' , 100 , function ( key , value ) { console . log ( key + ' did ' + value ) ; } ) ; // Time in ms con
zookeeper分布式集群中Curator的NodeCache监测特定节点数据更新添加删除
Zhang Phil
09-09 1139
zookeeper分布式集群中Curator的NodeCache监测特定节点数据更新添加删除 import org.apache.curator.RetryPolicy; import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFrameworkFac...
java使用curator在集群zkserver中创建watcher事件(usingWatcher，NodeCache一次注册N次监听NodeCacheListener）
qq_37432174的博客
12-11 422
补
java 持久监听blockqueue的变化_Curator目录监听
weixin_39728221的博客
02-28 467
Curator目录监听write by donaldhan, 2018-06-29 09:40引言上一篇文章，我们简单看一下Curator的CDRWA相关的构造器，及Curator框架实现，[Curator][]框架工厂CuratorFrameworkFactory内部，主要成员变量为默认的会话超时与连接超时时间，本地地址，字节压缩器GzipCompressionProvider，默认的Zooke...
（八）Dubbo常见的错误总结
HaC 的博客
12-29 4430
dubbo常见错误总结
zookeeper入门之Curator的使用之几种监听器的使用
筑梦者
05-18 2万+
package com.git.zookeeper.passwordmanager.listener; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import org.
ClassNotFoundException: org.apache.curator.framework.recipes.cache.TreeCacheListener
weixin_44451520的博客
05-15 1653
并没有找到合适的解决方法， 用中文搜索锁不到，重新加maven依赖也不好使，用英文搜索在github上说是版本的问题，说2.6.0版本不行，我把curator-recipes和curator-framework的版本由2.12换成2.8.0解决，
org.apache.curator.framework.recipes.cache.TreeCache:handleException| java.util.ConcurrentModificationException: null at java.util.HashMap$HashIterator.nextNode(HashMap.java:1445) at java.util.HashMap$EntryIterator.next(HashMap.java:1479) at java.util.HashMap$EntryIterator.next(HashMap.java:1477)
06-10
这是一段Java程序的异常信息，具体是HashMap的并发修改异常。这种异常通常是因为在多个线程同时修改HashMap时，导致HashMap的结构发生变化，从而出现异常。为了解决这个问题，可以使用线程安全的Map实现，如ConcurrentHashMap，或者在对HashMap进行修改时使用线程同步机制，如synchronized关键字。此外，还可以尽量避免在多线程环境下对同一个HashMap进行修改操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值