文章预览：

• Zookeeper
• • • 1、介绍zookeeper
    • 【目标】
    • 【路径】
    • 【概述】
    • • 1.1、zookeeper概述
      • 1.2、zookeeper的发展历程
      • 1.3、什么是分布式
      • • 1.3.1、集中式系统
        • 1.3.2、分布式系统
      • 1.4、zookeeper的应用场景【面试 知道】
      • • 1.4.1、 注册中心
        • 1.4.2、配置中心
        • 1.4.3、分布式锁（面试）
        • 1.4.4、分布式队列（了解）
        • 1.4.5、负载均衡
    • 【小结】
    • 2、zookeeper环境搭建【重点】
    • 【目标】
    • 【路径】
    • 【讲解】
    • • 2.1、 前提
      • 2.2、安装zookeeper
      • • 2.2.1、下载
        • 2.2.2、解压
        • 2.2.3、修改配置文件
        • 2.2.4、启动zookeeper
        • 2.2.5、启动客户端测试
    • 【小结】
    • 3、zookeeper基本操作【次重点，存小抄】
    • 【目标】
    • 【路径】
    • 【讲解】
    • • 3.1、zookeeper数据结构
      • 3.2、节点的分类【重点】
      • 3.2、客户端命令
      • • 3.2.1、查询所有命令
        • 3.2.2、查询跟路径下的节点
        • 3.2.3、创建普通永久节点
        • 3.2.4、创建带序号永久节点
        • 3.2.5、创建普通临时节点
        • 3.2.6、创建带序号临时节点
        • 3.2.7、查询节点数据
        • 3.2.8、修改节点数据
        • 3.2.9、删除节点
        • 3.2.10、递归删除节点
        • 3.2.11、查看节点状态
        • 3.4.12、日志的可视化
      • 小结
      • 3.3、zookeeper 的java Api介绍
      • • 3.3.1、ZooKeeper常用Java API
        • 3.3.2、创建java 工程，导入依赖
        • 3.3.3、java创建节点
        • 3.3.4 小结
      • 3.4、watch机制【机制重点】
      • • 3.4.1、什么是watch机制
        • 3.4.2、 NodeCache
        • 增加监听
        • 3.4.3、 PathChildrenCache
        • 3.4.4、TreeCache
    • 【小结】

Zookeeper

• 了解zookeeper
• 了解zookeeper的应用场景
• 了解zookeeper的基本概念和数据模型
• 能够搭建和配置zookeeper
• 熟练操作zookeeper服务端和客户端命令
• 能够使用java api 操作zookeeper
• 理解zookeeper watch机制
• 能搭建zookeeper集群

1、介绍zookeeper

【目标】

1：了解Zookeeper的概念

2：了解分布式的概念

【路径】

1：Zookeeper概述

2：Zookeeper的发展历程

3：什么是分布式

4：Zookeeper的应用场景

【概述】

1.1、zookeeper概述

​ ZooKeeper从字面意思理解，【Zoo - 动物园，Keeper - 管理员】动物园中有很多种动物，这里的动物就可以比作分布式环境下多种多样的服务，而ZooKeeper做的就是管理这些服务。
​ Apache ZooKeeper的系统为分布式协调是构建分布式应用的高性能服务。
​ ZooKeeper 本质上是一个分布式的小文件存储系统。提供基于类似于文件系统的目录树方式的数据存储，并且可以对树中的节点进行有效管理。从而用来维护和监控你存储的数据的状态变化。通过监控这些数据状态的变化，从而可以达到基于数据的集群管理。
​ ZooKeeper 适用于存储和协同相关的关键数据，不适合用于大数据量存储。

是一个分布式的小文件管理系统，管理分布式服务(Web Service)

1.2、zookeeper的发展历程

​ ZooKeeper 最早起源于雅虎研究院的一个研究小组。当时研究人员发现，在雅虎内部很多大型系统基本都需要依赖一个系统来进行分布式协同，但是这些系统往往都存在分布式单点问题。
​ 所以，雅虎的开发人员就开发了一个通用的无单点问题的分布式协调框架，这就是ZooKeeper。ZooKeeper之后在开源界被大量使用，很多著名开源项目都在使用zookeeper，例如：

