ZooKeeper入门实战：从零开始掌握分布式协调服务

在分布式系统中，如何让多个服务节点协同工作？如何实现服务注册与发现？如何保证配置的一致性？答案都在ZooKeeper这个强大的分布式协调服务中。

一、什么是ZooKeeper？

ZooKeeper是一个开源的分布式协调服务，由Apache基金会维护。它最初是雅虎公司为了解决分布式系统中的协调问题而开发的，现在已经成为Hadoop、HBase、Kafka等众多分布式系统的基础设施。

1.1 ZooKeeper的核心特性

简单性：提供了一个类似文件系统的层级命名空间
高可用性：通过集群部署保证服务的高可用性
一致性：保证数据在所有服务器上的一致性
实时性：客户端可以实时获取数据的变化通知

1.2 为什么需要ZooKeeper？

在分布式系统中，我们经常面临以下挑战：

服务注册与发现：微服务架构中，服务如何相互发现？
配置管理：多个服务实例如何保持配置一致？
分布式锁：如何避免多个服务同时操作同一资源？
Leader选举：如何从多个服务节点中选出一个主节点？
分布式协调：如何协调多个服务节点的行为？

ZooKeeper正是为了解决这些问题而生的！

二、ZooKeeper的数据模型

ZooKeeper的数据模型类似于Unix文件系统，采用层级化的树状结构。树中的节点被称为"Znode"。

2.1 Znode的类型

根据节点的生命周期和特性，Znode可以分为四种类型：

1. 持久节点（PERSISTENT）

节点创建后会一直存在，直到显式删除
适用于存储配置信息、服务列表等数据
示例：/config/database

2. 临时节点（EPHEMERAL）

节点的生命周期与客户端会话绑定
客户端会话结束后，节点自动删除
适用于服务注册、心跳检测等场景
示例：/services/provider-001

3. 持久顺序节点（PERSISTENT_SEQUENTIAL）

基本特性与持久节点相同
创建时自动在节点名后追加10位数字序号
适用于分布式队列、全局ID生成等场景
示例：/tasks/seq-0000000001

4. 临时顺序节点（EPHEMERAL_SEQUENTIAL）

基本特性与临时节点相同
创建时自动追加序号
适用于分布式锁、Leader选举等场景
示例：/locks/resource-0000000001

2.2 Znode的结构

每个Znode包含以下信息：

java 复制代码

public class ZnodeData {
    String path;           // 节点路径
    byte[] data;           // 节点数据（最大1MB）
    int version;           // 数据版本号
    int cversion;          // 子节点版本号
    int aversion;          // ACL版本号
    long ephemeralOwner;   // 临时节点所属会话ID
    long dataLength;       // 数据长度
    int numChildren;       // 子节点数量
    long pzxid;            // 最后修改子节点的事务ID
}

三、ZooKeeper的基本操作

ZooKeeper提供了丰富的API来进行节点操作，主要包括以下几类：

3.1 创建连接

首先需要创建ZooKeeper客户端连接：

java 复制代码

public class ZooKeeperConnection {
    private static final int SESSION_TIMEOUT = 30000; // 30秒会话超时
    private static final String CONNECTION_STRING = "localhost:2181";

    private ZooKeeper zooKeeper;
    private CountDownLatch connectedLatch = new CountDownLatch(1);

    public ZooKeeper connectSync() throws IOException, InterruptedException {
        zooKeeper = new ZooKeeper(CONNECTION_STRING, SESSION_TIMEOUT, event -> {
            if (event.getState() == Event.KeeperState.SyncConnected) {
                connectedLatch.countDown();
            }
        });

        connectedLatch.await(10, TimeUnit.SECONDS);
        return zooKeeper;
    }
}

关键参数说明：

connectionString：服务器地址，格式为host:port，多个服务器用逗号分隔
sessionTimeout：会话超时时间，单位毫秒
watcher：监听器，用于接收ZooKeeper的事件通知

3.2 创建节点

java 复制代码

// 创建持久节点
String path = zooKeeper.create(
    "/config/database",                    // 节点路径
    "mysql://localhost:3306/db".getBytes(), // 数据
    ZooDefs.Ids.OPEN_ACL_UNSAFE,          // 权限（开放）
    CreateMode.PERSISTENT                 // 节点类型
);

