大数据下的协调者Zookeeper详解

Zookeeper框架

为什么要学习Zookeeper框架

1、Zookeeper是作为大数据生态圈框架中非常重要的一员
2、Zookeeper单独使用没有意义，主要是用来管理其他框架，被称为动物管理员
3、后期Hadoop的高可用框架、Kafka都需要依赖Zookeeper

Zookeeper的概述

1、Zookeeper本身是一个分布式集群
2、Zookeeper是协调服务框架，用来协调其他框架，让其他框架能够和睦的正常的工作
3、Zookeeper本身可以看做是一个数据库，是可以存数据的，一般存储的都是配置信息\
4、Zookeeper集群满足过半机制，最坏情况下只有有超过一半的机器在工作，这个集群就能正常运转

Zookeeper的他特点

1、全局数据一致性，ZK中只要有一个服务器有数据，其他的主机会跟着进行数据同步，所有主机的数据都完全一样，不会出现有的主机有数据，有的主机没有数据

2、顺序性：某一台主机比如创建了两个节点，创建顺序是A,B，其他的主机创建顺序也一定是A，B

3、时效性：在ZK集群创建节点这个过程所消耗的时间是近乎实时的

(重点)Zookeeper集群的角色

• Leader

  1、集群的管理者，管理集群
  2、Leader既可以处理写请求（事务操作），也处理读请求（非事务操作）
  

• Follower（正式工）

  1、集群的从角色
  2、Follower只能处理读请求（非事务操作），如果收到客户端的写请求，则必须转发给Leader
  3、各个Follower要不断的给Leader发送心跳包，告知其状态
  4、如果Leader挂掉，则会从剩余的Follower中重新选举出新的Leader，有投票权
  

• Observer（临时工、外包工）

  Oberser除了不能选举新Leader之外，和Follower没有任何区别，类似被剥夺政治权利
  

（重点）Zookeeper的集群操作

方式1-绝对路径

#1-启动集群
/export/server/zookeeper-3.4.6/bin/zkServer.sh start

#2-停止集群
/export/server/zookeeper-3.4.6/bin/zkServer.sh stop

#3-查看集群状态
/export/server/zookeeper-3.4.6/bin/zkServer.sh status

方式2-环境变量

#配置环境变量之后使用该方式

#1-启动集群
 zkServer.sh start

#2-停止集群
 zkServer.sh stop

#3-查看集群状态
zkServer.sh status

方式3-shell脚本

#!/bin/bash
option=""
echo "你要进行什么操作?"
PS3="请输入你的选择:"
select var in "启动集群" "停止集群" "查看集群状态"
do
 echo ""
 echo ""
 case $var in
    "启动集群")
      option="start"
      echo ".........开始启动集群............"
     ;;
    "停止集群")
      option="stop"
      echo ".........开始停止集群............"
     ;;
    "查看集群状态")
      option="status"
      echo "........开始集群状态............"
     ;;
   *)
    echo "选择错误"
   ;;
 esac

 break;
done


for n in  1 2 3
do
 echo "---------node$n--------------"
 ssh root@node$n "source /etc/profile;zkServer.sh $option"
done

ZK的Znode节点特性

1、ZK的Znode节点是一个树形结构，最上边是根/节点
2、ZK的Znode节点既像文件（存数据），又像文件夹（可以有子节点）
3、ZK的Znode一般用来存储配置信息，数据量不会太大，每个Znode节点最多不超过1M数据
4、ZK的Znode节点必须使用绝对路径来访问，不能使用相对路径

ZK的Znode节点类型

PERSISTENT：永久节点
EPHEMERAL： 临时节点
PERSISTENT_SEQUENTIAL：永久节点、序列化
EPHEMERAL_SEQUENTIAL： 临时节点、序列化

（重点）ZK的Znode节点的Shell操作

进入Shell终端

#方式1-可以连接任意服务器
zkCli.sh -server node1:2181

#方式2-连接本主机
zkCli.sh 

Shell命令

1：创建普通永久节点
#不依赖当前会话，节点永远存在，除非手动删除
 create /app1 hello

2: 创建永久顺序（序列化）节点
#不依赖当前会话，节点永远存在，除非手动删除,会在节点名字的后边加上一串数字，数字越大，表示节点越新
#同一条创建命令多次创建不会失败
create -s /app2 world

3:创建临时节点
#依赖当前创建该节点的终端会话，如果会话（session）在，则节点在，如果会话消失，则节点消失
create -e /tempnode world

4:创建顺序的临时节点
#依赖当前创建该节点的终端会话，如果会话（session）在，则节点在，如果会话消失，则节点消失
#会在节点名字的后边加上一串数字，数字越大，表示节点越新，同一条创建命令多次创建不会失败