• Hadoop：使用ZooKeeper 做Namenode 的高可用。
• HBase：保证集群中只有一个master，保存hbase:meta表的位置，保存集群中的RegionServer列表。
• Kafka：集群成员管理，controller 节点选举。

1.3、什么是分布式

1.3.1、集中式系统

集中式系统，集中式系统中整个项目就是一个独立的应用，整个应用也就是整个项目，所有的东西都在一个应用里面。部署到一个服务器上。
布署项目时，放到一个tomcat里的。也称为单体架构

1.3.2、分布式系统

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是==利用更多的机器，处理更多的数据==

随着公司的发展，应用的客户变多，功能也日益完善，加了很多的功能，整个项目在一个tomcat上跑，tomcat说它也很累，能不能少跑点代码，这时候 就产生了。我们可以把大项目按功能划分为很多的模块，比如说单独一个系统处理订单，一个处理用户登录，一个处理后台等等，然后每一个模块都单独在一个tomcat中跑，合起来就是一个完整的大项目，这样每一个tomcat都非常轻松。

分布式系统的描述总结是：

• 多台计算机构成
• 计算机之间通过网络进行通信
• 彼此进行交互
• 共同目标 有共同的功能

小结：

集中式：开发项目时都是在同一个应用里，布署到一个tomcat，只有一个tomcat即可

分布式：分多个工程开发，布署多个tomcat里， 单个拆成多个

1.4、zookeeper的应用场景【面试 知道】

1.4.1、 注册中心

​ 分布式应用中，通常需要有一套完整的命名规则，既能够产生唯一的名称又便于人识别和记住，通常情况下用树形的名称结构是一个理想的选择，树形的名称结构是一个有层次的目录结构。通过调用Zookeeper提供的创建节点的API，能够很容易创建一个全局唯一的path，这个path就可以作为一个名称。
​ 阿里巴巴集团开源的分布式服务框架Dubbo中使用ZooKeeper来作为其命名服务，维护全局的服务地址列表。

1.4.2、配置中心

​ 数据发布/订阅即所谓的配置中心：发布者将数据发布到ZooKeeper一系列节点上面，订阅者进行数据订阅，当数据有变化时，可以及时得到数据的变化通知，达到动态获取数据的目的。

ZooKeeper 采用的是推拉结合的方式。

1、推: 服务端会推给注册了监控节点的客户端 Wathcer 事件通知

2、拉: 客户端获得通知后，然后主动到服务端拉取最新的数据

1.4.3、分布式锁（面试）

​ 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。

1.4.4、分布式队列（了解）

​ 在传统的单进程编程中，我们使用队列来存储一些数据结构，用来在多线程之间共享或传递数据。分布式环境下，我们同样需要一个类似单进程队列的组件，用来实现跨进程、跨主机、跨网络的数据共享和数据传递，这就是我们的分布式队列。

RabbitMQ

1.4.5、负载均衡

​ 负载均衡是通过负载均衡算法，用来把对某种资源的访问分摊给不同的设备，从而减轻单点的压力。

上图中左侧为ZooKeeper集群，右侧上方为工作服务器，下面为客户端。每台工作服务器在启动时都会去ZooKeeper的servers节点下注册临时节点，每台客户端在启动时都会去servers节点下取得所有可用的工作服务器列表，并通过一定的负载均衡算法计算得出一台工作服务器，并与之建立网络连接

让分布式中服务被调用的次数相对就均匀

【小结】

Zookeeper: 分布式小文件存储系统，管理的是分布式中服务，树形层级目录结构

作用：

• 注册中心 房产中介 协调服务提供者与消费者 正常的调用

• 配置中心 分布式的所有应该都来中心读取配置,订阅，中心一旦修改，就会通知服务，服务就会去获取新的配置，所有应该都更新配置

• 分布式锁：多个应用在同一时刻只能有一个应用能访问资源。

  zookeeper: 一旦获得资源，标记已使用（ 创建临时节点数据），被标记了则订阅。释放（删除数据），订阅者就会收到通知，竞争资源 惊群效应问题

