一、概述

上一篇文章提到的可以通過java api操作zookeeper數據節點，並對節點狀態進行監聽

https://blog.csdn.net/qq_33513250/article/details/102289689

下面介紹操作znode並異步處理結果：

創建znode、獲取數據、設置數據、獲取子節點、權限設置、節點存在判斷、刪除節點

二、異步處理回調

1.創建節點

package com.szwn.zk;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

public class AsyncCreateNote implements Watcher {
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        ZooKeeper zookeeper = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncCreateNote());
        System.out.println(zookeeper.getState());
        // 2.等待連接完成
        connectedSemaphore.await();

        // 3.異步創建節點，節點類型爲ephemeral，並設置ctx值
        zookeeper.create("/zk-test-ephemeral-", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL,
                new IStringCallback(), "I am context. ");

        // 4.異步創建節點，節點類型爲ephemeral，並設置ctx值，相同路徑報錯
        zookeeper.create("/zk-test-ephemeral-", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL,
                new IStringCallback(), "I am context. ");

        // 5.異步創建節點，節點類型爲ephemeral_sequential，並設置ctx值
        zookeeper.create("/zk-test-ephemeral-", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,
                new IStringCallback(), "I am context. ");
        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            // 監聽連接成功事件
            connectedSemaphore.countDown();
        }
    }
}

class IStringCallback implements AsyncCallback.StringCallback {
    public void processResult(int rc, String path, Object ctx, String name) {
        // 異步回調處理創建節點結果
        System.out.println("Create path result: [" + rc + ", " + path + ", " + ctx + ", real path name: " + name);
    }
}

運行結果如下，0表示運行成功，-110表示NodeExists.

代碼中創建節點回調接口爲 AsyncCallback.StringCallback

AsyncCallback接口中包含所有操作znode節點結果的回調接口

package org.apache.zookeeper;

import java.util.List;

import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;

public interface AsyncCallback {
    // 獲取stat回調
    interface StatCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx, Stat stat);
    }
    // 修改數據回調
    interface DataCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx, byte data[],
                Stat stat);
    }
    // 權限控制回調
    interface ACLCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx,
                List<ACL> acl, Stat stat);
    }
    // 子節點回調
    interface ChildrenCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx,
                List<String> children);
    }
    // 子節點回調
    interface Children2Callback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx,
                List<String> children, Stat stat);
    }
    // 創建節點回調
    interface StringCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx, String name);
    }
    // 刪除節點回調
    interface VoidCallback extends AsyncCallback {
        public void processResult(int rc, String path, Object ctx);
    }
}

2.獲取數據

package com.szwn.zk;

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class AsyncGetData implements Watcher {
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk = null;

    public static void main(String[] args) throws Exception {
        String path = "/zk-book";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncGetData());
        // 2.等待連接完成
        connectedSemaphore.await();
        // 3.創建節點，節點類型爲ephemeral
        zk.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path);

        // 4.獲取數據，異步處理結果並且繼續監聽事件
        zk.getData(path, true, new IDataCallback(), null);

        // 5.修改數據
        zk.setData(path, "123".getBytes(), -1);

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                // 監聽連接成功事件
                connectedSemaphore.countDown();
            } else if (event.getType() == Event.EventType.NodeDataChanged) {
                try {
                    // 監聽數據改變事件，並且異步處理結果，同時繼續監聽
                    zk.getData(event.getPath(), true, new IDataCallback(), null);
                } catch (Exception e) {
                }
            }
        }
    }
}

class IDataCallback implements AsyncCallback.DataCallback {
    @Override
    public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
        // 異步回調處理獲取數據結果
        System.out.println("rc: " + rc + ", path: " + path + ", data: " + new String(data));
        System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
    }
}

3.設置數據

package com.szwn.zk;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.concurrent.CountDownLatch;

public class AsyncSetData implements Watcher{
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk;

