Zookeeper其二，zk的java和选举机制，Hadoop的高可用和联邦机制

一、Zk是用java代码进行操作（了解）

[使用java代码操作zk 3.5以下版本，使用的技术还是Curator](#使用java代码操作zk 3.5以下版本，使用的技术还是Curator)

二、zk的选举机制

三、Hadoop集群的高可用（HA）

[1）搭建namenode的高可用](#1）搭建namenode的高可用)

[Java 代码操作 HA 的 hdfs 代码演示：](#Java 代码操作 HA 的 hdfs 代码演示：)

2）搭建resourcemanager的高可用

四、NameNode的联邦机制【了解】

一、Zk是用java代码进行操作（了解）

复制代码

有很多的软件都是可以使用命令，也可以使用代码进行操作：
MySQL -- SQL语句、使用java代码（JDBC）
HDFS -- shell、Java代码
zookeeper -- shell、Java代码

有两种操作方案：

JDBC 的代码--原生的

DBUtils 工具包

1、原生的API进行操作

2、Curator 工具包进行操作（建议同学们学习这个东西）

第一步：导入Curator工具包

复制代码

<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-framework</artifactId>
  <version>4.2.0</version>
</dependency>
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-recipes</artifactId>
  <version>4.2.0</version>
</dependency>
<dependency>
  <groupId>com.google.collections</groupId>
  <artifactId>google-collections</artifactId>
  <version>1.0</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>RELEASE</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-simple</artifactId>
  <version>1.7.25</version>
</dependency>

package com.bigdata;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.ChildData;
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;

import java.util.Arrays;
import java.util.List;

public class TestZk {
    CuratorFramework curator =null;
    @Before
    public void init(){
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,2);
        curator = CuratorFrameworkFactory.newClient(
                "bigdata01:2181", retryPolicy
        );
        curator.start();
    }

    @After
    public void destory(){
        curator.close();
    }

    @Test  //
    public void testCreate() throws Exception {
        // 一个类的对象如果是null, 使用null调用任何方法，都报空指针异常
        // 创建一个临时的节点，节点的名字是/hello1
        curator.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/xihu/abcd");
        //Thread.sleep(20000);

    }

    @Test  //
    public void testLs() throws Exception {
        // 一个类的对象如果是null, 使用null调用任何方法，都报空指针异常
        // 创建一个临时的节点，节点的名字是/hello1
        //2、查询子节点：ls
        List<String> list = curator.getChildren().forPath("/");
        System.out.println(list);

    }

    @Test  //
    public void testSetData() throws Exception {
        curator.setData().forPath("/xihu/abcd","西湖的水，我的泪".getBytes());
    }

    @Test
    public void testGetData() throws Exception{
        byte[] bytes = curator.getData().forPath("/xihu");
        System.out.println(new String(bytes));
    }

    @Test
    public void testString(){
        // 只学两个东西： 集合(ArrayList HashSet HashMap)   工具类的API (String)   二八原则
        // 想将一个字符串变为byte数组
        String a = "hello";
        byte[] arr = a.getBytes();
        System.out.println(Arrays.toString(arr));
        // 想将一个byte数组变为字符串
        String str = new String(arr);
        System.out.println(str);
    }

    @Test
    public void testDelete() throws Exception{
        curator.delete().forPath("/xihu/abc");
    }

    // 演示watch 监听
    @Test
    public void testWatch() throws Exception{
        TreeCache treeCache = new TreeCache(curator, "/xihu");
        // 一个接口中只有一个未实现的方法，该接口是函数式接口，函数式接口：lambda
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                TreeCacheEvent.Type type = treeCacheEvent.getType();
                ChildData data = treeCacheEvent.getData();
                if(type == TreeCacheEvent.Type.NODE_ADDED){
                    System.out.println("/xihu 下创建了一个新的节点");
                    // data.getData()  如果节点没有数据，返回的是IP；如果节点上有数据，返回的是节点的值
                    System.out.println("该节点上的数据是："+new String(data.getData()));
                    System.out.println("新增了个路径："+data.getPath());
                }
                if(type == TreeCacheEvent.Type.NODE_UPDATED){
                    System.out.println("/xihu 下修改了一个节点");
                    // data.getData() 返回的是IP
                    System.out.println("该节点上的数据是："+new String(data.getData()));
                    System.out.println("修改的路径："+data.getPath());
                }
                if(type == TreeCacheEvent.Type.NODE_REMOVED){
                    System.out.println("删除了个路径："+data.getPath());
                }
            }
        });

        treeCache.start();

        Thread.sleep(1000*100);
    }

    @Test
    public void testSwith(){
        String season= "冬";
        switch (season){
            case "冬":
                System.out.println("冬天冷...");
                break;
            case "春":
                System.out.println("春天来了，冬天还会源码？");
                break;
        }
    }

    @Test
    public void testEnum(){
        // WINTER 是枚举类的一个实例化对象
        Season season = Season.WINTER;

        switch (season){
            case WINTER:
                System.out.println("冬天冷...");
                break;
            case SPRING:
                System.out.println("春天来了，冬天还会源码？");
                break;
        }
    }

}

