zookeeper实战04-Java操作zookeeper

最新推荐文章于 2024-05-07 12:57:08 发布

滴血的菜鸟

最新推荐文章于 2024-05-07 12:57:08 发布

阅读量170

点赞数

分类专栏： zookeeper

本文链接：https://blog.csdn.net/qq_38061755/article/details/98995033

版权

zookeeper 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了如何使用Java操作Zookeeper，包括Zookeeper的会话重连机制，以及同步和异步方式创建、修改、删除节点，以及获取节点数据和判断节点存在的方法。

摘要由CSDN通过智能技术生成

测试zookeeper连接案列

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ZKConnect implements Watcher {
    public static final Logger logger = LoggerFactory.getLogger(ZKConnect.class);
    public static final String ZKSERVERPATH = "192.168.1.112:2181";  //配置连接的url
    public static final Integer TIMEOUT = 50000;  //设置超时时间
    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接受到watch通知：{}", watchedEvent);
    }
    public static void main(String[] args) throws Exception {
        ZooKeeper zooKeeper = new ZooKeeper(ZKSERVERPATH,TIMEOUT,new ZKConnect());
        logger.warn("客户端开始连接zookeeper服务器...");
        logger.warn("连接状态：{}", zooKeeper.getState()); //设置连接的状态
        new Thread().sleep(2000);
        logger.warn("连接状态：{}", zooKeeper.getState());
    }
}

zookeeper会话重连机制案例实例

何为zookeeper会话重连机制？即通过sessionid和session密码去恢复上一次的会话。

public class ZKConnectSessionWatche implements Watcher {
    public static final Logger logger = LoggerFactory.getLogger(ZKConnectSessionWatche.class);

    public static final String ZOOKEEPERSERVERPATH = "192.168.1.109:2181"; //连接zookeeper的地址

    public static final Integer TIMEOUT = 20000;//设置超时的时间

    public static void main(String[] args) throws Exception {
      ZooKeeper zooKeeper = new ZooKeeper(ZOOKEEPERSERVERPATH,TIMEOUT,new ZKConnectSessionWatche());
        logger.warn("客户端开始连接zookeeper服务器...");
        logger.warn("连接状态：{}", zooKeeper.getState());
        Thread.sleep(2000);
        logger.warn("连接状态：{}", zooKeeper.getState());

        // 记录本次会话的sessionId
        long sessionId = zooKeeper.getSessionId();
        // 转换成16进制进行打印
        //logger.warn("sid：{}", "0x" + Long.toHexString(sessionId));
        // 记录本次会话的session密码
        byte[] sessionPassword = zooKeeper.getSessionPasswd();

        Thread.sleep(200);

        // 开始会话重连
        logger.warn("开始会话重连...");
        // 加上sessionId和password参数去实例化zookeeper客户端
        ZooKeeper zkSession = new ZooKeeper(ZOOKEEPERSERVERPATH,TIMEOUT, new ZKConnectSessionWatche(), sessionId, sessionPassword);
        logger.warn("重新连接状态zkSession：{}", zkSession.getState());
        Thread.sleep(2000);
        logger.warn("重新连接状态zkSession：{}", zkSession.getState());
    }
    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到watcher通知：{}",watchedEvent);
    }
}

同步方式创建节点

public class ZKNodeOperator implements Watcher {
    public static final Logger logger = LoggerFactory.getLogger(ZKNodeOperator.class);

    // 集群模式则是多个ip
    private static final String zkServerIps = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    // 超时时间
    private static final Integer timeout = 50000;
    private ZooKeeper zooKeeper;

    public ZooKeeper getZooKeeper() {
        return zooKeeper;
    }

