1.2 Zookeeper 数据模型

1.2 Zookeeper 数据模型

1.2 Zookeeper 数据模型：构建分布式协调的基石

1.2.1 ZNode - 构成数据模型的基本单元

Zookeeper 数据模型的核心概念是 ZNode (Zookeeper Node)。我们可以将 ZNode 理解为 Zookeeper 命名空间中的一个节点，类似于文件系统中的目录或文件。每个 ZNode 都可以存储少量的数据，并且可以拥有子节点，从而构成一个层次化的树形结构。

更具体来说，一个 ZNode 包含了以下几个关键组成部分：

• 节点名称 (Name): ZNode 通过路径进行唯一标识，路径由一系列以斜杠 / 分隔的名称组成，例如 /app1/config/db。根节点始终是 /。节点名称在其父节点下必须是唯一的。

• 数据 (Data): 每个 ZNode 都可以关联少量的数据，这些数据可以是任何形式的字节数组，但通常用于存储配置信息、状态信息等。Zookeeper 设计之初就不是为了存储大量数据，因此建议 ZNode 存储的数据量保持在 1MB 以内，通常最佳实践是几 KB 甚至更小。

• 元数据 (Stat): 每个 ZNode 都维护一组元数据，称为 Stat 结构，用于描述 ZNode 的版本、时间戳、ACL 权限等信息。这些元数据对于实现 Zookeeper 的一致性和可靠性至关重要。

• 访问控制列表 (ACL): Zookeeper 允许为每个 ZNode 设置 ACL，用于控制对 ZNode 的访问权限，例如读取、写入、创建、删除等。ACL 机制保证了 Zookeeper 数据的安全性。

可以用 Mermaid 的 graph TD 图来简单表示一个 ZNode 的组成结构：

图 1.2.1 ZNode 组成结构

如图所示，一个 ZNode 包含了名称、数据、元数据 Stat 和 ACL 权限控制列表。这些组件共同定义了 ZNode 的特性和行为。

1.2.2 层次命名空间 - 树形结构

Zookeeper 的数据模型采用层次化的命名空间，这使得 Zookeeper 的数据组织方式非常直观和易于管理。整个命名空间由一个根节点 / 开始，可以创建子节点，子节点的子节点，以此类推，形成一棵树状结构。这种结构与我们熟悉的文件系统非常相似，易于理解和使用。

路径 (Path) 是访问 ZNode 的方式。通过指定 ZNode 的路径，我们可以定位到树中的特定节点。路径由根节点开始，沿着树的分支，直到目标 ZNode，路径中的每个节点名称之间用斜杠 / 分隔。例如，/app1/config/db 表示一个位于 /app1/config 节点下的名为 db 的 ZNode。

这种树形结构带来了以下优势：

• 组织性: 层次结构使得数据组织更有条理，可以根据应用场景和功能模块将数据进行分组和隔离。例如，可以将不同应用的配置信息放在不同的路径下，如 /app1 和 /app2。

• 易于导航: 通过路径可以快速定位到特定的 ZNode，方便进行数据的读取和操作。

• 权限管理: 可以针对树的不同分支设置不同的 ACL 权限，实现更细粒度的权限控制。

我们可以使用 Mermaid 的 graph TD 图来表示 Zookeeper 的层次命名空间：

图 1.2.2 Zookeeper 层次命名空间示例

如图所示，根节点 / 下可以创建多个子节点，例如 app1 和 app2，代表不同的应用。每个应用下又可以进一步细分子节点，例如 config 和 servers，代表配置信息和服务器列表。这种树形结构可以灵活地适应各种分布式应用的数据组织需求。

1.2.3 ZNode 数据

ZNode 的数据部分用于存储与节点相关的少量信息。Zookeeper 设计的初衷并非作为大型数据存储系统，而是专注于协调和配置管理。因此，ZNode 存储的数据量通常较小，建议控制在 1MB 以内，最佳实践是几 KB 甚至更小。

