Zookeeper

概念背景

• Zookeeper 是 Apache Hadoop 项目下的一个子项目，是一个树形目录服务。
• Zookeeper 翻译过来就是 动物园管理员，他是用来管 Hadoop（大象）、Hive(蜜蜂)、Pig(小 猪)的管理员。简称zk
• Zookeeper 是一个分布式的、开源的分布式应用程序的协调服务。
• 主要功能：

1. 配置管理：配置中心。用于管理公共配置文件，方便变更

2. 分布式锁：分布式锁组件。用于保证数据访问的安全性，对数据加锁，由服务器取锁来使用数据
   

3. 集群管理：注册中心

Zookeeper安装和启动

• 安装省略
• 启动文件 bin目录下的zkServer.sh文件
• 启动命令： bin目录下执行 ./zkServer.sh start
• 停止命令： bin目录下执行 ./zkServer.sh stop
• 查看运行状态： bin目录下执行 ./zkServer.sh status
  Client port found: 2181. Client address: localhost.–>2181为zookeeper的默认端口号，可在conf的目录下修改 zoo.cfg文件中的clientPort=2181属性
  Mode: standalone—>单节点模式，未搭建集群

Zookeeper的命令行操作

数据 模型

服务端命令

转上

客户端命令

1启动并连接服务端 ./zkCli.sh （-server localhost:2181连接本机可省略 ）
2退出客户端quit
3查看节点下由哪些子节点ls 节点名（/是根节点）
4创建子节点create （节点目录）/父节点名子节点名 数据（可选）
5获取节点数据 get 节点目录/节点名
6为节点设置数据 set 节点目录/节点名 数据
7删除单个节点 delete 节点目录/节点名 -->当有子节点时删除失败
8 删除节点以及子节点 deleteall 节点目录/节点名
9help帮助命令 ls2 节点目录—>ls -s
10查看节点详细信息

• 以上创建节点为持久化节点
• 创建其他类型节点：
  -e 创建临时节点
  -s 创建顺序节点
  -es 创建临时顺序节点

**消费者和提供者的ip的地址存放在相应节点中 **

JavaApi操作

Curator客户端

• 基本操作下方都有无需背
• java的zookeeper操作客户端/框架

连接zookeeper的jar4.0版本必须比zookeepr3.5.6的版本>=

• 使用：pom文件导入依赖，java代码直接使用，无需配置文件

<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.0modelVersion>

    <groupId>org.yhgroupId>
    <artifactId>zk-client-CuratorartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <maven.compiler.source>15maven.compiler.source>
        <maven.compiler.target>15maven.compiler.target>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>org.apache.curatorgroupId>
            <artifactId>curator-frameworkartifactId>
            <version>4.0.0version>
        dependency>
        <dependency>
            <groupId>org.apache.curatorgroupId>
            <artifactId>curator-recipesartifactId>
            <version>4.0.0version>
        dependency>
        
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-apiartifactId>
            <version>1.7.26version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.7.21version>
        dependency>
    dependencies>

    <build>
        <plugins>
            
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.8.0version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                configuration>
            plugin>
        plugins>
    build>

project>

1. 连接zk服务端且启动curator客户端：
   常用第二种方式

//此方法用于连接zk服务
    @Test
    public void connectTest(){
        String url="192.168.23.129:2181";//存放zk服务的url
        int sessionTimeOut=60*1000;//存放会话超时时间
        int connectTimeOut=15*1000;//存放连接超时时间
        //重试策略--间隔时间重试
        RetryPolicy retryPolicy=new ExponentialBackoffRetry(3000,10);//三秒重试一次，重试10次最多
        //1.连接zk服务
        //1.1第一种方式----》不能指定命名空间
        //CuratorFramework client = CuratorFrameworkFactory.newClient(url, sessionTimeOut, connectTimeOut, retryPolicy);
        //1.2第二种方式链式编程
        client = CuratorFrameworkFactory.builder().connectString(url).sessionTimeoutMs(sessionTimeOut).connectionTimeoutMs(connectTimeOut).retryPolicy(retryPolicy).build();
        //2.开启客户端
        client.start();
    }

2. 创建节点：
   创建时如果未指定数据，则默认客户端ip为节点数据

• 创建无数据节点

