zooker学习笔记

Zookeeper入门学习

提示：适合刚刚入门的Zookeeper小伙伴。

---

---

一、入门环境准备

1.1、三台Linux操作系统

1.2、三台Linux装有java环境。

1、Linux安装JDK。

• 1、查看Linux中是否有自带的JDK，删除自带的JDK。
  

• 2、如果安装了，检查下安装的路径 which java（查看JDK的安装路径）
  

• 3、删除 rm -rf JDK路径（卸载JDK） rm -rf /usr/bin/java。
  

• 4、检查下自带的JDK。
  

  • 如果没有输入信息表示没有安装。
  • 如果安装可以使用rpm -qa | grep java | xargs rpm -e --nodeps 批量卸载所有带有Java的文件。删除后再次检查JDK。
    

• 5、使用远程连接工具Xftp 7将JDK的压缩包，放入到 /opt目录下。
  

• 6、解压到当前目录，删除JDK压缩包。
  

• 7、查看看JDK解压目录，后面配置环境变量需要。
  

• 8、配置环境变量。打开编辑 /etc/profile 文件。

  • 在文件最后添加以下内容。

    export JAVA_HOME=/opt/jdk1.8.0_301
    export PATH=$PATH:$JAVA_HOME/bin
    export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    export JRE_HOME=$JAVA_HOME/jre
    

    
  • 再次检查安装是否成功。
    

2、扩展：多台Linux服务之间的文件传输。

二、Zookeeper 入门

2.1 概述

• Zookeeper 是一个开源的分布式的，为分布式框架提供协调服务的 Apache 项目(动物饲养员)。
  

2.2、ZooKeeper的工作机制

• Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。
  

2.3、ZooKeeper的特点

• 1）Zookeeper：一个领导者（Leader），只能有一个Leader，因为只能有一个老大负责写数据，多个老大写数据会造成数据的不统一，多个跟随者（Follower）组成的集群，处理数据的读取操作。
• 2）集群中只要有半数以上节点存活，Zookeeper集群就能正常服务。所以Zookeeper适合安装奇数台服务器(原因：如果是偶数太服务器，集群挂掉半数服务器后，服务器存活数依然不大于半数以上的节点，多一台服务器不能提高性能，没必要)。
• 3）全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。
• 4）更新请求顺序执行，来自同一个Client的更新请求按其发送顺序依次执行（任务顺序执行）。
• 5）数据更新原子性，一次数据更新要么成功，要么失败（每次写操作都有事务id（zxid））。
• 6）实时性，在一定时间范围内，Client能读到最新数据。

2.4、ZooKeeper的数据结构

• ZooKeeper 数据模型的结构与 Unix（Linux） 文件系统很类似，整体上可以看作是一棵树，每个节点称做一个 ZNode。每一个 ZNode 默认能够存储 1MB 的数据（不能存储海量的数据，只能存储较小的数据量），每个 ZNode 都可以通过其路径唯一标识。
  

2.5、 应用场景

• 提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡等。

1、统一命名服务

• 在分布式环境下，经常需要对应用/服务进行统一命名，便于识别。例如：IP不容易记住，而域名容易记住，通过同一个域名，访问不同的服务器。
  

2、统一配置管理

• 1）分布式环境下，配置文件同步非常常见。
  • （1）一般要求一个集群中，所有节点的配置信息是一致的，比如 Kafka 集群。
  • （2）对配置文件修改后，希望能够快速同步到各个节点上。
• 2）配置管理可交由ZooKeeper实现。
  • （1）可将配置信息写入ZooKeeper上的一个Znode
  • （2）各个客户端服务器监听这个Znode。
  • （3）一旦Znode中的数据被修改，ZooKeeper将通知各个客户端服务器。
    

3、统一集群管理

• 1）分布式环境中，实时掌握每个节点的状态是必要的。
  • （1）可根据节点实时状态做出一些调整。
• 2）ZooKeeper可以实现实时监控节点状态变化
  • （1）可将节点信息写入ZooKeeper上的一个ZNode。
  • （2）监听这个ZNode可获取它的实时状态变化
    

4、服务器节点动态上下线

• 客户端能实时洞察到服务器上下线的变化
  

5、软负载均衡

• 在Zookeeper中记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户端请求
  

2.6、 下载地址

• 1）官网首页：

  • https://zookeeper.apache.org/

  

• 2）下载截图
  

三、 Zookeeper 本地安装

3.1、 本地模式安装

• 1）安装前准备
  • （1）安装 JDK
    
  • （2）拷贝 apache-zookeeper-3.5.7-bin.tar.gz 安装包到 Linux 系统下
    
  • （3）解压到指定目录（前提目录必须存在，没有需要创建）
    
  • （4）目录结构如下：
    
    