ZNode 数据可以存储各种类型的信息，例如：

• 配置信息: 例如数据库连接字符串、应用配置参数、服务地址列表等。

• 状态信息: 例如服务运行状态、leader 选举结果、任务分配信息等。

• 控制信息: 例如锁的持有者信息、队列的消费者信息等。

数据更新和版本控制: Zookeeper 保证数据更新的原子性。当客户端更新 ZNode 的数据时，要么整个更新成功，要么整个更新失败。同时，每次数据更新都会导致 ZNode 的版本号 (version) 递增。版本号机制对于实现乐观锁和数据一致性非常重要。客户端在更新数据时可以指定期望的版本号，如果当前版本号与期望版本号不一致，则更新操作会失败，从而避免并发更新导致的数据冲突。

数据读取: 客户端可以读取 ZNode 的数据。Zookeeper 保证数据读取的一致性，即客户端在同一会话中多次读取同一个 ZNode 的数据，将看到相同的结果，除非有其他客户端更新了该 ZNode 的数据。

数据大小限制: 虽然 ZNode 可以存储字节数组，但出于性能和稳定性的考虑，Zookeeper 对 ZNode 数据的大小有限制。默认情况下，ZNode 数据大小限制为 1MB。如果需要存储大量数据，建议将数据存储在外部存储系统 (例如分布式文件系统或数据库) 中，然后在 ZNode 中存储数据的索引或元信息。

1.2.4 ZNode 元数据 (Stat)

每个 ZNode 除了存储数据外，还维护了一组元数据 (Stat)，用于描述 ZNode 的状态和属性。Stat 结构包含了以下关键字段：

• czxid (Creation Transaction Id): 创建 ZNode 的事务 ID。Zookeeper 使用事务 ID (zxid) 来标识事务的顺序，zxid 是一个单调递增的 64 位数字。

• ctime (Creation Time): ZNode 的创建时间，以毫秒为单位的 UTC 时间。

• mzxid (Modification Transaction Id): 最后一次修改 ZNode 数据的事务 ID。

• mtime (Modification Time): 最后一次修改 ZNode 数据的时间，以毫秒为单位的 UTC 时间。

• pzxid (Parent Transaction Id): 最后一次修改子节点的事务 ID。只有子节点列表发生变化时，pzxid 才会更新。

• cversion (Child Version): 子节点的版本号。每次子节点列表发生变化，cversion 都会递增。

• dataVersion (Data Version): 数据版本号。每次 ZNode 的数据被修改，dataVersion 都会递增。

• aclVersion (ACL Version): ACL 版本号。每次 ZNode 的 ACL 列表被修改，aclVersion 都会递增。

• ephemeralOwner (Ephemeral Owner): 如果 ZNode 是临时节点，则 ephemeralOwner 记录创建该临时节点的会话 ID。如果 ZNode 是持久节点，则 ephemeralOwner 为 0。

• dataLength (Data Length): ZNode 存储的数据的长度，以字节为单位。

• numChildren (Number of Children): ZNode 的子节点数量。

Stat 的作用:

• 版本控制: dataVersion、cversion 和 aclVersion 用于实现版本控制，可以用于乐观锁和数据一致性检查。

• 时间戳: ctime 和 mtime 记录了 ZNode 的创建和修改时间，可以用于审计和监控。

• 事务 ID: czxid、mzxid 和 pzxid 提供了事务的顺序信息，对于理解 Zookeeper 的内部机制和排查问题很有帮助。

• 节点类型: ephemeralOwner 用于区分持久节点和临时节点。

• 节点状态: dataLength 和 numChildren 反映了 ZNode 的数据大小和子节点数量。

客户端可以通过 getData 或 exists 操作获取 ZNode 的 Stat 信息。Stat 信息对于理解 ZNode 的状态和进行并发控制非常重要。

1.2.5 ZNode 类型