• 分布式队列：使用zookeeper有序节点数据，惊群-监听上一个

• 负载均衡: 多个应用被调用的次数相对平均

  • 随机
  • 轮循
  • 最小活跃数
  • 一致性哈希

2、zookeeper环境搭建【重点】

【目标】

1：在window上安装Zookeeper

【路径】

1：安装Zookeeper的前提

2：在window上安装Zookeeper

【讲解】

2.1、 前提

​ 必须安装==jdk 1.8==，配置jdk环境变量，步骤略

2.2、安装zookeeper

2.2.1、下载

下载地址：http://zookeeper.apache.org

2.2.2、解压

【注意】解压到没有中文路径的目录下（不要出现中文和空格）

2.2.3、修改配置文件

在zookeeper路径下创建一个data目录及log目录

修改配置文件

conf路径中复制一份zoo_sample.cfg,改名为 zoo.cfg

指定保存数据的目录：data目录和log存储日志

如果需要日志，可以创建log文件夹，指定dataLogDir属性

2.2.4、启动zookeeper

打开bin路径，双击zkServer.cmd,启动zookeeper服务

2.2.5、启动客户端测试

启动客户端，看到 ‘Welcome to Zookeeper!’ 说明成功

【小结】

1：安装Zookeeper的前提 环境变量 jdk1.8

2：在window上安装Zookeeper 解压到没有中文没有空格的目录

​ 创建data目录与bin同级

​ 复制conf/zoo_simple.cfg，改名为zoo.cfg(启动时加载)

​ zoo.cfg -> dataDir=…/data

​ log日志，创建log目录与bin同级

​ zoo.cfg -> dataLogDir=…/log

3: 【注意】：服务端 窗口不要选中任何区域（阻塞请求，客户端连不上），如果选中了则按 ESC 键

右击窗口的属性，去除编辑与插入模式钩选

3、zookeeper基本操作【次重点，存小抄】

【目标】

1：Zookeeper的客户端命令
help查看命令,以下命令在zookeeper不同版本的命令可能有所不同

2：Zookeeper的java的api操作

【路径】

1：Zookeeper的数据结构

2：节点的分类

• 持久性
• 临时性

3：客户端命令（创建、查询、修改、删除）

4：Zookeeper的java的api介绍（创建、查询、修改、删除）

5：Zookeeper的watch机制

• NodeCache
• PathChildrenCache
• TreeCache

【讲解】

3.1、zookeeper数据结构

​ ZooKeeper 的数据模型是层次模型。层次模型常见于文件系统。例如：我的电脑可以分为多个盘符（例如C、D、E等），每个盘符下可以创建多个目录，每个目录下面可以创建文件，也可以创建子目录，最终构成了一个树型结构。通过这种树型结构的目录，我们可以将文件分门别类的进行存放，方便我们后期查找。而且磁盘上的每个文件都有一个唯一的访问路径，例如：C:\Windows\itcast\hello.txt。

层次模型和key-value 模型是两种主流的数据模型。ZooKeeper 使用文件系统模型主要基于以下两点考虑：

1. 文件系统的树形结构便于表达数据之间的层次关系。

2. 文件系统的树形结构便于为不同的应用分配独立的命名空间（namespace 路径url 唯一）。

​ ZooKeeper 的层次模型称作data tree。Datatree 的每个节点叫作znode（Zookeeper node）。不同于文件系统，每个节点都可以保存数据。每个节点都有一个版本(version)。版本从0 开始计数。

如图所示，data tree中有两个子树，用于应用1( /app1)和应用2（/app2）。

每个客户端进程pi 创建一个znode节点 p_i 在 /app1下， /app1/p_1就代表一个客户端在运行。

3.2、节点的分类【重点】

一：一个znode可以是持久性的，也可以是临时性的

1. 持久性znode[PERSISTENT]，这个znode一旦创建不会丢失，无论是zookeeper宕机，还是client宕机。

2. 临时性的znode[EPHEMERAL]，如果zookeeper宕机了，或者client在指定的timeout时间内没有连接server，都会被认为丢失。 -e

