动物园铲屎官Zookeeper——实战篇

最新推荐文章于 2024-04-19 22:54:03 发布
最新推荐文章于 2024-04-19 22:54:03 发布
阅读量165 收藏
点赞数
分类专栏： Hadoop生态圈 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44110741/article/details/108919205
版权

目录

 一、客户端命令行操作 

1．启动客户端

2．显示所有操作命令

3．查看当前znode中所包含的内容

4．查看当前节点数据并能看到更新次数等数据

5．创建普通节点

6．获得节点的值

7．创建短暂节点

8．创建带序号的节点

9．修改节点数据值

10．节点的值变化监听

11．节点的子节点变化监听（路径变化）

12．删除节点

13．递归删除节点

14．查看节点状态

二、API应用

1、Idea环境搭建

3、Java客户端操作（带监听）

三、监听服务器动态上下线案例

1．需求

2．需求分析

3．代码实现

 一、客户端命令行操作 

命令基本语法

功能描述

help

显示所有操作命令

ls path [watch]

使用 ls 命令来查看当前znode中所包含的内容

ls2 path [watch]

查看当前节点数据并能看到更新次数等数据

create

普通创建

-s  含有序列

-e  临时（重启或者超时消失）

get path [watch]

获得节点的值

set

设置节点的具体值

stat

查看节点状态

delete

删除节点

rmr

递归删除节点

1．启动客户端

[root@hadoop003 zookeeper-3.4.10]$ bin/zkCli.sh

2．显示所有操作命令

[zk: localhost:2181(CONNECTED) 1] help

3．查看当前znode中所包含的内容

[zk: localhost:2181(CONNECTED) 0] ls /
[zookeeper]

4．查看当前节点数据并能看到更新次数等数据

[zk: localhost:2181(CONNECTED) 1] ls2 /
[zookeeper]
cZxid = 0x0
ctime = Thu Jan 01 08:00:00 CST 1970
mZxid = 0x0
mtime = Thu Jan 01 08:00:00 CST 1970
pZxid = 0x0
cversion = -1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 0
numChildren = 1

5．创建普通节点

[zk: localhost:2181(CONNECTED) 2] create /app1 "hello app1"
Created /app1
[zk: localhost:2181(CONNECTED) 4] create /app1/server101 "192.168.1.101"
Created /app1/server101

6．获得节点的值

[zk: localhost:2181(CONNECTED) 6] get /app1
hello app1
cZxid = 0x20000000a
ctime = Mon Jul 17 16:08:35 CST 2017
mZxid = 0x20000000a
mtime = Mon Jul 17 16:08:35 CST 2017
pZxid = 0x20000000b
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 10
numChildren = 1
[zk: localhost:2181(CONNECTED) 8] get /app1/server101
192.168.1.101
cZxid = 0x20000000b
ctime = Mon Jul 17 16:11:04 CST 2017
mZxid = 0x20000000b
mtime = Mon Jul 17 16:11:04 CST 2017
pZxid = 0x20000000b
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 13
numChildren = 0

7．创建短暂节点

[zk: localhost:2181(CONNECTED) 9] create -e /app-emphemeral 8888

（1）在当前客户端是能查看到的

[zk: localhost:2181(CONNECTED) 10] ls /
[app1, app-emphemeral, zookeeper]

（2）退出当前客户端然后再重启客户端

[zk: localhost:2181(CONNECTED) 12] quit
[bigdata@hadoop104 zookeeper-3.4.10]$ bin/zkCli.sh

（3）再次查看根目录下短暂节点已经删除

[zk: localhost:2181(CONNECTED) 0] ls /
[app1, zookeeper]

8．创建带序号的节点

（1）先创建一个普通的根节点app2

[zk: localhost:2181(CONNECTED) 11] create /app2 "app2"

（2）创建带序号的节点

[zk: localhost:2181(CONNECTED) 13] create -s /app2/aa 888
Created /app2/aa0000000000
[zk: localhost:2181(CONNECTED) 14] create -s /app2/bb 888
Created /app2/bb0000000001
[zk: localhost:2181(CONNECTED) 15] create -s /app2/cc 888
Created /app2/cc0000000002
如果原节点下有1个节点，则再排序时从1开始，以此类推。
[zk: localhost:2181(CONNECTED) 16] create -s /app1/aa 888
Created /app1/aa0000000001

9．修改节点数据值

[zk: localhost:2181(CONNECTED) 2] set /app1 999

10．节点的值变化监听