// 创建临时节点
String tempPath = zooKeeper.create(
    "/services/provider-001",
    "192.168.1.100:8080".getBytes(),
    ZooDefs.Ids.OPEN_ACL_UNSAFE,
    CreateMode.EPHEMERAL
);

// 创建顺序节点
String seqPath = zooKeeper.create(
    "/tasks/task-",
    "task data".getBytes(),
    ZooDefs.Ids.OPEN_ACL_UNSAFE,
    CreateMode.PERSISTENT_SEQUENTIAL
);
// 返回路径如：/tasks/task-0000000001

生产环境最佳实践：

创建节点前先检查父路径是否存在
异常处理要完善，特别是NodeExistsException
顺序节点的序号是单调递增的，可用于生成全局唯一ID

3.3 读取节点数据

java 复制代码

// 读取数据
byte[] data = zooKeeper.getData("/config/database", false, null);
String config = new String(data);

// 读取数据并监听变化
Stat stat = new Stat();
byte[] data = zooKeeper.getData("/config/database", watcher, stat);
System.out.println("版本号：" + stat.getVersion());
System.out.println("数据大小：" + stat.getDataLength());

数据版本控制：

每次数据更新都会增加版本号
可以使用CAS（Compare-And-Swap）机制进行乐观锁更新
Stat对象包含节点的详细元信息

3.4 更新节点数据

java 复制代码

// 获取当前状态
Stat stat = zooKeeper.exists("/config/database", false);

// 使用版本号更新（乐观锁）
Stat newStat = zooKeeper.setData(
    "/config/database",
    "mysql://prod-db:3306/appdb".getBytes(),
    stat.getVersion()  // 指定版本号
);

注意事项：

版本号不匹配会抛出BadVersionException
如果版本号为-1，则不检查版本（强制更新）
数据大小不能超过1MB

3.5 删除节点

java 复制代码

// 删除节点（需要指定版本号）
Stat stat = zooKeeper.exists("/config/old", false);
if (stat != null) {
    zooKeeper.delete("/config/old", stat.getVersion());
}

// 递归删除节点及其子节点
public void deleteRecursive(String path) throws Exception {
    List<String> children = zooKeeper.getChildren(path, false);
    for (String child : children) {
        deleteRecursive(path + "/" + child);
    }
    zooKeeper.delete(path, -1);
}

3.6 获取子节点列表

java 复制代码

// 获取子节点列表
List<String> children = zooKeeper.getChildren("/services", false);

// 遍历子节点
for (String child : children) {
    String childPath = "/services/" + child;
    byte[] data = zooKeeper.getData(childPath, false, null);
    System.out.println(child + " -> " + new String(data));
}

四、Watcher监听机制

Watcher是ZooKeeper的核心特性之一，允许客户端监听节点变化并接收实时通知。

4.1 Watcher的工作原理

重要特性：

一次性触发：Watcher触发后自动失效，需要重新注册
顺序保证：客户端会按顺序收到Watcher事件
轻量级：Watcher只通知事件类型，不传递具体数据

4.2 可监听的事件类型

java 复制代码

public enum EventType {
    None(-1),              // 连接状态变化
    NodeCreated(1),        // 节点被创建
    NodeDeleted(2),        // 节点被删除
    NodeDataChanged(3),    // 节点数据被修改
    NodeChildrenChanged(4),// 子节点列表变化
    DataWatchRemoved(5),   // Watcher被移除
    ChildWatchRemoved(6)   // 子节点Watcher被移除
}

4.3 Watcher使用示例

java 复制代码

public class ConfigWatcher implements Watcher {
    private ZooKeeper zooKeeper;

