[大数据]大数据----9.zookeeper的详细配置信息的分析和原理；常用命令；api的使用

zookeeper的详细配置信息的分析和原理；常用命令；api的使用

1.解读zoo.cfg 文件中参数含义

1．tickTime：通信心跳数，Zookeeper服务器心跳时间，单位毫秒

Zookeeper使用的基本时间，服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个tickTime时间就会发送一个心跳，时间单位为毫秒。

它用于心跳机制，并且设置最小的session超时时间为两倍心跳时间。(session的最小超时时间是2*tickTime)； 大于2倍的心跳时间，就是超时了；

2．initLimit：LF初始通信时限

集群中的follower跟随者服务器(F)与leader领导者服务器(L)之间初始连接时能容忍的最多心跳数（tickTime的数量），用它来限定集群中的Zookeeper服务器连接到Leader的时限。

投票选举新leader的初始化时间

Follower在启动过程中，会从Leader同步所有最新数据，然后确定自己能够对外服务的起始状态。

Leader允许F在initLimit时间内完成这个工作。

3．syncLimit：LF同步通信时限

集群中Leader与Follower之间的最大响应时间单位，假如响应超过syncLimit * tickTime，

Leader认为Follwer死掉，从服务器列表中删除Follwer。

在运行过程中，Leader负责与ZK集群中所有机器进行通信，例如通过一些心跳检测机制，来检测机器的存活状态。

如果L发出心跳包在syncLimit之后，还没有从F那收到响应，那么就认为这个F已经不在线了。

4．dataDir：数据文件目录+数据持久化路径

保存内存数据库快照信息的位置，如果没有其他说明，更新的事务日志也保存到数据库。

5．clientPort：客户端连接端口

监听客户端连接的端口

2.Zookeeper内部原理

2.1 选举机制

1）半数机制（Paxos 协议）：集群中半数以上机器存活，集群可用。所以zookeeper适合装在奇数台机器上。

2）Zookeeper虽然在配置文件中并没有指定master和slave。但是，zookeeper工作时，是有一个节点为leader，其他则为follower，Leader是通过内部的选举机制临时产生的

3）以一个简单的例子来说明整个选举的过程。

假设有五台服务器组成的zookeeper集群，它们的id从1-5，同时它们都是最新启动的，也就是没有历史数据，在存放数据量这一点上，都是一样的。假设这些服务器依序启动，来看看会发生什么，如图5-8所示。

图5-8 Zookeeper的选举机制

（1）服务器1启动，此时只有它一台服务器启动了，它发出去的报没有任何响应，所以它的选举状态一直是LOOKING状态。

（2）服务器2启动，它与最开始启动的服务器1进行通信，互相交换自己的选举结果，由于两者都没有历史数据，所以id值较大的服务器2胜出，但是由于没有达到超过半数以上的服务器都同意选举它(这个例子中的半数以上是3)，所以服务器1、2还是继续保持LOOKING状态。

（3）服务器3启动，根据前面的理论分析，服务器3成为服务器1、2、3中的老大，而与上面不同的是，此时有三台服务器选举了它，所以它成为了这次选举的leader。

（4）服务器4启动，根据前面的分析，理论上服务器4应该是服务器1、2、3、4中最大的，但是由于前面已经有半数以上的服务器选举了服务器3，所以它只能接收当小弟的命了。

（5）服务器5启动，同4一样当小弟。

2.2节点类型

1．Znode有两种类型(需要结合命令行的模式来进行测试)

短暂（ephemeral）：客户端和服务器端断开连接后，创建的节点自己删除

持久（persistent）：客户端和服务器端断开连接后，创建的节点不删除

2．Znode有四种形式的目录节点（默认是persistent ）

（1）持久化目录节点（PERSISTENT）

? 客户端与zookeeper断开连接后，该节点依旧存在

（2）持久化顺序编号目录节点（PERSISTENT_SEQUENTIAL）

? 客户端与zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进行顺序编号

（3）临时目录节点（EPHEMERAL）

客户端与zookeeper断开连接后，该节点被删除

（4）临时顺序编号目录节点（EPHEMERAL_SEQUENTIAL）

客户端与zookeeper断开连接后，该节点被删除，只是Zookeeper给该节点名称进行顺序编号，如图5-9所示

图5-9 Zookeeper节点类型

3．创建znode时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护

4．在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样客户端可以通过顺序号推断事件的顺序

2.3 Zookeeper工作机制

2.4 Zookeeper目录结构

2.5监听器原理

图5-10 监听器原理

1．监听原理详解，如图5-10所示

1）首先要有一个main()线程

