Zookeeper-核心概念(Znode、Stat、Watcher、ACL、ZkClient、Curator、分布式配置中心、分布式锁、分布服务注册订阅)

最新推荐文章于 2023-07-26 12:45:32 发布
最新推荐文章于 2023-07-26 12:45:32 发布
阅读量405 收藏 4
点赞数 2
分类专栏： 分布式框架 文章标签： zookeeper 分布式 配置中心 分布式锁 分布式服务注册与订阅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44642403/article/details/118078103
版权

Zookeeper核心概念

Zookeeper是什么？

简单来说Zookeeper和Mysql，Redis一样都是用于存储数据的一个服务，那么Zookeeper有什么特点呢？

Zookeeper是一个典型的分布式数据一致性的解决方案，分布式应用程序可以基于它实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能

在这里插入图片描述

Zookeeper的数据结构

Zookeeper的存储方式与以往我们使用的mysql、redis不一样，Zookeeper存储方式更加像一个文件系统，整个Zookeeper只有一个根节点/在存储文件时，就像平时我们使用的文件夹一样，每一个文件夹(节点)会对应着一些数据，每一个文件夹里面也可能还有文件夹(子节点)，并且同一级文件夹的名字是不允许重复的

在这里插入图片描述

Zookeeper简单使用

首先使用简单的命令creat、ls、get，对Zookeeper进行节点创建

create(创建节点) /userApp(节点名称) userApp(该节点对应保存的数据)，ls /userApp(查看/userApp节点下的子节点)

在这里插入图片描述

znode

Zookeeper操作和维护的一个个数据节点，称为znode，经过上面我们执行的create命令后Zookeeper中最终的数据结构如下，可以看出我们创建的每一个文件夹都是一个节点

在这里插入图片描述

znode的类型

znode共有4种类型：持久无序、临时无序、持久有序、临时有序

属性命令说明
PERSISTENT(默认)create持久无序类型，创建的节点需手动删除否则一直存在
PERSISTENT_SEQUENTIALcreate -s持久有序类型，创建节点也需要手动删除，并且创建的节点会自动在后面加上一个自增序号
EPHEMERALcreate -e临时无序的，创建节点客户端在session失效就会自动删除节点，没有子节点
EPHEMERAL_SEQUENTIALcreate -es临时有序的，创建节点客户端session失效就会删除节点，并且创建的节点会自动在后面加上一个自增序号

Stat数据结构

Stat中记录这个Znode的3个数据版本信息

通过get -s命令可以获取节点状态信息、版本、权限相关

在这里插入图片描述

属性说明
cZxid节点创建时的zxid(在整个集群中是唯一的)
ctime节点创建时的时间戳
mZxid节点最新一次更新发生时的zxid
mtime节点最新一次更新发生的时间戳
cversion其子节点的更新次数
dataVersion节点数据的更新次数
aclVersion节点的ACL(授权信息)的更新次数
ephemeralOwner如果节点是EPHEMERAL(临时节点)，ephemeralOwner的值表示该节点绑定的sessionId如果该节点不是EPHEMERAL=0
dataLength节点数据的字节数
numChildren子节点个数

更新节点内容查看Stat的变化

在这里插入图片描述

Session会话

每一个客户端与Zookeeper建立的是TCP/IP长连接，客户端的连接有3种状态，分别是连接中、连接成功、断开连接

状态说明
CONNECTING连接中
CONNECTED连接成功
CLOSED断开连接

watcher事件监听器

Watcher(事件监听器)，是Zookeeper中一个很重要的特性，Zookeeper允许用户在指定的znod(节点)上注册一些Wathcher，并且在一些特定事件触发的时候，Zookeeper服务端会将事件通知到感兴趣的客户端上面，该机制是Zookeeper实现分布式协调服务的重要特性

在这里插入图片描述

事件类型