二：znode也可以是顺序性的，每一个顺序性的znode关联一个唯一的单调递增整数。这个单调递增整数是znode名字的后缀。

3. 持久顺序性的znode(PERSISTENT_SEQUENTIAL):znode 处理具备持久性的znode的特点之外，znode的名称具备顺序性。 -s

4. 临时顺序性的znode(EPHEMERAL_SEQUENTIAL):znode处理具备临时性的znode特点，znode的名称具备顺序性。-s

3.2、客户端命令

3.2.1、查询所有命令

help

3.2.2、查询跟路径下的节点

ls /zookeeper

3.2.3、创建普通永久节点

create /app1 "helloworld"

创建app1节点，值为helloworld

3.2.4、创建带序号永久节点

create -s /hello "helloworld2"

3.2.5、创建普通临时节点

create -e /app3 'app3'

-e:表示普通临时节点

关闭客户端，再次打开查看 app3节点消失

3.2.6、创建带序号临时节点

create -e -s /app4 'app4'

-e:表示普通临时节点

-s:表示带序号节点

关闭客户端，再次打开查看 app4节点消失

close是关闭客户端服务器,connection是连接客户端服务器

3.2.7、查询节点数据

get /app

# ­­­­­­­­­­­节点的状态信息，也称为stat结构体­­­­­­­­­­­­­­­­­­­
# 创建该znode的事务的zxid(ZooKeeper Transaction ID)
# 事务ID是ZooKeeper为每次更新操作/事务操作分配一个全局唯一的id，表示zxid，值越小，表示越先执行
cZxid = 0x4454 # 0x0表示十六进制数0
ctime = Thu Jan 01 08:00:00 CST 1970  # 创建时间
mZxid = 0x4454 						  # 最后一次更新的zxid
mtime = Thu Jan 01 08:00:00 CST 1970  # 最后一次更新的时间
pZxid = 0x4454 						  # 最后更新的子节点的zxid
cversion = 5 						  # 子节点的变化号，表示子节点被修改的次数
dataVersion = 0 					  # 表示当前节点的数据变化号，0表示当前节点从未被修改过
aclVersion = 0  					  # 访问控制列表的变化号 access control list
# 如果临时节点，表示当前节点的拥有者的sessionId
ephemeralOwner = 0x0				  # 如果不是临时节点，则值为0
dataLength = 13 					  # 数据长度
numChildren = 1 					  # 子节点的数量

3.2.8、修改节点数据

set /app 'hellotoday'

3.2.9、删除节点

delete /hello0000000001

3.2.10、递归删除节点

delete /hello

rmr /hello

3.2.11、查看节点状态

stat /zookeeper

3.4.12、日志的可视化

• 这是日志的存储路径

  

• 日志都是以二进制文件存储的，使用记事本打开，无意义。

  

• 为了能正常查看日志，把查看日志需要的jar包放到统一路径下

• 在当前目录下进入cmd，执行以下命令可以直接查看正常日志

java -classpath ".;*" org.apache.zookeeper.server.LogFormatter log.1

小结

数据类型： 持久，临时 -e， 有序 -s和无序

【注意】路径必须以/打头

ls 查看

help查看所有命令

create 路径 数据 -s 代表有序 -e 代临时

get 路径 查询

set 路径 新的数据

delete 路径 单一路径，没有子节点

rmr 路径 递归删除

stat 路径 查看节点状态 没有数据显示

日志 配置日志存储路径，依赖2个zookeeper-xxx.jar, sfl4-api.jar

​ java -classpath “.;*” org.apache.zookeeper.server.LogFormatter log.1 4

3.3、zookeeper 的java Api介绍

3.3.1、ZooKeeper常用Java API

• 原生Java API（不推荐使用）

​ ZooKeeper 原生Java API位于org.apache.ZooKeeper包中

​ ZooKeeper-3.x.x. Jar （这里有多个版本）为官方提供的 java API

• Apache Curator（推荐使用）

​ Apache Curator是 Apache ZooKeeper的Java客户端库。

​ Curator.项目的目标是简化ZooKeeper客户端的使用。