2）在main线程中创建Zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信（connet），一个负责监听（listener）。

3）通过connect线程将注册的监听事件发送给Zookeeper。

4）在Zookeeper的注册监听器列表中将注册的监听事件添加到列表中。

5）Zookeeper监听到有数据或路径变化，就会将这个消息发送给listener线程。

6）listener线程内部调用了process（）方法。

2．常见的监听

（1）监听节点数据的变化：

get path [watch]

? （2）监听子节点增减的变化

ls path [watch]

2.6 写数据流程

图5-11 Zookeeper写数据流程

ZooKeeper 的写数据流程主要分为以下几步，如图5-11所示：

1）比如 Client 向 ZooKeeper 的 Server1 上写数据，发送一个写请求。

2）如果Server1不是Leader，那么Server1 会把接受到的请求进一步转发给Leader，因为每个ZooKeeper的Server里面有一个是Leader。这个Leader 会将写请求广播给各个Server，比如Server1和Server2， 各个Server写成功后就会通知Leader。

3）当Leader收到大多数 Server 数据写成功了，那么就说明数据写成功了。如果这里三个节点的话，只要有两个节点数据写成功了，那么就认为数据写成功了。写成功之后，Leader会告诉Server1数据写成功了。

4）Server1会进一步通知 Client 数据写成功了，这时就认为整个写操作成功。ZooKeeper 整个写数据流程就是这样的。

3.客户端命令行操作

表5-1

4.命令的使用

1．启动客户端

[root@hadoop01 zookeeper-3.4.10]# bin/zkCli.sh （如果配置了环境变量就直接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

cZxid Zookeeper为节点分配的Id
cTime 节点创建时间
mZxid 修改后的id
mtime 修改时间
pZxid 子节点id
cversion 子节点的version
dataVersion 当前节点数据的版本号
aclVersion 权限Version
dataLength 数据长度
numChildren 子节点个数

5．创建普通节点

[zk: localhost:2181(CONNECTED) 2] create /hfc123 “hellohfc123”

Created /hfc123

主要：hellohfc123 不能有空格；

[zk: localhost:2181(CONNECTED) 4] create /app1/server01 “192.168.1.101”

Created /app1/server01

这个先要创建一个 app1这个节点要存在； 不存在就不可以的；就会报错；

注意点：存储数据的时候空格问题：

无效的ACL

这里因为是用Linux来操作的 ，也就是说用命令来执行的。命令的格式 create /path data ，图里面 ni hao 之间是用空格分开的，

而对于Linux来说 相当于 你只打了 ni，而没有打hao 。 对于命令来说，(空格是真的重要)

至于在eclipse里操作，因为你打的是一个字符串，所以可以成功

6．获得节点的值(因为他们是一个集群 所以在任何一个节点上都可以获取内容)

[zk: localhost:2181(CONNECTED) 6] get /hfc123

hellohfc123

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/server01

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 /emphfc “aaaaaaaaaa”

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

[zk: localhost:2181(CONNECTED) 10] ls /

[emphfc, zookeeper, test1, hfc123]

（2）退出当前客户端然后再重启客户端(也可以不退出，过一会到时间就没有了)

[zk: localhost:2181(CONNECTED) 12] quit

[root@hadoop01 zookeeper-3.4.10]# bin/zkCli.sh

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

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

[zookeeper, test1, hfc123]

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 /test1 “changetest1”

修改后的数据：

10．节点的值变化监听

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

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

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

[zk: localhost:2181(CONNECTED) 5] set /test1 “hfc”

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

WATCHER::

WatchedEvent state:SyncConnected type:NodeDataChanged path:/app1

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

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

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

[aa0000000000, bb0000000001, cc0000000002]

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

[zk: localhost:2181(CONNECTED) 6] create /app1/dd 8888

Created /app1/dd

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

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

5.zookeeper的java调用api

5.1 zookeeper的节点基本api

5.1.1 基本的zookeeper的操作：（maven加入需要的jar包；）

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

import java.security.NoSuchAlgorithmException;
import java.util.List;

/**
 * @Program BigData
 * @Package PACKAGE_NAME
 * @Auther TeacherHuang
 * @Date 2021/8/7 21:46
 * @Version 1.0
 */
