Zookeeper案例

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

1. 统一配置中心

在分布式集群系统中，经常要对某个配置信息进行修改，若一台一台对服务器进行修改，非常浪费时间，假如服务的体量非常大，几十台上百台甚至上千台服务器进行修改的话，几乎很不现实。zookeeper通过对节点数据进行监听，一旦配置信息发生变化，立马通知所有的客户端对数据进行重新读取。
下面通过Java代码的方式对统一配置中心进行简单的实现。

1.1 客户端
package cn.tianqb.zookeeper;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

/**
 * @Description: 客户端
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/21 20:26
 * @Version v1.0
 */
public class ZKClient {

    public ZooKeeper zooKeeper;
    public CountDownLatch countDownLatch = new CountDownLatch(1);
    // zookeeper服务器地址
    private String IP;
    // 会话超时时间
    private Integer SESSION_TIME_OUT;
    // url信息
    private String URL_PATH;
    // 用户名信息
    private String USER_PATH;
    // 密码信息
    private String PASSWD_PATH;

    public ZKClient(String IP, Integer SESSION_TIME_OUT, String URL_PATH, String USER_PATH, String PASSWD_PATH) {
        this.IP = IP;
        this.SESSION_TIME_OUT = SESSION_TIME_OUT;
        this.URL_PATH = URL_PATH;
        this.USER_PATH = USER_PATH;
        this.PASSWD_PATH = PASSWD_PATH;
        init();
    }

