Zookeeper（15）Zookeeper的ZooKeeper API包含哪些主要操作？

Zookeeper 的 ZooKeeper API 提供了一系列操作来管理 Zookeeper 的数据节点（znodes）。这些操作主要包括创建节点、删除节点、读取节点数据、设置节点数据、列出子节点、检查节点是否存在，以及注册 Watcher 等。以下是这些操作的详细介绍和代码示例。

主要操作

1. 创建节点 (create)
2. 删除节点 (delete)
3. 读取节点数据 (getData)
4. 设置节点数据 (setData)
5. 列出子节点 (getChildren)
6. 检查节点是否存在 (exists)
7. 注册 Watcher（监听节点变化）

代码示例

以下代码示例展示了如何使用 Zookeeper API 实现上述主要操作。

1. 添加 Maven 依赖

在 pom.xml 中添加 Zookeeper 客户端的依赖：

<dependency>
    <groupId>org.apache.zookeepergroupId>
    <artifactId>zookeeperartifactId>
    <version>3.6.3version>
dependency>

2. 创建 Zookeeper 客户端

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;

import java.io.IOException;

public class ZookeeperClient {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final int SESSION_TIMEOUT = 3000;

    private ZooKeeper zooKeeper;

    public void connect() throws IOException {
        zooKeeper = new ZooKeeper(ZK_ADDRESS, SESSION_TIMEOUT, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                System.out.println("Event received: " + event);
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    System.out.println("Successfully connected to Zookeeper");
                }
            }
        });
    }

    public void close() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    public ZooKeeper getZooKeeper() {
        return zooKeeper;
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();

        // Perform some operations...

        client.close();
    }
}

3. 创建节点

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperCreateNode {
    private ZooKeeper zooKeeper;

    public ZookeeperCreateNode(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public void createNode(String path, String data) throws Exception {
        if (zooKeeper.exists(path, false) == null) {
            zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("Node created: " + path);
        }
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperCreateNode createNode = new ZookeeperCreateNode(zooKeeper);
        createNode.createNode("/example_node", "initial_data");

        client.close();
    }
}

4. 删除节点

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

public class ZookeeperDeleteNode {
    private ZooKeeper zooKeeper;

    public ZookeeperDeleteNode(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public void deleteNode(String path) throws Exception {
        Stat stat = zooKeeper.exists(path, false);
        if (stat != null) {
            zooKeeper.delete(path, stat.getVersion());
            System.out.println("Node deleted: " + path);
        }
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperDeleteNode deleteNode = new ZookeeperDeleteNode(zooKeeper);
        deleteNode.deleteNode("/example_node");

        client.close();
    }
}

5. 读取节点数据

import org.apache.zookeeper.ZooKeeper;

public class ZookeeperReadNode {
    private ZooKeeper zooKeeper;

    public ZookeeperReadNode(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public String readNode(String path) throws Exception {
        byte[] data = zooKeeper.getData(path, false, null);
        return new String(data);
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperReadNode readNode = new ZookeeperReadNode(zooKeeper);
        String data = readNode.readNode("/example_node");
        System.out.println("Read node data: " + data);

        client.close();
    }
}

6. 设置节点数据

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

public class ZookeeperUpdateNode {
    private ZooKeeper zooKeeper;

    public ZookeeperUpdateNode(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public void updateNode(String path, String data) throws Exception {
        Stat stat = zooKeeper.exists(path, false);
        if (stat != null) {
            zooKeeper.setData(path, data.getBytes(), stat.getVersion());
            System.out.println("Node updated: " + path);
        }
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperUpdateNode updateNode = new ZookeeperUpdateNode(zooKeeper);
        updateNode.updateNode("/example_node", "updated_data");

        client.close();
    }
}

7. 列出子节点

import org.apache.zookeeper.ZooKeeper;

import java.util.List;

public class ZookeeperListChildren {
    private ZooKeeper zooKeeper;

    public ZookeeperListChildren(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public List<String> listChildren(String path) throws Exception {
        return zooKeeper.getChildren(path, false);
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperListChildren listChildren = new ZookeeperListChildren(zooKeeper);
        List<String> children = listChildren.listChildren("/");
        System.out.println("Children of root node: " + children);

        client.close();
    }
}

8. 检查节点是否存在

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

public class ZookeeperCheckExists {
    private ZooKeeper zooKeeper;

    public ZookeeperCheckExists(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public boolean checkExists(String path) throws Exception {
        Stat stat = zooKeeper.exists(path, false);
        return stat != null;
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperCheckExists checkExists = new ZookeeperCheckExists(zooKeeper);
        boolean exists = checkExists.checkExists("/example_node");
        System.out.println("Node exists: " + exists);

        client.close();
    }
}

9. 注册 Watcher（监听节点变化）

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperWatcher implements Watcher {
    private ZooKeeper zooKeeper;

    public ZookeeperWatcher(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    @Override
    public void process(WatchedEvent event) {
        System.out.println("Event received: " + event);
        if (event.getType() == Event.EventType.NodeDataChanged) {
            try {
                byte[] data = zooKeeper.getData(event.getPath(), this, null);
                System.out.println("Node data changed: " + new String(data));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void watchNode(String path) throws Exception {
        zooKeeper.getData(path, this, null);
    }

    public static void main(String[] args) throws Exception {
        ZookeeperClient client = new ZookeeperClient();
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        ZookeeperWatcher watcher = new ZookeeperWatcher(zooKeeper);
        watcher.watchNode("/example_node");

        // Simulate some other operations...

        client.close();
    }
}

详细解释

1. 创建节点：

   • 使用 create 方法创建节点，指定节点路径、数据、ACL（访问控制列表）和创建模式（持久、临时、顺序等）。

2. 删除节点：

   • 使用 delete 方法删除节点，指定节点路径和版本号。

3. 读取节点数据：

   • 使用 getData 方法读取节点数据，指定节点路径和是否注册 Watcher。

4. 设置节点数据：

   • 使用 setData 方法设置节点数据，指定节点路径、数据和版本号。

5. 列出子节点：

   • 使用 getChildren 方法列出子节点，指定节点路径和是否注册 Watcher。

6. 检查节点是否存在：

   • 使用 exists 方法检查节点是否存在，指定节点路径和是否注册 Watcher。

7. 注册 Watcher：

   • 实现 Watcher 接口，重写 process 方法处理事件。
   • 使用 getData 方法注册 Watcher，监听节点数据变化。

总结

Zookeeper 的 ZooKeeper API 提供了一系列操作来管理数据节点，包括创建、删除、读取、更新、列出子节点、检查节点是否存在以及注册 Watcher。这些操作通过 TCP 长连接进行通信，确保数据的可靠传输和事件通知。通过上述代码示例，可以直观地了解如何使用 Zookeeper API 实现这些主要操作，帮助开发者在实际应用中更好地管理和使用 Zookeeper。