public class ZkClient {
//    定义连接的地址
    private String connectString =
            "192.168.219.110:2181," +
            "192.168.219.120:2181," +
            "192.168.219.130:2181";
//    定义session的超时时间
    private int sessionTimeout = 3000;
//    创建zookeeper对象
    ZooKeeper zkCli = null;


//    初始化操作
@Before
    public  void init() throws  Exception{

    zkCli=new ZooKeeper(connectString, sessionTimeout, new Watcher() {

        public void process(WatchedEvent watchedEvent) {
            // 收到事件通知后的回调函数（用户的业务逻辑）
            System.out.println("监听到 发送变化后的回调--------");
            System.out.println(watchedEvent.getPath() + "\t" + watchedEvent.getState() + "\t" + watchedEvent.getType());

            try {
                // 再次启动监听 监听根目录；根目录发生变化的时候监控
                System.out.println("--------------（初始化方法调用）有数据和目录发生了变化----------------------");
              List<String> list = zkCli.getChildren("/",true);

              for (String str:list){
                  System.out.println(str);
              }
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    });

}


    // 创建子节点
    @Test
    public void createZnode() throws KeeperException, InterruptedException {

//        ZooDefs.Ids.OPEN_ACL_UNSAFE   完全开放的ACL，任何连接的客户端都可以操作该属性znode
      /*  CREATOR_ALL_ACL : 只有创建者才有ACL权限
          READ_ACL_UNSAFE：只能读取ACL
        */

//       CreateMode.PERSISTENT  持久化的写入数据
//       CreateMode.EPHEMERAL  短暂的写入数据

        String path = zkCli.create("/hello01", "world   world".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println(path);
    }


    // 获取子节点
    @Test
    public void getChild() throws KeeperException, InterruptedException {
        List<String> children = zkCli.getChildren("/", true);
        System.out.println("------------------获取具体的目录先的节点数-----------------------");
        for (String c : children) {
            System.out.println(c);
        }
        Thread.sleep(Long.MAX_VALUE);
    }


    // 删除节点
    @Test
    public void rmChildData() throws KeeperException, InterruptedException, NoSuchAlgorithmException {
         byte[] data = zkCli.getData("/hello01", true, null);
         System.out.println(new String(data));
         zkCli.delete("/hello01", -1);
    }


    // 判断节点是否存在
    @Test
    public void testExist() throws KeeperException, InterruptedException {
        Stat exists = zkCli.exists("/hello", false);
        System.out.println(exists == null ? "not exists" : "exists");
    }

}

5.2 zookeeper的监听节点 api

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

import java.io.IOException;

/**
 * @Program BigData
 * @Package PACKAGE_NAME
 * @Auther TeacherHuang
 * @Date 2021/8/8 8:28
 * @Version 1.0
 */
public class WatchNodeDemo {
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        ZooKeeper zkCli = new ZooKeeper("192.168.219.110:2181,192.168.219.120:2181,192.168.219.130:2181", 3000,
                new Watcher() {
                    // 监听回调

                    public void process(WatchedEvent event) {

                    }
                });

        byte[] data = zkCli.getData("/hello", new Watcher() {
            // 监听的具体内容

            public void process(WatchedEvent event) {
                System.out.println("监听路径为：" + event.getPath());
                System.out.println("监听的类型为：" + event.getType());
                System.out.println("监听被修改了！！！");
            }
        }, null);

        System.out.println(new String(data));
        Thread.sleep(Long.MAX_VALUE);
    }
}

5.3 zookeeper监听目录

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.util.List;

/**
 * @Program BigData
 * @Package PACKAGE_NAME
 * @Auther TeacherHuang
 * @Date 2021/8/8 8:31
 * @Version 1.0
 */
public class WatchPathDemo {

    static List<String> children = null;

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        ZooKeeper zkCli = new ZooKeeper("192.168.219.110:2181,192.168.219.120:2181,192.168.219.130:2181", 3000,
                new Watcher() {
                    // 监听回调

                    public void process(WatchedEvent event) {
                        System.out.println("正在监听中......");
                    }
                });

        // 监听目录
        children = zkCli.getChildren("/", new Watcher() {

            public void process(WatchedEvent event) {
                System.out.println("监听路径为：" + event.getPath());
                System.out.println("监听的类型为：" + event.getType());
                System.out.println("监听被修改了！！！");
                for (String c : children) {
                    System.out.println(c);
                }
            }
        });
        Thread.sleep(Long.MAX_VALUE);
    }
}

6.zookeeper实现动态感知服务器上下线

在实际的生产环境中我们一般都是集群环境部署的，同一个程序我们会部署在相同的几台服务器中，这时我们可以通过负载均衡服务器去调度，但是我们并不能很快速的获知哪台服务器挂掉了，这时我们就可以使用zookeeper来解决这个问题。

zookeeper的动态感知
??动态感知其实利用的就是zookeeper的watch功能，我们先来看下常规的负载均衡服务器的结构

再来看下我们用zookeeper实现的结构

再来看下我们用zookeeper实现的结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cPsY4wBX-1629287370031)(https://i.loli.net/2021/08/08/1tDbWTk74vcA3Qy.png)]

文字描述：
1.感知上线
??当服务器启动的时候通过程序知道后会同时在zookeeper的servers节点下创建一个新的短暂有序节点来存储当前服务器的信息。客户端通过对servers节点的watch可以立马知道有新的服务器上线了

2.感知下线
??当我们有个服务器下线后，对应的servers下的短暂有序节点会被删除，此时watch servers节点的客户端也能立马知道哪个服务器下线了，能够及时将访问列表中对应的服务器信息移除，从而实现及时感知服务器的变化。

客户端：

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.util.ArrayList;
import java.util.List;

/**
 * @Program BigData
 * @Package PACKAGE_NAME
 * @Auther TeacherHuang
 * @Date 2021/8/8 17:23
 * @Version 1.0
 */
public class ZkWatchClient {
    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        // 1.获取连接
        ZkWatchClient ZkWatchClient = new ZkWatchClient();
        ZkWatchClient.getConnect();

        // 2.监听服务的节点信息
        ZkWatchClient.getServers();

        // 3.业务逻辑（一直监听）
        ZkWatchClient.getWatch();
    }

    // 3.业务逻辑
    public void getWatch() throws InterruptedException {
        Thread.sleep(Long.MAX_VALUE);
    }

    // 2.监听服务的节点信息
    public void getServers() throws KeeperException, InterruptedException {
        List<String> children = zkCli.getChildren("/servers", true);
        ArrayList<String> serverList = new ArrayList<String>();

        // 获取每个节点的数据
        for (String c : children) {
            byte[] data = zkCli.getData("/servers/" + c, true, null);
            serverList.add(new String(data));
        }

        // 打印服务器列表
        System.out.println(serverList);
    }

    private String connectString = "192.168.219.110:2181,192.168.219.120:2181,192.168.219.130:2181";
    private int sessionTimeout = 3000;
    ZooKeeper zkCli = null;

    // 1.连接集群
    public void getConnect() throws IOException {
        zkCli = new ZooKeeper(connectString, sessionTimeout, new Watcher() {


            public void process(WatchedEvent event) {
                List<String> children = null;
                try {
                    // 监听父节点
                    children = zkCli.getChildren("/servers", true);

                    // 创建集合存储服务器列表
                    ArrayList<String> serverList = new ArrayList<String>();

                    // 获取每个节点的数据
                    for (String c : children) {
                        byte[] data = zkCli.getData("/servers/" + c, true, null);
                        serverList.add(new String(data));
                    }

                    // 打印服务器列表
                    System.out.println(serverList);
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

服务端：

import org.apache.zookeeper.*;

import java.io.IOException;

/**
 * @Program BigData
 * @Package PACKAGE_NAME
 * @Auther TeacherHuang
 * @Date 2021/8/8 17:14
 * @Version 1.0
 */
public class ZkWatchServer {

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        // 1.连接zkServer
        ZkWatchServer zkServer = new ZkWatchServer();
        zkServer.getConnect();

        // 2.注册节点信息 服务器ip添加到zk中
        zkServer.regist(args[0]);

        // 3.业务逻辑处理
        zkServer.build(args[0]);
    }

    //如果要多开服务的时候去调用端口号；不然会报错
    private String connectString = "192.168.219.100,192.168.219.120,192.168.219.130";
    private int sessionTimeout = 3000;
    ZooKeeper zkCli = null;
    // 定义父节点
    private String parentNode = "/servers";

    // 1.连接zkServer
    public void getConnect() throws IOException {
        zkCli = new ZooKeeper(connectString, sessionTimeout, new Watcher() {


            public void process(WatchedEvent event) {

            }
        });
    }

    // 2.注册信息
    public void regist(String hostname) throws KeeperException, InterruptedException {
        String node = zkCli.create(parentNode + "/server", hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(node);
    }

    // 3.构造服务器
    public void build(String hostname) throws InterruptedException {
        System.out.println(hostname + ":服务器上线了！");
        Thread.sleep(Long.MAX_VALUE);
    }
}

1、只启动客户端时，控制台输出为：（当前这个节点中没有数据）

2、此时在集群的某一台机器执行以下命令：（添加数据到zookeeper中）

3、此时客户端控制台输出：

4、同时启动客户端和服务端

服务端执行（如果要多开几个服务端的时候，需要进设置；和去掉代码中的端口号；不然会报错）

idea的多启动：

此时服务端输出：

客户端输出：

这样就实现了简单的动态上下线感知。