学习Zookeeper

半亩花草  金牌会员 | 2024-11-30 00:57:16 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 799|帖子 799|积分 2397

以下内容是在阅读大量博客并联合个人明白后整理总结的，作为个人学习笔记分享给大家。文末将附上相干的参考资料链接。如果此中有涉及到侵权的内容，请及时告知，我会立即删除相干部分。在此，特别感谢各位前辈的无私分享和指导，也希望本文可以或许对读者有所帮助。
  

1. 初识ZooKeeper

Zookeeper是Apache Hadoop项目下的一个子项目，是一个树形目次服务。
   Zookeeper翻译过来就是动物园管理员，他是用来管Hadoop(大象）、Hive(蜜蜂)、Pig(小猪)的管理员。简称zk
  Zookeeper是一个分布式的、开源的分布式应用步伐的协调服务。
重要为了办理分布式架构下数据一致性题目， 它是集群的管理者， 监视着集群中各个节点的状态，根据节点提交的反馈举行下一步合理操纵。 最终， 将简单易用的接口和性能高效、 功能稳定的体系提供给用户。
Zookeeper提供的重要功能包括：
分布式设置中央、分布式注册中央、分布式锁、分布式队列、集群选举、分布式屏障、发布/订阅等场景。

1.1 安装ZooKeeper

这个环境安装的我费劲死了。。
安装这一类的 一定注意jdk的 版本，不然真的会踩坑很多，今后我知道了 ，如果想入门一个技能栈，先把jdk1.8安装好，并且环境变量设置好，然后在忘后学习新的东西！！！！


  • JDK1.8安装教程：https://blog.csdn.net/qq_40771292/article/details/107615925
  • ZooKeeper安装教程：https://gongna-au.github.io/2022-10-14-test-markdown/
不消担心教程题目，一步一步来就好，碰到题目办理题目


1.2 ZooKeeper命令操纵

1.2.1 Zookeeper数据模子

ZooKeeper是一个树形目次服务，其数据模子和Unix的文件体系目次树很类似，拥有一个层次化布局。

ZooKeeper 数据模子（Data model）采用层次化的多叉树形布局，每个节点上都可以存储数据，这些数据可以是数字、字符串或者是二级制序列。并且，每个节点还可以拥有 N 个子节点，最上层是根节点以/来代表。
每个数据节点在 ZooKeeper 中被称为 znode，它是 ZooKeeper 中数据的最小单元。并且，每个 znode 都一个唯一的路径标识。由于ZooKeeper 重要是用来协调服务的，而不是用来存储业务数据的，这种特性使得 Zookeeper 不能用于存放大量的数据，每个节点的存放数据上限为1M。
和文件体系一样，我们可以或许自由的增加、删除znode，在一个znode下增加、删除子znode，唯一的不同在于znode是可以存储数据的。默认有四种类型的znode：


  • PERSISTENT恒久化节点
  • EPHEMERAL临时节点：-e
  • PERSISTENT_SEQUENTIAL恒久化顺序节点：-S
  • EPHEMERAL_SEQUENTIAL临时顺序节点：-es

1.2.2 Zookeeper 服务端常用命令

当然要在zookeeper的bin：我的路径上为 ：/usr/local/zookeeper/apache-zookeeper/bin

  • 启动ZooKeeper服务：./zkServer.sh start
  • 检察ZooKeeper服务状态：./zkServer.sh status
  • 制止ZooKeeper服务：./zkServer.sh stop
  • 重启ZooKeeper服务：./zkServer.sh restart

1.2.3 Zookeeper客户端常用命令


起首毗连服务端：./zkCli.sh -server ip:port
输入quit 退出
检察子节点：ls

创建节点：create /节点名称 节点内容

   create的时间不能创建相同名称节点
  获取数据：get /节点名称

   如果在 create的时间不设置数据，则get的时间为null
通过set /节点path value 设置节点值
  删除节点： delete /节点名称

检察全部命令：help

节点 可以 创建 四大类：create -e /app1 value


  • PERSISTENT恒久化节点
  • EPHEMERAL临时节点：-e
  • PERSISTENT_SEQUENTIAL恒久化顺序节点：-S
  • EPHEMERAL_SEQUENTIAL临时顺序节点：-es
znode 状态信息解释cZxidcreate ZXID，即该数据节点被创建时的变乱 idctimecreate time，znode 被创建的毫秒数(从1970 年开始)mZxidmodified ZXID，znode 最后更新的变乱 idmtimemodified time，znode 最后修改的毫秒数(从1970 年开始)pZxidznode 最后更新子节点列表的变乱 id，只有子节点列表变动才会更新 pZxid，子节点内容变动不会更新cversionznode 子节点变化号，znode 子节点修改次数，子节点每次变化时值增加 1dataVersionznode 数据变化号，节点创建时为 0，每更新一次节点内容(不管内容有无变化)该版本号的值增加 1aclVersionznode 访问控制列表(ACL )版本号，表现该节点 ACL 信息变动次数ephemeralOwner如果是临时节点，这个是 znode 拥有者的 sessionid。如果不是临时节，则 ephemeralOwner=0dataLengthznode 的数据长度numChildrenznode 子节点数量 2. ZooKeeperJavaAPl操纵

2.1 Curator介绍

Curator是Apache ZooKeeper 的Java客户端库。Curator 提供了一组易于使用的API和工具，简化了与ZooKeeper 的交互，同时提供了更高级别的抽象和功能。
   常见的ZooKeeperJava API：
  

  • 原生Java API
  • ZkClient
  • Curator
  Curator项目的目的是简化ZooKeeper客户端的使用。Curator最初是Netfix研发的，厥后捐献了Apache基金会，现在是Apache的顶级项目。 官网：http://curator.apache.org/
2.2 CuratorAPI常用操纵

2.2.0 引入Curator支持

  1. <!-- zookeeper支持 -->
  2. <dependency>
  3.     <groupId>org.apache.zookeeper</groupId>
  4.     <artifactId>zookeeper</artifactId>
  5.     <version>3.6.4</version>
  6. </dependency>
  7. <!-- curator-recipes -->
  8. <dependency>
  9.     <groupId>org.apache.curator</groupId>
  10.     <artifactId>curator-recipes</artifactId>
  11.     <version>5.5.0</version>
  12. </dependency>
  13. <!-- curator-framework -->
  14. <dependency>
  15.     <groupId>org.apache.curator</groupId>
  16.     <artifactId>curator-framework</artifactId>
  17.     <version>5.5.0</version>
  18. </dependency>
复制代码
2.2.1 创建毗连

  1. //超时重试（连接间隔时间和超时连接次数）
  2. RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
  3. //连接zookeeper对象
  4. client = CuratorFrameworkFactory.newClient(
  5.         "ip:port",
  6.         1000,
  7.         60*1000,
  8.         retryPolicy);
  9. //开始连接
  10. client.start();
复制代码
2.2.2 添加节点

  1. //1、创建节点并赋值
  2. String path = client.create().forPath("/zuxia","helloworld".getBytes());
  3. System.out.println("创建节点："+path);
  4. ​
  5. //2、创建节点带子节点（如果不给子节点赋值，子节点的值默认为当前系统的IP地址）
  6. String path = client.create().creatingParentsIfNeeded().forPath("/zuxia/abc");
  7. System.out.println("创建节点："+path);
  8. ​
  9. //3、创建临时节点（当断开连接时临时节点会自动删除,withMode中的属性可选择）
  10. String path =client.create().withMode(CreateMode.EPHEMERAL).forPath("/a","helloworld".getBytes());
  11. System.out.println("创建节点："+path);
复制代码
2.2.3 删除节点

  1. //1、删除节点
  2. System.out.println("删除节点："+client.delete().forPath("/wjh"));
  3. ​
  4. //2、删除带有子节点的目录节点
  5. System.out.println("删除子节点："+client.delete().deletingChildrenIfNeeded().forPath("/zuxia"));
复制代码
2.2.4 修改节点

  1. //给节点赋值（返回值为Stat,可写可不写）
  2. client.setData().forPath("/ab", "hello".getBytes());
复制代码
2.2.5 查询节点

  1. //1、查询节点的数据
  2. byte[] bytes = client.getData().forPath("/zuxia");
  3. System.out.println(new String(bytes));
  4. ​
  5. //2、查询节点的数据（详情信息）
  6. Stat stats=new Stat();
  7. System.out.println(stats);//为了区分两个结果的不同
  8. byte[] be = client.getData().storingStatIn(stats).forPath("/zuxia");
  9. System.out.println(stats);
复制代码
2.2.6 Watch变乱监听



  • ZooKeeper 允许用户在指定节点上注册一些Watcher，并且在一些特定变乱触发的时间，ZooKeeper 服务端会将变乱关照到感爱好的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。
  • ZooKeeper 中引入了Watcher机制来实现了发布/订阅功能，可以或许让多个订阅者同时监听某一个对象，当一个对象自身状态变化时，会关照所有订阅者。
ZooKeeper提供了三种Watcher：


  • NodeCache : 只是监听某一个特定的节点
  • PathChildrenCache : 监控一个ZNode的子节点.
  • TreeCache : 可以监控整个树上的所有节点，类似于PathChildrenCache和NodeCache的组合
2.2.6.1 NodeCache 监听变乱

  1. @Test
  2. void testNodeCache() throws Exception {
  3. // 1. 创建NodeCache
  4. NodeCache nodeCache = new NodeCache(client, "/ab");
  5. // 2. 注册监听
  6. nodeCache.getListenable().addListener(new NodeCacheListener() {
  7.     @Override
  8.     public void nodeChanged() throws Exception {
  9.         System.out.println("/ab节点发生变更");
  10.         byte[] dataBytes = nodeCache.getCurrentData().getData();
  11.         System.out.println("节点修改后的数据：" + new String(dataBytes));
  12.     }
  13. });
  14. // 3. 开启监听，如果设置为true，则开启监听时，加载缓冲数据
  15. nodeCache.start(true);
  16. while(true){}
  17. }
复制代码
2.2.6.2 PathChildrenCache 监听变乱

  1. @Test
  2. void testPathChildrenCache() throws Exception {
  3. //创建监听对象(监听指定节点下的)
  4. PathChildrenCache pathChildrenCache= new PathChildrenCache(client, "/zuxia", true);
  5. //注册监听事件
  6. pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
  7.     @Override
  8.     public void childEvent(CuratorFramework cf, PathChildrenCacheEvent event) throws Exception {
  9.         System.out.println("节点发生变化了");
  10.         PathChildrenCacheEvent.Type type = event.getType();
  11.         //当前判断的是当节点发生更新时进入改方法，可以选择添加或者删除的方法
  12.         if (type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
  13.             byte[] bytes = event.getData().getData();
  14.             System.out.println("节点修改后的数据"+new String(bytes));
  15.         }
  16.     }
  17. });
  18. //开启监听
  19. pathChildrenCache.start();
  20. while (true){}
  21. }