• 2）安装前准备
  • （1）配置修改，修改样例配置文件的名称以及内容。
    
  • （2）打开 zoo.cfg 文件：
    
  • （3）在/opt/module/zookeeper-3.5.7/这个目录上创建 zkData 文件夹
    
  • （4）修改 dataDir 路径（因为 /tmp 目录Linux的临时文件目录，会定期清理）：
    
• 3）操作 Zookeeper
  • （1）启动 Zookeeper
    
    jps：用来查看本地运行着几个java程序，并显示他们的进程号。使用jps时，不需要传递进程号做为参数。
    
  • （2）查看状态
    
  • （3）启动客户端（后面不需要跟参数）
    
  • （4）查看ZooKeeper中的根节点信息，默认有一个zookeeper的节点。
    
  • （5）退出客户端
    
  • （6）停止 Zookeepe
    

3.2、 配置参数解读

Zookeeper中的配置文件zoo.cfg中参数含义解读如下：

• 1）tickTime = 2000：通信心跳时间，Zookeeper服务器与客户端心跳时间，单位毫秒。
  
• 2）initLimit = 10：LF初始通信时限，在第一次Leader和Follower连接时的最大连接心跳次数，时长就是 initLimit*tickTime = 10 * 2000ms = 20s。
  
  • Leader和Follower初始连接时能容忍的最多心跳数（tickTime的数量）。
• 3）syncLimit = 5：LF同步通信时限，Leader和Follower之间通信的心跳次数，时长就是 initLimit*tickTime = 5 * 2000ms = 10s。
  
  • Leader和Follower之间通信时间如果超过syncLimit * tickTime，Leader认为Follwer死掉，从服务器列表中删除Follwer。
• 4）dataDir：保存Zookeeper中的数据
  • 注意：默认的tmp目录，容易被Linux系统定期删除，所以一般不用默认的tmp目录。
• 5）clientPort = 2181：客户端连接端口，通常不做修改。

四、Zookeeper 集群操作

4.1、 集群操作

4.1.1 集群安装

• 1）集群规划
  • 在 hadoop102、hadoop103 和 hadoop104 三个节点上都部署 Zookeeper。
  • 思考：如果是 10 台服务器，需要部署多少台 Zookeeper？
• 2）解压安装
  • 在本地安装模块以讲述，此处不在讲述。
• 3）配置服务器编号
  • （1）在/opt/zookeeper/zookeeper-3.5.7这个目录下创建 zkData（上面也已经创建过了）。
  • （2）在/opt/module/zookeeper-3.5.7/zkData 目录下创建一个 myid 的文件，在文件中添加与 server 对应的编号（注意：名称必须为myid，且不同服务器的值必须不一样，上下不要有空行，左右不要有空格，添加 myid 文件，一定要在 Linux 里面创建，在 notepad++里面很可能乱码）
    
  • （3）拷贝配置好的 zookeeper 到其他机器上，并分别在 其他两个虚拟机上，修改 myid 文件中内容为 2、3。（集群分发脚本可参考这篇文章）
    
• 4）配置zoo.cfg文件
  • （1）重命名/opt/zookeeper/zookeeper-3.5.7/conf 这个目录下的 zoo_sample.cfg 为zoo.cfg（前面已经进行了修改）
  • （2）打开 zoo.cfg 文件

    #修改数据存储路径配置 前面已经进行了修改
    dataDir=/opt/zookeeper/zookeeper-3.5.7/zkData
    

  • （3）配置参数解读，zookeeper就知道有三台服务器了。

    #zoo.cfg  增加如下配置
    ##############cluster  需要自己对应的IP################
    server.1=169.254.118.173:2888:3888
    server.2=169.254.118.175:2888:3888
    server.3=169.254.118.171:2888:3888
    

    • server.A=B:C:D。
    • A 是一个数字，表示这个是第几号服务器； 集群模式下配置一个文件 myid，这个文件在 dataDir目录下，这个文件里面有一个数据 就是 A 的值，Zookeeper 启动时读取此文件，拿到里面的数据与 zoo.cfg 里面的配置信息比较从而判断到底是哪个 server。
    • B 是这个服务器的地址；
    • C 是这个服务器 Follower 与集群中的 Leader服务器交换信息的端口（follower和leader的信息交流窗口）；
    • D 是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。
      
  • （4）同步 zoo.cfg 配置文件到各个服务器上。
    
• 5）集群操作（最好将三台Linux操作系统的防火墙关闭，防止不必要的错误）
  • （1）分别启动 Zookeeper，启动第一台zookeeper服务器，查看状态，发现报错是未启动的状态，原因：因为配置了三台服务器，未超过半数的服务器启动，导致zookeeper会自动停止所有服务器。
    
  • （2）再次开启一个zookeeper，查看其状态（过一会儿在查看状态，马上查看可能状态不会立马改变）。
  • （3）查看第一台zookeeper的状态，状态变为了follower。
    
  • （4）启动最后一台zookeeper，查看其状态。
    