​ 另外 Curator为常见的分布式协同服务提供了高质量的实现。
​ Apache Curator最初是Netflix研发的,后来捐献了 Apache基金会,目前是 Apache的*项目

• ZkClient（不推荐使用）

​ Github上一个开源的ZooKeeper客户端，由datameer的工程师Stefan Groschupf和Peter Voss一起开发。 zkclient-x.x.Jar也是在源生 api 基础之上进行扩展的开源 JAVA 客户端。

3.3.2、创建java 工程，导入依赖

导入依赖

<!--zookeeper的依赖-->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.7</version>
</dependency>
<!--	zookeeper CuratorFramework 是Netflix公司开发一款连接zookeeper服务的框架，通过封装的一套高级API 简化了ZooKeeper的操作，提供了比较全面的功能，除了基础的节点的操作，节点的监听，还有集群的连接以及重试。-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.0.1</version>
</dependency>
<!--测试-->
<dependency>
  	<groupId>junit</groupId>
  	<artifactId>junit</artifactId>
  	<version>4.12</version>
</dependency>

连接客户端

3.3.3、java创建节点

//1. 创建一个空节点(a)（只能创建一层节点）
//2. 创建一个有内容的b节点（只能创建一层节点）
//3. 创建持久节点，同时创建多层节点
//4. 创建带有的序号的持久节点
//5. 创建临时节点（客户端关闭，节点消失），设置延时5秒关闭（Thread.sleep(5000)）
//6. 创建临时带序号节点（客户端关闭，节点消失），设置延时5秒关闭（Thread.sleep(5000)）
//7. 修改节点的数据
//8. 获取节点数据
//9. 删除单一节点数据
//10.删除多级节点

/**
 *  RetryPolicy： 失败的重试策略的公共接口
 *  ExponentialBackoffRetry是 公共接口的其中一个实现类
 *      参数1： 初始化sleep的时间，用于计算之后的每次重试的sleep时间
 *      参数2：最大重试次数
        参数3（可以省略）：最大sleep时间，如果上述的当前sleep计算出来比这个大，那么sleep用这个时间
 */
RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3,10);
//创建客户端
/**
 * 参数1：连接的ip地址和端口号
 * 参数2：会话超时时间，单位毫秒
 * 参数3：连接超时时间，单位毫秒
 * 参数4：失败重试策略
 */
CuratorFramework client =  CuratorFrameworkFactory.newClient("127.0.0.1:2181",3000,1000,retryPolicy);
//开启客户端(会阻塞到会话连接成功为止)
client.start();
/**
 * 创建节点
 */
//1. 创建一个空节点(a)（只能创建一层节点）
// client.create().forPath("/a");
//2. 创建一个有内容的b节点（只能创建一层节点）
// client.create().forPath("/b", "这是b节点的内容".getBytes());
//3. 创建多层节点
// （creatingParentsIfNeeded）是否需要递归创建节点
// withMode(CreateMode.PERSISTENT)  创建持久性 b节点
// client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/g");
//4. 创建带有的序号的节点
//  client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/e");
//5. 创建临时节点（客户端关闭，节点消失），设置延时5秒关闭
// client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath("/f");
//6. 创建临时带序号节点（客户端关闭，节点消失），设置延时5秒关闭
client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath("/f");
Thread.sleep(5000);
//7. 修改节点的数据
 client.setData().forPath("/app","helloworld".getBytes());
 //8. 获取节点的数据
 byte[] bytes = client.getData().forPath("/app");
        String s = new String(bytes);
        System.out.println(s);
 // 9. 删除单一节点数据
 client.delete().forPath("/a");
 // 10. 删除多级节点
// client.delete().deletingChildrenIfNeeded().forPath("/wei");
//关闭客户端
client.close();

3.3.4 小结

1. Curator是Appache封装操作Zookeeper的客户端, 操作zookeer数据变得更简单

