zookeeper
zookeeper是一个开源的分布式的，为分布式应用提供协调服务的Apache项目。
zookeeper从设计模式角度来理解：是一个基于[观察者模式]设计的分布式服务管理框架，它[负责存储和管理大家关系的数据],然后[接受观察者的注册]，一旦这些数据的状态发生了变化，zookeeper就将[负责通知已经在zookeeper上注册的那些观察者]做出相应的反应
1]服务器启动时去注册信息(创建都是临时节点)
2]客户端获取到当前在线服务器列表(zookeeper集群),并且注册监听
3]服务器节点一旦下线
4]zookeeper集群发生状态，通知客户端服务器节点上下线事件通知
5]process()重新再去获取服务器列表，并注册监听
特点
1]一个领导者leader，多个follower组成的集群
2]集群中只要有半数以上的节点存活，zookeeper集群就能正常服务
3]全局数据一致：每个server保存一份相同的数据副本(存储核心信息如配置文件等)，client无论连接到哪个server，数据都是一致的。
4]更新请求顺序进行，来自同一个client的更新请求按其[发送顺序]依次执行。
5]数据更新原子性，一次数据更新[要么成功，要么失败]。
6]实时性，在一定时间范围内，client能读到最新数据[数据量小].
数据结构
zookeeper数据模型的结构与unix文件系统很类,整体上可以看作是一棵树，每个节点称做一个znode。每一个znode默认能够存储[1MB]的数据，每个znode都可以通过其路径唯一标识。
应用场景
统一命名服务
在分布式环境下，经常需要对应用/服务进行统一命名，便于识别。[例如 ip不容易记住，而域名容易记住]
统一配置管理
1]分布式环境下，配置文件同步非常常见
a.一般要求一个集群中，所有节点的配置信息是一致的,比如Kafka集群.
b.对配置文件修改后，希望能够快速同步到各个节点上。
2]配置管理可交由zookeeper实现。
a.可将配置信息写入zookeeper上的一个znode。
b.各个客户端服务器监听这个znode。
c.一旦znode中的数据被修改，zookeeper将通知各个客户端服务器
统一集群管理
1]分布式环境中，实时掌握每个节点的状态是必要的。
a.可根据节点实时状态做出一些调整。
b.可以实现实时监控节点状态变化
c.可将节点信息写入zookeeper上的一个znode。
d.监听这个znode可获取它的实时状态变化
服务器动态上下线
1]客户端能实时洞察到服务器上下线的变化
2]软负载均衡
3]在zookeeper中记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户端请求
软负载均衡
在zookeeper中记录每台服务器的访问数，让[访问数最少的服务器]去处理最新的客户端请求。
安装homebrew
进入终端：
1]直接复制输入：
/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"
2]默认下载镜像选择序号 1
brew安装zookeeper
brew info zookeeper [查看稳定的zookeeper最新版本]
brew install zookeeper [安装稳定最新版本的zookeeper]
配置文件:zoo.cfg
zkServer start [启动zookeeper]
zkServer status [查看zookeeper状态]
zkCli [启动客户端]
quit [退出客户端交互平台]
zkServer stop [关闭zookeeper]
参考博客：https://segmentfault.com/a/1190000022287477/
# The number of milliseconds of each tick
tickTime=2000 #通信心跳数 单位ms zookeeper服务器与客户端心跳时间
# The number of ticks that the initial
# synchronization phase can take
initLimit=10 #lf初始通信时限 leader和follower通信时长=initLimit*tickTime
# The number of ticks that can pass between
# sending a request and getting an acknowledgement
syncLimit=5 #lf同步通信时限(最大响应单位时间 syncLimit*ticktime)
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just
# example sakes.
dataDir=/usr/local/var/run/zookeeper/data #数据文件目录+数据持久化路径 主要用于保存zookeeper中的数据
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
# The number of snapshots to retain in dataDir
#autopurge.snapRetainCount=3
# Purge task interval in hours
# Set to "0" to disable auto purge feature
#autopurge.purgeInterval=1
## Metrics Providers
#
# https://prometheus.io Metrics Exporter
#metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider
#metricsProvider.httpPort=7000
#metricsProvider.exportJvmInfo=true
zookeeper内部原理
选举机制
1]半数机制：集群中半数以上机器存活，集群可用。所以zookeeper适合安装奇数台服务器。
2]zookeeper虽然在配置文件中并没有指定master和slave。但zookeeper工作时，是有一个节点为leader，其他则为follower，leader是通过内部的选举机制临时产生的。
例如：有5台服务器
服务器1启动，此时只有一台服务器启动，发出去的报文没有任何响应，所以它的选举状态一直是looking状态。
服务器2启动，服务器1和服务器2都选举服务器2，由于没有达到超过半数故无效
服务器3启动，服务器1、2、3都选举3，3当选leader
服务器4启动，服务器3已经选举
服务器5启动，服务器3已经选举
节点类型
持久persistent：客户端和服务器断开连接后，创建的节点[不删除]。
1]持久化目录节点
客户端与zookeeper断开连接后，该节点依旧存在
2]持久化顺序编号目录节点
客户端与zookeeper断开连接后，该节点依旧存在，只是zookeeper给该节点的名称进行[顺序编号]。
[说明：创建znode时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护。
*在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样子客户端可以通过顺序号推断事件的顺序]
短暂ephemeral：客户端和服务器断开连接后，创建的节点自己删除。
1]临时目录节点
客户端与zookeeper断开连接后，该节点被删除
2]临时顺序编号目录节点
stat结构体
[zk: localhost:2181(CONNECTED) 15] stat /
cZxid = 0x0 [创建节点的事务zxid]
ctime = Thu Jan 01 08:00:00 CST 1970 [被创建的毫秒数 从1970年开始]
mZxid = 0x0 [最后更新的事务]
mtime = Thu Jan 01 08:00:00 CST 1970 [最后修改的毫秒数]
pZxid = 0x9 [最后更新的子节点zxid]
cversion = 1 [子节点变化号,znode子节点修改次数]
dataVersion = 0 [数据变化号]
aclVersion = 0 [访问控制列表的变化号]
ephemeralOwner = 0x0 [如果是临时节点，这个是znode拥有者的session id,如果不是临时节点则是0]
dataLength = 0 [znodo的数据长度]
numChildren = 1 [znode子节点数量]
监听器原理
1]首先要有一个main()线程
2]在main线程中创建zookeeper客户端，这时就会创建两个线程，一个负责网络连接通信connect，一个负责监听listener
3]通过connect线程将注册的监听事件发送给zookeeper
4]在zookeeper的注册监听列表中将注册的监听事件添加到列表中
5]zookeepe监听到有数据或路径变化，就会将这个消息发送listener线程。
6]listener线程内部调用了process()方法
常见的监听
1]监听节点数据的变化 get path [watch]
2]监听子节点增减的变化 ls path [watch]
写数据的流程
1]客户端client向zookeeper的server1上写数据
2]如果server1不是leader，那么server1会把接收到的请求进一步转发给leader，因为每个zookeeper的server里面有一个是leader。这个leader会将写请求广播给各个server，各个server写成功后就会通知leader[保证每个服务器都有副本]。
3]当leader收到大多数server数据写成功了，那么就说明数据写成功了(半数以上)。写成功之后，leader会告诉server1数据写成功了。
4]server1会进一步通知客户端数据写成功了，这时就认为整个写操作成功。
分布式安装部署
1、集群规划
在hadoop上分别部署zookeeper
2、解压安装zookeeper
3、配置服务器编号
mkdir -p zkData
touch myid
vi myid [在文件中添加与server对应的编号]
4、配置zoo.cfg文件
vim zoo.cfg
#增加如下配置
server.a=b:c:d [例如：server.2=hadoop102:2888:3888]
[a是一个数字，表示这个是第几号服务器]
[b是这个服务器的ip地址]
[c是这个服务器与集群中的leader服务器交换信息的端口]
[d是万一集群中的一个leader服务器挂了，需要一个端口来重新进行选举，选出一个新的leader，而这个端口就是用来执行选举时服务器相互通信的端口]
5、集群操作
分别启动zookeeper
查看状态
[客户端]命令行操作
help 显示所有操作命令
ls path [watch] 使用ls命令查看当前znode中所包含的内容
create 普通创建
-s 含有序列
-e 临时(重启或者超时消失)
get path [watch] 获取节点的值
set 设置节点的具体值
stat 查看节点状态
delete 删除节点 [可直接删除]
#rmr 递归删除节点[3.6无]
/*
服务器动态上下线案例分析
需求：客户端能实时洞察到服务器上下线的变化。
说明：对于zookeeper集群而言，客户端和服务器都是"客户端"
*/
package com.example.zookeeper;
import java.io.IOException;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;
/**
* 服务器
*/
public class DistributeServer {
public static void main(String[] args) throws Exception {
DistributeServer server = new DistributeServer();
// 1 连接zookeeper集群
server.getConnect();
// 2 注册节点 将服务器信息写入到zookeeper集群中 args[0]运行时设置参数
server.register(args[0]);
// 3 业务逻辑处理 进程不结束
server.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void register(String hostname) throws KeeperException, InterruptedException {
//临时的带序号的节点
String path = zkClient.create("/servers/server", hostname.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(hostname +"is online ");
}
private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
private int sessionTimeout = 2000;
private ZooKeeper zkClient;
private void getConnect() throws IOException {
zkClient = new ZooKeeper(connectString , sessionTimeout , new Watcher() {
@Override
public void process(WatchedEvent event) {
// TODO Auto-generated method stub
}
});
}
}
客户端：
package com.example.zookeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
/**
* 客户端
*/
public class DistributeClient {
public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
DistributeClient client = new DistributeClient();
// 1 获取zookeeper集群连接
client.getConnect();
// 2 注册监听
client.getChildren();
// 3 业务逻辑处理
client.business();
}
private void business() throws InterruptedException {
Thread.sleep(Long.MAX_VALUE);
}
private void getChildren() throws KeeperException, InterruptedException {
//监听的路径
List<String> children = zkClient.getChildren("/servers", true);
// 存储服务器节点主机名称集合
ArrayList<String> hosts = new ArrayList<>();
for (String child : children) {
byte[] data = zkClient.getData("/servers/"+child, false, null);
hosts.add(new String(data));
}
// 将所有在线主机名称打印到控制台
System.out.println(hosts);
}
private String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
private int sessionTimeout = 2000;
private ZooKeeper zkClient;
private void getConnect() throws IOException {
zkClient = new ZooKeeper(connectString , sessionTimeout , new Watcher() {
//监听
@Override
public void process(WatchedEvent event) {
try {
getChildren();
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
/*
测试
*/
package com.example.zookeeper;
import java.io.IOException;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;
public class TestZookeeper {
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 event) {
// System.out.println("---------start----------");
// List<String> children;
// try {
// children = zkClient.getChildren("/", true);
//
// for (String child : children) {
// System.out.println(child);
// }
// System.out.println("---------end----------");
// } catch (KeeperException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
});
}
// 1 创建节点
@Test
public void createNode() throws KeeperException, InterruptedException{
String path = zkClient.create("/example", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println(path);
}
// 2 获取子节点 并监控节点的变化
@Test
public void getDataAndWatch() throws KeeperException, InterruptedException{
List<String> children = zkClient.getChildren("/", true);
for (String child : children) {
System.out.println(child);
}
Thread.sleep(Long.MAX_VALUE);
}
// 3 判断节点是否存在
@Test
public void exist() throws KeeperException, InterruptedException{
Stat stat = zkClient.exists("/example", false);
System.out.println(stat==null? "not exist":"exist");
}
}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>zookeeper</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.14.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.6.2</version>
</dependency>
</dependencies>
</project>
log4j
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
原文：https://www.cnblogs.com/wuzimeimei/p/14420228.html