    public static void main(String[] args) throws Exception {
        String path = "/zk-book";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncSetData());
        // 2.等待連接完成
        connectedSemaphore.await();

        // 3.創建節點，節點類型爲ephemeral
        zk.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path);
        // 4.修改數據並異步處理回調
        zk.setData(path, "456".getBytes(), -1, new IStatCallback(), null);

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            // 監聽連接成功事件
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            }
        }
    }
}

class IStatCallback implements AsyncCallback.StatCallback {
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        // 異步回調處理獲取數據結果
        System.out.println("rc: " + rc + ", path: " + path + ", stat: " + stat);
    }
}

4.獲取子節點

package com.szwn.zk;

import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class AsyncGetChildren implements Watcher {
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk = null;

    public static void main(String[] args) throws Exception {
        String path = "/zk-book";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncGetChildren());
        // 2.等待連接完成
        connectedSemaphore.await();
        // 3.創建節點，節點類型爲persistent
        zk.create(path, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path);
        // 4.創建節點/path/c1，節點類型爲ephemeral
        zk.create(path + "/c1", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path + "/c1");
        // 5.獲取path子節點信息，設置監聽爲true，回調異步處理結果
        zk.getChildren(path, true, new IChildren2Callback(), null);
        // 6.創建節點/path/c2，節點類型爲ephemeral
        zk.create(path + "/c2", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path + "/c2");

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            // 監聽連接成功事件
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
                // 監聽子節點變化事件
            } else if (event.getType() == Event.EventType.NodeChildrenChanged) {
                try {
                    // 獲取path子節點信息，設置監聽爲true，回調異步處理結果
                    zk.getChildren(event.getPath(), true, new IChildren2Callback(), null);
                } catch (Exception e) {
                }
            }
        }
    }
}

class IChildren2Callback implements AsyncCallback.Children2Callback {
    public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
        // 異步回調處理獲取子節點信息結果
        System.out.println("Get Children znode result: [response code: " + rc + ", param path: " + path + ", ctx: " + ctx + ", children list: " + children
                        + ", stat: " + stat);
    }
}

5.權限設置獲取

package com.szwn.zk;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.apache.zookeeper.data.Stat;

public class AsyncGetSetAcl implements Watcher {
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk = null;

    public static void main(String[] args) throws Exception {
        String path = "/zk-async-acl";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncGetSetAcl());
        // 2.等待連接完成
        connectedSemaphore.await();
        // 3.創建節點，節點類型爲ephemeral
        zk.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("success create znode: " + path);

        // 4.獲取acl，異步處理結果並且繼續監聽事件
        zk.getACL(path,null,new IACLCallback(),"async process get acl");

        // 5.修改acl
        List<ACL> digest = Arrays.asList(new ACL(1, new Id("digest", "foo:true")));
        zk.setACL(path,digest,-1,new IStatCallbackAcl(),"async process set acl");

        // 6.獲取acl，異步處理結果並且繼續監聽事件
        zk.getACL(path,null,new IACLCallback(),"async process get acl2");

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                // 監聽連接成功事件
                connectedSemaphore.countDown();
            }
        }
    }
}

class IACLCallback implements AsyncCallback.ACLCallback {
    @Override
    public void processResult(int rc, String path, Object ctx, List<ACL> acl, Stat stat) {
        // 異步回調處理獲取權限結果
        System.out.println("rc: " + rc + ", path: " + path + ", acl: " + acl);
        System.out.println("czxID: " + stat.getCzxid() + ", mzxID: " + stat.getMzxid() + ", version: " + stat.getVersion());
    }
}

class IStatCallbackAcl implements AsyncCallback.StatCallback {
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        // 異步回調處理獲取數據結果
        System.out.println("rc: " + rc + ", path: " + path + ", stat: " + stat);
    }
}

6.節點存在

package com.szwn.zk;

