Zookeeper 入门 ——（简介，下载配置；；集群操作）

第一章 Zookeeper入门

1.概述

1. Zookeeper 是一个开源的分布式的，为分布式框架提供协调服务的 Apache 项目。
   从设计模式角度理解：基于观察者模式设计的分布式管理框架，负责存储和管理数据，然后接受观察者的注册，一旦数据发生变化就会通知Zookeeper上注册的那些观察者做出相应的反应。（Zookeeper = 文件系统 + 通知机制）

2. 特点：
   1）一个leader，多个folloer组成的集群
   2）集群中只要有半数以上节点存活，zookeeper集群就能正常服务。所以zookeeper适合安装奇数台服务器
   3）全局数据一致
   4）更新请求顺序执行
   5）数据更新原子性，一次数据更新要么成功要么失败
   6）实时性 在一定时间范围内，Client能读到最新的数据

3. 数据结构：zookeeper的数据结和Linux很相似，整体上是一棵树，每个节点称作ZNode。默认存储1MB数据

4. 应用场景：统一命名服务、统一配置管理、服务器节点动态上下线、软负载均衡等。

2. 下载配置Zookeeper

官网下载：https://zookeeper.apache.org/

2.1 本地模式安装

1）安装前准备：

（1）安装 JDK
（2）拷贝 apache-zookeeper-3.5.7-bin.tar.gz 安装包到 Linux 系统下
（3）解压到指定目录
（4）修改名称

2）配置修改：

最好添加一下环境变量/etc/profile.d/my_env.sh

（1）将/opt/module/zookeeper-3.5.7/conf 这个路径下的 zoo_sample.cfg 修改为 zoo.cfg；
[atguigu@hadoop102 conf]$ mv zoo_sample.cfg zoo.cfg

（2）打开zoo.cfg 文件，修改 dataDir 路径：
[atguigu@hadoop102 zookeeper-3.5.7]$ vim zoo.cfg
修改如下内容：
dataDir=/opt/module/zookeeper-3.5.7/zkData

（3）在/opt/module/zookeeper-3.5.7/这个目录上创建 zkData 文件夹
[atguigu@hadoop102 zookeeper-3.5.7]$ mkdir zkData

3）操作 Zookeeper：

3）操作 Zookeeper

（1）启动Zookeeper
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start
（2）查看进程是否启动
[atguigu@hadoop102 zookeeper-3.5.7]$ jps
4020 Jps
4001 QuorumPeerMain
（3）查看状态
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh status ZooKeeper JMX enabled by default
Using config: /opt/module/zookeeper-3.5.7/bin/…/conf/zoo.cfg Mode: standalone

（4）启动客户端
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkCli.sh
（5）退出客户端：
[zk: localhost:2181(CONNECTED) 0] quit
（6）停止Zookeeper
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh stop

2.2 集群安装

1）集群规划：

在 hadoop102、hadoop103 和 hadoop104 三个节点上都部署 Zookeeper。

2）解压安装

（1）在 hadoop102 解压Zookeeper 安装包到/opt/module/目录下
（2）修改 apache-zookeeper-3.5.7-bin 名称为 zookeeper-3.5.7

3）配置服务器编号：

（1）在/opt/module/zookeeper-3.5.7/这个目录下创建 zkData
（2）在/opt/module/zookeeper-3.5.7/zkData 目录下创建一个 myid 的文件
在文件中添加与 server 对应的编号（注意：上下不要有空行，左右不要有空格）
注：添加 myid 文件，一定要在 Linux 里面创建，在 notepad++里面很可能乱码
（3）拷贝配置好的 zookeeper 到其他机器上
并分别在 hadoop103、hadoop104 上修改 myid 文件中内容为 3、4

4）配置zoo.cfg文件：

（1）重命名/opt/module/zookeeper-3.5.7/conf 这个目录下的 zoo_sample.cfg 为 zoo.cfg
（2）打开zoo.cfg 文件

#修改数据存储路径配置

dataDir=/opt/module/zookeeper-3.5.7/zkData

#增加如下配置

#######################cluster##########################
server.2=hadoop102:2888:3888 
server.3=hadoop103:2888:3888 
server.4=hadoop104:2888:3888