复制代码
2.2.6.3 TreeCache 监听变乱

  1. @Test
  2. void testTreeCache() throws Exception {
  3.     //创建监听对象
  4.     TreeCache treeCache = new TreeCache(client, "/zuxia");
  5.     //注册监听
  6.     treeCache.getListenable().addListener(new TreeCacheListener() {
  7.         @Override
  8.         public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
  9.             System.out.println("节点发生变化了");
  10.             TreeCacheEvent.Type type = treeCacheEvent.getType();
  11.             if (type.equals(TreeCacheEvent.Type.NODE_ADDED)){
  12.                 System.out.println("节点添加了");
  13.             }
  14.         }
  15.     });
  16.     //开启监听
  17.     treeCache.start();
  18.     while (true){}
  19. }
复制代码

2.3 分布式锁

一种更加高级的锁机制，来处理种跨呆板的进程之间的数据同步题目——这就是分布式锁
核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点。

  • 客户端获取锁时，在lock节点下创建临时顺序节点。
  • 然后获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现本身创建的子节点序号最小，那么就认为该客户端获取到了锁。使用完锁后，将该节点删除。
  • 如果发现本身创建的节点并非lock所有子节点中最小的，说明本身还没有获取到锁，此时客户端需要找到比本身小的那个节点，同时对其注册变乱监听器，监听删除变乱。
  • 如果发现比本身小的那个节点被删除，则客户端的Watcher会收到相应关照，此时再次判断本身创建的节点是否是lock子节点中序号最小的，如果是则获取到了锁，如果不是则重复以上步骤继承获取到比本身小的一个节点并注册监听。