    public void setZooKeeper(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public ZKNodeOperator() {
    }

    public ZKNodeOperator(String connectStr) {
        try {
            // 在使用该构造器的时候，实例化zk客户端对象
            zooKeeper = new ZooKeeper(connectStr, timeout, new ZKNodeOperator());
        } catch (IOException e) {
            e.printStackTrace();
            try {
                if (zooKeeper != null) {
                    zooKeeper.close();
                }
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        }
    }

    // Watch事件通知方法
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到watch通知：{}", watchedEvent);
    }

    /**
     * @Title: ZKOperatorDemo.java
     * @Description: 创建zk节点
     */
    public void createZKNode(String path, byte[] data, List<ACL> acls) {
        String result = "";
        try {
            /**
             * 同步或者异步创建节点，都不支持子节点的递归创建，异步有一个callback函数
             * 参数：
             * path：节点创建的路径
             * data：节点所存储的数据的byte[]
             * acl：控制权限策略
             *          Ids.OPEN_ACL_UNSAFE --> world:anyone:cdrwa
             *          CREATOR_ALL_ACL --> auth:user:password:cdrwa
             * createMode：节点类型, 是一个枚举
             *          PERSISTENT：持久节点
             *          PERSISTENT_SEQUENTIAL：持久顺序节点
             *          EPHEMERAL：临时节点
             *          EPHEMERAL_SEQUENTIAL：临时顺序节点
             */
            // 同步创建zk节点，节点类型为临时节点
            result = zooKeeper.create(path, data, acls, CreateMode.EPHEMERAL);
            System.out.println("创建节点：\t" + result + "\t成功...");
            Thread.sleep(2000);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ZKNodeOperator zkServer = new ZKNodeOperator(zkServerIps );

        // 创建zk节点
        zkServer.createZKNode("/testNode", "testNode-data".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE);
    }
}

异步方式创建节点

//编写一个类实现 StringCallback接口
public class CreateCallBack implements StringCallback {
    //回调函数
    @Override
    public void processResult(int i, String s, Object o, String s1) {
        System.out.println("创建节点：" + s);
        System.out.println((String)o);
    }
}

//编写create方法
   public void createZKNode(String path, byte[] data, List<ACL> acls) {
        try {
           String ctx = "{'create':'success'}";
            zooKeeper.create(path, data, acls, CreateMode.PERSISTENT, new CreateCallBack(), ctx);
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

同步方式修改zookeeper节点的数据

public class ZKNodeAlterOperator implements Watcher {
    Logger logger = LoggerFactory.getLogger(ZKNodeAlterOperator.class);

    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer  timeout = 50000;
    private ZooKeeper zooKeeper;

    public ZooKeeper getZooKeeper() {
        return zooKeeper;
    }

    public void setZookeeper(ZooKeeper zooKeeper){
        this.zooKeeper = zooKeeper;
    }

    public ZKNodeAlterOperator(){}

    public ZKNodeAlterOperator(String connStr){
        try {
            zooKeeper = new ZooKeeper(connStr,timeout,new ZKNodeAlterOperator());
        } catch (IOException e) {
            e.printStackTrace();
            try {
                if(zooKeeper != null){
                    zooKeeper.close();
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到watcher通知：{}",watchedEvent);
    }

    public static void main(String[] args) throws Exception {
        ZKNodeAlterOperator zkNodeAlterOperator = new ZKNodeAlterOperator(path);
        Stat stat  = zkNodeAlterOperator.getZooKeeper().setData("/testNode","ok".getBytes(),0);
        System.out.println("当前的版本号为："+stat.getAversion());
    }
}

异步方式修改节点的值

//实现StatCallback接口
public class AlterCallBack implements AsyncCallback.StatCallback {
    @Override
    public void processResult(int i, String s, Object o, Stat stat) {
        System.out.println("修改节点：" + s + "成功");
        System.out.println("当前的数据版本为：" + stat.getAversion());
        System.out.println((String)o);
    }
}

//调用相关方法
public static void main(String[] args) throws Exception {
        ZKNodeAlterOperator zkNodeAlterOperator = new ZKNodeAlterOperator(path);
        String ctx = "{'alter':'success'}";
        zkNodeAlterOperator.getZooKeeper().setData("/testNode","lp".getBytes(),0,new AlterCallBack(),ctx);
        Thread.sleep(2000);
    }

同步删除节点数据

public class ZKNodeDeleteOPerator implements Watcher {
    private static final Logger logger = LoggerFactory.getLogger(ZKNodeDeleteOPerator.class);
    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer timeout = 50000;
    private static ZooKeeper zooKeeper;

    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到loggert通知：{}",watchedEvent);
    }
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        zooKeeper = new ZooKeeper(path,timeout,new ZKNodeDeleteOPerator());
        zooKeeper.create("/testDeleteNode","testDeleteNode".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        Thread.sleep(2000);
        zooKeeper.delete("/testDeleteNode",0);
        zooKeeper.close();
    }
}

异步方式删除节点数据

//实现删除回调接口VoidCallback
public class DeleteCallBack implements AsyncCallback.VoidCallback {
    @Override
    public void processResult(int i, String s, Object o) {
        System.out.println("删除节点：" + s + "成功");
        System.out.println((String)o);
    }
}

public class ZKNodeDeleteOPerator implements Watcher {
    private static final Logger logger = LoggerFactory.getLogger(ZKNodeDeleteOPerator.class);
    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer timeout = 50000;
    private static ZooKeeper zooKeeper;

    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到loggert通知：{}",watchedEvent);
    }
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        zooKeeper = new ZooKeeper(path,timeout,new ZKNodeDeleteOPerator());
        zooKeeper.create("/testDeleteNode","testDeleteNode".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        Thread.sleep(2000);

        String ctx = "{'delete':'success'}";
        zooKeeper.delete("/testDeleteNode",0,new DeleteCallBack(),ctx);
        Thread.sleep(1000);
        zooKeeper.close();
    }
}

获取zookeeper节点的数据

public class ZKGetNodeData implements Watcher {
    private static final Logger logger = LoggerFactory.getLogger(ZKNodeDeleteOPerator.class);
    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer timeout = 50000;
    private static ZooKeeper zooKeeper;
    private static Stat stat = new Stat();
    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到通知：{}",watchedEvent);
    }

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        zooKeeper = new ZooKeeper(path,timeout,new ZKGetNodeData());
        byte [] res = zooKeeper.getData("/testNode",true,stat);
        String result = new String(res);
        System.out.println(result);
        zooKeeper.close();
    }
}

-判断节点的是否存在

public class ZKNodeExists implements Watcher {
    private static final Logger logger = LoggerFactory.getLogger(ZKNodeDeleteOPerator.class);
    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer timeout = 50000;
    private static ZooKeeper zooKeeper;
    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到通知：{}",watchedEvent);
    }

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        zooKeeper = new ZooKeeper(path,timeout,new ZKNodeExists());
        Stat stat = zooKeeper.exists("/testNode",true);
        if(stat != null){
            System.out.println("指定的节点存在");
            System.out.println("版本号为："+stat.getAversion());
        }else{
            System.out.println("该节点不存在");
        }
    }
}

获取zookeeper子节点列表

public class ZKGetChildrenList implements Watcher {
    private static final Logger logger = LoggerFactory.getLogger(ZKNodeDeleteOPerator.class);
    private static final String path = "192.168.1.109:2181,192.168.1.109:2182,192.168.1.109:2183";
    private static final Integer timeout = 50000;
    private static ZooKeeper zooKeeper;

    @Override
    public void process(WatchedEvent watchedEvent) {
        logger.warn("接收到通知：{}",watchedEvent);
    }

    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        zooKeeper = new ZooKeeper(path,timeout,new ZKGetChildrenList());
        List<String> stringList = zooKeeper.getChildren("/testNode",false);
        for(String s : stringList){
            System.out.println(s);
        }
    }
}

滴血的菜鸟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
zookeeper实战04-Java操作zookeeper

基本的测试zookeeper连接案列import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.ZooKeeper;import org.slf4j.Logger;import org.slf4j.LoggerFactory;...
复制链接

扫一扫