利用zookeeper模拟实现HA高可用
1、需求
在分布式场景中，对于主从架构来说，最大的问题就是单点故障。当学过zookeeper之后，我们都知道，可以利用zookeeper集群来帮助实现Hadoop的HA，那到底Hadoop的HA是如何实现的呢？
2、实现思路
zookeeper给我们提供了两个非常重要的组件：
1、znode系统：提供了存储关键数据的能力
2、监听机制：提供了监听感兴趣数据变化的能力
利用zookeeper的这两点能力，我们实现HA
3、具体实现功能
1、当开始启动namenode的时候，所有刚启动的namenode都需要去争抢成为active的namenode，没有争抢成功的则成为standby的状态
2、当active的namenode死掉之后，需要剩下的所有的stanby都需要去争抢成为active的状态
4、具体代码实现
package com.ghgj.zookeeper.zkapp1903;
import org.apache.zookeeper.*;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooDefs.Ids;
import java.util.List;
/**
* 需求：
* 模拟实现HA
* <p>
* 具体的功能：
* 1、当开始启动namenode的时候，所有刚启动的namenode都需要去争抢成为active的namenode
* 没有争抢成功的则成为standby的状态
* 2、当active的namenode死掉之后，需要剩下的所有的stanby都需要去争抢成为active的状态
* <p>
* 在这个模拟实现中，假定所有的namenode之间的数据状态都是同步的。没有数据状态差别
* <p>
* 分析实现思路：
* 见代码注释
*/
public class NameNodeHA {
// 连接信息
private static final String CONNECT_STR = "hadoop02:2181,hadoop03:2181";
// 会话超时时长 会话建立成功最长的等待时间
private static final int TIME_OUT = 5000;
// 存储active namenode的父级znode节点
private static final String ACTIVE_PARENT = "/namenode_active";
// 存储standby namenode的父级znode节点
private static final String STANBY_PARENT = "/namenode_standbys";
// 锁节点
private static final String LOCK_ZNODE = "/namenode_lock";
// 当前上线的节点名称
private static final String NAMENODE_HOST = "hadoop02";
static ZooKeeper zookeeper = null;
public static void main(String[] args) throws Exception {
/**
* 获取连接
*
* 关于监听器的知识：
* 有两种添加监听的方式：
* 1、通过会话对象添加，这个会话对象中的所有的相应都能接收到，都在这个监听器对象中的process
* 方法中执行业务逻辑的回调
* 在获取会话的时候添加的监听是属于全局监听，当前这个会话中的任何事件响应，都会回调这个监听器对象中的
* process方法
*
* 2、在对应的三种添加监听的方式中，注入自定义的监听对象，那么注入的监听器对象是谁，
* 当事件响应的时候，就回调这个监听器对象中的process方法
*/
zookeeper = new ZooKeeper(CONNECT_STR, TIME_OUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
// 哪个znode节点
String path = event.getPath();
// 事件的类型
EventType type = event.getType();
// 如果是 ACTIVE_PARENT 的 NodeChildrenChanged 事件
// 当active namenode死掉或者增加都会触发process回调
if (path.equals(ACTIVE_PARENT) && type == EventType.NodeChildrenChanged) {
try {
// 争抢成为active namenode
List<String> onlyAtiveNM = zookeeper.getChildren(ACTIVE_PARENT, null);
if (onlyAtiveNM.size() == 0) {
// 原来的active namenode死掉了
// 正式实现：争抢成为active namenode
// 抢锁: 使用创建一个znode来模式实现抢锁，谁创建成功就是谁获取到了这把锁
// 注册监听
// 关注 LOCK_ZNODE 的 NodeCreated 事件
zookeeper.exists(LOCK_ZNODE, true);
// 创建锁节点
// 触发了 LOCK_ZNODE 的 NodeCreated 事件
if (zookeeper.exists(LOCK_ZNODE, false) == null) {
zookeeper.create(LOCK_ZNODE, NAMENODE_HOST.getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
}
} else if (onlyAtiveNM.size() == 1) {
// 相当于已经有一个anmenode把自己切换成为active了
// 所以不需要做什么操作
}
} catch (Exception e) {
e.printStackTrace();
}
} else if (path.equals(LOCK_ZNODE) && type == EventType.NodeCreated) {
String namenode_lock_znode = null;
try {
// 真正的来判断，谁创建成功的锁节点，如果是自己创建成功的，则切换自己的状态成为 active
byte[] data = zookeeper.getData(LOCK_ZNODE, false, null);
// namenode_lock_znode
// 这个对象 namenode_lock_znode 就是谁创建成功的那个namenode的节点名称
namenode_lock_znode = new String(data, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
}
// 需要判断，是否是自己创建成功的锁节点
if (NAMENODE_HOST.equals(namenode_lock_znode)) {
// 是自己创建成功的锁节点
// 切换自己的状态
try {
// 首先删除自己在 STANDBY_PERENT节点下的该表自己的znode
String deletePath = STANBY_PARENT + "/" + NAMENODE_HOST;
if (zookeeper.exists(deletePath, false) != null) {
zookeeper.delete(deletePath, -1);
}
// 再创建一个znode节点在ACTIVE_PARNET下面
String createPath = ACTIVE_PARENT + "/" + NAMENODE_HOST;
zookeeper.create(createPath, NAMENODE_HOST.getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
System.out.println(NAMENODE_HOST + " 注册成为active角色");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
} else {
// 判断得出结果 锁节点不是自己创建成功，不要成为active
// 什么都不做
}
}
}
});
/**
* 执行各种操作
*/
// 确保两个父节点存在
if (zookeeper.exists(ACTIVE_PARENT, null) == null) {
zookeeper.create(ACTIVE_PARENT, "storage active namenode data".getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
if (zookeeper.exists(STANBY_PARENT, null) == null) {
zookeeper.create(STANBY_PARENT, "storage standby namenode data".getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
// 先来判断是否有active的namenode
List<String> activeNM = zookeeper.getChildren(ACTIVE_PARENT, null);
if (activeNM.size() == 1) {
System.out.println(activeNM.get(0) + " 节点是active角色, 自己 " + NAMENODE_HOST + "成为standby角色");
// 如果有active的namenode， 则自动成为 standby的namenode
// 到 STANBY_PARENT 这个znode节点下，创建一个子节点代表当前这个standby namenode
String standByPath = STANBY_PARENT + "/" + NAMENODE_HOST;
zookeeper.create(standByPath, NAMENODE_HOST.getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
// 注册监听：关注现在的active namenode 是否死掉
// ACTIVE_PARENT 的 NodeChildrenChanged 事件
// 关心是否 active 的namenode 死掉
zookeeper.getChildren(ACTIVE_PARENT, true);
} else {
// 当发现没有active的namenode的时候：
// 先争抢锁
// 争抢锁争抢到了的话，就切换自己的状态
// 注册监听
// 关注 LOCK_ZNODE 的 NodeCreated 事件
zookeeper.exists(LOCK_ZNODE, true);
// 创建锁节点
// 触发了 LOCK_ZNODE 的 NodeCreated 事件
zookeeper.create(LOCK_ZNODE, NAMENODE_HOST.getBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
System.out.println("发现没有active，去争抢成为" + NAMENODE_HOST + " 节点成为standby节点");
}
/**
* 关闭连接
*/
while (true) {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
5、执行效果
当hadoop02节点启动：
当hadoop03启动的时候：
当hadoop04启动的时候：
当现在为active的hadoop02宕机的时候：
当hadoop02被宕机的时候，发现最终，hadoop03和hadoop04争抢成为active角色，最后发现hadoop04竞争成功成为active角色