shell客户端

客户端启动连接

bin/zkCli.sh 本地连接

bin/zkCli.sh -server doit02:2181 连接到指定的服务节点

查看某个路径下的key

[zk: localhost:2181(CONNECTED) 5] ls /

[taoge, zookeeper]

ls2 /

[zookeeper]

cZxid = 0x0

ctime = Wed Dec 31 19:00:00 EST 1969

mZxid = 0x0

mtime = Wed Dec 31 19:00:00 EST 1969

pZxid = 0x0

cversion = -1

dataVersion = 0

aclVersion = 0

ephemeralOwner = 0x0

dataLength = 0

numChildren = 1

创建一个znode

create /aaa ddd

[zk: localhost:2181(CONNECTED) 1] create /taoge the_greatest_coder

Created /taoge

参数 -s 创建的节点有一个唯一的序号

参数 -e 临时节点 , 客户端断开以后 , 这个节点会被删除

创建一个znode的子节点 reate /aaa/bb bb

[zk: localhost:2181(CONNECTED) 4] create /taoge/hadoop 98

Created /taoge/hadoop

查看一个key的value

[zk: localhost:2181(CONNECTED) 8] get /taoge/hadoop

98

cZxid = 0x400000003

ctime = Sun Jul 07 22:59:27 EDT 2019

mZxid = 0x400000003

mtime = Sun Jul 07 22:59:27 EDT 2019

pZxid = 0x400000003

cversion = 0

dataVersion = 0

aclVersion = 0

ephemeralOwner = 0x0

dataLength = 2

numChildren = 0

删除一个znode节点

[zk: localhost:2181(CONNECTED) 11] rmr /taoge

事件监听

zookeeper中对znode的变化描述有3中事件类型：

节点value变化事件
节点的子节点变化事件
节点被创建、被删除事件

对应的，客户端向zk注册监听的命令为：

get    /abc watch

ls     /abc watch

ls2    /abc watch

stat  /abc watch

第一个客户端get /teacher watch 获取节点数据的时候监控(监控当前节点数据的变化)
克隆一个会话再客户端修改节点数据的值
第一个客户端会出现如下信息:

WatchedEvent state:SyncConnected type:NodeDataChanged path:/teacher

第一个客户端ls /teache watch
克隆一个会话创建一个客户端 , 在/teacher节点下创建一个新的节点/删除节点下的子节点
第一个客户端会出现如下信息:

WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/teacher

注意：客户端向zk注册的事件监听，只会被通知1次！如果需要持续监听，则需要反复注册

java客户端

创建maven项目

获取ZK客户端

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:  java连接zk
 * 获取指定节点下的所有的子节点
 */
public class Demo1 {

    public static void main(String[] args) throws Exception {
        String connectionString = "linux01:2181,linux02:2181,linux03:2181" ;
        // 超时时间  单位毫秒
        int sessionTimeOut = 2000 ;
        // 参数三  监听  null
        // alt+enter   导包  异常处理
        // 快速返回值    .var   或者   ctrl+alt+v
        // 获取操作ZK的java客户端对象
        ZooKeeper zooKeeper = new ZooKeeper(connectionString, sessionTimeOut, null);
        /**
         * 获取指定目录下的所有的子节点
         * 参数一  路径   一定以/开始
         * 参数二 是否监控
         */
        List<String> list = zooKeeper.getChildren("/", null);
        // 遍历指定节点下的所有的子节点
        for (String s : list) {
            System.out.println("/节点下的所有的子节点有: /"+s);  // "/"s
        }

        zooKeeper.close();
    }
}

工具类

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 */
public class ZKUtils {
    /**
     * 获取ZK的客户端对象
     * @return
     * @throws Exception
     */
    public  static ZooKeeper getZK() throws Exception {
        return  new ZooKeeper("linux01:2181", 2000, null);
    }
}

创建节点

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 * 创建节点
 *    临时
 *       1) 有序
 *       2) 无序
 *    永久节点
 *       1) 有序
 *       2) 无序
 */
public class CreateNode {
    public static void main(String[] args) throws Exception {
        // 获取ZK的java客户端
        ZooKeeper zk = new ZooKeeper("linux01:2181", 2000, null);
        // 调用api
        /**
         * create
         *  参数一 节点的名称  /开头
         *  参数二  值  字节数组  ZK底层的值是字节
         *  参数三  权限
         *  参数四  节点的类型
         *    EPHEMERAL临时的   session级别的临时  客户端断开以后 节点会被删除
         *    EPHEMERA _SEQUENTIAL临时有序
         *    PERSISTENT 永久
         *    PERSISTENT_SEQUENTIAL 永久有序
         */
        String s = zk.create("/teacher", "胡冠宇".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        // 打印当前节点的名称
        System.out.println(s);
        // 释放资源
        zk.close();
    }

}

删除节点


/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 删除节点
 */
public class DeleteNode {
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        // 删除指定节点
        /**
         * 注意 :  只能删除空节点
         */
        zk.delete("/teacher/java", -1);
        zk.close();
    }
}

递归删除节点

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 */
public class RmrNode {
    static ZooKeeper zk = null;