4.1.2 选举机制（面试重点）

1、Zookeeper选举机制——第一次启动

1.1、5台服务器，启动选举过程

• （1）服务器1启动，发起一次选举。服务器1投自己一票。此时服务器1票数一票，不够半数以上（3票），选举无法完成，服务器1状态保持为LOOKING；
• （2）服务器2启动，再发起一次选举。服务器1和2分别投自己一票并交换选票信息：此时服务器1发现服务器2的myid比自己目前投票推举的（服务器1）大，更改选票为推举服务器2。此时服务器1票数0票，服务器2票数2票，没有半数以上结果，选举无法完成，服务器1，2状态保持LOOKING
• （3）服务器3启动，发起一次选举。此时服务器1和2都会更改选票为服务器3。此次投票结果：服务器1为0票，服务器2为0票，服务器3为3票。此时服务器3的票数已经超过半数，服务器3当选Leader。服务器1，2更改状态FOLLOWING，服务器3更改状态为LEADING；
• （4）服务器4启动，发起一次选举。此时服务器1，2，3已经不是LOOKING状态，不会更改选票信息。交换选票信息结果：服务器3为3票，服务器4为1票。此时服务器4服从多数，更改选票信息为服务器3，并更改状态为FOLLOWING；
• （5）服务器5启动，同4一样当小弟。
  

1.2、三个ID

• SID：服务器ID。用来唯一标识一台ZooKeeper集群中的机器，每台机器不能重复，和myid一致。
• ZXID：事务ID。ZXID是一个事务ID，用来标识一次服务器状态的变更。在某一时刻，集群中的每台机器的ZXID值不一定完全一致，这和ZooKeeper服务器对于客户端“更新请求”的处理逻辑有关。
• Epoch：每个Leader任期的代号。没有Leader时同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增

2、Zookeeper选举机制——非第一次启动

• （1）当ZooKeeper集群中的一台服务器出现以下两种情况之一时，就会开始进Leader选举：
  • 服务器初始化启动（上面描述过）。
  • 服务器运行期间无法和Leader保持连接。
• （2）而当一台机器进入Leader选举流程时，当前集群也可能会处于以下两种状态：
  • 集群中本来就已经存在一个Leader。
    • 对于第一种已经存在Leader的情况，机器试图去选举Leader时，会被告知当前服务器的Leader信息，对于该机器来说，仅仅需要和Leader机器建立连接，并进行状态同步即可。
      
  • 集群中确实不存在Leader。
    • 假设ZooKeeper由5台服务器组成，SID分别为1、2、3、4、5，ZXID分别为8、8、8、7、7，并且此时SID为3的服务器是Leader。某一时刻，3和5服务器出现故障，因此开始进行Leader选举。
      
    • SID为1、2、4的机器（超过半数服务器，继续选举leader）投票情况：最终选举服务器2为leader。

机器	EPOCH	ZXID	SID
1	1	8	1
2	1	8	2
4	1	7	4

• （3）选举Leader规则：
  • ①EPOCH大的直接胜出
  • ②EPOCH相同，事务id大的胜出
  • ③事务id相同，服务器id大的胜

4.1.3、 ZK 集群启动停止脚本

• 1）停止所有的服务器
  

• 2）在 hadoop102 的/home/bin 目录下创建脚本（注意需要换成自己对应的IP）
  

  #!/bin/bash
  
  case $1 in
  "start"){
  	for i in 169.254.118.173 169.254.118.175 169.254.118.171
  	do
  		echo -------- zookeeper $i 启动--------
  		ssh $i "/opt/zookeeper/zookeeper-3.5.7/bin/zkServer.sh start"
  	done
  }
  ;;
  "stop"){
  	for i in 169.254.118.173 169.254.118.175 169.254.118.171
  	do
  		echo -------- zookeeper $i 停止--------
  		ssh $i "/opt/zookeeper/zookeeper-3.5.7/bin/zkServer.sh stop"
  	done
  }
  ;;
  "status"){
  	for i in 169.254.118.173 169.254.118.175 169.254.118.171
  	do
  		echo -------- zookeeper $i 状态--------
  		ssh $i "/opt/zookeeper/zookeeper-3.5.7/bin/zkServer.sh status"
  	done
  }
  ;;
  esac
  

• 3）增加脚本执行权限
  

• 4）Zookeeper 集群启动脚本

  • 正常启动（启动前关闭所有服务器的防火墙，防止启动失败）
    
  • 如果启动不了报错以下的，与JAVA_HOME相关，可参考文章

