ZookeeperApi——Zookeeper的使用场景

最新推荐文章于 2024-07-25 15:39:35 发布
最新推荐文章于 2024-07-25 15:39:35 发布
阅读量137 收藏 1
点赞数 1
分类专栏： zookeeper 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_eryue/article/details/113504967
版权

目录

1.配置中心

2.生成分布式唯一ID

3.分布式锁

1.配置中心

工作中是否有这样的一个场景：数据库用户和密码信息放在一个配置文件中，应用读取该配置文件，配置文件信息放入缓存。若数据库的用户名和密码改变，还需要重新加载缓存，比较麻烦，通过zookeeper可以轻松完成，当数据库发生变化时自动完成缓存同步。

设计思路：

  1. 连接zookeeper服务器
  2. 读取zookeeper中的配置信息，注册watcher监听器，存入本地变量
  3. 当zookeeper中的配置信息发生变化时，通过watcher的回调方法捕获数据变化事件
  4. 重新获取配置信息

package com.cjian.zookeeper;

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

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: CJ
 * @time: 2021/1/29 15:27
 */
public class MyConfigCenter implements Watcher {
    // zk连接对象
    ZooKeeper zooKeeper;

    // 计数器对象
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    // zk的连接串
    private String ip = "127.0.0.1:2181";

    // 用于本地化配置存储信息
    private String url;

    private String username;

    private String password;