KeeperStateEventType触发条件说明操作
SyncConnected(3)None(-1)客户端与服务端成功建立连接此时客户端和服务器处于连接状态
SyncConnected(3)NodeCreated(1)数据节点被创建此时客户端和服务器处于连接状态create /xxx
SyncConnected(3)NodeDeleted(2)数据节点被删除此时客户端和服务器处于连接状态delete /xxx
SyncConnected(3)NodeDataChang(3)数据节点被修改此时客户端和服务器处于连接状态set /xxx
SyncConnected(3)NodeChildChang(4)数据节点的子节点列表发送改变此时客户端和服务器处于连接状态create /xxx/xxx
set /xxx/xxx
delete /xxx/xxx
Disconnect(0)Node(-1)客户端与Zookeeper服务断开连接此时客户端与服务器处于断开连接状态
Expired(-112)Node(-1)会话超时此时客户端会话失效，通常同时也会收到SessionExpiredException异常
AuthFailed(4)None(-1)通常有2种情况
1、使用错误的schema进行权限检查
2、SASL权限检查失效		通常同时也会收到AuthFailedException异常

ACL访问控制

ACL(Access Control List)，对节点进行认证授权，那些节点访问需要认证，对那些节点操作需要权限

认证类型

类型说明
world(默认)所有客户端都可以访问
auth认证通过的用户才能访问cli中使用 addauth digest user:pwd来添加授权用户
digest通过用户名:密码这种方式认证，这也是业务系统最常用的
ip使用IP地址认证

权限类型

类型说明
CREATE能创建子节点
READ能获取节点数据和列出子节点
WRITE能设置节点数据
DELETE能删除子节点
ADMIN能设置权限

查看认证类型与权限类型

'world,'anyone：所有客户端都可以访问

: cdrwa：所有权限都可以操作(cdrwa对应权限各类型首字母)

在这里插入图片描述

实战练习

刚刚演示的都是在Liunx上使用命令行对Zookeeper进行操作，那么接下来实战练习使用的是java客户端连接Zookeeper并且进行相应的操作

原生API

使用Zookeeper原生的API完成CRUD

依赖引入
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.9</version>
</dependency>
增删改查
ZookeeperCrud

首先是最简单的CRUD

public class ZookeeperCrud {

    private String connectString="192.168.100.101:2181";
    private ZooKeeper zooKeeper;