（3）配置参数解读
server.A=B:C:D。
A 是一个数字，表示这个是第几号服务器；

集群模式下配置一个文件myid，这个文件在 dataDir 目录下，这个文件里面有一个数据就是 A 的值，Zookeeper 启动时读取此文件，拿到里面的数据与 zoo.cfg 里面的配置信息比较从而判断到底是哪个 server。
B 是这个服务器的地址；

C 是这个服务器Follower 与集群中的 Leader 服务器交换信息的端口；

D 是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的

Leader，而这个端口就是用来执行选举时服务器相互通信的端口。

（4）同步zoo.cfg 配置文件：xsync

5）集群操作：

（1）分别启动Zookeeper
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start
[atguigu@hadoop103 zookeeper-3.5.7]$ bin/zkServer.sh start [atguigu@hadoop104 zookeeper-3.5.7]$ bin/zkServer.sh start

（2）查看状态:zkServer.sh status

3. 集群操作

3.1 选举机制

1. 初始化：
   
2. 非第一次启动：
   

3.2 zz.sh 群起脚本

#!/bin/bash

case $1 in 
"start"){
	for i in hadoop102 hadoop103 hadoop104
	do
		echo ---------- zookeeper $i 启动 ------------
		ssh	$i	"/opt/module/zookeeper-3.6.3/bin/zkServer.sh start"
	done
};;
"stop"){
	for i in hadoop102 hadoop103 hadoop104 
	do
	echo ---------- zookeeper $i 停止 ------------
	ssh	$i	"/opt/module/zookeeper-3.6.3/bin/zkServer.sh stop"
	done
};;
"status"){
	for i in hadoop102 hadoop103 hadoop104 
	do
		echo ---------- zookeeper $i 状态 ------------
		ssh	$i	"/opt/module/zookeeper-3.6.3/bin/zkServer.sh status"
	done
};;
esac

3.3 客户端命令执行

3.3.1 语法和启动

1）命令行语法：

• help （显示所有操作命令）
• ls path 使用 ls 命令来查看当前 znode 的子节点 [可监听]
  -w 监听子节点变化
  -s 附加次级信息
• create 普通创建
  -s 含有序列
  -e 临时（重启或者超时消失）
• get path 获得节点的值 [可监听]
  -w 监听节点内容变化
  -s 附加次级信息
• set 设置节点的具体值
• stat 查看节点状态
• delete 删除节点
• deleteall 递归删除节点

2）启动客户端
[wts@hadoop102 ~]$ zkCli.sh -server hadoop102:2181

3.3.2 znode节点数据信息

1）查看当前znode中所包含的内容：
[zk: hadoop102:2181(CONNECTED) 9] ls /
[zookeeper]