2.4 模拟12306售票案例

•在Curator中有五种锁方案：
•InterProcessSemaphoreMutex：分布式排它锁（非可重入锁）
•InterProcessMutex：分布式可重入排它锁
•InterProcessReadWriteLock：分布式读写锁
•InterProcessMultiLock：将多个锁作为单个实体管理的容器
•InterProcessSemaphoreV2：共享信号量
  1. package com.wjh;
  2. ​
  3. import org.apache.curator.RetryPolicy;
  4. import org.apache.curator.framework.CuratorFramework;
  5. import org.apache.curator.framework.CuratorFrameworkFactory;
  6. import org.apache.curator.framework.recipes.locks.InterProcessMutex;
  7. import org.apache.curator.retry.ExponentialBackoffRetry;
  8. ​
  9. import java.util.concurrent.TimeUnit;
  10. ​
  11. public class TickTest implements Runnable{
  12.     private int x=10;//票数
  13.     //创建分布式可重入排它锁对象
  14.     private InterProcessMutex lock;
  15.     private CuratorFramework client;
  16. ​
  17.     //当前方法的构造方法
  18.     public TickTest() {
  19.         //超时重试（连接间隔时间和超时连接次数）
  20.         RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
  21.         //连接zookeeper对象
  22.         client = CuratorFrameworkFactory.newClient(
  23.                 "ip:port",
  24.                 1000,
  25.                 60*1000,
  26.                 retryPolicy);
  27.         //开始连接
  28.         client.start();
  29.         //创建分布式可重入排它锁对象连接zookeeper注册中心客户端
  30.         //客户端中不用创建，这里会自动创建
  31.         lock = new InterProcessMutex(client, "/lock");
  32.     }
  33. ​
  34.     @Override
  35.     public void run() {
  36.         try {
  37.             //设置锁
  38.             lock.acquire(3, TimeUnit.SECONDS);
  39.             while (true) {
  40.                 if(x>0){
  41.                     //输出的调用线程的对象以及票数的数量
  42.                     System.out.println(Thread.currentThread()+"票数:" + x);
  43.                     //间隔200毫秒输出一次
  44.                     Thread.sleep(200);
  45.                     x--;
  46.                 }
  47.             }
  48.         } catch (Exception e) {
  49.             throw new RuntimeException(e);
  50.         }finally {
  51.             try {
  52.                 //释放锁
  53.                 lock.release();
  54.             } catch (Exception e) {
  55.                 throw new RuntimeException(e);
  56. ​
  57.             }
  58.         }
  59.     }
  60. }
  61. ​