Zookeeper 的 ZNode 根据其生命周期和特性可以分为不同的类型，主要包括以下几种：

• 持久节点 (Persistent Node): 持久节点是最常用的节点类型。一旦创建，持久节点会一直存在于 Zookeeper 中，直到客户端显式地删除它。即使创建该节点的客户端会话失效，持久节点仍然存在。持久节点通常用于存储配置信息、元数据、应用状态等需要长期保存的信息。

• 临时节点 (Ephemeral Node): 临时节点的生命周期与创建它的客户端会话绑定。当创建临时节点的客户端会话失效 (例如客户端崩溃、网络断开、显式关闭会话) 时，Zookeeper 会自动删除该临时节点。临时节点通常用于leader 选举、服务注册与发现、会话管理等场景。

• 顺序节点 (Sequential Node): 顺序节点可以与持久节点或临时节点结合使用。当创建一个顺序节点时，Zookeeper 会在节点名称后面自动追加一个单调递增的数字后缀。例如，如果创建一个名为 /tasks/task- 的顺序节点，Zookeeper 可能会创建名为 /tasks/task-0000000001、/tasks/task-0000000002 等节点。顺序节点主要用于实现公平锁、队列、分布式 ID 生成等场景。

根据持久性与顺序性，ZNode 可以组合成以下四种类型：

• 持久节点 (PERSISTENT)

• 持久顺序节点 (PERSISTENT_SEQUENTIAL)

• 临时节点 (EPHEMERAL)

• 临时顺序节点 (EPHEMERAL_SEQUENTIAL)

节点类型选择: 选择合适的节点类型取决于具体的应用场景。

• 持久节点: 适用于存储需要长期保存的信息，例如配置信息、元数据等。

• 临时节点: 适用于存储与会话相关的临时信息，例如会话状态、服务实例信息等。

• 顺序节点: 适用于需要保证节点创建顺序的场景，例如实现公平锁、队列等。

节点类型总结:

1.2.6 代码实践

为了更好地理解 Zookeeper 数据模型，我们通过 Java Zookeeper 客户端进行代码实践。以下代码示例演示了如何使用 Zookeeper Java 客户端进行 ZNode 的创建、读取、更新、删除等操作，并展示了不同类型 ZNode 的特性。

环境准备: 首先需要引入 Zookeeper Java 客户端依赖，例如 Maven 项目可以在 pom.xml 中添加：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.6.3</version> <!-- 使用最新稳定版本 -->
</dependency>
​