• 5）Zookeeper 集群查看状态脚本
  

• 6）Zookeeper 集群停止脚本
  

4.2 客户端命令行操作

4.2.1、命令行语法

• 基本语法

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

• 1）启动客户端，前缀默认为 localhost
  

• 2）显示的改变前缀（不能随意取，只能用ip，否则会启动之后报错）
  

• 3）显示所有操作命令
  

4.2.2、 znode 节点数据信息

• 使用ls / 查看/(根节点)节点下状况和详细数据
  
• （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 子节点数量

4.2.3 、节点类型（持久/短暂/有序号/无序号）

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

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

• （1）持久化目录节点（Client1）

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

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

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

• （3）临时目录节点（Client3）

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

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

  • 客户端与 Zookeeper 断开连接后，该节点被删除，只是Zookeeper给该节点名称进行顺序编号。

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

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

• 启动客户端
  

• 1）分别创建2个普通节点（永久节点 + 不带序号）
  

• 2）获得节点的值
  

• 3）创建带序号的节点（永久节点 + 带序号）

  • 如果原来没有序号节点，序号从 0 开始依次递增。如果原节点下已有 2 个节点，则再排序时从 2 开始，以此类推。
    

• 4）创建短暂节点（短暂节点 + 不带序号和带序号）

  • （1）创建短暂的不带序号的节点和短暂的带序号的节点
    

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

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

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

• 5）修改节点数据值
  

4.2.4、监听器原理

• 客户端注册监听它关心的目录节点，当目录节点发生变化（数据改变、节点删除、子目录节点增加删除）时，ZooKeeper 会通知客户端。监听机制保证 ZooKeeper 保存的任何的数据的任何改变都能快速的响应到监听了该节点的应用程序。
• 1、监听原理详解
  • 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]
• 3、节点的值变化监听

  • （1）穹顶主机1和主机2的客户端
    

  • （2）在主机1上注册监听/sanguo 节点数据变化
    

  • （3）在主机2上修改/sanguo 节点的数据
    

  • （4）观察主机1收到数据变化的监听
    

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

• 6、节点的子节点变化监听（路径变化）

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

  • （2）在主机2 /sanguo 节点上创建子节点
    

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

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

4.2.5 、节点删除与查看

• 1）删除节点
  
• 2）递归删除节点
  
• 3）查看节点状态
  

4.3、客户端 API 操作

• 前提：保证三台服务器上 Zookeeper 集群服务端启动。

4.3.1、 IDEA 环境搭建

• 1）创建一个maven工程：zookeeper
  
• 2）添加pom文件

  <dependencies>
      <dependency>
          <groupId>org.apache.logging.log4j</groupId>
          <artifactId>log4j-core</artifactId>
          <version>2.8.2</version>
      </dependency>
      <dependency>
          <groupId>org.apache.zookeeper</groupId>
          <artifactId>zookeeper</artifactId>
          <version>3.5.7</version>
      </dependency>
  </dependencies>
  

• 3）拷贝log4j.properties文件到项目根目录
• 需要在项目的 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 
  

• 4）创建包
• 5）创建类名称ZkClient

4.3.2、 创建 ZooKeeper 客户端

• ZkClient连接代码

  public class ZkClient {
     //连接IP地址和对应的端口号，多个主机之间用,分割,逗号前后不能有空格，否则会报错
      private static String connection = "169.254.118.173:2181,169.254.118.177:2181";
      //超时时间
      private static int sessionTime = 200000;
      public static void main(String[] args) throws IOException {
        
          init();
      }
      /**
       * 客户端连接服务端
       */
      private static void init() throws IOException {
          /**
           *connection:连接的主机IP地址和对应的端口号，多个连接用逗号分开
           *sessionTime：连接服务器的超时时间，单位毫秒
           *watcher:监听的触发事件
           */
          ZooKeeper zooKeeper = new ZooKeeper(connection, sessionTime, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
  
              }
          });
      }
  }
  

• 运行结果
  

4.3.3、 创建子节点

• ZkClient创建子节点代码

  public class ZkClient {
      //连接IP地址和对应的端口号，多个主机之间用,分割,逗号前后不能有空格，否则会报错
      private static String connection = "169.254.118.173:2181,169.254.118.177:2181";
      //超时时间
      private static int sessionTime = 200000;
  
      private static ZooKeeper zooKeeper;
  
      public static void main(String[] args) throws Exception {
  
          init();
          create();
      }
      /**
       * 客户端连接服务端
       */
      private static void init() throws IOException {
          /**
           *connection:连接的主机IP地址和对应的端口号，多个连接用逗号分开
           *sessionTime：连接服务器的超时时间，单位毫秒
           *watcher:监听的触发事件
           */
          zooKeeper = new ZooKeeper(connection, sessionTime, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
  
              }
          });
      }
      /**
       * 创建节点
       */
      public static void create() throws Exception {
          /**
           * path:创建的节点路径
           * data:节点对应的值
           * acl:权限
           * createMode:节点类型(持久型节点、临时节点)
           */
          String s = zooKeeper.create("/noMy", "pj".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
          System.out.println(s);
      }
  }
  

  • 节点权限和节点类型的设置值的具体情况
    
    