2）查看详细信息：
[zk: hadoop102:2181(CONNECTED) 8] ls -s /
[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

（1）czxid：创建节点的事务 zxid
每次修改ZooKeeper 状态都会产生一个ZooKeeper 事务 ID。事务 ID 是ZooKeeper 中所有修改总的次序。每次修改都有唯一的 zxid，如果 zxid1 小于 zxid2，那么zxid1 在 zxid2 之前发生。
（2）ctime：znode 被创建的毫秒数（从 1970 年开始）
（3）mzxid：znode 最后更新的事务zxid
（4）mtime：znode 最后修改的毫秒数（从 1970 年开始）
（5）pZxid：znode 最后更新的子节点zxid
（6）cversion：znode 子节点变化号，znode 子节点修改次数
（7）dataversion：znode 数据变化号
（8）aclVersion：znode 访问控制列表的变化号

（9）ephemeralOwner：如果是临时节点，这个是 znode 拥有者的 session id。如果不是临时节点则是 0。
（10）dataLength：znode 的数据长度
（11）numChildren：znode 子节点数量

3.3.3 节点类型

总共四个节点类型：

1）创建2个普通节点（永久 + 不带序号）
[zk: hadoop102:2181(CONNECTED) 10] create /sanguo “diaochan”
[zk: hadoop102:2181(CONNECTED) 12] create /sanguo/shuguo “liubei”
注：创建节点，需要赋值

2）获取上述节点的值
[zk: hadoop102:2181(CONNECTED) 17] get -s /sanguo
diaochan
cZxid = 0x500000004
ctime = Thu May 19 13:29:15 CST 2022
mZxid = 0x500000004
mtime = Thu May 19 13:29:15 CST 2022
pZxid = 0x500000005
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 8
numChildren = 1

[zk: hadoop102:2181(CONNECTED) 18] get -s /sanguo/shuguo
liubei
cZxid = 0x500000005
ctime = Thu May 19 13:30:10 CST 2022
mZxid = 0x500000005
mtime = Thu May 19 13:30:10 CST 2022
pZxid = 0x500000005
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 6
numChildren = 0

3）创建节点（永久 + 带序号）
[zk: hadoop102:2181(CONNECTED) 20] create -s /sanguo/weiguo/zhangliao “zhangliao”
Created /sanguo/weiguo/zhangliao0000000000
[zk: hadoop102:2181(CONNECTED) 21] create -s /sanguo/weiguo/zhangliao “zhangliao”
Created /sanguo/weiguo/zhangliao0000000001
[zk: hadoop102:2181(CONNECTED) 22] create -s /sanguo/weiguo/xuchu “xuchu”
Created /sanguo/weiguo/xuchu0000000002

4）创建节点（零时+ 无序/有序）
[zk: hadoop102:2181(CONNECTED) 23] create -e /sanguo/wuguo “zhouyu”
Created /sanguo/wuguo
[zk: hadoop102:2181(CONNECTED) 24] create -e -s /sanguo/wuguo “zhouyu”
Created /sanguo/wuguo0000000003
[zk: hadoop102:2181(CONNECTED) 25] ls -s /sanguo
[shuguo, weiguo, wuguo, wuguo0000000003]

重启客户端后，临时节点消失
[zk: hadoop102:2181(CONNECTED) 0] ls -s /sanguo
[shuguo, weiguo]

5）修改节点数值
[zk: hadoop102:2181(CONNECTED) 1] set /sanguo “wts”
（从原来的“diaochan”更改成了“wts”）

3.3.4 监听器原理

监听操作：

1. 节点的值变化监听
   (1) 在 hadoop104 主机上注册监听/sanguo 节点数据变化：
   [zk: localhost:2181(CONNECTED) 1] get -w /sanguo
   wts01
   (2)在 hadoop103 主机上修改/sanguo 节点的数据[zk: localhost:2181(CONNECTED) 0] set /sanguo “wts”
   (3) 观察 hadoop104 主机收到数据变化的监听
   [zk: localhost:2181(CONNECTED) 2]
   WATCHER::
   WatchedEvent state:SyncConnected type:NodeDataChanged path:/sanguo
   [zk: localhost:2181(CONNECTED) 3] get /sanguo
   wts

注意： 在hadoop103再多次修改/sanguo的值， hadoop104上不会再收到监听。因为注册 一次， 只能监听一次。想再次监听， 需要再次注册。

2. 节点的子节点变化监听(路径变化)
   (1)在 hadoop104 主机上注册监听/sanguo 节点的子节点变化
   [zk: localhost:2181(CONNECTED) 4] ls -w /sanguo
   [shuguo, weiguo]
   (2) 在 hadoop103 主机/sanguo 节点上创建子节点
   [zk: localhost:2181(CONNECTED) 2] create /sanguo/jin “simayi” Created /sanguo/jin
   (3) 观察 hadoop104 主机收到子节点变化的监听
   [zk: localhost:2181(CONNECTED) 5]
   WATCHER::
   WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/sang
   uo
   [zk: localhost:2181(CONNECTED) 5] ls /sanguo
   [jin, shuguo, weiguo]

注意： 节点的路径变化， 也是注册一次， 生效一次。想多次生效， 就需要多次注册。

3.3.5 节点的删除与查看

1. 删除节点
   [zk: localhost:2181(CONNECTED) 4] delete /sanguo/jin
2. 递归删除节点
   [zk: localhost:2181(CONNECTED) 15] deleteall /sanguo/shuguo
3. 查看节点状态
   [zk: localhost:2181(CONNECTED) 17] stat /sanguo
   cZxid = 0x100000003
   ctime = Wed Aug 29 00:03:23 CST 2018
   mZxid = 0x100000011
   mtime = Wed Aug 29 00:21:23 CST 2018
   pZxid = 0x100000014
   cversion = 9
   dataVersion = 1
   aclVersion = 0
   ephemeralOwner = 0x0
   dataLength = 4
   numChildren = 1

3.4 客户端API操作

1）环境准备：创建maven工程

1. pom文件内容如下：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.30</version>
</dependency>

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.6.3</version>
</dependency>

2. 需要在项目的 src/main/resources 目录下，新建一个文件， 命名为“log4j.properties ”，并添加如下：

    log4j.rootLogger=INFO, stdout  
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
    log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  
    log4j.appender.logfile=org.apache.log4j.FileAppender  
    log4j.appender.logfile.File=target/spring.log  
    log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  
    log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
   

3. 创建包com.wts.zookeeper；创建类ZKClient

代码书写：

1）创建ZooKeeper客户端，并创建子节点

package com.wts.zookeeper;

import org.apache.zookeeper.*;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

public class ZKClient {

    //"hadoop102:2181,hadoop103:2181,hadoop104:2181",逗号不能有空格
    private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    private int sessionTimeout = 2000;
    private ZooKeeper zkClient;

    @Before
    public void init() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
            }
        });
    }

    @Test
    public void create() throws InterruptedException, KeeperException {
        String nodeCreated = zkClient.create("/wts", "wts001".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }
}