import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class AsyncExist implements Watcher {
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk;

    public static void main(String[] args) throws Exception {
        String path = "/zk-async-exist";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000, new AsyncExist());
        // 2.等待連接完成
        connectedSemaphore.await();
        // 3.請求節點是否存在，設置監聽爲true,並異步處理返回結果
        zk.exists(path, true, new IIStatCallback(), null);
        // 4.創建節點
        zk.create(path, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        // 5.設置數據
        zk.setData(path, "123".getBytes(), -1);
        // 6.創建子節點path/exist
        zk.create(path + "/exist", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path + "/c1");
        // 7.刪除子節點path/exist
        zk.delete(path + "/exist", -1);
        zk.delete(path, -1);

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        try {
            if (Event.KeeperState.SyncConnected == event.getState()) {
                // 監聽連接成功事件
                if (Event.EventType.None == event.getType() && null == event.getPath()) {
                    connectedSemaphore.countDown();
                    // 監聽節點創建事件，並重新加入監聽，異步處理返回結果
                } else if (Event.EventType.NodeCreated == event.getType()) {
                    System.out.println("success create znode: " + event.getPath());
                    zk.exists(event.getPath(), true, new IIStatCallback(), null);
                } else if (Event.EventType.NodeDeleted == event.getType()) {
                    System.out.println("success delete znode: " + event.getPath());
                    zk.exists(event.getPath(), true, new IIStatCallback(), null);
                } else if (Event.EventType.NodeDataChanged == event.getType()) {
                    System.out.println("data changed of znode: " + event.getPath());
                    zk.exists(event.getPath(), true, new IIStatCallback(), null);
                }
            }
        } catch (Exception e) {
        }
    }
}

class IIStatCallback implements AsyncCallback.StatCallback {
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        // 異步回調處理結果
        System.out.println("rc: " + rc + ", path: " + path + ", stat: " + stat);
    }
}

rc: -101（node does not exist）

7.刪除節點

package com.szwn.zk;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

public class AsyncDeleteNode implements Watcher{
    private static CountDownLatch connectedSemaphore = new CountDownLatch(1);
    private static ZooKeeper zk;

    public static void main(String[] args) throws Exception {
        String path = "/zk-async-delete";
        // 1.連接zookeeper 客戶端，參數分別爲服務器連接地址，集羣用逗號隔開，sessionTimeout,事件監聽器
        zk = new ZooKeeper("127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183", 5000,
                new AsyncDeleteNode());
        // 2.等待連接完成
        connectedSemaphore.await();
        // 3.創建節點
        zk.create(path, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path);
        // 4.創建子節點/path/c1
        zk.create(path + "/c1", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("success create znode: " + path + "/c1");
        // 5.刪除節點/path,直接刪除，有子節點會報錯
        zk.delete(path, -1, new IVoidCallback(), null);
        // 6.刪除子節點/path/c1
        zk.delete(path + "/c1", -1, new IVoidCallback(), null);
        // 7.刪除節點/path
        zk.delete(path, -1, new IVoidCallback(), null);

        Thread.sleep(Integer.MAX_VALUE);
    }

    public void process(WatchedEvent event) {
        if (Event.KeeperState.SyncConnected == event.getState()) {
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                connectedSemaphore.countDown();
            }
        }
    }
}

class IVoidCallback implements AsyncCallback.VoidCallback {
    public void processResult(int rc, String path, Object ctx) {
        System.out.println(rc + ", " + path + ", " + ctx);
    }
}

rc: -111（the node has children）

zookeeper java api 操作（二）| 異步處理結果

目錄

一、概述

二、異步處理回調

1.創建節點

2.獲取數據

3.設置數據

4.獲取子節點

5.權限設置獲取

6.節點存在

7.刪除節點

Dubbo源碼分析之SPI(一) | serviceLoader

Dubbo源碼分析之Netty網絡服務（二）

Dubbo源碼分析之SPI(二) | ExtensionLoader

zookeeper的windows和Linux的安裝與啓動

zookeeper java api 操作（三） | zkclient

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結