• 如果抛出一下异常，请增大 sessionTimeout 的连接时间，具体原因请查看这篇文章。
  

• 运行结果
  

• 在主机上的，zk 客户端上查看创建节点情况

4.3.4、 获取子节点并监听节点变化

注意：这里只能监控直接子节点，且子节点的增减情况能够监控到，节点值变化不会被监控。

• （1）ZkClient监听子节点代码

  public class ZkClient {
      //连接IP地址和对应的端口号，多个主机之间用,分割,逗号前后不能有空格，否则会报错
      private static String connection = "169.254.118.173:2181,169.254.118.177:2181";
      //超时时间
      private static int sessionTime = 200000;
  
      private static ZooKeeper zooKeeper;
  
      public static void main(String[] args) throws Exception {
          init();
          getChildren();
      }
  
      /**
       * 客户端连接服务端
       */
      private static void init() throws IOException {
          /**
           *connection:连接的主机IP地址和对应的端口号，多个连接用逗号分开
           *sessionTime：连接服务器的超时时间，单位毫秒
           *watcher:监听的触发事件
           */
          zooKeeper = new ZooKeeper(connection, sessionTime, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
              	System.out.println("--------------");
                  List<String> children = null;
                  try {
                      children = zooKeeper.getChildren("/", true);
                      for (String child : children) {
                          System.out.println(child);
                      }
                      System.out.println("--------------");
                  } catch (Exception e) {
                  }
  
              }
          });
      }
  
      /**
       * 客户端，监听某个节点
       */
      public static void getChildren() throws Exception{
          /**
           *getChildren()方法仅仅监控对应节点直接子目录的一次变化，
           *但是只会监控直接子节点的增减情况，不会监控数据变化情况！
           *若要每次对应节点发生增减变化都被监测到，那么每次都得先调用
           *getChildren()方法获取一遍节点的子节点列表！
           *
           * path：监听的节点路径
           * watch:监听事件，true代表监听，且监听事件使用的是初始化时候的监听事件
           new ZooKeeper(connection, sessionTime, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
  
              }
              });
           */
          zooKeeper.getChildren("/", true);
  		//延迟阻塞，使程序不停止，一直监控
          Thread.sleep(Integer.MAX_VALUE);
      }
  }
  
  

• （2）在 IDEA 控制台上看到如下节点
  

• （3）在主机1的客户端上创建再创建一个节点/noMy2，观察 IDEA 控制台
  

• （4）在主机1的客户端上删除节点/noMy2，观察 IDEA 控制台
  

4.3.5 、判断 Znode 是否存在

• （1）ZkClient判断子节点是否代码

  public class ZkClient {
      //连接IP地址和对应的端口号，多个主机之间用,分割,逗号前后不能有空格，否则会报错
      private static String connection = "169.254.118.173:2181,169.254.118.177:2181";
      //超时时间
      private static int sessionTime = 200000;
  
      private static ZooKeeper zooKeeper;
  
      public static void main(String[] args) throws Exception {
          init();
          exist();
      }
  
      /**
       * 客户端连接服务端
       */
      private static void init() throws IOException {
          /**
           *connection:连接的主机IP地址和对应的端口号，多个连接用逗号分开
           *sessionTime：连接服务器的超时时间，单位毫秒
           *watcher:监听的触发事件
           */
          zooKeeper = new ZooKeeper(connection, sessionTime, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
                  // 收到事件通知后的回调函数（用户的业务逻辑）
                  System.out.println("--------------");
                  // 再次启动监听
                  List<String> children = null;
                  try {
                      children = zooKeeper.getChildren("/", true);
                      for (String child : children) {
                          System.out.println(child);
                      }
                      System.out.println("--------------");
                  } catch (Exception e) {
                  }
  
              }
          });
      }
      /**
       * 判断节点路径是否存在
       */
      public static void exist() throws KeeperException, InterruptedException {
          Stat exists = zooKeeper.exists("/noMy2", false);
          System.out.println(exists==null?"不存在":"存在");
      }
  }
  

• 运行结果
  

4.4、 客户端向服务端写数据流程

4.4.1、写流程之写入请求直接发送给Leader节点