    /**
     * 建立连接
     */
    public ZookeeperCrud() {
        try {
            this.zooKeeper = new ZooKeeper(connectString,5000,new ZookeeperWatcher());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建一个持久无序、无权限控制节点
     * @param path 路径
     * @param data 数据
     * @return
     */
    public String createPersistent(String path,String data){
        try {
            return zooKeeper.create(path,data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 创建一个临时无序、无权限控制节点
     * @param path 路径
     * @param data 数据
     * @return
     */
    public String createEphemeral(String path,String data){
        try {
            return zooKeeper.create(path,data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 更新信息
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String getData(String path) throws KeeperException, InterruptedException {
        byte data[] = zooKeeper.getData(path,false,null);
        data = (data == null)? "null".getBytes() : data;
        return new String(data);
    }


    /***
     * 更新信息
     * @param path
     * @param data
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat setData(String path, String data) throws KeeperException, InterruptedException {
        return zooKeeper.setData(path, data.getBytes(), -1);
    }

    /***
     * 是否存在
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat exists(String path) throws KeeperException, InterruptedException {
        return zooKeeper.exists(path,false);

    }


    /***
     * 删除
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void delete(String path) throws KeeperException, InterruptedException {
        zooKeeper.delete(path,-1);
    }
    /***
     * 删除 递归
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void deleteRecursive(String path) throws KeeperException, InterruptedException {
        ZKUtil.deleteRecursive(zooKeeper, path);
    }

    /**
     * 隔壁客户端连接
     * @throws InterruptedException
     */
    public void close() throws InterruptedException {
        zooKeeper.close();
    }
}
ZookeeperCrudTest

编写测试类，报错信息是由于没有设置监听器而提示的空指针占时忽略，现在关注的是能不能完成CRUD操作，可以看到添加了一个节点并且打印了节点内容

在这里插入图片描述

事件监听
ZookeeperWatcher

ZookeeperWatcher对原来的ZookeeperCrud进行增强，实现了事件监听，并且可以设置事件监听

public class ZookeeperWatcher implements Watcher {

    private String connectString="192.168.100.101:2181";
    private ZooKeeper zookeeper;

    public ZookeeperWatcher() {
        try {
            this.zookeeper = new ZooKeeper(connectString, 5000,this);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /***
     * 创建持久节点
     * @param path
     * @param data
     * @return
     */
    public String createPersistent(String path,String data){
        try {
            return  zookeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return  null;
    }


    /***
     * 创建临时节点
     * @param path
     * @param data
     * @return
     */
    public String createEphemeral(String path,String data){
        try {
            return  zookeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return  null;
    }
    
    /***
     * 删除
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void delete(String path) throws KeeperException, InterruptedException {
        zookeeper.delete(path,-1);
    }
    /***
     * 删除
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void deleteRecursive(String path) throws KeeperException, InterruptedException {
        ZKUtil.deleteRecursive(zookeeper, path);
    }

    public void close() throws InterruptedException {
        zookeeper.close();
    }
    
    //新增方法如下====================================================================================

    /***
     * 更新信息
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String getData(String path,boolean watcher) throws KeeperException, InterruptedException {
        byte data[] = zookeeper.getData(path,watcher,null);
        data = (data == null)? "null".getBytes() : data;
        return new String(data);
    }


    /***
     * 更新信息
     * @param path
     * @param data
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat setData(String path, String data) throws KeeperException, InterruptedException {
        return zookeeper.setData(path, data.getBytes(), -1);
    }

    /***
     * 是否存在
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat exists(String path,boolean watcher) throws KeeperException, InterruptedException {
        return zookeeper.exists(path,watcher);

    }

    @Override
    public void process(WatchedEvent event) {
        // 连接状态
        Event.KeeperState keeperState = event.getState();
        // 事件类型
        Event.EventType eventType = event.getType();
        // 受影响的path
        String path = event.getPath();

        System.out.println("连接状态:"+keeperState+",事件类型："+eventType+",受影响的path:"+path);
        System.out.println("--------------------");
        if (Event.EventType.None.equals(eventType)){

        }

        try {
            if(null != path && null != this.exists(path,true)) {
                System.out.println("内容:"+ this.getData(path, true));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
ZookeeperWatcherTest

设置监听节点，当节点发送改变时会触发事件

在这里插入图片描述

权限控制
ZookeeperAcl

ZookeeperWatcher对原来的ZookeeperAcl进行增强，增加了可以创建需要权限控制的节点

public class ZookeeperAcl {

    private String connectString = "192.168.100.101:2181";
    private ZooKeeper zooKeeper;
    /**
     * 认证类型
     */
    final static String scheme = "digest";
    final static String auth = "jolyoulu:123";//用户名:密码

    /**
     * 创建连接
     * @param acl 是否开启认证
     */
    public ZookeeperAcl(boolean acl) {
        try {
            this.zooKeeper = new ZooKeeper(connectString, 5000, null);
            if (acl){
                zooKeeper.addAuthInfo(scheme, auth.getBytes());//给当前客户端添加认证信息
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //新增方法===================================================================
    /***
     * 创建持久节点
     * @param path
     * @param data
     * @return
     */
    public String createPersistentAcl(String path, String data) {
        try {
            return zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.CREATOR_ALL_ACL, CreateMode.PERSISTENT);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
    //新增方法===================================================================

    /***
     * 创建持久节点
     * @param path
     * @param data
     * @return
     */
    public String createPersistent(String path, String data) {
        try {
            return zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }


    /***
     * 创建临时节点
     * @param path
     * @param data
     * @return
     */
    public String createEphemeral(String path, String data) {
        try {
            return zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 更新信息
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String getData(String path) throws KeeperException, InterruptedException {
        byte data[] = zooKeeper.getData(path, false, null);
        data = (data == null) ? "null".getBytes() : data;
        return new String(data);
    }


    /***
     * 更新信息
     * @param path
     * @param data
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat setData(String path, String data) throws KeeperException, InterruptedException {
        return zooKeeper.setData(path, data.getBytes(), -1);
    }

    /***
     * 是否存在
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public Stat exists(String path) throws KeeperException, InterruptedException {
        return zooKeeper.exists(path, false);

    }


    /***
     * 删除
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void delete(String path) throws KeeperException, InterruptedException {
        zooKeeper.delete(path, -1);
    }

    /***
     * 删除
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public void deleteRecursive(String path) throws KeeperException, InterruptedException {
        ZKUtil.deleteRecursive(zooKeeper, path);
    }

    public void close() throws InterruptedException {
        zooKeeper.close();
    }


}
ZookeeperAclTest

创建带权限控制的节点后，其它没有权限的客户端无法获取到节点信息

在这里插入图片描述

ZkClientAPI

ZkClient是对Zookeeper原生的API进一步分装，更加容易的使用，dubbo的是通过ZkClient操作Zookeeper的

github仓库：https://github.com/sgroschupf/zkclient.git

依赖引入
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.101tec/zkclient -->
<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.11</version>
</dependency>
快速上手

ZkClient使用起来也很简单，直接通过构造方法获取即可，并且也提供了多种的构造方法，如设置session超时，连接超时，序列化方式等，以下是简单的使用

在这里插入图片描述

增删改查

以create开头的方法都是创建节点，并且传参数的方式有多种，对象、容器等都可以``

在这里插入图片描述

以delete开头的方法都是删除节点

在这里插入图片描述

以write开头的方法都是修改节点

在这里插入图片描述

以read开头的方法都是读取节点内容

在这里插入图片描述

事件监听

ZkChild将来事件分为3类ChildListener、DataListener、StateListener

接口类注册监听的方法解除监听的方法说明
IZkChildListenersubscribeChildChanges(String path, IZkChildListener listener)unsubscribeChildChanges(String path, IZkChildListener childListener)监听当前节点子节点的变化
IZkDataListenersubscribeDataChanges(String path, IZkDataListener listener)unsubscribeDataChanges(String path, IZkDataListener dataListener)监听当前节点发送的变化
IZkStateListenersubscribeStateChanges(final IZkStateListener listener)unsubscribeStateChanges(IZkStateListener stateListener)监听连接状态
unsubscribeAll()解除所有监听器
ZkClientWatcher

在这里插入图片描述

运行测试，发现事件能成功触发，每执行完需要让线程休息一下，是为了让回调函数执行完毕，否则监听的回调未执行完毕然后又执行了下一个操作回调函数是不会被触发的，大家可以删除几个sleep看一下，会发现如果2次操作相隔太近不会触发回调

在这里插入图片描述

CuratorAPI

Curator是由Apache开源的，现在已经是apache的顶级开源项目了，Curator使用起来更加的灵活已经有更加丰富的功能，如链式调用、分布式锁、自动重连、队列等

Curator和原生的Zookeeper操作很像

依赖引入
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.9</version>
</dependency>
<!-- curator 基础框架 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.1.0</version>
</dependency>
<!-- curator 分布式锁、队列等 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>5.1.0</version>
</dependency>
<!-- 客户端重试策略 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-client</artifactId>
    <version>5.1.0</version>
</dependency>
增删改查
CuratorCrud
public class CuratorCrud {

    public CuratorFramework cf;

    public CuratorCrud() {
        //自动重连设置 初试时间1S，重试10次
        ExponentialBackoffRetry retry = new ExponentialBackoffRetry(1000, 10);
        cf = CuratorFrameworkFactory.builder()
                .connectString("192.168.100.101:2181")
                .sessionTimeoutMs(5000)
                .retryPolicy(retry)
                .build();
        cf.start();
    }


    /**
     * 创建一个无序持久节点
     * @param path
     * @param data
     * @return
     */
    public String createPersistent(String path,String  data){
        try {
            cf.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path,data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }

        return  null;
    }

    /**
     * 获取节点数据
     * @param path
     * @return
     */
    public String getData(String path){
        try {
            return new String(cf.getData().forPath(path));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  null;
    }


    /**
     * 删除节点
     * @param path
     */
    public void delete(String path){
        try {
            cf.delete().guaranteed().deletingChildrenIfNeeded().forPath(path);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    /**
     * 修改节点
     * @param path
     * @param data
     */
    public void setData(String path,String  data){
        try {
            cf.setData().forPath(path,data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
CuratorCrudTest

在这里插入图片描述

事件监听

事件监听其实和原生的Zookeeper操作差不多，也是传入的是Watcher

在这里插入图片描述

Zookeeper应用思路

分布式配置中心

什么是分布式配置中心？

随着我们的微服务的演变-架构学习笔记31到最后每一个业务都被拆分成多个服务，随着服务的增多随之而来的那就是服务的管理，以及数据一致性的问题，比如某天突然需要修改mysql配置，那么这里带来问题如果我们有100台服务那么岂不是要修改100个配置文件重启100次，这时就需要一个分布式配置中心，Zookeeper是一个很好的解决方案

  1. Zookeeper数据结构特性，可将来相同类型配置存放一起
  2. Zookeeper的Watcjer(监听机制）能够解决服务之间数据一致性问题
  3. 每个服务连接上Zookeeper获取整服务配置列表保存到本地，预防极端情况下整个Zookeeper宕机后也可以去本地服务列表获取相应服务保证高可用

在这里插入图片描述

分布式锁

利用Zookeeper的znode节点特性可以实现分布式锁，由于znode是不允许重复名称的那么表示如果有别的应用创建了该节点，其它应用想创建同一个节点时就会报错，那么利用这个特点就可以实现分布式锁，执行完毕后使用delete释放锁即可

在这里插入图片描述

分布式服务注册于订阅

什么是分布式服务注册于发现？

随着我们的微服务的演变-架构学习笔记31到最后每一个业务都被拆分成多个服务，随着服务的增多随之而来的那就是那些服务能够正常访问、那些服务不能正常访问、我们当前有多少服务等问题，这时就需要一个分布式服务注册于订阅，Zookeeper是一个很好的解决方案

  1. Zookeeper数据结构特性，可将来相同类型服务存放一起
  2. Zookeeper的Watcjer(监听机制）若有服务宕机失去连接后zookeeper会通知订阅者

在这里插入图片描述

JolyouLu
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ZooKeeper - 四字命令解析
The Secret
04-07 1077
四字命令 操作方式 echo “ruok” | nc 192.168.0.106 2181 cons 输出当前服务器的所有客户端的连接信息 NIOServerCnxn代码： private class ConsCommand extends CommandThread { public ConsCommand(PrintWriter pw) { super...
分布式专题-分布式协调服务02-Zookeeper的核心原理
01-20
在分布式系统中，Zookeeper作为一个重要的分布式协调服务，它的核心原理和设计对于理解和构建高可用、高性能的分布式架构至关重要。Zookeeper的诞生源于雅虎为了解决内部系统间的分布式协调需求，因谷歌的Chubby不...
【Apache ZooKeeper】为ZNode设置watcher
云原生社区博客分享
09-17 4799
Apache ZooKeeper监控ZNode并为其设置watcher。
zookeeper c api 之Stat结构
weixin_33863087的博客
03-14 118
在头文件zookeeper.jute.h中，找到Stat这个结构，首先需要明白这个变量的特点： 1 存在大部分的zookeeper c api的参数中 2 作为znode的节点信息变量传递出去，供外部查询和使用 结构声明如下： struct Stat { int64_t czxid; int64_t mzxid; int64_t ctime; int64_t mti...
ZooKeeper的stat结构
大叶子不小的博客
05-25 854
ZooKeeper命名空间中的每个znode都有一个与之关联的stat结构，类似于Unix/Linux文件系统中文件的stat结构。 znode的stat结构中的字段显示如下，各自的含义如下： cZxid：这是导致创建znode更改的事务ID。 mZxid：这是最后修改znode更改的事务ID。 pZxid：这是用于添加或删除子节点的znode更改的事务ID。 ctime：表示从1970-01-01T00:00:00Z开始以毫秒为单位的znode创建时间。 mtime：表示从1970-01-01T
Zookeeper学习：Zookeeper 简介
小松de博客
10-22 243
1. 概述 Zookeeper 是一个开源的分布式的，为分布式应用提供协调服务的 Apache 项目 Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理数据，然后接受观察者的注册，一旦这些数据的状态发生变化 ，Zookeeper就将负责通知已经在Zookeeper上注册那些观察者做出相应的反应。 2. 特点 Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群。 集群中只要有半数以上节点存活，Zooke
Java-zookeeper实践代码(分布式锁/注册中心)
11-23
在压缩包`zookeeperCase`中，可能包含了实现这些功能的Java代码示例，包括创建Zookeeper客户端连接、创建和删除ZNode、监听节点变化、实现分布式锁逻辑以及服务注册和发现的相关类。通过学习和分析这些代码，可以...
5、zookeeper的java -Curator（服务注册与发现）
05-29
总的来说，Zookeeper结合Curator的`ServiceDiscovery`机制，为分布式系统中的服务提供了一种可靠、灵活的注册与发现方案。开发者可以通过上述接口轻松地实现服务的生命周期管理和查找，确保服务之间的通信稳定可靠。...
一文彻底理解ZooKeeper分布式锁的实现原理
01-20
ZooKeeper，简称zk，作为一个高可用的分布式协调服务，常被用于构建分布式系统中的各种组件，如分布式锁。在本篇文章中，我们将深入探讨如何利用Curator这个流行的开源框架，实现基于ZooKeeper的分布式锁。 一、...
Zookeeper分布式应用程序协调服务：zookeeper-3.4.13
12-10
Zookeeper-3.4.13是该服务的一个稳定版本，提供了多种关键功能，以支持大规模分布式系统的运行。 首先，Zookeeper的核心功能之一是**配置管理**。在分布式环境中，各个节点需要共享和同步配置信息。Zookeeper提供了...
Zookeeper中Stat结构体
weixin_38932035的博客
12-19 196
czxid 创建节点的事务zxid 每次修改ZooKeeper状态都会收到一个zxid形式的时间戳，也就是ZooKeeper事务ID。 事务ID是ZooKeeper中所有修改总的次序。每个修改都有唯一的zxid，如果zxid1小于zxid2，那么zxid1在zxid2之前发生。 ctime znode被创建的毫秒数(从1970年开始) mzxid znode最后更新的事务zxid mtime z...
zookeeper：znode
weixin_33860722的博客
06-04 276
overview zookeeper内部存储数据的数据结构是一棵树，类似于linux文件系统的组织方式。最上层有一个根节点 /，根节点下有子节点，字节点下又能递归地拥有子节点。没有任何子节点的节点称之为叶子节点。在zookeeper的术语中，节点称之为znode。 zookeeper只是在内存中维护这样一份树状的数据结构，并没有直接提供分...
Zookeeper中stat结构体参数介绍
TomAndersen的博客
02-20 842
stat结构体示例 [zk: localhost:2181(CONNECTED) 1] stat / cZxid = 0x0 ctime = Thu Jan 01 08:00:00 CST 1970 mZxid = 0x0 mtime = Thu Jan 01 08:00:00 CST 1970 pZxid = 0x300000002 cversion = 0 dataVersion = 0 ac...
Zookeeper ZNode Stat对象信息解析
恐龙弟旺仔的博客
06-19 765
Zookeeper的视图结构和标准的UNIX文件系统类似，整个结构也是以树形目录结构展现的。Zookeeper中的每个节点称为ZNode，每个ZNode上既可以保存数据，也可以挂载子节点。关于ZNode，不仅可以存储数据，节点本身也有一些状态信息（Stat），本文就来分析下这个Stat信息。我们随意创建一个节点，可以使用Zookeeper客户端命令，如下所示： 我们来逐个看下这些参数的含义cZxid即create zxid的缩写（创建该节点的事务ID），每一次事务操作都会有一个特定的zxid来代表当前事
zookeeper DataTree内存模型介绍及对Znode的四大特性介绍和Stat结构分析
weixin_30411997的博客
03-07 153
一、 zookeeper的内存模型 　 　 1. zookeeper是一个由 znode节点组成的一个树形结构 　　2. 每个znode都可以做成一个subject。。。 　　 3. 客户端可以监控每一个节点。（比如说在datamip添加一个子节点，客户端会接收到通知） 二、 znode具有那些类型 1. 持久性的znode 　　zookee...
zookeeper的stat的结构体介绍
sinat_27818621的博客
08-30 268
cZxid： 创建该znode(节点)的事务ID。 ctime：表示从1970-01-01T00:00:00Z开始以毫秒为单位的znode(节点)创建时间。 mZxid：最后修改znode(节点)更改的事务ID。 mtime：表示从1970-01-01T00:00:00Z开始以毫秒为单位的znode最近修改时间。 pZxid：这是用于添加或删除该znode(节点)的子节点的更改的事务ID，如果该znode没有子节点，那么这个值就是当前节点的cZxid(创建事物ID)。 dataVersion：表示对该z..
Zookeeper-内部原理，选举机制，stat结构介绍，监听器原理
一个写湿的程序猿
07-29 411
Zookeeper-内部原理，选举机制，stat结构介绍，监听器原理 文章目录Zookeeper-内部原理，选举机制，stat结构介绍，监听器原理节点类型Stat结构体参数介绍监听器原理选举机制写数据流程 节点类型 Stat结构体参数介绍 （1）czxid - znode 创建节点的事务zxid 每次修改ZooKeeper状态都会收到一个zxid形式的时间戳，也就是ZooKeeper事务ID。 事务ID是ZooKeeper中所有修改总的次序。每个修改都有唯一的zxid，如果zxid1小于zxid2
大数据之Zookeeper（三）-Zookeeper内部原理（选举机制、节点类型、Stat结构体、监听器原理和写数据流程）
jQueryZK的博客
10-06 3086
1、Zookeeper内部选举机制 1、半数机制： 集群中必须要有半数以上机器存活，集群才可以正常使用。 （Zookeeper适合安装奇数台服务器） 2、Zookeeper虽然在配置文件中并没有指定Master和Slave。但是，Zookeeper工作时，是有一个节点为Leader，其他则为Follower，Leader是通过内部选举机制临时产生的 3、以一个简单的例子来说明整个选举的过程 假设有五台服务器组成的Zookeeper集群，它们的id从1~5，同时它们都是最新启动的，也就是没有历史数据，在存放数
Zookeeper命令总结
最新发布
白羊座的橙子
07-26 3319
客户端注册监听它关心的目录节点，当目录节点发生变化（数据改变、节点删除、子目录节点增加删除）时，ZooKeeper 会通知客户端。
分布式专题-04分布式协调服务之Zookeeper实践及与原理分析
01-20
分布式专题-04分布式协调服务之Zookeeper实践及与原理分析 在分布式系统中，协调服务是非常关键的一部分。Zookeeper作为一种分布式协调服务，提供了高效的协调、通知、数据同步等功能。本文将从初步认识Zookeeper...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JolyouLu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值