（1）在hadoop005主机上注册监听/app1节点数据变化

[zk: localhost:2181(CONNECTED) 26] get /app1 watch

（2）在hadoop004主机上修改/app1节点的数据

[zk: localhost:2181(CONNECTED) 5] set /app1  777

（3）观察hadoop005主机收到数据变化的监听

WATCHER::
WatchedEvent state:SyncConnected type:NodeDataChanged path:/app1

11．节点的子节点变化监听（路径变化）

（1）在hadoop005主机上注册监听/app1节点的子节点变化

[zk: localhost:2181(CONNECTED) 1] ls /app1 watch
[aa0000000001, server101]

（2）在hadoop004主机/app1节点上创建子节点

[zk: localhost:2181(CONNECTED) 6] create /app1/bb 666
Created /app1/bb

（3）观察hadoop005主机收到子节点变化的监听

WATCHER::
WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/app1

12．删除节点

[zk: localhost:2181(CONNECTED) 4] delete /app1/bb

13．递归删除节点

[zk: localhost:2181(CONNECTED) 7] rmr /app2

14．查看节点状态

[zk: localhost:2181(CONNECTED) 12] stat /app1
cZxid = 0x20000000a
ctime = Mon Jul 17 16:08:35 CST 2017
mZxid = 0x200000018
mtime = Mon Jul 17 16:54:38 CST 2017
pZxid = 0x20000001c
cversion = 4
dataVersion = 2
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 3
numChildren = 2

注意：监听只管用一次，要想再次监听，只能再次执行监控命令。

二、API应用

1、Idea环境搭建

（1）创建一个Maven工程

（2）添加pom文件

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>2.8.2</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.4.10</version>
		</dependency>
	</dependencies>

（3）拷贝log4j.properties文件到项目根目录


2、Java客户端操作（不带监听）