    @Override
    public void process(WatchedEvent event) {
        switch (event.getType()) {
            case NodeDataChanged:
                System.out.println("配置数据已变更：" + event.getPath());
                // 读取新配置
                try {
                    byte[] data = zooKeeper.getData(event.getPath(), this, null);
                    System.out.println("新配置：" + new String(data));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                break;

            case NodeDeleted:
                System.out.println("配置节点已删除");
                break;

            default:
                break;
        }
    }
}

4.4 Watcher的最佳实践

持续监听：在Watcher回调中重新注册Watcher
异常处理：处理ConnectionLoss、SessionExpired等异常
性能优化：避免过度使用Watcher，合理设置监听粒度

五、实战应用

5.1 服务注册与发现

场景描述 ：微服务架构中，服务提供者启动时将自己的地址注册到ZooKeeper，服务消费者从ZooKeeper获取服务提供者列表。

实现方案：

java 复制代码

// 服务提供者注册
public class ServiceProvider {
    private ZooKeeper zooKeeper;
    private String servicePath = "/services/user-service";

    public void register(String address) throws Exception {
        // 创建临时节点，会话断开后自动删除
        String path = zooKeeper.create(
            servicePath + "/provider-",
            address.getBytes(),
            ZooDefs.Ids.OPEN_ACL_UNSAFE,
            CreateMode.EPHEMERAL_SEQUENTIAL
        );
        System.out.println("服务注册成功：" + path);
    }
}

// 服务消费者发现
public class ServiceConsumer {
    private ZooKeeper zooKeeper;

    public List<String> discover(String serviceName) throws Exception {
        String path = "/services/" + serviceName;
        List<String> providers = zooKeeper.getChildren(path, false);

        List<String> addresses = new ArrayList<>();
        for (String provider : providers) {
            byte[] data = zooKeeper.getData(path + "/" + provider, false, null);
            addresses.add(new String(data));
        }

        return addresses;
    }
}

生产环境增强：

添加负载均衡策略（随机、轮询、最少连接等）
实现健康检查机制
支持多版本服务共存

5.2 分布式配置中心

场景描述：多个微服务实例需要共享配置，配置变更后需要实时推送到所有实例。

实现方案：

java 复制代码

public class ConfigCenter {
    private ZooKeeper zooKeeper;
    private volatile ConfigData currentConfig;

    public void init(String configPath) throws Exception {
        // 监听配置变化
        watchConfig(configPath);

        // 加载初始配置
        loadConfig(configPath);
    }