@Test
    public void createTest1() {
        try {
            client.create().forPath("/h1");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

• 创建带数据节点
  注意数据参数时byte[]数组类型

@Test
    public void createTest2() {
        try {
            client.create().forPath("/h2","h2!!".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

• 创建不同类型节点(如临时，顺序，临时顺序)

@Test
    public void createTest3() {
        try {
            //创建临时节点
            client.create().withMode(CreateMode.EPHEMERAL).forPath("/h3","h3!!".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
        //用于检测临时节点
        while (true){}

    }

• 创建多级节点

@Test
public void createTest4() {
try {
client.create().creatingParentsIfNeeded().forPath("/h4/g1",“g1!!”.getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
e.printStackTrace();
}

}

3. 查询节点：

• 查询数据 get

@Test
    public void getTest1() {
        try {
            byte[] bytes = client.getData().forPath("/h4");
            System.out.println(new String(bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 查询子节点ls

@Test
    public void getTest2() {
        try {
            List<String> strings = client.getChildren().forPath("/h4");
            System.out.println(strings);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 查询节点状态信息ls -s

@Test
    public void getTest3() {
        Stat stat=new Stat();//节点状态信息对象
        System.out.println(stat);
        try {
            byte[] bytes = client.getData().storingStatIn(stat).forPath("/h4");
            System.out.println(stat);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4. 修改节点

• 基本修改数据

    @Test
    public void setTest1() {
        try {
            client.setData().forPath("/h1","h1!!!!".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 根据版本修改
  场景：多个客户端或线程在同一时间段内都修改一个数据导致需求不满足被干扰
  解决：修改前指定该节点的版本信息，只有版本信息一致才可以修改，更改后版本信息值(zk:dataVersion Curator的Stat：version)会自动+1

@Test
    public void setTest2() {
        Stat stat=new Stat();
        try {
            //查询节点的版本信息
            client.getData().storingStatIn(stat).forPath("/h1");
            int version = stat.getVersion();
            System.out.println(version);//1
            client.setData().withVersion(version).forPath("/h1","h1!!!!--".getBytes(StandardCharsets.UTF_8));
            System.out.println(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

执行后查询该节点信息发现版本变为2

5. 删除节点

• 删除单个节点delete

    @Test
    public void deleteTest1() {
        try {
            client.delete().forPath("/h1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 删除带子节点的删除deletall

    @Test
    public void deleteTest2() {
        try {
            client.delete().deletingChildrenIfNeeded().forPath("/h4");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 必须成功的删除（当会话中请求超时时）–>一般会加上该方法，防止网络抖动

    @Test
    public void deleteTest3() {
        try {
            client.delete().guaranteed().forPath("/h2");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

• 删除后回调

    @Test
    public void deleteTest4() {
        try {
            client.delete().guaranteed().inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                    System.out.println("h1被删除了");
                    System.out.println(curatorEvent);
                }
            }).forPath("/h1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Watch事件监听

用Curator启动zookeeper的事件监听

步骤：创建监听对象–>绑定监听器–>开启监听—再此之前先要连接zk服务端(代码在上)

• 概念：
  ZooKeeper 允许用户在指定节点上注册一些Watcher，并且在一些特定事件触发的时候，ZooKeeper 服务端会将事件通知到感兴趣的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。

•ZooKeeper 中引入了Watcher机制来实现了发布/订阅功能能，能够让多个订阅者同时监听某一个对象，当一个对象自身状态变化时，会通知所有订阅者。

•ZooKeeper 原生支持通过注册Watcher来进行事件监听，但是其使用并不是特别方便

​ 需要开发人员自己反复注册Watcher，比较繁琐。

•Curator引入了Cache 来实现对 ZooKeeper 服务端事件的监听。

• ZooKeeper提供了三种Watcher：

1. NodeCache : 只是监听某一个特定的节点

//1. NodeCache : 只是监听某一个特定的节点
    @Test
    public void nodeCacheTest() throws Exception {
        //1.创建监听器对象
        //三个参数，客户端对象，监听节点路径，是否压缩数据
        NodeCache nodeCache = new NodeCache(client, "/h1", false);
        //2.绑定监听器
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println("当前节点变化了");
                //只有数据更改才会触发监听
                //获取修改后的数据
                byte[] data = nodeCache.getCurrentData().getData();
                System.out.println(new String(data));
            }
        });
        //3.开启监听
        //参数为true为加载缓冲数据
        nodeCache.start(true);
        //为确保进程不结束
        while (true) {
        }
    }

2. PathChildrenCache : 监控一个ZNode的子节点.
   PathChildrenCacheEvent 中存放了状态和改变后的数据

    //2. PathChildrenCache : 监控一个ZNode的子节点.
    @Test
    public void pathChildrenCacheTest() throws Exception {
        PathChildrenCache pathChildrenCache=new PathChildrenCache(client,"/h1",true);
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                System.out.println("子节点改变了");
                System.out.println(pathChildrenCacheEvent);
                //获取节点变化类型
                PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
                //判断是否是update
                if (type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
                    System.out.println("数据改变了");
                    byte[] data = pathChildrenCacheEvent.getData().getData();
                    System.out.println(new String(data));
                }
            }
        });
        pathChildrenCache.start();
        //为确保进程不结束
        while (true) {
        }
    }

event中发现节点数据存储在data下的date中

3. TreeCache : 可以监控整个树上的所有节点，类似于PathChildrenCache和NodeCache的组合

    //3. TreeCache : 可以监控整个树上的所有节点
    @Test
    public void treeCacheTest() throws Exception {
        TreeCache treeCache=new TreeCache(client,"/h1");
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                System.out.println("树改变了");
                System.out.println(treeCacheEvent);
                //获取状态和数据同上
            }
        });
        treeCache.start();
        //为确保进程不结束
        while (true) {
        }
    

• 三种Watch的编码实现：

分布式锁

• 概念：在我们进行单机应用开发，涉及并发同步的时候，我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题，这时多线程的运行都是在同一个JVM之下，没有任何问题。

但当我们的应用是分布式集群工作的情况下，属于多JVM下的工作环境，跨JVM之间已经无法通过多线程的锁解决同步问题。

• 作用：处理种跨机器的进程之间的数据同步问题
• 三种实现：
  
• Zookeeper分布式锁原理：
  •核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点。

1.客户端获取锁时，在lock节点下创建临时顺序节点。

2.然后获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现自己创建的子节点序号最小，那么就认为该客户端获取到了锁。使用完锁后，将该节点删除。

3.如果发现自己创建的节点并非lock所有子节点中最小的，说明自己还没有获取到锁，此时客户端需要找到比自己小的那个节点，同时对其注册事件监听器，监听删除事件。

4.如果发现比自己小的那个节点被删除，则客户端的

​ Watcher会收到相应通知，此时再次判断自己创建的节点

​ 是否是lock子节点中序号最小的，如果是则获取到了锁，

​ 如果不是则重复以上步骤继续获取到比自己小的一个节点

​ 并注册监听。

Curator实现分布式锁API

• 在Curator中有五种锁方案：

  • InterProcessSemaphoreMutex：分布式排它锁（非可重入锁）

  • InterProcessMutex：分布式可重入排它锁

  • InterProcessReadWriteLock：分布式读写锁

  • InterProcessMultiLock：将多个锁作为单个实体管理的容器

  • InterProcessSemaphoreV2：共享信号量

• 代码实现：
  eg：模拟12306买票小demo
  

• 未加锁：
  卖票服务：

import org.apache.zookeeper.data.Id;

//此类用于模拟 12306的卖票服务
public class Ticket12306 implements Runnable{
    private int tickets=10;//数据库中待卖票数
    @Override
    public void run() {
        //保持卖票服务一直提供
        while (true){
            if (tickets>0){
                System.out.println(Thread.currentThread()+":"+tickets);
                tickets--;
            }
        }
    }
}

买票模拟：

 public static void main(String[] args) {
        Ticket12306 t=new Ticket12306();
        //创建买票客户端
        //传入的第一个参数为一个线程对象（在线程启动时调用其run方法的对象。如果为空，则调用该线程的run方法。），第二个参数为所建线程的名字
        Thread t1=new Thread(t,"携程");
        Thread t2=new Thread(t,"肥猪");
        //开启线程
        t1.start();
        t2.start();
    }

运行结果

发生超卖现象

• 加锁后
  卖票服务：

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

//此类用于模拟 12306的卖票服务，添加分布式锁
public class Ticket12306Lock implements Runnable{
    private int tickets=10;//数据库中待卖票数
    private InterProcessMutex lock;//分布式锁对象

    //此方法用于Curator连接zookeeper服务端---->可以做成工具类
    public CuratorFramework connectZookeeper() {
        String url = "192.168.23.129:2181";//存放zk服务的url
        int sessionTimeOut = 60 * 1000;//存放会话超时时间
        int connectTimeOut = 15 * 1000;//存放连接超时时间
        //String namespace="yh";//命名空间，会以此为节点的根目录
        //重试策略--间隔时间重试
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);//三秒重试一次，重试10次最多
        //1.连接zk服务
        //1.1第一种方式--->不能指定命名空间
        //CuratorFramework client = CuratorFrameworkFactory.newClient(url, sessionTimeOut, connectTimeOut, retryPolicy);
        //1.2第二种方式链式编程
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString(url).sessionTimeoutMs(sessionTimeOut).connectionTimeoutMs(connectTimeOut).retryPolicy(retryPolicy).build();
        //2.开启客户端
        client.start();
        return client;
    }

    public Ticket12306Lock() {
        lock=new InterProcessMutex(connectZookeeper(),"/lock");
    }

    @Override
    public void run() {
        //保持卖票服务一直提供
        while (true){
            //为卖票服务添加锁----描述不准确
            //获取锁
            try {
                lock.acquire(3, TimeUnit.SECONDS);
                //卖票服务
                if (tickets>0){
                    System.out.println(Thread.currentThread()+":"+tickets);
                    Thread.sleep(200);//防止异常，用于查看分布式锁工作原理--=查看lock目录下的临时顺序节点
                    tickets--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //释放锁
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

买票模拟：

//此类用于测试zookeeper的javaApi框架curator的操作
public class LockTest {


    public static void main(String[] args) {
        //Ticket12306 t=new Ticket12306();
        Ticket12306Lock t=new Ticket12306Lock();
        //创建买票客户端
        //传入的第一个参数为一个线程对象（在线程启动时调用其run方法的对象。如果为空，则调用该线程的run方法。），第二个参数为所建线程的名字
        Thread t1=new Thread(t,"携程");
        Thread t2=new Thread(t,"肥猪");
        //开启线程
        t1.start();
        t2.start();
    }

}

运行结果：

• Curator连接Zookeeeper服务器工具类
  链接：添加链接描述
  提取码：281m

CuratorConnectZkUtil.java

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;

//Curator客户端连接Zookeeper服务端的工具类
public class CuratorConnectZkUtil {
    private static CuratorFramework client;
    private static CuratorFrameworkFactory.Builder builder;
    static {
        String url = "192.168.23.129:2181";//存放zk服务的url
        int sessionTimeOut = 60 * 1000;//存放会话超时时间
        int connectTimeOut = 15 * 1000;//存放连接超时时间
        /*String namespace="yh";//命名空间，会以此为节点的根目录*/
        //重试策略--间隔时间重试
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);//三秒重试一次，重试10次最多
        //1.连接zk服务
        //1.1第一种方式--->不能指定命名空间
        //CuratorFramework client = CuratorFrameworkFactory.newClient(url, sessionTimeOut, connectTimeOut, retryPolicy);
        //1.2第二种方式链式编程
        builder = CuratorFrameworkFactory.builder().connectString(url).sessionTimeoutMs(sessionTimeOut).connectionTimeoutMs(connectTimeOut).retryPolicy(retryPolicy);
    }
    //获取客户端对象
    //参数为指定命名空间
    /*
    * @param namespace 指定命名空间，会以此为节点的根目录*/
    public static CuratorFramework getClient(String namespace) {
        client= builder.namespace(namespace).build();
        //2.开启客户端
        client.start();
        return client;
    }

    public static void close() {
        //关闭连接，资源释放
        client.close();
    }

}

• 上述源码
  链接：添加链接描述
  提取码：2eba

zookeeper集群

zookeeper作为组织者协调者管理者非常重要，单节点非常不安全，故需要搭建zookeeper集群

• Leader选举：

•Serverid：服务器ID

比如有三台服务器，编号分别是1,2,3。

编号越大在选择算法中的权重越大。

•Zxid：数据ID

服务器中存放的最大数据ID.值越大说明数据 越新，在选举算法中数据越新权重越大。

•在Leader选举的过程中，如果某台ZooKeeper

​ 获得了超过半数的选票，

​ 则此ZooKeeper就可以成为Leader了。

• zookeeper集群角色
  •Leader 领导者 ：

​ 1. 处理事务请求

​ 2. 集群内部各服务器的调度者–>领导者：调度者，处理事务请求后同步数据给跟随者

•Follower 跟随者 ：

​ 1. 处理客户端非事务请求，转发事务请求给Leader服务器

​ 2. 参与Leader选举投票

•Observer 观察者：

1. 处理客户端非事务请求，转发事务请求给Leader服务器-->观察者是用来分担跟随者压力，不参与选投票 

• 搭建步骤参考
  链接：添加链接描述
  提取码：usrz