使用java代码操作zk 3.5以下版本，使用的技术还是Curator

第一步：创建项目

第二步：导入包：

复制代码

<!--zk的客户端( curator )-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>2.7.1</version>
</dependency>

<!--junit测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

package com.bigdata;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.*;
import org.apache.curator.retry.RetryNTimes;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class TestZk {

    CuratorFramework curator = null;

    @Before
    public void init() {
        // 1. 创建一个连接(自动重连)
        RetryNTimes retry = new RetryNTimes(2, 5);// 重连10次，每次间隔1000秒
        // 2. 创建一个客户端对象。
        curator = CuratorFrameworkFactory.newClient("bigdata01:2181,bigdata02:2181,bigdata03:2181", retry);
        // 3. 启动客户端
        curator.start();
    }

    // 新增节点  永久的
    @Test
    public void testAddNode() throws Exception {
        // 这个里面可以创建四种类型的节点  永久节点 临时节点 永久序列节点 临时序列节点
        String s = curator.create().withMode(CreateMode.PERSISTENT)
        .forPath("/a1", "测试".getBytes());
        System.out.println(s);
    }

    // 获取zk的数据
    @Test
    public void testGetData() throws Exception {
        byte[] bytes = curator.getData().forPath("/a1");
        // byte数组如何变为字符串，使用 String 的构造方法
        System.out.println(new String(bytes));
    }

    // 修改数据
    @Test
    public void testSetData() throws Exception {
        curator.setData().forPath("/a1", "我是打水哥".getBytes());
    }

    // 删除节点
    @Test
    public void testDeleteNode() throws Exception {
        curator.delete().forPath("/a1");
    }

    // 判断一个节点是否存在
    @Test
    public void testIsExists() throws Exception {
        // Stat 表示一个节点信息，如果获取不到节点信息，为null
        Stat stat = curator.checkExists().forPath("/a1");
        System.out.println(stat == null ? "该节点不存在" : "存在");
    }

    // 获取子节点信息，只能获取一层
    @Test
    public void testGetChild() throws Exception {
        List<String> list = curator.getChildren().forPath("/");
        for (String fileName : list) {
            System.out.println(fileName);
        }
    }

    // 给一个节点添加监听器  get /abc watch
    @Test
    public void testSetWatch() throws Exception {
        NodeCache nodeCache = new NodeCache(curator, "/a1");
        nodeCache.start();
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                byte[] data = nodeCache.getCurrentData().getData();
                System.out.println(new String(data));
            }
        });
        // 这个地方添加这句话的意思是不让程序跑结束，否则一切都白搭了
        Thread.sleep(Integer.MAX_VALUE);
    }


    // 给一个节点的子节点添加监听器  ls /abc watch
    @Test
    public void testSetWatchChild() throws Exception {
        PathChildrenCache cache = new PathChildrenCache(curator, "/a1", true);
        cache.start();
        // 添加监听
        cache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
                                   // 需要知道是新增了还是修改了还是删除了
                                   System.out.println(event.getType());
                                   switch (event.getType()) {
                                   case CHILD_ADDED:
                                   System.out.println("添加了一个节点");
                                   System.out.println(event.getData().getPath());
                                   System.out.println(new String(event.getData().getData()));
                                   break;
                                   case CHILD_UPDATED:
                                   System.out.println("数据更新了");
                                   System.out.println(event.getData().getPath());
                                   System.out.println(new String(event.getData().getData()));
                                   break;
                                   case CHILD_REMOVED:
                                   System.out.println("节点被删除了");
                                   System.out.println(event.getData().getPath());
                                   break;
                                   default:
                                   System.out.println("节点发生了其他变化");
                                   break;
                                   }
                                   }
                                   });

                                   // 这个地方添加这句话的意思是不让程序跑结束，否则一切都白搭了
                                   Thread.sleep(Integer.MAX_VALUE);
                                   }

                                   }

什么是API?

一般是一个技术诞生后，为了方便开发人员通过代码获取其对应的服务，就会开发出来一些方法，开发人员只需要知道调用这个方法有什么效果即可，不需要懂内部的原理，这样的一系列方法就是该技术的API。

什么是接口？

接口一般存在于web端，规定只要传递响应的参数，我就完成对应的功能，并且返回结果数据。一般是java工程师和web工程师配合工作时使用，很多开源的技术，为了方便别人使用，会对外开放很多接口，供开发人员进行调用。

枚举类：

复制代码

package com.bigdata;


// 枚举类
public enum Season {

    SPRING, // Season SPRING = new Season("春");
    SUMMER,
    AUTUMN,
    WINTER;

    // 以下这四个，分别是Season类的四个实例化对象
    Season(String a){

    }

    Season(){

    }
}

枚举类的使用：

复制代码

@Test
    public void testEnum(){
        // WINTER 是枚举类的一个实例化对象
        Season season = Season.WINTER;

        switch (season){
            case WINTER:
                System.out.println("冬天冷...");
                break;
            case SPRING:
                System.out.println("春天来了，冬天还会源码？");
                break;
        }
    }

假如新增节点，报如下错误：当然这个错误也影响结果