imp

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class MyZookeeperTestWithoutWatch {

    ZooKeeper client = null;

    @Before // 获取客户端
    public void getClient()throws Exception {
        client = new ZooKeeper("hadoop003:2181,hadoop004:2181,hadoop005:2181", 2000, null);
        System.out.println(client);
    }
    @Test // 获取指定节点的所有子节点
    public void getAllChildren()throws Exception {
        List<String> children = client.getChildren("/story", false);
        for (String child : children) {
            System.out.println(child); // aaa  bbb
        }
    }

    @Test // 创建节点
    public void createNode()throws Exception {
        String s = client.create("/idea", "bigdata".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println(s); //    /idea
    }

    @Test // 查询指定节点的数据
    public void getNodeData()throws Exception {
        // Stat stat = new Stat();
       // stat.setCzxid(0x200000022L);
        byte[] data = client.getData("/idea", false, null);
        System.out.println(new String(data));
    }

    @Test // 修改指定节点数据
    public void modifyNodeData()throws Exception {
        // 第一个参数：要修改的节点名称
        // 第二个参数：要修改的数据
        // 第三个参数：数据版本号
        Stat stat = client.setData("/idea", "bigdata".getBytes(), -1);
        System.out.println("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"+stat);
    }


    @Test // 删除节点
    public void deleteNode()throws Exception {
        client.delete("/idea",-1);
        System.out.println("删除成功");
    }

    @Test //  判断节点是否存在
    public void existNode()throws Exception {
        Stat exists = client.exists("/idea", false);
        if(exists == null){
         System.out.println("节点不存在");
        }
    }

3、Java客户端操作（带监听）

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class MyZookeeperTestWithWatch {

    ZooKeeper client = null;
    @Before
    public void getClient()throws Exception {
        client = new ZooKeeper("hadoop003:2181,hadoop004:2181,hadoop005:2181", 2000, new Watcher() {

            // 先委托zookeeper帮我监听，如果数据真的发生变化了，那么zookeeper就会调用该方法通知我们，
            // 我们在这里实现自己的业务
            public void process(WatchedEvent event) {
                System.out.println("回调方法执行："+event.getPath() + "--" + event.getType());
                try {
                    //client.getChildren("/story", true);
                    client.getData("/story", true, null);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        });
        System.out.println("获取到客户端："+client);
    }


    @Test // 监听某节点的子节点的增减变化
    public void getChildrenNode()throws Exception {
        List<String> children = client.getChildren("/story", true);
        for (String child : children) {
            System.out.println(child);
        }
        Thread.sleep(Long.MAX_VALUE);
    }

    @Test // 监听某节点的数据变化
    public void getDataWatch()throws Exception {
        byte[] data = client.getData("/story", true, null);
        System.out.println(new String(data));

        Thread.sleep(Long.MAX_VALUE);
    }

}

三、监听服务器动态上下线案例

1．需求

某分布式系统中，主节点可以有多台，可以动态上下线，任意一台客户端都能实时感知到主节点服务器的上下线。

2．需求分析

1）提供时间查询服务，客户端系统调用该时间查询服务。

2）动态上线，下线该时间查询服务的节点，让客户端实时感知服务器列表变化，查询时候访问最新的机器节点。

3）具体实现：

        先在集群上创建/servers节点

[zk: localhost:2181(CONNECTED) 10] create /servers "servers"
Created /servers

3．代码实现

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

public class TimeServer {

    ZooKeeper client = null;

    public static void main(String[] args) throws Exception {
        TimeServer timeServer = new TimeServer();
        // 1 获取zookeeper客户端
        timeServer.getClient();
        // 2 向zookeeper注册自身的ip和端口号，其实就是在/servers/下创建临时节点，并把数据写上去
        timeServer.registInfo(args[0],args[1]);
        // 3 开始授时服务
        new TimeService(Integer.parseInt(args[1])).start();
    }

    public void getClient()throws Exception {
        client = new ZooKeeper("hadoop003:2181,hadoop004:2181,hadoop005:2181", 2000, null);
    }

    public void registInfo(String ip,String port) throws KeeperException, InterruptedException {
        //   /servers/server0000001  127.0.0.1:5555
        String s = client.create("/servers/server", (ip + ":" + port).getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("时间服务器上线了，"+"ip："+ip+",port:"+port+",创建临时节点："+s);
    }

}
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

public class TimeService extends Thread {

    private int port ;

    public TimeService(int port){
        this.port = port;
    }
    @Override
    public void run() {

        System.out.println("授时服务开始了");
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while(true){
                //是个阻塞方法，当有客户端连接的时候，才会建立Socket对象，跟该客户端通信
                Socket accept = serverSocket.accept();
                OutputStream outputStream = accept.getOutputStream();
                outputStream.write(new Date().toString().getBytes());
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class TimeClient {

    ZooKeeper client = null;
    List<String> serverList = null;
    public static void main(String[] args) throws Exception {
        TimeClient timeClient = new TimeClient();
        // 1 获取zookeeper客户端
        timeClient.getClient();
        // 2 获取时间服务器列表，并委托监听
        timeClient.getServerList();
        // 3 跟时间服务器通信，获取时间
        timeClient.sendRequest();
    }

    public void getClient()throws Exception {
        client = new ZooKeeper("hadoop003:2181,hadoop004:2181,hadoop005:2181", 2000, new Watcher() {
            public void process(WatchedEvent event) {
                System.out.println("回调方法执行："+event.getPath() + "--" + event.getType());
                try {
                    getServerList();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public void getServerList() throws KeeperException, InterruptedException {
        List<String>  ipPortList =  new ArrayList();
        List<String> children = client.getChildren("/servers", true);
        for (String child : children) {
            // server0000001
            byte[] data = client.getData("/servers/" + child, false, null);
            String ipAndPort = new String(data);
            ipPortList.add(ipAndPort);
        }
        serverList = ipPortList;
        System.out.println("获取到最新的时间服务器列表:"+serverList);
    }

    public void sendRequest() throws IOException, InterruptedException {

        while (true){
            Random random = new Random();
            int index = random.nextInt(serverList.size());
            // 127.0.0.1:5555
            String ipAndPort = serverList.get(index);
            String[] split = ipAndPort.split(":");
            String ip = split[0];
            int port = Integer.parseInt(split[1]);
            Socket socket = new Socket(ip, port);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("haha".getBytes());
            outputStream.flush();
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            inputStream.read(bytes);
            System.out.println("从时间服务器："+ipAndPort+"获取时间："+new String(bytes));
            inputStream.close();
            outputStream.close();
            socket.close();

            Thread.sleep(5000);

        }



    }
}

 

✔✔✔✔
关注
专栏目录
大数据Hadoop学习(5)-ZooKeeper安装
LoongKK的博客
05-04 198
Zookeeper分布式安装及客户端命令行操作 分布式安装部署 1．集群规划 在node1、node2和node3三个节点上部署Zookeeper。 2．解压安装 官网下载https://zookeeper.apache.org/ 1）解压zookeeper安装包到/opt/module/目录下 [root@node1 module]$ tar -zxvf zookeeper-3.4.6.tar....
05_ZooKeeper
aren
03-30 85
1.ZooKeeper    1.1 zk可以用来保证数据在zk集群之间的数据的事务性一致。2.如何搭建ZooKeeper服务器集群    2.1 zk服务器集群规模不小于3个节点，要求各服务器之间系统时间要保持一致。    2.2 在hadoop0的/usr/local目录下，解压缩zk....tar.gz，设置环境变量    2.3 在conf目录下，修改文件 cp zoo_sample.cf...
hadoop生态的kerberos认证系列1-zookeeper
tiki的博客
12-17 1492
hadoop生态的kerberos认证一、zookeeper1.准备工作2.配置2.1创建服务端用户2.2导出凭证：2.3修改zookeeper的配置文件2.4生成jaas.conf文件2.5创建client的priincipal并导出2.6配置client-jaas.conf文件3.验证zk的kerberos 一、zookeeper 1.准备工作 停掉hadoop集群； 安装好kerberos认证服务； 2.配置 节点名为node，本文以单节点为例说明，集群一般也差不多，只要配置文件统一、凭证区分开即可（
zookeeper的安装、使用和结合sheepdog部署、使用
weimingyu945的专栏
11-08 3280
ZooKeeper的安装模式分为三种，分别为：单机模式（stand-alone）、集群模式和集群伪分布模式。ZooKeeper 单机模式的安装相对比较简单，如果第一次接触ZooKeeper的话，建议安装ZooKeeper单机模式或者集群伪分布模式。 ZooKeeper Standalone模式 从Apache网站上（zookeeper.apache.org）下载ZooK
Zookeeper 3.5.7（铲屎官）学习教程
菜鸟玩Java
02-21 2668
目录一、Zookeeper介绍二、Zookeeper的选举机制1.服务器启动初始化2.非第一次启动三、脚本案例1.启动脚本2.客户端命令操作四、动态监听服务器上下线1.具体实现五、Zookeeper分布式锁1.实现Zookeeper分布式锁2.Curator实现分布式锁2.1官网解释：2.2原生API缺点：2.3curator实现案例六、算法基础1.拜占庭将军问题2.Paxos算法3.ZAB协议3.1ZAB介绍4.CAP理论七、详细流程1.Zookeeper服务端初始化流程2.Zookeeper选举流程 一
分布式系统的基石之ZooKeeper——基本原理+场景应用+集群搭建（最强万字入门指南）(1)
Y1567409的博客
04-19 948
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
ZooKeeper分布式配置——看这篇就够了
牧小农
10-21 1512
ZooKeeper 的由来 PS：这一段不重要，不感兴趣的小伙伴可以跳过 ZooKeeper 最早起源于雅虎研究院的一个研究小组，在当时，研究人员发现，在雅虎内部有很多的大型系统基本上都需要依赖一个类似的系统来进行分布式协调，但是这些系统往往都存在分布式单点的问题，所有雅虎的开发人员就尝试开发了一个通用的无单点问题的分布式协调框架，以便让开发人员将精力集中在处理业务逻辑上。关于"ZooKeeper"这个项目的名字。也有一个故事，在项目开始初期，因为考虑到内部的很多项目都是用动物的名字来命名的（例如：Pig项
分布式系统的基石之ZooKeeper——基本原理+场景应用+集群搭建（最强万字入门指南）
你学废了吗？
09-12 2834
ZooKeeper是一个可靠的、强一致性的、没有单点故障的分布式数据存储系统。因为其出色的设计（ZAB一致性算法，Watch机制等）和协调能力，使得它成为很多分布式系统的基石，就像其名称动物园管理员一样，做着比较基层的管理协调工作，比如配置管理，命名服务，服务注册发现等。
12zookeeper——好程序
01-07
zookeeper的基础与架构、集群搭建 zookeeper是什么？？ zookeeper是一个分布式协调服务，就是为用户的分布式应用提供协调服务 zookeeper是为其他的分布式程序服务的 zookeeper本身也是一个分布式程序（只要有半数...
《Paxos到Zookeeper——分布式一致性原理与实践》高清完整版
12-03
《Paxos到Zookeeper——分布式一致性原理与实践》是一本深入探讨分布式一致性问题的书籍，对于理解并应用Zookeeper这一关键的分布式协调系统具有重要价值。本书旨在帮助读者掌握分布式环境中的数据一致性原理，并...
Linux Centos7 环境搭建Docker部署Zookeeper服务实战.pdf
03-08
Linux Centos7 环境搭建Docker部署Zookeeper服务实战
4.zookeeper运维实战视频教程资料-详细课件笔记总结
最新发布
05-25
7.zookeeper的watch监听机制实战演示 8.zookeeper中三种角色、Zab协议(崩溃选举和数据同步） 9.zookeeper中锁的种类、读锁、写锁和羊群效应 10.CAP的三个概念和CAP理论 11.zookeeper集群节点为什么是奇数台 12....
zookeeper——监控命令详解
保暖透气大裤衩LeoLee的博客
05-26 1922
前言 zookeeper的监控命令需要通过telnet或者nc工具向zookeeper服务进行提交 如使用telnet工具： telnet 127.0.0.1 2181 之后telnet工具连接zookeeper成功可以使用四字监控命令进行操作。在连接建立之后输入对应的命令后回车。 在使用监控命令之前，需要修改zookeeper的配置文件，开启四字监控命令，否则会报错如下： nc命令使用方法自行搜索，使用什么工具与本文关系不大。 开启监控命令 修改zoo.cfg文件，在配置文件中加入如
Flume简介
qq_44110741的博客
10-06 1666
一、Flume是什么 Flume是Cloudera提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统。Flume基于流式架构，灵活简单。 简单来说，flume是一个分布式的实时数据采集系统。flume最主要的作用就是，实时读取服务器本地磁盘中的数据，上传到hdfs。 flume的核心是，搞清楚采集，收集，读取的数据从哪里来，配置合适类型的source；根据数据目的地，配置合适的sink；在送到目的地之前，会先缓存数据(channel),...
Hive学习之HQL（DDL、DML、DQL）
qq_44110741的博客
10-05 1483
目录 一、DDL数据定义 1 创建数据库 2 查询数据库 （1）显示数据库 （2）查看数据库详情 （3） 切换当前数据库 3 删除数据库 4 创建表 1 内部表（管理表） 1．理论 2．案例实操 2 外部表 1．理论 2．管理表和外部表的使用场景 3．案例实操 5 分区表 1 分区表基本操作 2 分区表注意事项 6 修改表 1 重命名表 2 增加/修改列信息 7 删除表 二、DML数据操作 1 数据导入 1 向表中装载数据（Load） 2 通过查询语句..
Impala学习笔记
qq_44110741的博客
10-06 1255
目录 一、Impala 概述 1.1 什么是 Impala 2.2 Impala 的功能 2.3 Impala 的优缺点 2.4 关系数据库和impala 2.5Hive，Hbase和Impala 二、Impala 架构 三、Impala的操作命令 3.1Impala的外部shell 3.2Impala的外部shell 四、Impala 的 SQL 操作 4.1Impala数据类型 4.2 数据库操作 4.3 Impala 表操作 4.3.1 创建表 4.3.2 分区...
MapReduce入门讲解及案例
qq_44110741的博客
09-05 812
文章目录 前言 二、MapReduce的优缺点 1.优点 2.缺点 三、MapReduce的核心编程思想 四、MapReduce编程规范（八股文） 1.Mapper阶段 2.Reduce阶段 3.Driver阶段 五、WordCount案例实操 1．需求 2．数据准备 3．分析 4. 代码实现 5．本地测试 6．集群上测试 总结 前言 hadoop由四部分组成：hdfs（分布式文件系统），MapReduce（一个分布式的离线并行计算程序框架框架），yarn（作业..
MapReduce框架原理之ReduceTask工作机制
qq_44110741的博客
09-19 699
一、Reduce Task 并行度决定机制 reduce task的并行度，也就是同时开启了几个reduce task。分为两种情况： 1、如果我们自己定义了分区器，我们能够确定自己的分区器能够形成几个物理分区，加入我们要生成5个分区，那么我们要再driver中设置与分区数量相等的reduce task数量： //默认值是1，手动设置为5 job.setNumReduceTasks(5); 2、如果我们采用默认的分区器，也就是HashPartitioner，那么只需要根据实际情况在dr...
ZooKeeper Java客户端实战：官方API与Curator
本课程聚焦Zookeeper的经典应用场景实战，旨在通过Java客户端API介绍如何操作ZooKeeper集群。内容涵盖Zookeeper官方API的局限性，以及第三方客户端如Curator的优势。此外，还探讨了Zookeeper的Watcher机制和会话超时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值