create -s -e /tempnode2 aaa

5、创建子节点
 create /app1/app11  hello


6:获取节点数据
   get  /app1
   get  /app1/app11

6:修改节点数据
   set /app1  hadoop
   set /app1/app11  hadoop

7:删除节点
  delete  /app1   #删除的节点不能有子节点
  rmr    /app1    #递归删除
  rmr    /app1/app11    #递归删除

ZK的Znode节点的属性

mZxid ：Znode被修改的事务id，即每次对znode的修改都会更新mZxid。

ephemeralOwner:如果该节点为临时节点, ephemeralOwner值表示与该节点绑定的session id. 如果不是, ephemeralOwner值为0.

（重点）Zk的操作代码

package pack01_zookeeper_api;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.TreeCache;
import org.apache.curator.framework.recipes.cache.TreeCacheEvent;
import org.apache.curator.framework.recipes.cache.TreeCacheListener;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.CreateMode;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class ZookeeperDemo1 {
    CuratorFramework client;
    @Before
    public void init(){
        //1:定制一个重试策略
        /**
         *  3000:如果没有连接上ZK集群，则每隔3秒重试一次
         *  3：最多重试3次
         */
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,3);

        //2:获取ZK的客户端对象
        //String serverList = "192.168.88.161:2181,192.168.88.162:2181,192.168.88.163:2181";
        //需要配置：C:\Windows\System32\drivers\etc\hosts文件
        /*
            192.168.88.161 node1
            192.168.88.162 node2
            192.168.88.163 node3
         */
        String serverList = "node1:2181,node2:2181,node3:2181";
        client = CuratorFrameworkFactory.newClient(serverList, retryPolicy);

        //3:开启客户端
        client.start();
    }

    @After
    public void close(){
        //5:关闭客户端
        client.close();
    }


    //Znode的watch机制
    @Test
    public void test5ZnodeWatch() throws Exception {
        //1:将要监听的节点树存入缓存中
        TreeCache treeCache = new TreeCache(client, "/app1");

        //2:自定义监听 - 使能  使他能
        treeCache.getListenable().addListener(new TreeCacheListener() {
            //childEvent该方法自动执行，只要有事件被触发，则就会自动执行该方法
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                //因为不管是：增加/删除/修改节点，都会执行该方法，但是具体是因为哪一种才执行该方法，则需要进一步确认
                switch (treeCacheEvent.getType()) {
                    case NODE_ADDED:
                        System.out.println("监控到增加节点事件!");
                        System.out.println("有客户端上线了!");
                        break;
                    case NODE_REMOVED:
                        System.out.println("监控到节点移除事件!");
                        System.out.println("主节点挂掉了!");
                        System.out.println("让备用节点称为新的主节点!");
                        break;
                    case NODE_UPDATED:
                        System.out.println("监控到节点修改事件!");
                        //重新读取配置文件
                        break;
                    case CONNECTION_SUSPENDED:
                        break;
                    case CONNECTION_RECONNECTED:
                        break;
                    case CONNECTION_LOST:
                        break;
                    case INITIALIZED:
                        break;
                }

            }
        });

        //3:开启监听
        treeCache.start();

        //4:让程序挂起
        Thread.sleep(100000000);
    }


    //删除节点
    @Test
    public void test4DeleteZnode() throws Exception {
        client.delete().deletingChildrenIfNeeded().forPath("/app1");
    }

    //获取节点数据
    @Test
    public void test3GetZnodeData() throws Exception {
        byte[] bytes = client.getData().forPath("/app1");
        String data = new String(bytes);
        System.out.println(data);
    }



    //修改节点数据数据
    @Test
    public void test2SetZnode() throws Exception {
        client.setData().forPath("/app1","node1".getBytes());
    }

    //Znode节点的创建
    @Test
    public void test1CreateZnode() throws Exception {

        //4:进行ZK节点创建
        /*
          节点类型、节点路径、节点携带的初始数据
         */
        //创建永久节点-单级节点-携带初始化数据
        //client.create().withMode(CreateMode.PERSISTENT).forPath("/app1","windows_localhost".getBytes());
        //创建永久节点-多级节点-携带初始化数据
        //client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/xxx/yyy/zzz","windows_localhost".getBytes());
        //创建永久节点-单级节点-不携带初始化数据
        //client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/app2");

        //创建临时节点-单级节点-不携带初始化数据
        client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath("/tempnode");

        Thread.sleep(10000);

    }
}

ZK的选举机制

场景1-集群首次启动选举

场景2-Leader宕机重新选举