    static {
        try {
            zk = ZKUtils.getZK();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 删除任意节点
     *   空节点
     *   非空节点
     * @param path
     * @throws Exception
     */
    public static void rmr(String path) throws Exception {
        // 遍历节点  是否有子节点
        List<String> list = zk.getChildren(path, null);
        // 如果有  调用自己删除
        if(list!=null && list.size()>0){
            for (String node : list) {
                rmr(path+"/"+node) ;
            }
        }
        zk.delete(path,-1);
    }

    public static void main(String[] args) throws Exception {

        rmr("/a");

    }
}

获取节点的数据

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 获取节点的值
 */
public class GetData {
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        /**
         * 获取节点的值
         * 参数一  节点
         * 参数二 监控
         * 参数三 状态对象
         */
        byte[] data = zk.getData("/a0000000004", null, null);
        String str = new String(data);
        System.out.println(str);
        zk.close();
    }
}

修改节点的数据

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 */
public class SetData {
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        /**
         * 更新节点的数据
         *  参数一  节点
         *  参数二  value的值
         *  参数三 数据版本
         */
        Stat stat = zk.setData("/a", "abc".getBytes(), -1);
        zk.close();
    }
}

监控通知

入门

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 */
public class ZkWatchDemo1 {
    public static void main(String[] args) throws Exception {
        /**
         * 获取Zk客户端
         * 参数一  ZooKeeper集群的位置
         * 参数二 超时时间
         * 参数三  连接成功以后的监控  初始化的工作
         */
        ZooKeeper zk =   new ZooKeeper("linux01:2181,linux02:2181,linux03:2181", 2000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                // 不对节点做真正的监听
                System.out.println("成功获取客户端连接对象....");
            }
        });
        zk.close();
    }
}

监控节点变化一

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 监听节点数据的变化
 */
public class NodeDataChangedDemo {

    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        /**
         * 参数二监听
         */
        byte[] data = zk.getData("/servers", new Watcher() {
            @Override
            public void process(WatchedEvent event) { // 节点的数据发生变化会执行一次
                // 再次注册  获取值
                try {
                    byte[] data1 = zk.getData("/servers", this, null);
                    System.out.println(new String(data1));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },null) ;
        // 打印值
        System.out.println(new String(data));
        Thread.sleep(Integer.MAX_VALUE);

    }
}

监控节点变换二

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description:
 */
public class ReGetListChildrenNode {
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        List<String> list = zk.getChildren("/servers", new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                try {
                    // 再次注册
                    List<String> children = zk.getChildren("/servers", this);
                  //  System.out.println(children);
                    for (String child : children) {
                        // 获取所有的子节点的值
                        System.out.println(new String(zk.getData("/servers/"+child,null,null)));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        // 遍历所有的子节点
        System.out.println(list);
       /* for (String s : list) {
            System.out.println(s);
        }*/
        Thread.sleep(Integer.MAX_VALUE);
    }


}

监控节点数据变化

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 监听某个节点的子节点的变化
 */
public class ChildrenNodeChangedDemo {
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = ZKUtils.getZK();
        /**
         * 参数一  监控的节点
         * 参数二 当当前的节点的子节点的个数发生变化的时候 会调用process方法  做监控逻辑
         */
        List<String> list = zk.getChildren("/", new Watcher() {
            // 只监控一次
            @Override
            public void process(WatchedEvent event) { // 获取监控事件的类型和监控的路径
                System.out.println(event.getPath() + "--发生了--" + event.getType());
                // 再次注册
                try {
                    zk.getChildren("/", this);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        Thread.sleep(Integer.MAX_VALUE);
        //  zk.close();
    }
}

综合案-服务上下线感知

模拟namenode端

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 监控节点下的所有的子节点
 */
public class NameNode {
    ZooKeeper zk = null;

    public void start() throws Exception {
        zk = new ZooKeeper("linux01:2181,linux02:2181,linux03:2181", 2000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                System.out.println("namenode上线了........");
            }
        });
    }

    public void listDatanode() throws KeeperException, InterruptedException {
        List<String> list = zk.getChildren("/datanodes", new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                try {
                    List<String> children = zk.getChildren("/datanodes", this);
                    List<String> ls = new ArrayList<>();
                    for (String child : children) {
                        byte[] data = zk.getData("/datanodes/" + child, null, null);
                        String hosts = new String(data);
                        ls.add(hosts);
                    }
                    System.out.println(ls);
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });
        System.out.println(list);

    }

    public void  service() throws InterruptedException {
        System.out.println("namenode在服务.....");
        Thread.sleep(Integer.MAX_VALUE);
    }

    public static void main(String[] args) throws Exception {
        NameNode nn = new NameNode() ;
        nn.start();
        nn.listDatanode();
        nn.service();

    }

}

模拟datanode端

/**
 * @Auther: 多易教育-行哥
 * @Date: 2020/6/9
 * @Description: 启动以后注册到ZK集群
 */
public class DataNode {
    ZooKeeper zk = null ;
    public void start(String hostname) throws Exception {
       zk =  new ZooKeeper("linux01:2181,linux02:2181,linux03:2181", 2000, new Watcher() {
           @Override
           public void process(WatchedEvent event) {
               System.out.println(hostname+"上线了........");
           }
       });
    }

    public  void register(String hostname) throws Exception {
        zk.create("/datanodes/datanode" ,hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    }

    public  void  service(String hostname) throws Exception {
        System.out.println(hostname+"节点开始工作......");
        Thread.sleep(Integer.MAX_VALUE);
    }

    public static void main(String[] args) throws Exception {
        if(args.length==1){
            String hostname = args[0] ;
            DataNode dn = new DataNode() ;
            dn.start(hostname);
            dn.register(hostname);
            dn.service(hostname);
        }

    }

}

ZooKeeper详细笔记-客户端操作

shell客户端

java客户端

监控通知

综合案-服务上下线感知

猜你喜欢