Zookeeper（59）Zookeeper在分布式系统中的作用是什么？

最新推荐文章于 2025-06-04 20:31:14 发布

辞暮尔尔-烟火年年

最新推荐文章于 2025-06-04 20:31:14 发布

阅读量566

点赞数 7

CC 4.0 BY-SA版权

分类专栏：微服务文章标签： zookeeper 分布式云原生

本文链接：https://blog.youkuaiyun.com/qq_43012298/article/details/139402284

微服务专栏收录该内容

270 篇文章

订阅专栏

Zookeeper 在分布式系统中扮演着至关重要的角色，主要用于协调和管理分布式应用程序。它提供了一种集中化的服务，用于维护配置信息、命名、提供分布式同步、组服务等。以下是 Zookeeper 在分布式系统中的主要作用，以及详细的解释和代码示例。

1. 配置管理

在分布式系统中，配置管理是一项复杂的任务。Zookeeper 提供了一个集中存储配置的地方，所有节点都可以从中读取最新的配置，确保一致性。

示例：集中配置管理

假设我们有一个分布式系统，需要管理多个服务的配置。可以将配置存储在 Zookeeper 中，并在应用启动时从 Zookeeper 中读取配置。

配置存储在 Zookeeper 中的 /config 节点下

import org.apache.zookeeper.ZooKeeper;

public class ConfigManager {
    private ZooKeeper zooKeeper;

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

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

    public void setConfig(String configPath, String configData) throws Exception {
        zooKeeper.setData(configPath, configData.getBytes(), -1);
    }

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

            // 设置配置
            configManager.setConfig("/config/serviceA", "configDataForServiceA");

            // 获取配置
            String config = configManager.getConfig("/config/serviceA");
            System.out.println("Config for Service A: " + config);

            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 命名服务

Zookeeper 可以用来实现命名服务，提供一种方式使得分布式系统中的各个组件可以通过唯一的名称找到彼此。

示例：命名服务

假设我们有多个服务实例，需要一个集中化的命名服务来管理这些实例。

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

public class NamingService {
    private ZooKeeper zooKeeper;

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

    public void registerService(String serviceName, String serviceAddress) throws Exception {
        String servicePath = "/services/" + serviceName;
        zooKeeper.create(servicePath, serviceAddress.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    }

    public String lookupService(String serviceName) throws Exception {
        String servicePath = "/services/" + serviceName;
        byte[] data = zooKeeper.getData(servicePath, false, null);
        return new String(data);
    }

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

            // 注册服务
            namingService.registerService("serviceA", "192.168.1.100:8080");

            // 查找服务
            String serviceAddress = namingService.lookupService("serviceA");
            System.out.println("Service A Address: " + serviceAddress);

            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 分布式锁

Zookeeper 可以用来实现分布式锁，确保在分布式系统中只有一个节点可以执行特定的任务。

示例：分布式锁

见之前的回答中的 DistributedLock 类。

4. 集群管理

Zookeeper 可以用来管理集群中的节点，监控节点的状态和变化。

示例：集群管理

假设我们有一个分布式系统，需要监控各个节点的状态。

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;

public class ClusterManager {
    private ZooKeeper zooKeeper;

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

    public void registerNode(String nodeName, String nodeAddress) throws Exception {
        String nodePath = "/nodes/" + nodeName;
        zooKeeper.create(nodePath, nodeAddress.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    }

    public void watchNodes() throws Exception {
        zooKeeper.getChildren("/nodes", new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeChildrenChanged) {
                    try {
                        System.out.println("Nodes changed: " + zooKeeper.getChildren("/nodes", this));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

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

            // 注册节点
            clusterManager.registerNode("node1", "192.168.1.101:8080");

            // 监视节点
            clusterManager.watchNodes();

            // 模拟业务逻辑
            Thread.sleep(10000);

            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5. 分布式队列

Zookeeper 可以用来实现分布式队列，确保任务在多个节点之间得到公平分配和处理。

示例：分布式队列

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

import java.util.Collections;
import java.util.List;

public class DistributedQueue {
    private ZooKeeper zooKeeper;
    private String queuePath;

    public DistributedQueue(ZooKeeper zooKeeper, String queuePath) throws Exception {
        this.zooKeeper = zooKeeper;
        this.queuePath = queuePath;
        if (zooKeeper.exists(queuePath, false) == null) {
            zooKeeper.create(queuePath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    public void enqueue(String data) throws Exception {
        zooKeeper.create(queuePath + "/element_", data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
    }

    public String dequeue() throws Exception {
        while (true) {
            List<String> children = zooKeeper.getChildren(queuePath, false);
            if (children.isEmpty()) {
                return null;
            }
            Collections.sort(children);
            String firstChild = children.get(0);
            String firstChildPath = queuePath + "/" + firstChild;
            byte[] data = zooKeeper.getData(firstChildPath, false, null);
            zooKeeper.delete(firstChildPath, -1);
            return new String(data);
        }
    }

    public static void main(String[] args) {
        ZookeeperClient client = new ZookeeperClient();
        try {
            client.connect();
            ZooKeeper zooKeeper = client.getZooKeeper();
            DistributedQueue queue = new DistributedQueue(zooKeeper, "/queue");

            // 入队操作
            queue.enqueue("task1");
            queue.enqueue("task2");

            // 出队操作
            String task = queue.dequeue();
            System.out.println("Dequeued task: " + task);

            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}