4.4.2、写流程之写入请求发送给follower节点

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

5.1 、需求

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

5.2、 需求分析

• 服务器动态上下线

5.3、实现

• （1）先在集群上创建/servers 节点
  

• （2）服务器端向 Zookeeper 注册代码

  /**
   * 服务器动态上下线监听 服务端
   */
  public class DistributeServer {
  
      private static ZooKeeper zooKeeper;
      private String connectString = "169.254.118.173:2181,169.254.118.177:2181";
      private int sessionTimeOut = 200000;
      private String parentNode = "/servers";
  
      public static void main(String[] args) throws Exception {
          DistributeServer distributeServer = new DistributeServer();
          // 1 获取 zk 连接
          distributeServer.getConnect();
  
          // 2 利用 zk 连接注册服务器信息
          distributeServer.registServer(args[0]);
  
          // 3 启动业务功能
          distributeServer.business();
      }
  
      //业务流程
      private void business() {
          try {
              //让服务器一直启动着
              Thread.sleep(Long.MAX_VALUE);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      //获取连接
      private void getConnect() throws IOException {
          zooKeeper = new ZooKeeper(connectString, sessionTimeOut, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
  
              }
          });
      }
  
      /**
       * 将服务器注册到zk中
       * @param hostName 主机服务器
       */
      private void registServer(String hostName) throws KeeperException, InterruptedException {
          /**
           *  创建一个节点
           *      节点路径为：/servers/server
           *      值为hostName
           *      节点权限为:所有人都可以访问
           *      节点类型为:临时带序号的节点
           */
          String s = zooKeeper.create(parentNode + "/server", hostName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
          System.out.println(hostName+"已连接"+ s);
      }
  }
  

• （3）客户端代码

  /**
   * 服务器动态上下线监听 服务端
   */
  public class DistributeClient {
  
      private ZooKeeper zooKeeper;
      private String connectString = "169.254.118.173:2181,169.254.118.177:2181";
      private int sessionTimeOut = 200000;
      private String parentNode = "/servers";
  
  
      public static void main(String[] args) throws Exception {
          DistributeClient distributeClient = new DistributeClient();
          // 1 获取 zk 连接
          distributeClient.getConnect();
  
          // 2 获取 servers 的子节点信息，监控/servers 下节点的增加、删除，从中获取服务器信息列表
          distributeClient.getServerList();
  
          // 3 业务进程启动（休眠）
          // 3 业务进程启动
          distributeClient.business();
      }
  
      // 业务功能
      private void business() {
          try {
              Thread.sleep(Long.MAX_VALUE);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      /**
       * 获取服务器列表信息
       */
      private void getServerList() throws KeeperException, InterruptedException {
          /**
           * 获取/servers 节点路径下的所有节点，
           * 且进行监控，使用new ZooKeeper()时的监听事件，
           * 如果自己new Watcher()就使用自己的
           */
          List<String> children = zooKeeper.getChildren(parentNode, true);
          byte[] data;
          //遍历所有节点，获取节点中的主机名称信息
          for (String child : children) {
              /**
               * 获取数据
               *   path:节点路径，获取节点路径为 /servers/的每个节点下的值
               *   watch:是否监控
               *   stat：状态
               */
              data = zooKeeper.getData(parentNode + "/" + child, false, null);
              System.out.println(parentNode + "/" + child +"节点的值为:"+new String(data));
          }
      }
  
      //获取zk服务端连接
      private void getConnect() throws IOException {
          zooKeeper = new ZooKeeper(connectString, sessionTimeOut, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
                  try {
                      //持续监控 parentNode 节点路径
                      getServerList();
                  } catch (KeeperException e) {
                      e.printStackTrace();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          });
      }
  }
  

5.4 测试

• 1）在 Linux 命令行上操作增加减少服务器，测试客户端代码是否正确
  • （1）启动 DistributeClient 客户端
  • （2）在 主机1上 zk 的客户端/servers 目录上创建临时带序号节点
    
  • （3）观察 Idea 控制台变化
    
  • （4）执行删除操作
    
  • （5）观察 Idea 控制台变化
    
• 2）在 Idea 上操作增加减少服务器
  • （1）启动 DistributeClient 客户端（如果已经启动过，不需要重启）
  • （2）启动 DistributeServer 服务
    • ①点击 Edit Configurations…
      
    • ②在弹出的窗口中（Program arguments）输入想启动的主机，点击确认，例如，169.254.118.173
      
    • ③回到 DistributeServer 的 main 方 法 ， 运行main方法。
  • （3）观察 DistributeServer 控制台，提示" 169.254.118.173已连接/servers/server0000000003"
    
  • （4）观察 DistributeClient 控制台。
    
  • （5）更改连接主机ip，测试。
    

六、 ZooKeeper 分布式锁案例

6.1、什么叫做分布式锁呢？

• 比如说"进程 1"在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。
  

6.2、 原生 Zookeeper 实现分布式锁案例

• 1）分布式锁实现

  /**
   * 原生 Zookeeper 实现分布式锁案例
   */
  public class DistributedLock {
      private ZooKeeper zooKeeper;
      private String connectString = "169.254.118.173:2181,169.254.118.177:2181";
      private int sessionTimeOut = 200000;
      private String rootNode = "/locks";
      private String subNode = "/seq-";
      //ZooKeeper 连接 等待锁
      private CountDownLatch countDownLatch = new CountDownLatch(1);
      //ZooKeeper 节点等待 等待锁
      private CountDownLatch waitLatch = new CountDownLatch(1);
      private String currentNode;
      private String waitPath;
  
  
      // 和 zk 服务建立连接，如果根节点不存在，就创建根节点
      public DistributedLock() throws Exception {
          //创建连接
          zooKeeper = new ZooKeeper(connectString, sessionTimeOut, new Watcher() {
              @Override
              public void process(WatchedEvent watchedEvent) {
                  // 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程
                  //获取当前连接的状态，判断是否是异步连接
                  if (watchedEvent.getState()==Event.KeeperState.SyncConnected){
                      //异步连接上了之后，释放 zk连接锁
                      countDownLatch.countDown();
                  }
                  // 发生了 waitPath 的删除事件  且删除的路径为 最小的路径  就打开节点等待锁
                  if (watchedEvent.getType() == Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)){
                      waitLatch.countDown();
                  }
              }
          });
  
          //等待zk连接上之后在往下执行
          countDownLatch.await();
  
          //判断 /locks锁是否存在
          Stat exists = zooKeeper.exists(rootNode, false);
          if (exists == null){
              //不存在就创建
              //创建一个 /locks 路径 值为 locks的节点、不带序号的持久性节点
              zooKeeper.create(rootNode, "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
          }
          //存在就不需要创建
      }
  
      //加锁方法
      public void zkLock() throws Exception {
          //在根节点下创建临时顺序节点，返回值为创建的节点路径
          currentNode = zooKeeper.create(rootNode + subNode, subNode.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
          // wait 一小会, 让结果更清晰一些
          Thread.sleep(10);
  
          // 获取 /locks 下所有节点，注意, 没有必要监听"/locks"的子节点的变化情况
          List<String> children = zooKeeper.getChildren(rootNode, false);
  
          // 列表中只有一个子节点, 那肯定就是 currentNode , 说明client 获得锁
          if (children.size() == 1){
              return;
          }else {
              //对根节点下的所有临时顺序节点进行从小到大排序
              Collections.sort(children);
  
              //当前节点名称  /locks/seq-0000000000  获取的就是  seq-0000000000
              String thisNode = currentNode.substring((rootNode+"/").length());
              //获取当前节点的位置
              int index = children.indexOf(thisNode);
  
              if (index == -1){
                  //当前节点不存在集合中
                  System.out.println(thisNode + "数据异常");
              }else if (index == 0){
                  // index == 0, 说明 创建的 thisNode 在列表中最小, 当前client 获得锁
                  return;
              }else {
                  //index >0 证明当前创建的节点不在最小的位置，需要往上面找小的节点，并监听他
                  // 获得排名比 currentNode 前 1 位的节点
                  waitPath =rootNode+"/"+ children.get(index - 1);
                  //获取waitPath的数据
                  zooKeeper.getData( waitPath, true, null);
                  waitLatch.await();
                  return;
  
              }
  
          }
  
      }
  
      //解锁放发
      public void zkUnlock(){
          try {
              //删除加锁时，创建的节点
              zooKeeper.delete(currentNode, -1);
          } catch (InterruptedException e) {
              e.printStackTrace();
          } catch (KeeperException e) {
              e.printStackTrace();
          }
      }
  }
  
  

• 2）分布式锁测试

  /**
   * 原生 Zookeeper 实现分布式锁案例 测试类
   */
  public class DistributedLockTest {
      public static void main(String[] args) throws Exception {
          DistributedLock lock1 = new DistributedLock();
          DistributedLock lock2 = new DistributedLock();
          DistributedLock lock3 = new DistributedLock();
          new Thread(() -> {
              try {
                  lock1.zkLock();
                  System.out.println("lock1获取到锁");
                  Thread.sleep(5 * 1000);
                  lock1.zkUnlock();
                  System.out.println("lock1释放锁");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "线程1").start();
  
          new Thread(() -> {
              try {
                  lock2.zkLock();
                  System.out.println("lock2获取到锁");
                  Thread.sleep(5 * 1000);
                  lock2.zkUnlock();
                  System.out.println("lock2释放锁");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "线程2").start();
  
          new Thread(() -> {
              try {
                  lock3.zkLock();
                  System.out.println("lock3获取到锁");
                  Thread.sleep(5 * 1000);
                  lock3.zkUnlock();
                  System.out.println("lock3释放锁");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }, "线程3").start();
      }
  }
  
  

• 3）观察控制台变化
  

6.3、 Curator 框架实现分布式锁案例

• 1）原生的 Java API 开发存在的问题

  • （1）会话连接是异步的，需要自己去处理。比如使用 CountDownLatch
  • （2）Watch 需要重复注册，不然就不能生效
  • （3）开发的复杂性还是比较高的
  • （4）不支持多节点删除和创建。需要自己去递归

• 2）Curator 是一个专门解决分布式锁的框架，解决了原生 JavaAPI 开发分布式遇到的问题。

  • 详情请查看官方文档：https://curator.apache.org/index.html

• 3）Curator 案例实操

  • （1）添加依赖

    <dependency>
    	 <groupId>org.apache.curator</groupId>
    	 <artifactId>curator-framework</artifactId>
    	 <version>4.3.0</version>
    </dependency>
    <dependency>
    	 <groupId>org.apache.curator</groupId>
    	 <artifactId>curator-recipes</artifactId>
    	 <version>4.3.0</version>
    </dependency>
    <dependency>
    	 <groupId>org.apache.curator</groupId>
    	 <artifactId>curator-client</artifactId>
    	 <version>4.3.0</version>
    </dependency>
    

  • （2）代码实现

    /**
     * Curator 框架实现分布式锁案例
     */
    public class CuratorLockTest {
        private static String rootNode = "/locks";
        private static int connectionTimeout = 200000;
        private static String connectString = "169.254.118.173:2181,169.254.118.177:2181";
        private static int sessionTimeout = 200000;
    
        public static void main(String[] args) {
            // 创建分布式锁 1
            InterProcessLock lock1 = new InterProcessMutex(getCuratorFramework(),rootNode);
            // 创建分布式锁 2
            InterProcessLock lock2 = new InterProcessMutex(getCuratorFramework(),rootNode);
    
            new Thread(() -> {
    
                try {
                    // 获取锁对象
                    lock1.acquire();
                    System.out.println("lock1上锁");
    
                    // 测试锁重入
                    lock1.acquire();
                    System.out.println("lock1再次上锁");
    
                    Thread.sleep(5 * 1000);
    
                    lock1.release();
                    System.out.println("lock1释放锁");
    
                    lock1.release();
                    System.out.println("lock1再次释放锁");
    
                } catch (Exception e) {
    
                    e.printStackTrace();
                }
            }, "线程1").start();
    
            new Thread(() -> {
    
                try {
                    lock2.acquire();
                    System.out.println("lock2上锁");
    
                    lock2.acquire();
                    System.out.println("lock2再次上锁");
    
                    Thread.sleep(5 * 1000);
    
                    lock2.release();
                    System.out.println("lock2释放锁");
    
                    lock2.release();
                    System.out.println("lock2再次释放锁");
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "线程2").start();
        }
    
        // 分布式锁初始化
        private static CuratorFramework getCuratorFramework() {
            //重试策略，初试时间 3 秒，重试 3 次
            RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 3);
    
            //通过工厂创建 Curator
            CuratorFramework build = CuratorFrameworkFactory.builder()
                    .connectString(connectString)
                    .connectionTimeoutMs(connectionTimeout)
                    .sessionTimeoutMs(sessionTimeout)
                    .retryPolicy(retryPolicy).build();
            //开启连接
            build.start();
            System.out.println("zookeeper 初始化完成...");
            return build;
        }
    }
    
    

  • （3）观察控制台变化
    

7、 企业面试真题（面试重点）

7.1、 选举机制

• 半数机制，超过半数的投票通过，即通过。
  • （1）第一次启动选举规则：投票过半数时，服务器 id（myid） 大的胜出
  • （2）第二次启动选举规则：
    • ①EPOCH 大的直接胜出
    • ②EPOCH 相同，事务 id 大的胜出
    • ③事务 id 相同，服务器 id 大的胜出

7.2、 生产集群安装多少 zk 合适？

• 安装奇数台。
• 生产经验：
  • 10 台服务器：3 台 安装zk；
  • 20 台服务器：5 台 安装zk；
  • 100 台服务器：11 台 安装zk；
  • 200 台服务器：11 台 安装zk
• 服务器台数多：好处，提高可靠性；坏处：提高通信延时（半数机制会导致）

7.3、 常用命令

• ls、get、create、delet