    private void watchConfig(String path) throws Exception {
        zooKeeper.exists(path, event -> {
            if (event.getType() == Event.EventType.NodeDataChanged) {
                try {
                    loadConfig(path);
                    watchConfig(path);  // 重新注册Watcher
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    private void loadConfig(String path) throws Exception {
        byte[] data = zooKeeper.getData(path, false, null);
        ConfigData newConfig = parseConfig(data);
        this.currentConfig = newConfig;
        System.out.println("配置已更新：" + newConfig);
    }

    public ConfigData getConfig() {
        return currentConfig;
    }
}

配置格式示例：

json 复制代码

{
    "database": {
        "url": "jdbc:mysql://localhost:3306/appdb",
        "username": "admin",
        "password": "password"
    },
    "redis": {
        "host": "localhost",
        "port": 6379
    }
}

5.3 分布式锁

场景描述：多个服务实例同时操作同一资源时，需要使用分布式锁保证互斥访问。

实现方案 ：

使用临时顺序节点实现公平锁：

java 复制代码

public class DistributedLock {
    private ZooKeeper zooKeeper;
    private String lockPath;
    private String currentLock;

    public boolean lock(long timeout, TimeUnit unit) throws Exception {
        // 创建临时顺序节点
        currentLock = zooKeeper.create(
            lockPath + "/lock-",
            null,
            ZooDefs.Ids.OPEN_ACL_UNSAFE,
            CreateMode.EPHEMERAL_SEQUENTIAL
        );

        // 检查是否是最小的节点
        while (true) {
            List<String> locks = zooKeeper.getChildren(lockPath, false);
            Collections.sort(locks);

            String current = currentLock.substring(currentLock.lastIndexOf('/') + 1);
            int index = locks.indexOf(current);

            if (index == 0) {
                return true;  // 获得锁
            }

            // 监听前一个节点
            String previousLock = locks.get(index - 1);
            final CountDownLatch latch = new CountDownLatch(1);

            Stat stat = zooKeeper.exists(
                lockPath + "/" + previousLock,
                event -> {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        latch.countDown();
                    }
                }
            );

            if (stat == null) {
                continue;  // 前一个节点已不存在，重新检查
            }

            // 等待前一个节点释放
            latch.await(timeout, unit);
        }
    }

    public void unlock() throws Exception {
        zooKeeper.delete(currentLock, -1);
    }
}

使用示例：

java 复制代码

DistributedLock lock = new DistributedLock(zk, "/locks/order-resource");

try {
    if (lock.lock(10, TimeUnit.SECONDS)) {
        // 执行业务逻辑
        processOrder();
    }
} finally {
    lock.unlock();
}

锁的实现要点：

使用临时顺序节点避免羊群效应
只监听前一个节点，而非所有节点
客户端异常断开时，锁会自动释放
使用Curator框架可以简化实现

5.4 Leader选举

场景描述 ：在集群环境中，需要从多个节点中选出一个Leader节点负责执行特定任务。

实现方案：

java 复制代码

public class LeaderElection {
    private ZooKeeper zooKeeper;
    private String electionPath;
    private String currentNode;

    public void elect() throws Exception {
        // 创建临时顺序节点
        currentNode = zooKeeper.create(
            electionPath + "/node_",
            null,
            ZooDefs.Ids.OPEN_ACL_UNSAFE,
            CreateMode.EPHEMERAL_SEQUENTIAL
        );

        // 检查是否是Leader
        checkLeader();

        // 监听前一个节点
        watchPreviousNode();
    }

    private void checkLeader() throws Exception {
        List<String> nodes = zooKeeper.getChildren(electionPath, false);
        Collections.sort(nodes);

        String current = currentNode.substring(currentNode.lastIndexOf('/') + 1);
        int index = nodes.indexOf(current);

        if (index == 0) {
            onBecomeLeader();
        } else {
            onBecomeFollower();
        }
    }

    private void onBecomeLeader() {
        System.out.println("成为Leader节点");
        // 开始执行Leader任务
    }

    private void onBecomeFollower() {
        System.out.println("成为Follower节点");
        // 等待Leader变更
    }
}

六、最佳实践

6.1 部署架构

集群规模：

开发环境：3节点（允许1个节点故障）
生产环境：5-7节点（允许2-3个节点故障）
避免使用偶数个节点

服务器配置：

CPU：4核以上
内存：4GB以上
磁盘：使用SSD，数据目录独立
网络：低延迟、高带宽

6.2 配置优化

zoo.cfg关键配置：

properties 复制代码

# 基本配置
tickTime=2000                              # 心跳时间间隔（毫秒）
initLimit=10                               # 初始同步时限（tickTime倍数）
syncLimit=5                                # 数据同步时限（tickTime倍数）
dataDir=/var/lib/zookeeper                 # 数据目录
clientPort=2181                            # 客户端连接端口

# 集群配置
server.1=zk1:2888:3888                     # 节点1配置
server.2=zk2:2888:3888                     # 节点2配置
server.3=zk3:2888:3888                     # 节点3配置

# 性能优化
maxClientCnxns=60                          # 最大客户端连接数
autopurge.snapRetainCount=3                # 保留快照数量
autopurge.purgeInterval=1                  # 清理间隔（小时）
preAllocSize=64M                           # 预分配事务日志大小

# 集群配置（3节点集群示例）
server.1=192.168.1.101:2888:3888
server.2=192.168.1.102:2888:3888
server.3=192.168.1.103:2888:3888

6.3 客户端配置

java 复制代码

// 生产环境推荐的客户端配置
public ZooKeeper createProductionClient() throws IOException {
    // 连接字符串：所有集群节点
    String connectionString = "zk1:2181,zk2:2181,zk3:2181";

    // 会话超时：根据业务场景设置
    int sessionTimeout = 30000;  // 30秒

    // 连接超时
    int connectionTimeout = 10000; // 10秒

    ZooKeeper zk = new ZooKeeper(
        connectionString,
        sessionTimeout,
        event -> handleEvent(event)
    );

    return zk;
}

七、总结

ZooKeeper作为分布式协调服务，在微服务、大数据、分布式系统中扮演着重要角色。主要功能点：

核心概念：数据模型、节点类型、Watcher机制
基本操作：增删改查、权限控制
实战应用：服务发现、配置中心、分布式锁、Leader选举