（第二次复习为什么会报错?ECS虚拟机配置的hadoop102:2888:3888和代码里面的hadoop102。。。有问题吗？？跟ECS的两个IP有关吗？）

效果如下：

2）获取子节点，并监听节点变化

上代码：

package com.wts.zookeeper;

import org.apache.zookeeper.*;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.List;

public class ZKClient {

    //"hadoop102:2181,hadoop103:2181,hadoop104:2181",逗号不能有空格
    private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    private int sessionTimeout = 2000;
    private ZooKeeper zkClient;

    @Before
    public void init() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {

                System.out.println("----------------------------");

                //一次监听一次注册，多次监听，每次都要注册
                List<String> children = null;
                try {
                    children = zkClient.getChildren("/", true);

                    for (String child : children) {
                        System.out.println(child);
                    }

                    System.out.println("----------------------------");

                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    @Test
    public void create() throws InterruptedException, KeeperException {
        String nodeCreated = zkClient.create("/wts", "wts001".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }


    @Test //获取子节点和子节点的变化
    public void getChildren() throws InterruptedException, KeeperException {
        List<String> children = zkClient.getChildren("/", true);

        for (String child : children) {
            System.out.println(child);
        }
        //延时
        Thread.sleep(Long.MAX_VALUE);
    }
}

3）判断节点是否存在

上代码：

package com.wts.zookeeper;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.List;

public class ZKClient {

    //"hadoop102:2181,hadoop103:2181,hadoop104:2181",逗号不能有空格
    private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    private int sessionTimeout = 2000;
    private ZooKeeper zkClient;

    @Before
    public void init() throws IOException {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {

                System.out.println("----------------------------");

/*                //一次监听一次注册，多次监听，每次都要注册
                //watch就是监听的意思
                List<String> children = null;
                try {
                    children = zkClient.getChildren("/", true);

                    for (String child : children) {
                        System.out.println(child);
                    }

                    System.out.println("----------------------------");

                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
        });
    }

    @Test
    public void create() throws InterruptedException, KeeperException {
        String nodeCreated = zkClient.create("/wts", "wts001".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }


    @Test //获取子节点和子节点的变化
    public void getChildren() throws InterruptedException, KeeperException {
        List<String> children = zkClient.getChildren("/", true);//watch表示监听的意思，所以true

        for (String child : children) {
            System.out.println(child);
        }
        //延时
        Thread.sleep(Long.MAX_VALUE);
    }

    @Test //判断某一个节点是否存在
    public void exist() throws InterruptedException, KeeperException {
        Stat stat = zkClient.exists("/wts", false);//false监听，把上面的监听代码注释掉
        System.out.println((stat == null ? "not exist!" : "exist!"));
    }
}

效果：

客户端向服务端写数据流程（3.3 3.4解读）

1）写入请求直接发送给Leader

2）写入请求直接发送给follower

---