    /**
     * 连接至服务器
     */
    private void init() {

        ZKWatcher watcher = new ZKWatcher(countDownLatch, this);
        try {
            zooKeeper = new ZooKeeper(IP, SESSION_TIME_OUT, watcher);
            countDownLatch.await();
            pull();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            zooKeeper.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接到通知重新拉取数据
     */
    public void pull() {
        
        ZKWatcher watcher = new ZKWatcher(countDownLatch, this);
        try {
            System.out.println("客户端" + zooKeeper.getSessionId() + "---url:" + new String(zooKeeper.getData(URL_PATH, watcher,
                    null)));
            System.out.println("客户端" + zooKeeper.getSessionId() + "---user:" + new String(zooKeeper.getData(USER_PATH, watcher,
                    null)));
            System.out.println("客户端" + zooKeeper.getSessionId() + "---passwd:" + new String(zooKeeper.getData(PASSWD_PATH, watcher,
                    null)));
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1.2 常量
package cn.tianqb.zookeeper;

/**
 * @Description: 常量
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/21 20:34
 * @Version v1.0
 */
public class ZKConstant {
    // zookeeper服务器地址
    public static final String IP = "192.168.100.1:2181";
    // 会话超时时间
    public static final Integer SESSION_TIME_OUT = 5000;
    // url信息
    public static final String URL_PATH = "/conf/url";
    // 用户名信息
    public static final String USER_PATH = "/conf/user";
    // 密码信息
    public static final String PASSWD_PATH = "/conf/passwd";
}
1.3 监听器
package cn.tianqb.zookeeper;

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

import java.util.concurrent.CountDownLatch;

/**
 * @Description: 监听器
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/21 20:28
 * @Version v1.0
 */
public class ZKWatcher implements Watcher {

    private CountDownLatch countDownLatch;
    private ZKClient zkClient;

    private ZKWatcher() {
    }

    public ZKWatcher(CountDownLatch countDownLatch, ZKClient zkClient) {
        this.countDownLatch = countDownLatch;
        this.zkClient = zkClient;
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getType() == Event.EventType.None) {
            if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                System.out.println("服务连接成功");
                countDownLatch.countDown();
            }
        }else if (watchedEvent.getType() == Event.EventType.NodeDataChanged) {
            // 数据发生变化，客户端拉取数据
            zkClient.pull();
        }
    }
}
1.4 测试
package cn.tianqb.zookeeper;

/**
 * @Description:
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/21 20:46
 * @Version v1.0
 */
public class ZKMain {
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                ZKClient zkClient = new ZKClient(ZKConstant.IP, ZKConstant.SESSION_TIME_OUT, ZKConstant.URL_PATH, ZKConstant.USER_PATH,
                        ZKConstant.PASSWD_PATH);
                try {
                    Thread.sleep(60000);
                    zkClient.close();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
    }
}

2. 分布式唯一ID

适用的场景数据库进行分库分表时，插入数据无法使用auto_increment，这时需要数据的唯一性，即使在不同的服务器上！
案例代码如下：

2.1 生成ID类
package cn.tianqb.zookeeper;

import org.apache.zookeeper.*;

import java.util.concurrent.CountDownLatch;

/**
 * @Description: 分布式唯一ID
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/22 13:13
 * @Version v1.0
 */
public class GeneralUniqueId implements Watcher {

    private CountDownLatch countDownLatch = new CountDownLatch(1);
    private ZooKeeper zooKeeper;
    private String BASE_URL = "/uniqueId_";

    public GeneralUniqueId() {
        init();
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getType() == Event.EventType.None) {
            if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                System.out.println("连接成功！");
                countDownLatch.countDown();
            }
        }
    }

    private void init() {
        try {
            zooKeeper = new ZooKeeper(ZKConstant.IP, ZKConstant.SESSION_TIME_OUT, this);
            countDownLatch.await();
//            general();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String general() {
        String path;
        try {
            path = zooKeeper.create(BASE_URL, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.EPHEMERAL_SEQUENTIAL);
            return path.substring(10);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void close(){
        if (zooKeeper != null) {
            try {
                zooKeeper.close();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        GeneralUniqueId generalUniqueId = new GeneralUniqueId();
        for (int i = 0; i < 10; i++) {
            String id = generalUniqueId.general();
            System.out.println(id);
        }
        generalUniqueId.close();
    }
}
2.2 测试
package cn.tianqb.zookeeper;

/**
 * @Description:
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/22 15:58
 * @Version v1.0
 */
public class GeneralUniqueIdMain {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                GeneralUniqueId generalUniqueId = new GeneralUniqueId();
                String id = generalUniqueId.general();
                System.out.println(id);
                generalUniqueId.close();
            }).start();
        }
    }
}

3. 分布式锁

多个服务调用某个服务时，需要对访问进行同步处理，保证同一时刻只允许一个服务/事务存在。
案例代码如下：

3.1 分布式锁类
package cn.tianqb.zookeeper.lock;

import cn.tianqb.zookeeper.ZKConstant;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.Test;

import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * @Description: 分布式锁
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/22 16:08
 * @Version v1.0
 */
public class ZKLock {

    private CountDownLatch countDownLatch = new CountDownLatch(1);
    private ZooKeeper zooKeeper;
    private String BASE_URL = "/lock";
    private String NODE_URL = "lock_";
    private String lockId;

    public void init() {
        try {
            zooKeeper = new ZooKeeper(ZKConstant.IP, ZKConstant.SESSION_TIME_OUT, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getType() == Event.EventType.None) {
                        if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                            System.out.println("客户端" + zooKeeper.getSessionId() + "成功连接服务器！");
                            countDownLatch.countDown();
                        }
                    }
                }
            });
            countDownLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public ZKLock() {
        init();
    }