    // 构造方法
    public MyConfigCenter() {
        initValue();
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public void process(WatchedEvent event) {
        try {
            // 时间类型
            if (event.getType() == Watcher.Event.EventType.None) {
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                } else if (event.getState() == Watcher.Event.KeeperState.Disconnected) {
                    System.out.println("断开连接");
                } else if (event.getState() == Watcher.Event.KeeperState.Expired) {
                    System.out.println("会话超时");
                    zooKeeper = new ZooKeeper(ip, 5000, this); // 重连
                } else if (event.getState() == Watcher.Event.KeeperState.AuthFailed) {
                    System.out.println("验证失败");
                }
            } else if (event.getType() == Event.EventType.NodeDataChanged) { // 当配置信息发生变化，就重新去加载配置信息
                initValue();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 连接zookeeper服务器，读取配置信息
     */
    private void initValue() {
        //创建连对象
        try {
            // 创建链接
            if (zooKeeper == null) {
                zooKeeper = new ZooKeeper(ip, 5000, this);
            }
            // 阻塞线程，等待连接成功
            countDownLatch.await();
            // 读取配置信息
            this.url = new String(zooKeeper.getData("/config/url", true, null));
            this.username = new String(zooKeeper.getData("/config/username", true, null));
            this.password = new String(zooKeeper.getData("/config/password", true, null));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        try {
            MyConfigCenter myConfigCenter = new MyConfigCenter();
            for (int i = 0; i < 10; i++) {
                TimeUnit.SECONDS.sleep(5);
                System.out.println(myConfigCenter);
                System.out.println("==================================================");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "MyConfigCenter{" + "url='" + url + '\'' + ", username='" + username + '\'' + ", password='" + password
            + '\'' + '}';
    }
}

zookeeper客户端先创建好相关节点：

[zk: localhost:2181(CONNECTED) 104] create /config "config"
Created /config
[zk: localhost:2181(CONNECTED) 105] create /config/url "127.0.0.1:3306"
Created /config/url
[zk: localhost:2181(CONNECTED) 107] create /config/username "cjian"
Created /config/username
[zk: localhost:2181(CONNECTED) 108] create /config/password "111111"
Created /config/password

运行main方法后，执行： set /config/password "123456"

控制台输出：

连接创建成功
MyConfigCenter{url='127.0.0.1:3306', username='cjian', password='111111'}
==================================================
MyConfigCenter{url='127.0.0.1:3306', username='cjian', password='111111'}
==================================================
MyConfigCenter{url='127.0.0.1:3306', username='cjian', password='111111'}
==================================================
MyConfigCenter{url='127.0.0.1:3306', username='cjian', password='123456'}
==================================================
MyConfigCenter{url='127.0.0.1:3306', username='cjian', password='123456'}
==================================================

2.生成分布式唯一ID

在过去的单库单表型系统中，通常可以使用数据库字段自带的auto_increment属性来自动为每条记录生成一个唯一的ID。但是分库分表后，已经无法满足了，此时我们就可以用zookeeper在分布式环境下生成全局唯一ID.

设计思路：

  1. 连接Zookeeper；
  2. 指定路径生成临时有序节点；
  3. 取序列号即为分布式环境下的唯一ID.
package com.cjian.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;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * @description:
 * @author: CJ
 * @time: 2021/2/1 11:46
 */
public class GloballyUniqueId implements  Watcher{

    ZooKeeper zooKeeper;
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private String ip = "127.0.0.1:2181";
    // 用户生成序号的节点
    String defaultPath = "/Id";


    public GloballyUniqueId() {
        try {
            zooKeeper = new ZooKeeper(ip, 5000, this);
            // 阻塞线程
            countDownLatch.await();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void process(WatchedEvent event) {
        try {
            // 时间类型
            if (event.getType() == Watcher.Event.EventType.None) {
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    System.out.println("连接创建成功");
                    countDownLatch.countDown();
                } else if (event.getState() == Watcher.Event.KeeperState.Disconnected) {
                    System.out.println("断开连接");
                } else if (event.getState() == Watcher.Event.KeeperState.Expired) {
                    System.out.println("会话超时");
                    zooKeeper = new ZooKeeper(ip, 5000, this); // 重连
                } else if (event.getState() == Watcher.Event.KeeperState.AuthFailed) {
                    System.out.println("验证失败");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成ID的方法
     */
    public String getUnqiueId() {
        String path = "";
        try {
            //创建临时的有序节点
            path = zooKeeper.create(defaultPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return path.substring(3);
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        GloballyUniqueId globallyUniqueId = new GloballyUniqueId();
        for (int i = 0; i < 5; i++) {
            String unqiueId = globallyUniqueId.getUnqiueId();
            System.out.println(unqiueId);
        }
    }

}

测试：

连接创建成功
0000000047
0000000048
0000000049
0000000050
0000000051

 

3.分布式锁

分布式锁有多种实现方式，比如通过数据库、redis都可以实现。作为分布式协同工具Zookeeper当然也有着标准的实现方式，下面介绍在zookeeper中如何实现排他锁。

设计思路：

  1. 每个客户端往/Locks下创建临时有序节点/Locks/Lock_，创建成功后/Locks下面会有每个客户端对应的节点，如//Locks/Lock_000000001；
  2. 客户端取得/Locks下子节点，并进行排序，判断排在最前的是否为自己，如果自己的锁节点排在第一位，代表获得锁成功；
  3. 如果自己的锁节点不在第一位，则监听自己前一位的锁节点，例如，自己锁节点Lock_000000002，那么监听/Lock_000000001
  4. 当前一位锁节点/Lock_000000001 对应的客户端执行完毕，释放了锁，将会出触发监听客户端（Lock_000000002）的逻辑
  5. 监听客户端重新执行第二步的逻辑，判断自己是否获得了锁。
package com.cjian.zookeeper;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
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.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 * @author: CJ
 * @time: 2021/2/1 14:03
 */
public class MyLock {

    // zk连接对象
    public  static ZooKeeper zooKeeper;
    // 计数器对象
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    // zk的连接串
    private static final String IP = "127.0.0.1:2181";
    //  锁的节点名称
    public static final String LOCK_ROOT_PATH = "/Locks";
    public static final String LOCK_NODE_NAME = LOCK_ROOT_PATH + "/lock_";
    private String lockPath;
    public MyLock()  {
        try {
            zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if(watchedEvent.getType() == Event.EventType.None){
                        if (watchedEvent.getState() ==Event.KeeperState.SyncConnected ){
                            System.out.println("连接成功！");
                            countDownLatch.countDown();
                        }
                    }
                }
            });
            countDownLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    /**
     * 获取锁
     */
    public void acquireLock() {
        //创建节点
        createLock();
        //尝试获取锁
        attemptLock();
    }
    /**
     * 创建锁节点
     */
    private void createLock() {
        try {
            Stat exists = zooKeeper.exists(LOCK_ROOT_PATH, false);
            if(exists == null){
                zooKeeper.create(LOCK_ROOT_PATH, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
            //创建临时有序节点
            lockPath = zooKeeper.create(LOCK_NODE_NAME, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(lockPath+ " 创建成功");
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    Watcher watcher = new Watcher() {
        @Override
        public void process(WatchedEvent watchedEvent) {
            if(watchedEvent.getType() == Event.EventType.NodeDeleted){
                //有节点被删除，则唤醒所有等待的线程
                synchronized (this){
                    notifyAll();
                }
            }
        }
    };
    /**
     * 尝试获取锁
     */
    private void attemptLock() {
        try {
            //思路：
            //1.获取/Locks下的所有节点,只包含子节点的名称
            List<String> children = zooKeeper.getChildren(LOCK_ROOT_PATH, false);
            //2.对所有子节点排序
            Collections.sort(children);
            //3.判断当前节点在集合的位置
            int index = children.indexOf(lockPath.substring((LOCK_NODE_NAME.length() - LOCK_ROOT_PATH.length())+1));
            if(index == 0){
                System.out.println("获取锁成功！");
            }else{
                //上一个节点的位置
                String prevPath= children.get(index -1);
                Stat exists = zooKeeper.exists(LOCK_ROOT_PATH + "/" + prevPath, watcher);
                if(exists == null){//说明上一个节点被删除了->锁释放
                    attemptLock();
                }else{
                    //当前线程等待
                    synchronized (watcher){
                        watcher.wait();
                    }
                    attemptLock();
                }
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    /**
     * 释放锁
     */
    private void releaseLock() {
        try {
            zooKeeper.delete(lockPath, -1);
            zooKeeper.close();
            System.out.println(lockPath+" 锁已释放！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    public static void sall(){
        System.out.println("售票开始");
        // 线程休眠，模拟现实中耗时的操作
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("售票结束");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyLock myLock = new MyLock();
            // 获取锁
            myLock.acquireLock();
            sall();
            // 释放锁
            myLock.releaseLock();
        }

    }


}

开启两个main方法：

运行结果如下：

 

cj_eryue
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ZooKeeper 案例（配置中心/分布式锁/分布式唯一ID）
ccccrj博客
09-05 231
配置中心案例 场景： 数据库用户信息密码放在一个配置文件中，应该读取配置文件信息，放入缓存。信息改变时需要重新加载，通过ZooKeeper 自动完成缓存同步。 连接zookeeper服务器 读取zookeeper中的配置信息，注册watcher监听器，存入本地变量 当zookeeper中的配置信息发生变化时，通过watcher的回调方法捕获变化事件 重新获取配置信息 public class AutoSyncConfigInfo { private String username; p
Zookeeper典型使用场景
黑子
01-10 626
数据发布订阅： 概述： 数据发布／订阅（ Publish/Subscribe）系统，即所谓的配置中心，顾名思义就是发布者将数据发布到ZooKeeper的一个或一系列节点上，供订阅者进行数据订阅， 进而达到动态获取数据的目的，实现配置信息的集中式管理和数据的动态更新。 两种设计模式: 推(Push）模式: 服务端主动将数据更新发送给所有订阅的客户端 拉(Pull)模式: 由客户端
zookeeper配置中心
only one
06-02 1461
zookeeper配置中心 记录下学习zookeeper配置中心的内容，写的不好请指导 实际开发中我们会遇到修改一些配置文件的内容 比如数据库用户名和密码信息放在一个配置文件中，应用 读取该配置文件，配置文件信息放入缓存。 ​若数据库的用户名和密码改变时候，还需要重新加载缓存，比较麻烦，通过 ZooKeeper可以轻松完成，当数据库发生变化时自动完成缓存同步。 设计思路： 1. 连接zookeeper服务器 2. 读取zookeeper中的配置信息，注册watcher监听器，存入本地变量 3.
Zookeeper之事件监听机制
weixiaohuai的博客
01-20 1256
目录 一、watcher概念 二、watcher架构 三、watcher特性 四、watcher接口设计 五、watcher监控之检查节点是否存在 六、watcher监控之查看节点 七、watcher监控之查看子节点 八、总结 一、watcher概念 zookeeper提供了数据的发布/订阅功能，多个订阅者可同时监听某一特定主题对象，当该主题对象的自身状态发生变化时(例如节点内容改变、节点下的子节点列表改变等)，会实时、主动通知所有订阅者。 zookeeper采用了Watcher机制实
2、zookeeper的事件监听、分布式锁
yisuyanyu的博客
06-18 404
1、导入Maven依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-freemarker</artifactId> </dependency> <dependency> <groupId>org.sp...
ZooKeeper过期续订的实现
墨染百城
02-14 1742
问题概述使用客户端连接ZooKeeper过程中有时会因为网络延时的原因跟ZooKeeper集群断开连接。一旦断开的时间超过了配置文件中规定的时间，ZooKeeper集群就会设置sessionId过期，并清空该客户端产生的临时数据。而即使后来该客户端又重新连接到了ZooKeeper集群，ZooKeeper集群会发送一个Expired事件通知客户端会话已经过期。问题的解决要重新连接到ZooKeeper集
Zookeeper常见使用场景
hc1329964732的博客
03-05 161
大致来说，zookeeper 的常用的使用场景如下： 分布式协调 分布式锁 元数据/配置信息管理 HA 高可用性 分布式协调 这个其实是 zookeeper 很经典的一个用法，简单来说，就好比，你 A 系统发送个请求到 mq，然后 B 系统消息消费之后处理了。那 A 系统如何知道 B 系统的处理结果？用 zookeeper 就可以实现分布式系统之间的协调工作。A 系统发送请求之后可以在 zookeeper 上对某个节点的值注册个监听器，一旦 B 系统处理完了就修改 zookeeper 那个节点的值
Zookeeper 进阶之——典型应用场景（一）1
08-08
本文将探讨 Zookeeper 的几个典型应用场景，并通过代码示例进行解析。 **统一命名服务 (Name Service)** 在分布式环境中，Zookeeper 提供了一种层次化的命名空间，类似于文件系统的目录结构。开发者可以通过调用 ...
Zookeeper系列——2Zookeeper应用及常用命令
Eclipse_2019的博客
08-15 1534
了解Zookeeper原生核心API的使用掌握；Curator的使用。
Zookeeper系列——6Zookeeper的分布式锁及Leader选举原理分析
Eclipse_2019的博客
08-20 708
分布式锁的实现原理；Zookeeper实现分布式锁的核心流程解析；Zookeeper实现Leader选举的核心思想
Zookeeper总结——知识点、选举机制、客户端操作及写数据流程、API操作、zookeeper分布式锁之 Curator、ZAB协议、CAP理论之zookeeper的CP理论
weixin_44090845的博客
11-19 2022
Zookeeper一、什么是zookeeper1、zookeeper概述2、zookeeper特点3、zookeeper数据结构4、zookeeper应用场景二、Zookeeper本地安装1、本地模式安装2、配置参数解读三、Zookeeper集群操作1、集群操作1.1集群安装1.2 选举机制（面试重点）1.3 ZK集群启动停止脚本2、客户端命令行操作2.1 命令行基本语法2.2 znode节点数据信息2.3 节点类型 一、什么是zookeeper 1、zookeeper概述 Zookeeper是一个开源的
Zookeeper——基础篇
真一居士的博客
11-15 344
目录 Zookeeper 模型 数据模型 Znode 基本操作 API Watch 一致性 服务结构 ZAB ZXID 崩溃恢复 写入数据 参数详解 最低配置 高级配置 Zookeeper 模型 数据模型 它很像数据结构当中的树，也很像文件系统的目录。 树是由节点所组成，ZooKeeper 的数据存储也同样是基于节点，这种节点叫做Znode...
Zookeeper案例之分布式全局唯一ID生成
weixiaohuai的博客
01-21 2016
目录 一、概述 二、案例实现 一、概述 在单体架构中，我们通常使用数据库字段自带的自增auto_increment属性来自动为每一条记录生成唯一的ID，但是当我们采用分布式系统后，特别是分库分表后，就无法再依靠数据库的auto_increment属性来唯一标识一条记录，这就需要采用其他方法来生成全局唯一ID。 在zookeeper中，它提供了一种以创建临时有序节点来获取到全局唯一ID，它能保证在整个分布式系统中的全局唯一性。 下面我们通过一个简单的案例来说明如何利用zookeeper生成全局唯一
Zookeeper节点的基本操作——增删改查
cj_eryue的博客
01-28 2066
目录 1.新增节点 2.修改节点 3.删除节点 4.查看节点、状态 1.新增节点 create [-s] [-e] 节点名称 节点数据 -s：有序节点 -e：临时节点 这是一个持久节点，使用quit命令退出客户端后，再登进，依然可获取该节点数据 创建持久有序节点： 创建临时节点： 使用quit命令退出客户端后，再登进，不可获取该节点数据 创建临时有序节点： 2.修改节点 set 节点名称 节点数据 [dataVersi...
zookeeper动态扩缩容（无需重启）
cj_eryue的博客
02-20 1482
zookeeper动态扩/缩容的reconfig命令旨在不需要重启zookeeper中任何一个节点的情况下，对整个zookeeper集群进行动态扩/缩容。
zookeeper开启SASL权限认证
最新发布
cj_eryue的博客
07-25 1383
ZooKeeper 不使用任何形式的身份验证并允许匿名连接。但是，它支持 Java 身份验证与授权服务(JAAS)，可用于使用简单身份验证和安全层(SASL)设置身份验证
Zookeeper的zab协议及leader选举过程的简单理解
cj_eryue的博客
02-01 832
一、Zab协议 zab协议全称Zookeeper Atomic Broadcast（zookeeper原子广播）。zookeeper是通过zab协议来保证分布式事务的最终一致性 基于zab协议，zookeeper集群中华的角色主要由以下三类： 角色 描述 领导者（Leader） 领导者负责进行投票的发起和决议，更新系统状态 跟随者（Follower） Follower用于接收客户请求并向客户端返回结果，在选举过程中参与投票 观察者（Observer） Observe
Zookeeper的高级特性介绍——监听器以及ACL权限控制
cj_eryue的博客
01-28 501
目录 1.监听器 1.1监听当前节点 1.2监听子节点 2.ACL权限控制 2.1 world授权模式 2.2 IP授权模式 2.3auth授权模式 2.4 digest授权模式 2.5ACl超级管理员 前面我们讲解了zookeeper的节点的增删改查操作，接下来我们来看下zookeeper的一些高级特性： 1.监听器 十分重要，后面说操作zookeeper的API时再细说 1.1监听当前节点 get 节点路径 watch 注册一个监听，一次性的 st...
ZookeeperApi入门——增删改查
cj_eryue的博客
01-29 438
导入依赖： <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId> <version>3.4.12</version> </dependency> <dependency> <g
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值