复制代码
3. ZooKeeper集群搭建

3.1 zookeeper集群介绍

Leader选举：


  • Serverid ：服务器 ID

    • 比如有三台服务器，编号分别是1,2,3。
    • 编号越大在选择算法中的权重越大。

  • Zxid ：数据 ID

    • 服务器中存放的最大数据ID.值越大说明数据 越新，在选举算法中数据越新权重越大。

  • 在 Leader 选举的过程中，如果某台 ZooKeeper获得了超过半数的选票，则此ZooKeeper就可以成为Leader了
4. Zookeeper核心理论

对于集群来说，多加几台服务器就行（当然还得办理session共享，负载均衡等题目），而对于分布式来说，你起首需要将业务举行拆分，然后再加服务器，同时还要去办理分布式带来的一系列题目。比如各个分布式组件怎样协调起来，怎样淘汰各个体系之间的耦合度，怎样处理分布式变乱，怎样去设置整个分布式体系，怎样办理各分布式子体系的数据不一致题目等等。ZooKeeper 重要就是办理这些题目的。
很多著名的开源项目用到了 ZooKeeper，比如：


  • Kafka : ZooKeeper 重要为 Kafka 提供 Broker 和 Topic 的注册以及多个 Partition 的负载均衡等功能。
  • Hbase : ZooKeeper 为 Hbase 提供确保整个集群只有一个 Master 以及保存和提供 regionserver 状态信息（是否在线）等功能。
  • Hadoop : ZooKeeper 为 Namenode 提供高可用支持。
  • Dubbo：阿里巴巴团体开源的分布式服务框架，它使用 ZooKeeper 来作为其命名服务，维护全局的服务地址列表。
4.1 ZooKeeper的三种运行模式

ZooKeeper 有三种运行模式：单机模式、伪集群模式和集群模式。


  • 单机模式：这种模式一般适用于开发测试环境，一方面我们没有那么多呆板资源，别的就是平时的开发调试并不需要极好的稳定性。
  • 集群模式：一个 ZooKeeper 集群通常由一组呆板构成，一般 3 台以上就可以构成一个可用的 ZooKeeper 集群了。构成 ZooKeeper 集群的每台呆板都会在内存中维护当前的服务器状态，并且每台呆板之间都会相互保持通信。
    -伪集群模式：这是一种特殊的集群模式，即集群的所有服务器都部署在一台呆板上。当你手头上有一台比力好的呆板，如果作为单机模式举行部署，就会浪费资源，这种情况下，ZooKeeper 允许你在一台呆板上通过启动不同的端口来启动多个 ZooKeeper 服务实例，从而以集群的特性来对外服务。
继承学习：
https://blog.csdn.net/dream_ambition/article/details/136027023

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

半亩花草

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表