代码示例:

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.nio.charset.StandardCharsets;
import java.util.List;
public class ZookeeperDataModelExample {
    private static final String ZK_ADDRESS = "localhost:2181"; // Zookeeper 服务器地址
    private static final int SESSION_TIMEOUT = 5000; // 会话超时时间
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = connectZookeeper();
        try {
            // 1. 创建持久节点
            createPersistentNode(zk, "/myPersistentNode", "Persistent Node Data");
            // 2. 创建临时节点
            createEphemeralNode(zk, "/myEphemeralNode", "Ephemeral Node Data");
            // 3. 创建持久顺序节点
            createPersistentSequentialNode(zk, "/myPersistentSequentialNode-", "Persistent Sequential Node Data");
            // 4. 创建临时顺序节点
            createEphemeralSequentialNode(zk, "/myEphemeralSequentialNode-", "Ephemeral Sequential Node Data");
            // 5. 获取节点数据和 Stat
            getNodeDataAndStat(zk, "/myPersistentNode");
            // 6. 更新节点数据
            updateNodeData(zk, "/myPersistentNode", "Updated Persistent Node Data");
            getNodeDataAndStat(zk, "/myPersistentNode"); // 再次获取查看更新结果
            // 7. 获取子节点列表
            getChildren(zk, "/");
            // 8. 监听节点数据变化 (Watch)
            watchNodeData(zk, "/myPersistentNode");
            updateNodeData(zk, "/myPersistentNode", "Data Change for Watch Test"); // 触发 Watch 事件
            // 9. 删除节点
            deleteNode(zk, "/myPersistentNode");
            deleteNode(zk, "/myEphemeralNode"); // 临时节点无需手动删除，会话断开后自动删除
            deleteNode(zk, "/myPersistentSequentialNode-0000000000"); // 需要删除实际创建的顺序节点名称
            deleteNode(zk, "/myEphemeralSequentialNode-0000000001"); // 需要删除实际创建的顺序节点名称
        } finally {
            if (zk != null) {
                zk.close(); // 关闭 Zookeeper 连接
            }
        }
    }
    // 连接 Zookeeper
    private static ZooKeeper connectZookeeper() throws Exception {
        ZooKeeper zk = new ZooKeeper(ZK_ADDRESS, SESSION_TIMEOUT, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                System.out.println("Watcher Event: " + event);
            }
        });
        return zk;
    }
    // 创建持久节点
    private static void createPersistentNode(ZooKeeper zk, String path, String data) throws Exception {
        zk.create(path, data.getBytes(StandardCharsets.UTF_8), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("Created Persistent Node: " + path);
    }
    // 创建临时节点
    private static void createEphemeralNode(ZooKeeper zk, String path, String data) throws Exception {
        zk.create(path, data.getBytes(StandardCharsets.UTF_8), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("Created Ephemeral Node: " + path);
    }
    // 创建持久顺序节点
    private static void createPersistentSequentialNode(ZooKeeper zk, String path, String data) throws Exception {
        String createdPath = zk.create(path, data.getBytes(StandardCharsets.UTF_8), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println("Created Persistent Sequential Node: " + createdPath);
    }
    // 创建临时顺序节点
    private static void createEphemeralSequentialNode(ZooKeeper zk, String path, String data) throws Exception {
        String createdPath = zk.create(path, data.getBytes(StandardCharsets.UTF_8), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Created Ephemeral Sequential Node: " + createdPath);
    }
    // 获取节点数据和 Stat
    private static void getNodeDataAndStat(ZooKeeper zk, String path) throws Exception {
        Stat stat = new Stat();
        byte[] dataBytes = zk.getData(path, false, stat);
        String data = new String(dataBytes, StandardCharsets.UTF_8);
        System.out.println("Node: " + path + ", Data: " + data + ", Stat: " + stat);
    }
    // 更新节点数据
    private static void updateNodeData(ZooKeeper zk, String path, String newData) throws Exception {
        Stat stat = zk.setData(path, newData.getBytes(StandardCharsets.UTF_8), -1); // version -1 表示不检查版本，直接更新
        System.out.println("Updated Node: " + path + ", New Data: " + newData + ", Stat: " + stat);
    }
    // 获取子节点列表
    private static void getChildren(ZooKeeper zk, String path) throws Exception {
        List<String> children = zk.getChildren(path, false);
        System.out.println("Children of Node: " + path + ": " + children);
    }
    // 删除节点
    private static void deleteNode(ZooKeeper zk, String path) throws Exception {
        zk.delete(path, -1); // version -1 表示不检查版本，直接删除
        System.out.println("Deleted Node: " + path);
    }
    // 监听节点数据变化
    private static void watchNodeData(ZooKeeper zk, String path) throws Exception {
        zk.getData(path, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeDataChanged) {
                    try {
                        getNodeDataAndStat(zk, path); // 重新获取数据和 Stat
                        watchNodeData(zk, path); // 再次注册 Watch，实现持续监听
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("Data Watch Event: " + event);
                }
            }
        }, null);
        System.out.println("Set Data Watch on Node: " + path);
    }
}
​

代码详解:

• connectZookeeper(): 建立与 Zookeeper 服务器的连接。ZooKeeper 构造函数的参数包括 Zookeeper 服务器地址、会话超时时间和一个默认的 Watcher，用于处理连接状态变化事件。

• createPersistentNode(), createEphemeralNode(), createPersistentSequentialNode(), createEphemeralSequentialNode(): 分别创建不同类型的 ZNode。zk.create() 方法的参数包括节点路径、数据、ACL 列表和创建模式 CreateMode。CreateMode 枚举定义了 ZNode 的类型，例如 PERSISTENT、EPHEMERAL、PERSISTENT_SEQUENTIAL、EPHEMERAL_SEQUENTIAL。

• getNodeDataAndStat(): 获取指定路径 ZNode 的数据和 Stat 信息。zk.getData() 方法返回字节数组形式的数据，需要转换为字符串进行展示。Stat 对象包含了 ZNode 的元数据信息。

• updateNodeData(): 更新指定路径 ZNode 的数据。zk.setData() 方法的第三个参数是版本号，-1 表示不检查版本，直接更新。实际应用中，为了保证数据一致性，通常需要指定期望的版本号。

• getChildren(): 获取指定路径 ZNode 的子节点列表。zk.getChildren() 方法返回子节点名称的列表。

• deleteNode(): 删除指定路径 ZNode。zk.delete() 方法的第二个参数是版本号，-1 表示不检查版本，直接删除。

• watchNodeData(): 监听指定路径 ZNode 的数据变化事件。zk.getData() 方法的第二个参数是一个 Watcher 对象，用于处理事件。当 ZNode 的数据发生变化时，Watcher 的 process() 方法会被调用，并传入 WatchedEvent 对象，包含事件类型、事件状态和节点路径等信息。为了实现持续监听，需要在 process() 方法中再次注册 Watch。

运行代码: 确保本地或远程 Zookeeper 服务已经启动，运行上述 Java 代码，观察控制台输出。可以看到各种类型 ZNode 的创建信息、数据和 Stat 信息，以及 Watch 事件的触发信息。

实验与思考:

1. 临时节点生命周期: 运行代码后，观察 /myEphemeralNode 和 /myEphemeralSequentialNode-xxxx 节点。断开 Java 客户端连接 (例如停止程序)，等待一段时间后，使用 Zookeeper 客户端工具 (例如 zkCli.sh) 检查这些节点是否还存在。你会发现临时节点已经被自动删除。

2. 顺序节点编号: 多次运行创建顺序节点的代码，观察创建的节点名称，你会发现 Zookeeper 会自动为顺序节点追加单调递增的数字后缀。

3. Watch 机制: 运行 Watch 示例代码，观察控制台输出。修改 /myPersistentNode 节点的数据 (例如使用 zkCli.sh 的 set 命令)，观察客户端是否接收到 NodeDataChanged 事件，并打印出新的数据和 Stat 信息。

通过代码实践，可以更直观地理解 Zookeeper 数据模型的各个方面，包括 ZNode 的类型、数据操作、元数据信息以及 Watch 机制。

1.2.7 小结

Zookeeper 的数据模型是构建分布式协调服务的基础。本章节深入探讨了 Zookeeper 数据模型的关键概念：

• ZNode: 数据模型的基本单元，类似于文件系统中的节点，包含名称、数据、元数据 Stat 和 ACL。

• 层次命名空间: 树形结构，易于组织和管理数据，通过路径访问 ZNode。

• ZNode 数据: 存储少量配置、状态或控制信息，数据更新具有原子性和版本控制。

• ZNode 元数据 (Stat): 描述 ZNode 的状态和属性，用于版本控制、时间戳、事务 ID 等。

• ZNode 类型: 持久节点、临时节点、顺序节点，根据生命周期和特性适用于不同的应用场景。

通过代码实践，我们加深了对 Zookeeper 数据模型的理解，并掌握了如何使用 Java Zookeeper 客户端进行基本的数据操作和 Watch 机制。理解 Zookeeper 数据模型是深入学习和应用 Zookeeper 的关键一步，为后续学习 Zookeeper 的其他特性和应用场景打下坚实的基础。