2. 使用步骤：

   • 创建重试策略

   • 创建客户端 ip:port sessionTimeout, connectionTimeout, retryPolicy

   • 启动客户端 start

   • 使用客户端对节点操作

     – create forPath, creatingparent…, withMode(CreateMode.持久，临时，有序)

     – setData 修改数据

     – getData 查询数据

     – delete 删除数据， deletingChildrenIfNeeded递归删除

   • 关闭客户端, 测试临时数据时要睡眠一下

   3.4、watch机制【机制重点】

回顾：Zookeeper的应用场景中配置中心，其中看到watch机制

3.4.1、什么是watch机制

​ zookeeper作为一款成熟的分布式协调框架，订阅-发布功能是很重要的一个。所谓订阅发布功能，其实说白了就是观察者模式。观察者会订阅一些感兴趣的主题，然后这些主题一旦变化了，就会自动通知到这些观察者。

​ zookeeper的订阅发布也就是watch机制，是一个轻量级的设计。因为它采用了一种==推(服务端通知应用)拉（客户端获取服务端数据）==结合的模式。一旦服务端感知主题变了，那么只会发送一个事件类型和节点信息给关注的客户端，而不会包括具体的变更内容，所以事件本身是轻量级的，这就是所谓的“推”部分。然后，收到变更通知的客户端需要自己去拉变更的数据，这就是“拉”部分。watche机制分为添加数据和监听节点。

​ Curator在这方面做了优化，Curator引入了Cache的概念用来实现对ZooKeeper服务器端进行事件监听。Cache是Curator对事件监听的包装，其对事件的监听可以近似看做是一个本地缓存视图和远程ZooKeeper视图的对比过程。而且Curator会自动的再次监听，我们就不需要自己手动的重复监听了。

Curator中的cache共有三种

• NodeCache（监听和缓存根节点变化） 只监听单一个节点(变化 添加，修改，删除)
• PathChildrenCache（监听和缓存子节点变化） 监听这个节点下的所有子节点(变化 添加，修改，删除)
• TreeCache（监听和缓存根节点变化和子节点变化） NodeCache+ PathChildrenCache 监听当前节点及其下的所有子节点的变化

下面我们分别对三种cache详解

3.4.2、 NodeCache

• 介绍

  NodeCache是用来监听节点的数据变化的，当监听的节点的数据发生变化的时候就会回调对应的函数。

• 增加监听

 String connectString="127.0.0.1:2181";
        int sessionTimeoutMs=3000;
        int connectionTimeout=3000;
        RetryPolicy retryPolicy=new ExponentialBackoffRetry(1,3,1 );
        CuratorFramework client = CuratorFrameworkFactory.newClient(connectString, sessionTimeoutMs, connectionTimeout, retryPolicy);
        //启动客户端
        client.start();
        NodeCache nodeCache = new NodeCache(client, "/app");
        nodeCache.start(true);
        System.out.println(new String(nodeCache.getCurrentData().getData()));
        //添加监听对象
        //如果节点数据有变化，会回调该方法
        nodeCache.getListenable().addListener(()->{
            System.out.println("修改后的值"+new String(nodeCache.getCurrentData().getData()));
        });
        //    关闭客户端则不能监听，所以不能关闭客户端
        //client.close();
    //    阻塞
        System.in.read();

3.4.3、 PathChildrenCache

• 介绍

  PathChildrenCache是用来监听指定节点 的子节点变化情况

• 增加监听

RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,1);
CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", 1000, 1000, retryPolicy);
client.start();
//监听指定节点的子节点变化情况包括͹新增子节点 子节点数据变更 和子节点删除
//true表示用于配置是否把节点内容缓存起来，如果配置为true，客户端在接收到节点列表变更的同时，也能够获取到节点的数据内容（即：event.getData().getData()）ͺ如果为false 则无法取到数据内容（即：event.getData().getData()）
PathChildrenCache childrenCache = new PathChildrenCache(client,"/hello",true);
/**
 * NORMAL:  普通启动方式, 在启动时缓存子节点数据
 * POST_INITIALIZED_EVENT：在启动时缓存子节点数据，提示初始化
 * BUILD_INITIAL_CACHE: 在启动时什么都不会输出
 *  在官方解释中说是因为这种模式会在start执行执行之前先执行rebuild的方法，而rebuild的方法不会发出任何事件通知。
 */
childrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
System.out.println(childrenCache.getCurrentData());
//添加监听
childrenCache.getListenable().addListener(new PathChildrenCacheListener() {
    @Override
    public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
        if(event.getType() == PathChildrenCacheEvent.Type.CHILD_UPDATED){
            System.out.println("子节点更新");
            System.out.println("节点:"+event.getData().getPath());
            System.out.println("数据" + new String(event.getData().getData()));
        }else if(event.getType() == PathChildrenCacheEvent.Type.INITIALIZED ){
            System.out.println("初始化操作");
        }else if(event.getType() == PathChildrenCacheEvent.Type.CHILD_REMOVED ){
            System.out.println("删除子节点");
            System.out.println("节点:"+event.getData().getPath());
            System.out.println("数据" + new String(event.getData().getData()));
        }else if(event.getType() == PathChildrenCacheEvent.Type.CHILD_ADDED ){
            System.out.println("添加子节点");
            System.out.println("节点:"+event.getData().getPath());
            System.out.println("数据" + new String(event.getData().getData()));
        }else if(event.getType() == PathChildrenCacheEvent.Type.CONNECTION_SUSPENDED ){
            System.out.println("连接失效");
        }else if(event.getType() == PathChildrenCacheEvent.Type.CONNECTION_RECONNECTED ){
            System.out.println("重新连接");
        }else if(event.getType() == PathChildrenCacheEvent.Type.CONNECTION_LOST ){
            System.out.println("连接失效后稍等一会儿执行");
        }
    }
});
System.in.read(); // 使线程阻塞

3.4.4、TreeCache

• 介绍

  TreeCache有点像上面两种Cache的结合体，NodeCache能够监听自身节点的数据变化（或者是创建该节点），PathChildrenCache能够监听自身节点下的子节点的变化，而TreeCache既能够监听自身节点的变化、也能够监听子节点的变化。

• 添加监听

RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,1);
CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181", 1000, 1000, retryPolicy);
client.start();
TreeCache treeCache = new TreeCache(client,"/hello");
treeCache.start();
System.out.println(treeCache.getCurrentData("/hello"));
treeCache.getListenable().addListener(new TreeCacheListener() {
    @Override
    public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
            if(event.getType() == TreeCacheEvent.Type.NODE_ADDED){
                System.out.println(event.getData().getPath() + "节点添加");
            }else if (event.getType() == TreeCacheEvent.Type.NODE_REMOVED){
                System.out.println(event.getData().getPath() + "节点移除");
            }else if(event.getType() == TreeCacheEvent.Type.NODE_UPDATED){
                System.out.println(event.getData().getPath() + "节点修改");
            }else if(event.getType() == TreeCacheEvent.Type.INITIALIZED){
                System.out.println("初始化完成");
            }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_SUSPENDED){
                System.out.println("连接过时");
            }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_RECONNECTED){
                System.out.println("重新连接");
            }else if(event.getType() ==TreeCacheEvent.Type.CONNECTION_LOST){
                System.out.println("连接过时一段时间");
            }
    }
});
System.in.read();

【小结】

1： Zookeeper：分布小文件存储系统，树形层级数据结构，路径唯一

• 动物管理员，管的是分布中的服务
• 应用：注册中心(解决服务单点问题)、配置中心（修改配置麻烦问题，统一管理配置）、分布式锁（解决资源抢用）、分布式队列（解决惊群，资源公平使用）、负载均衡（相对均衡）

2: 安装：没有中文没有空格，jdk1.8(JAVA_HOME), 创建data,创建log 配置zoo.cfg dataPath, dataLogDir 2181

3: 节点类型：持久化（有序与无序 -s），临时（-e 临时， -s 有序与无序) crud

4: api: Curator 创建重试策略->客户端(url ip:port)->启动->使用client操作crud->关闭

5: Watch: 监听节点数据变化，一旦生变更（添加、修改、删除）时，服务端通知客户端（addListener)

NodeCache: 听监听单一节点变化

PathChildrenCache: 监听节点下的子节点

TreeCache: NodeCache+PathChildrenCache