    /**
     * 创建节点信息
     */
    public void create() {
        try {
            // 判断根节点是否存在
            Stat stat = zooKeeper.exists(BASE_URL, false);
            if (stat == null) {
                zooKeeper.create(BASE_URL, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
            }
            // 创建锁节点
            lockId = zooKeeper.create(BASE_URL + "/" + NODE_URL, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.EPHEMERAL_SEQUENTIAL);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void acquireLock() {
        create();
        lock();
    }

    Watcher watcher = new Watcher() {
        @Override
        public void process(WatchedEvent watchedEvent) {
            if (watchedEvent.getType() == Event.EventType.NodeDeleted) {
                synchronized (this) {
                    // 一旦监听到节点删除
                    // 通知所有客户端
                    notifyAll();
                }
            }
        }
    };

    /**
     * 获取锁
     */
    public void lock() {
        try {
            // 获取子节点
            List<String> children = zooKeeper.getChildren(BASE_URL, false);
            Collections.sort(children);
            int index = children.indexOf(lockId.substring(BASE_URL.length() + 1));
            // 判断当前节点是否在第一位
            if (index == 0) {
                System.out.println("-------------------------------");
                System.out.println("客户端" + zooKeeper.getSessionId() + "成功获取锁！");
                return;
            } else {
                // 获取上一个节点的路径
                String s = children.get(index - 1);
                Stat stat = zooKeeper.exists(BASE_URL + "/" + s, watcher);
                // 存在节点使用完已经删除的情况
                if (stat == null) {
                    // 再次获取锁
                    lock();
                } else {
                    // 阻塞当前线程
                    synchronized (watcher) {
                        watcher.wait();
                    }
                    lock();
                }
            }

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

    /**
     * 释放锁
     */
    public void unlock() {
        try {
            zooKeeper.delete(lockId, -1);
            System.out.println("客户端" + zooKeeper.getSessionId() + "锁已经释放！");
            System.out.println("-------------------------------");
            if (zooKeeper != null) {
                zooKeeper.close();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

}
3.2 测试
package cn.tianqb.zookeeper.lock;

/**
 * @Description:
 * @Author tianqb
 * @Mail tianqingbo@tianqb.cn
 * @Date 2020/5/22 19:01
 * @Version v1.0
 */
public class ZKLockMain {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++){
            new Thread(() -> {
                ZKLock zkLock = new ZKLock();
                zkLock.acquireLock();
                try {
                    System.out.println("插入数据！！！");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                zkLock.unlock();
            }).start();
        }
    }
}
田田田田__
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo+zookeeper案例
12-13
dubbo案例
我工作的公司是怎样使用zookeeper的？
qq_18244417的博客
09-14 432
我通过实际工作中的一个例子，讲解 zookeeper 是如何帮我解决分布式问题，以此引导大家发现自己系统中可以应用 zookeeper 的场景。真正把 zookeeper 使用起来！项目...
大数据技术之Zookeeper案例总结
weixin_44606952的博客
11-07 427
1. 服务器动态上下线监听案例 2. ZooKeeper 分布式锁案例 3.Curator 框架实现分布式锁案例
【ZooKeeper应用举例】
最新发布
qq_40641770的博客
01-23 707
在分布式锁服务中，有一种最典型应用场景，就是通过对集群进行Master选举，来解决分布式系统中的单点故障。什么是分布式系统中的单点故障：通常分布式系统采用主从模式，就是一个主控机连接多个处理节点。主节点负责分发任务，从节点负责处理任务，当我们的主节点发生故障时，那么整个系统就都瘫痪了，那么我们把这种故障叫作单点故障。
zookeeper案例
&volume的博客
08-13 1622
先在集群上创建/servers 节点（用于存储连接的服务器的主机和该服务器的节点数）相当于zookeeper集群 创建类对象该类为我们创建的服务端类： 获取zookeeper连接：自己创建连接方法： 让后server对象在main函数中调用注册是需要注册到zookeeper集群的/servers路径下，需要指定参数进行创建 （3）业务逻辑（睡眠）： 服务端代码如下： 客户端： （1）获取zookeeper的连接： 先创建客户端对
zookeeper第三章：项目案例
weixin_50835854的博客
08-22 612
zookeeper的基础内容差不多学完了，所以我们来完成几个案例
Zookeeper详细解析+简单实例
weixin_39033058的博客
06-29 727
zk 主从分布式框架，对其它的分布式框架提供协调服务 有一个文件系统存储数据 Zk维护和监控存储数据的状态变化，管理集群 主要用来解决分布式集群中应用系统的一致性问题。 为什么要使用zk： 分布式框架多个独立的程序，协同工作比较复杂 Zk简单易用 比如集群的主备切换，节点上下线的感知（集群中有若干个服务器，当有新的服务器添加上，zk可以及时感知到），统一命名服务，状态同步服务，集群管理，分布式应用配置管理，分布式锁等，协调问题 zkcli命令行： ...
springboot整合dubbo+zookeeper案例
12-08
包括案例代码dubbo-demo-parent，apache-tomcat-8.5.60，apache-zookeeper-3.5.8-bin，dubbo-admin-2.5.10.war
dubbo+zookeeper案例,dubbo和Zookeeper详解,Java
09-10
使用dubbo+zookeeper搭建的分布式代码案例，包含全套的代码和分布式集成的说明文档。
dubbo+zookeeper整合案例
09-29
详细的dubbo+zookeeper整合案例，包含安装配合示例，供参考使用
zookeeper 例子
09-11
zookeeper 测试例子，里面有一个简单的 zookeeper 日常操作例子，还有以zookeeper而实现的 leader 选举的例子...、分布式锁...
zookeeper权威的应用案例
lkx94的专栏
07-24 568
转载自：http://shiyanjun.cn/archives/492.html 我们通过学习借鉴，哪些项目或应用都使用了ZooKeeper，可以了解我们的应用使用ZooKeeper是否能真正地带来价值，当然，有些项目可能也未必非常适合使用ZooKeeper，我们要批判地学习、借鉴和吸收。 下面是一些使用了ZooKeeper实现的案例： HDFS HA(QJM) Ha
03-Zookeeper典型使用场景实战
zengqingfa123的博客
01-17 8353
幽灵结点是指当客户端创建节点成功后，没有收到服务端的回应，也就是客户端不知道自己已经成功创建了节点。这样就又会尝试创建新的结点，那之前创建的结点就是幽灵结点了。解决：Zookeeper规避的方式就是创建的时候给前面加一个uuid，客户端去创建节点的时候会先按这个uuid找。有的话就不会再创建。
zookeeper 的详细使用文档和使用案例
qq_37480069的博客
05-19 351
Zookeeper是一个开源的分布式协调服务，它提供了一个分布式的协调机制，以便在分布式应用程序中进行协同工作。Zookeeper主要用于管理分布式系统中的配置信息、命名空间、状态信息等，以及提供分布式锁、领导选举等功能。
ZooKeeper【实际案例】
m0_64261982的博客
06-14 1265
ZooKeeper实际案例、Curator实现分布式锁、可重入锁
zookeeper使用案例
技无涯的博客
04-30 256
zookeeper的实际应用场景案例 1、数据发布订阅/配置中心 1、原理：发布者将数据发布到zookeeper的节点上，订阅者获取节点上的数据，从而实现发布订阅的目的。实现配置信息的集中式管理和数据的动态更新 2、实现配置中心有两种模式：push （推送：服务器端推送）、pull（拉取：客户端主动拉取），客户端向服务端注册要关注的节点，一旦节点发生变化，服务端就会给客户端发送通知。 3、zo...
ZooKeeper简介及代码示例
Hello World
06-13 1391
Zookeeper 会每次选举最小编号的作为master，如果master挂掉了，自然对应的Znode节点就会被删除，然后让最小编号作为master，这样就能实现动态选举的功能了。节点被访问的时候会创建 带顺序号的临时节点，接着拿到该节点下的所有子节点，判断自己创建的是不是最小那个节点。只要A系统挂掉，那么对应的临时节点，也就会删除，其他的系统通过监听父节点下的子节点，就能感知A系统挂掉了。原理也很简单，如果想实现动态选举master的功能，Znode节点的类型是带顺序好的临时节点就好了。
zookeeper大全pdf
10-22
7. zookeeper的最佳实践和案例分析：分享一些使用zookeeper的最佳实践和典型案例，方便用户参考和借鉴。 综上所述，zookeeper大全pdf是一份全面介绍zookeeper相关知识和使用方法的文档，对于想要学习和使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值