2.15日学习打卡----初学Zookeeper(二)

这篇具有很好参考价值的文章主要介绍了2.15日学习打卡----初学Zookeeper(二)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

2.15日学习打卡

一. Zookeeper部署运行

伪集群安装

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
下载Zookeeper

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
选择第二个点击Download
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
下载最新版本即可
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
下载后将文件上传值虚拟机
可以使用xftp或者rz命令
将上传后的Zookeeper 解压后移动到 usr/local目录下

tar -zxvf apache-zookeeper-3.9.1-bin.tar.gz -C /usr/local

重命名文件夹

mv apache-zookeeper-3.9.1-bin zookeeper-3.9.1

修改配置文件

cd /usr/local/zookeeper/config
mv zoo_sample.cfg zoo.cfg

修改zoo.cfg

#The number of milliseconds of each tick
tickTime=2000initLimit=10
syncLimit=5
dataDir=/usr/local/zookeeper/zkdata
dataLogDir=/usr/local/zookeeper/zklogs
clientPort=2181
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

创建数据持久化目录

mkdir /usr/local/zookeeper/zkdata
mkdir /usr/local/zookeeper/zklogs

启动zookeeper服务(进入bin目录)

./zkServer.sh start

查看Zookeeper运行状态

zkServer.sh status

jps 查看进程
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
可以通过./zkCli.sh来判断是否搭建成功

./zkCli.sh
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

集群安装

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
环境准备(3个虚拟机)

192.168.66.100
192.168.66.110
192.168.66.120

解压zookeeper

tar -zxvf apache-zookeeper-3.6.3.tar.gz -C /usr/local

修改配置文件

cd /usr/local/zookeeper/config
mv zoo_sample.cfg zoo.cfg

修改zoo.cfg

添加
server.1=192.168.66.101:2888:3888
server.2=192.168.66.102:2888:3888
server.3=192.168.66.103:2888:3888

创建数据持久化目录和日志目录

对3台节点,都创建zkdata目录 。

mkdir /usr/local/zookeeper/zkdata
mkdir /usr/local/zookeeper/zklogs

在工作目录中生成myid文件

第一台机器上: echo 1 > /usr/local/zookeeper/zkdata/myid
第二台机器上: echo 2 > /usr/local/zookeeper/zkdata/myid
第三台机器上: echo 3 > /usr/local/zookeeper/zkdata/myid

启动zookeeper集群
zookeeper没有提供自动批量启动脚本,需要手动一台一台地起zookeeper进程 在每一台节点上,运行命令:

bin/zkServer.sh start

注意:
启动后,用jps应该能看到一个进程:QuorumPeerMain。光有进程不代表zk已经正常服务,需要用命令检查状态:bin/zkServer.sh status 能看到角色模式:为leader或follower,即正常了。

服务管理

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

脚本 说明
zkCleanup 清理Zookeeper历史数据,包括事务日志文件和快照数据文件
zkCli Zookeeper的简易客户端
zkEnv 设置Zookeeper的环境变量
zkServe r Zookeeper服务器的启动、停止和重启脚本

配置环境变量

修改文件
vim /etc/profile

export ZOOKEEPER_HOME=/usr/local/zookeeper
export PATH=$PATH:$JAVA_HOME/bin:$ZOOKEEPER_HOME/bin

生效环境变量

source /etc/profile

启动服务
如何启动zookeeper服务。

语法结构

sh zkServer.sh start

停止服务
语法结构:

sh zkServer.sh stop

查看zookeeper状态
语法结构:

sh zkServer.sh status

设置一键启动/一键停止脚本
编写一键启停脚本 vim zkStart-all.sh

#验证传入的参数
if [ $# -ne 1 ];then
   echo "无效参数,用法为: $1 
{start|stop|restart|status}"
   exit
fi
#遍历所有节点
for host in 192.168.66.100 192.168.66.110
192.168.66.120
do
   echo "========== $host 正在 $1 ========= "
   #发送命令给目标机器
   ssh $host "source /etc/profile;
/usr/local/zookeeper/bin/zkServer.sh $1"
done

二. Zookeeper系统模型

数据模型

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
在Zookeeper中,可以说 Zookeeper中的所有存储的数据是由znode组成的,节点也称为 znode,并以 key/value 形式存储数据


2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

介绍:
整体结构类似于 linux 文件系统的模式以树形结构存储。其中根路径以 / 开头

保存数据
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

注意:
以 key/value 形式存储数据。key就是znode的节点路径,比如 /java , /server。

节点特性

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
znode节点类型

ZooKeeper 节点是有生命周期的,这取决于节点的类型。节点类型可以分为持久节点、临时节点,以及时序节点,具体在节点创建过程中,一般是组合使用,可以生成以下 4 种节点类型。
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
持久节点

持久节点是zookeeper中最常见的一种节点类型。所谓持久节点,是指改数据节点被创建后,就会一直存在与zookeeper服务器上,直到有删除操作来主动清除这个节点。
示例:

/java  spring
/jjy  zbjjy

持久顺序节点

这类节点的基本特性和上面的节点类型是一致的。额外的特性是,在ZK中,每个父节点会为他的第一级子节点维护一份时序,会记录每个子节点创建的先后顺序。
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
示例:

/java00000000000001  spring
/jjy00000000000001  zbjjy

临时节点
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

区别:
和持久节点不同的是,临时节点的生命周期和客户端会话绑定。也就是说,如果客户端会话失效,那么这个节点就会自动被清除掉。注意,这里提到的是会话失效,而非连接断开。另外,在临时节点下面不能创建子节点。

临时顺序节点

临时顺序节点的基本特性和临时节点是一致的,同样是在临时节点的基础上,添加了顺序的特性。

示例:

/jjy0000000000000001  zbjjy
/jjy0000000000000002  zbjjy
/jjy0000000000000003  zbjjy

客户端命令行

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

创建

创建ZK节点

语法结构:

create [-s] [-e] path data acl

参数
-s:顺序节点
-e:临时节点
默认情况下,不添加-s或者-e参数的,创建的是持久节点。

实例:

[zk: localhost:2181(CONNECTED) 0]create /zk-book jjy

读取

读取节点信息ls命令和set命令。

ls命令
语法结构:

ls path [watch]

实例:

ls /

注意:
第一次部署的ZooKeeper集群,默认在根节点“1”下面有一个叫作/zookeeper的保留节点。

get命令
使用get命令,可以获取zookeeper指定节点的数据内容和属性信息。

语法格式:

get path [watch]

示例:

get /zk-book

更新

使用set命令,可以更新指定节点的数据内容。

语法结构:

set path data [version]

示例:

set /java springmvc

参数:
data就是要更新的新内容。注意,set命令后面还有一个version参数,在ZooKeeper 中,节点的数据是有版本概念的,这个参数用于指定本次更新操作是基于ZNode的哪一个数据版本进行的。

删除

删除zookeeper上的指定节点。

语法结构:

delete path [version]

示例:

create /zk-book 123
create /zk-book/child 12345
delete /zk-book

参数:
如果节点包含子节点就报错。

节点数据信息

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

节点的状态结构

每个节点都有属于自己的状态信息,这就很像每个人的身份信息一样。

语法结构:

[zk: localhost:2181(CONNECTED) 15] stat /a
cZxid = 0x300000014
ctime = Thu Dec 30 15:05:07 CST 2021
mZxid = 0x300000014
mtime = Thu Dec 30 15:05:07 CST 2021
pZxid = 0x300000015
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 1
numChildren = 1

查看节点类型

语法结构:

create 参数  /java  spring

参数
-e:临时节点
-s:顺序节点
默认不写就是持久型节点

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

Watcher监听机制

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
ZooKeeper 提供了分布式数据的发布/订阅功能。一个典型的发布/订阅模型系统定义了一种一对多的订阅关系,能够让多个订阅者同时监听某一个主题对象,当这个主题对象自身状态变化时,会通知所有订阅者,使它们能够做出相应的处理。
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

注意:
在ZooKeeper中,引入了Watcher机制来实现这种分布式的通知功能。ZooKeeper 允许客户端向服务端注册一个 Watcher 监听,当服务端的一些指定事件触发了这个Watcher,那么就会向指定客户端发送一个事件通知来实现分布式的通知功能。

监听机制

监听节点变化
语法结构:

ls -w path

参数:
命令如果使用watch,那么监听的是节点的变化,而不是值的变化。

监听节点的值的变化
语法结构:

get -w path

参数:
watch监听机制只能够使用一次,如果下次想要使用,必须重新监听,就比如ls path watch命令,只能监听节点路径的改变一次,如果还想监听,那么需要再执行一次ls path watch命令。

权限控制 ACL

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
在ZooKeeper的实际使用中,我们的做法往往是搭建一个共用的ZooKeeper集群,统一为若干个应用提供服务。在这种情况下,不同的应用之间往往是不会存在共享数据的使用场景的,因此需要解决不同应用之间的权限问题。

ACL 权限控制

  1. 权限模式(Schema)
  2. 授权对象(ID)
  3. 权限(Permission)

参数:

  1. ZooKeeper的权限控制是基于每个znode节点的,需要对每个节点设置权限
  2. 每个znode支持设置多种权限控制方案和多个权限
  3. 子节点不会继承父节点的权限,客户端无权访问某节点,但可能可以访问它的子节点

例子:

setAcl /test2 ip:128.0.0.1:crwda

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
schema

ZooKeeper内置了一些权限控制方案,可以用以下方案为每个节点设置权限:

方案 描述
world 只有一个用户:anyone,代表所有人(默认)
ip 使用IP地址认证
auth 使用已添加认证的用户认证
digest 使用“用户名:密码”方式认证

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
id

授权对象ID是指,权限赋予的用户或者一个实体,例如:IP 地址或
者机器。授权模式 schema 与 授权对象 ID 之间关系:

权限模式 授权对象
IP 通常是一个IP地址或是IP段,例如“192.168.66.101”
Digest 自定义,通常是“username:BASE64(SHA-1(username:password))”
World 只有一个ID:“anyone”
Super 与Digest模式一致

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

权限permission

权限 ACL简写 描述
CREATE c 可以创建子节点
DELETE d 可以删除子节点(仅下一级节点)
READ r 可以读取节点数据及显示子节点列表
WRITE w 可以设置节点数据
ADMIN a 可以设置节点访问控制列表权限

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
权限相关命令

命令 使用方式 描述
getAcl getAcl 读取ACL权限
setAcl setAcl 设置ACL权限
addauth addauth 添加认证用户

实战
World方案
语法格式:

setAcl <path> world:anyone:<acl>

客户端实例

[zk: localhost:2181(CONNECTED) 0] create /node1 1
Created /node1
[zk: localhost:2181(CONNECTED) 1] getAcl /node1 'world,'anyone #默认为world方案
: cdrwa #任何人都拥有所有权限

IP方案

语法格式:

setAcl <path> ip:<ip>:<acl>

参数
:可以是具体IP也可以是IP/bit格式,即IP转换为二进制,匹配前bit位,如192.168.0.0/16匹配192.168…

客户端实例

#创建节点
[zk: localhost:2181(CONNECTED) 0] create /node2 1
Created /node2
#设置权限
[zk: localhost:2181(CONNECTED) 1] setAcl /node2 ip:192.168.66.110:cdrwa #设置IP:192.168.66.110
拥有所有权限
cZxid = 0x1900000239
#使用IP非 192.168.66.101 的机器
[zk: localhost:2181(CONNECTED) 0] get /node2
Authentication is not valid : /node2 #没有权限

Auth方案
语法格式:

setAcl <path> auth:<user>:<acl>

添加认证用户

addauth digest <user>:<password>

客户端实例

#创建节点
[zk: localhost:2181(CONNECTED) 0] create /node3
1
Created /node3
#添加认证用户
[zk: localhost:2181(CONNECTED) 1] addauth digest jjy:123456
#设置权限
[zk: localhost:2181(CONNECTED) 2] setAcl /node3 auth:yoonper:cdrwa
#获取权限
[zk: localhost:2181(CONNECTED) 3] getAcl /node3 'digest,'jjy:UvJWhBril5yzpEiA2eV7bwwhfLs=: cdrwa

刚才已经添加认证用户,可以直接读取数据,断开会话重连需要重新addauth添加认证用户

[zk: localhost:2181(CONNECTED) 3] get /node3

Digest方案

语法格式:

setAcl <path> digest:<user>:<password>:<acl>

这里的密码是经过SHA1及BASE64处理的密文,在SHELL中可以通
过以下命令计算:

echo -n <user>:<password> | openssl dgst -binary -sha1 | openssl base64

先来计算一个密文

echo -n baizhan:123456 | openssl dgst -binary -sha1 | openssl base64
UvJWhBril5yzpEiA2eV7bwwhfLs=

客户端实例

#创建节点
[zk: localhost:2181(CONNECTED) 0] create /node4 1
Created /node4
#使用是上面算好的密文密码添加权限:
[zk: localhost:2181(CONNECTED) 1] setAcl /node4 digest:jjy:UvJWhBril5yzpEiA2eV7bwwhfLs=:cdr
wa
 #获取节点数据没有权限
[zk: localhost:2181(CONNECTED) 3] get /node4
Authentication is not valid : /node4
#添加认证用户
[zk: localhost:2181(CONNECTED) 4] addauth digest jjy:123456
#成功读取数据
[zk: localhost:2181(CONNECTED) 5] get /node4
1

三. 原生api操作Zookeeper

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
利用Zookeeper官方的原生java api进行连接,然后演示一些创建、删除、修改、查询节点的操作。

引入依赖

<dependencies>
  <dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.8</version>
  </dependency>
</dependencies>

创建会话

package com.jjy;

import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;

public class ZkMain {
    public static void main(String[] args) throws IOException {
        /**
         * 创建一个 Zookeeper 的实例
         * 此处为一个集群,Zookeeper 的 ip 之间用逗号隔开
         *
         * 参数解释:
         * param 1 - Zookeeper 的实例 ip ,此处是一个集群,所以配置了多个 ip,用逗号隔开
         * param 2 - session 过期时间,单位秒 (1000)
         * param 3 - 监视者,用于获取监听事件 (MyWatch)
         */
        //创建一个会话
        ZooKeeper zooKeeper = new ZooKeeper("192.168.66.100:2181,192.168.66.110:2181,192.168.66.120:2181", 4000, null);
        System.out.println(zooKeeper.getState());
    }
}

创建节点

private void createNodeSync() throws KeeperException, InterruptedException {
  String path = "/poype_node";
  /*
  *znode名称
  *节点数据
  *设置权限
  *znode类型
  *
  */
  String nodePath = zooKeeper.create(path, "123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  System.out.println(nodePath);
}

znode 类型有四种

  1. PERSISTENT - 持久化目录节点,客户端与zookeeper断开连接后,该节点依旧存在
  2. PERSISTENT_SEQUENTIAL - 持久化,并带有序列号
  3. EPHEMERAL - 临时目录节点,客户端与zookeeper断开连接后,该节点被删除
  4. EPHEMERAL_SEQUENTIAL - 临时,并带有序列号

删除节点
同步方式删除一个节点:

private void deleteSync() throws KeeperException, InterruptedException {
   zooKeeper.delete("/node_1", 12);
}

读取数据

private void getDataSync() throws KeeperException, InterruptedException {
   Stat stat = new Stat();
   // getData的返回值是该节点的数据值,节点的状态信息会赋值给stat对象
   byte[] data = zooKeeper.getData("/node_1",true, stat);
   System.out.println(new String(data));
   System.out.println(stat);
}

参数:
znode 名称 (/zoo)
监视者,用于获取监控事件 (MyWatch)
Zookeeper 实例信息和数据信息 (stat)

更新数据

Stat stat = zooKeeper.setData("/poype_node2", "poype5211314".getBytes(), 1);

参数:
param1:znode名称
param2:节点数据
param3:该节点的版本

检测节点是否存在

private void existSync() throws KeeperException, InterruptedException {
   Stat stat = zooKeeper.exists("/poype_node2", true);
   System.out.println(stat);
}

参数:
param1:znode 名称 (/zoo)
param2:监视者,用于获取监控事件 (MyWatch)

注册监听getChilren

通过zkCli.getchildren(“/”,new watch()){}来注册监听,监听的是整个根节点,但是这个监听只能监听一次。线程休眠是为了让监听等待事件发生,不然会随着程序直接运行完。

public class WatchDemo1 {
    
    static List<String> children = null;
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        


        ZooKeeper zkCli = new ZooKeeper("192.168.50.183:2181,192.168.50.184:2181,192.168.50.185:2181", 3000, new Watcher() {
                
                //监听回调
                @Override
                public void process(WatchedEvent event) {
                    System.out.println("正在监听中.....");
                }
            });
        
            //监听目录
            children = zkCli.getChildren("/", new Watcher() {
            
            @Override
            public void process(WatchedEvent event) {
                
                System.out.println("监听路径为:" + event.getPath());
                System.out.println("监听的类型为:" + event.getType());
                System.out.println("数据被2货修改了!!!");
                
                for(String c:children) {
                    System.out.println(c);
                }
            }
        }); 
            Thread.sleep(Long.MAX_VALUE);
    }   
}

注册监听getData

getData监听的为一个节点,同样只监听一次,返回的是该节点的内容。

public class WatchDemo {
    public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
        ZooKeeper zkCli = new ZooKeeper("192.168.50.183:2181,192.168.50.184:2181,192.168.50.185:2181", 3000, new Watcher() {
            
            //监听回调
            @Override
            public void process(WatchedEvent event) {
                
            }
        });
        
        byte[] data = zkCli.getData("/hunter", new Watcher() {
            //监听的具体内容
            @Override
            public void process(WatchedEvent event) {
                System.out.println("监听路径为:" + event.getPath());
                System.out.println("监听的类型为:" + event.getType());
                System.out.println("数据被2货修改了!!!");
            }
        }, null);
        System.out.println(new String(data));
        Thread.sleep(Long.MAX_VALUE);
    }
}


测试

package com.jjy;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.List;

public class ZkMain {
    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        /**
         * 创建一个 Zookeeper 的实例
         * 此处为一个集群,Zookeeper 的 ip 之间用逗号隔开
         *
         * 参数解释:
         * param 1 - Zookeeper 的实例 ip ,此处是一个集群,所以配置了多个 ip,用逗号隔开
         * param 2 - session 过期时间,单位秒 (1000)
         * param 3 - 监视者,用于获取监听事件 (MyWatch)
         */
        //创建一个会话
        ZooKeeper zooKeeper = new ZooKeeper("192.168.66.100:2181,192.168.66.110:2181,192.168.66.120:2181", 4000, null);
        System.out.println(zooKeeper.getState());
        /*
         *znode名称
         *节点数据
         *设置权限
         *znode类型
         *
         */
//        //创建结点
//        String s = zooKeeper.create("/node1", "1".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
//        System.out.println(s+"创建成功");

        //判断结点是否存在
        Stat exists = zooKeeper.exists("/node1", null);
        System.out.println(exists);

        //删除结点
        //zooKeeper.delete("/node1", -1);
        //修改结点
        //zooKeeper.setData("/node1","jjy".getBytes(),-1);
        //获取结点的数据
        byte[] data = zooKeeper.getData("/node1", null, null);
        System.out.println(new String(data));
        //获取节点
        List<String> children = zooKeeper.getChildren("/node1", null);
        for(String child : children){
            System.out.println(child);
        }


    }
}
package com.jjy;

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

import java.io.IOException;

public class ZkWacher {
    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        /**
         * 创建一个 Zookeeper 的实例
         * 此处为一个集群,Zookeeper 的 ip 之间用逗号隔开
         *
         * 参数解释:
         * param 1 - Zookeeper 的实例 ip ,此处是一个集群,所以配置了多个 ip,用逗号隔开
         * param 2 - session 过期时间,单位秒 (1000)
         * param 3 - 监视者,用于获取监听事件 (MyWatch)
         */
        //创建一个会话
        ZooKeeper zooKeeper = new ZooKeeper("192.168.66.100:2181,192.168.66.110:2181,192.168.66.120:2181", 4000, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                System.out.println("正在监听");
            }
        });
//       //注册监听机制 监听节点
//        zooKeeper.getChildren("/node1",new Watcher() {
//
//            @Override
//            public void process(WatchedEvent watchedEvent) {
//                //监听的路径
//                System.out.println(watchedEvent.getPath());
//                //监听类型
//                System.out.println(watchedEvent.getType());
//                System.out.println("节点被修改了");
//            }
//        });
        //监听数据
        zooKeeper.getData("/root",new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //监听的具体内容
                    System.out.println("监听路径为:" + event.getPath());
                    System.out.println("监听的类型为:" + event.getType());
                    System.out.println("数据被2货修改了!!!");
            }
        },null);
        Thread.sleep(Long.MAX_VALUE);

    }

}

四. zkclient库操作Zookeeper

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

使用zookeeper遇到问题:
重复注册watcher
session失效重连
异常处理(删除节点不能有子节点,新增节点必须有父节点等)

zkclient是Github上一个开源的Zookeeper客户端,在Zookeeper原生 API接口之上进行了包装,是一个更加易用的Zookeeper客户端。同时Zkclient在内部实现了诸如Session超时重连,Watcher反复注册等功能,从而提高开发效率。

添加依赖

<dependency>
   <groupId>com.101tec</groupId>
   <artifactId>zkclient</artifactId>
   <version>0.10</version>
</dependency>

创建会话

String connStr = "192.168.66.100:2181";
ZkClient zk = new ZkClient(connStr);

创建节点

String res = zk.create("/root", "jjy",
CreateMode.PERSISTENT);

修改节点数据

zk.writeData("/root", "zbjjy");

获取节点数据

String res = zk.readData("/root");

删除节点

zk.delete("/root");

注册数据监听

    zk.subscribeDataChanges("/root/ghz", new IZkDataListener() {


       @Override
       public void handleDataDeleted(String arg0) throws Exception {
         System.err.println("数据删除:" + arg0);
       }
       @Override
       public void handleDataChange(String arg0, Object arg1) throws Exception {
         System.err.println("数据修改:" + arg0 + "------" + arg1);


       }
     });

注册节点监听

zk.subscribeChildChanges("/root", (arg0, arg1) -> {
       System.err.println("子节点发生变化:" + arg0);
       arg1.forEach(f -> {
         System.out.println("content:" + f);
       });
     });

测试

package com.jjy;

import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.apache.zookeeper.CreateMode;

import java.util.List;

public class ZkClientMain {
    public static void main(String[] args) throws InterruptedException {
        //创建会话
        ZkClient zk = new ZkClient("192.168.66.100:2181,192.168.66.110:2181,192.168.66.120:2181");

       //获取子节点
        List<String> children = zk.getChildren("/node1");
        for (String child : children) {
            System.out.println(child);
        }
        //创建结点
        zk.create("/node2","2", CreateMode.PERSISTENT);
        System.out.println("创建节点成功");
        //修改结点数据
        zk.writeData("/node2","jjy");
        //获取数据
        String o = zk.readData("/node2");
        System.out.println(o);
        //删除数据
        zk.delete("/node2");
        //注册节点监听事件
        zk.subscribeChildChanges("/node1", new IZkChildListener() {
            @Override
            public void handleChildChange(String s, List<String> list) throws Exception {
                System.out.println("数据改变了");
                list.forEach(f->{System.out.println(f);});
            }
        });
        //注册结点数据
        zk.subscribeDataChanges("/node2", new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {
                System.out.println("数据改变了");
            }

            @Override
            public void handleDataDeleted(String s) throws Exception {
                System.out.println("数据删除了");
            }
        });
     Thread.sleep(Long.MAX_VALUE);
    }
}

五. Apache Curator操作Zookeeper

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
Curator是 Netflix公司开源的一套ZooKeeper客户端框架。和ZkClient一样,Curator解决了很多ZooKeeper客户端非常底层的细节开发工作,包括连接重连、反复注册Watcher和NodeExistsException异常等,目前已经成为了Apache的顶级项目,是全世界范围内使用最广泛的ZooKeeper客户端之一

Curator包
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式

添加Maven依赖

<dependency>
   <groupId>org.apache.curator</groupId>
   <artifactId>curator-recipes</artifactId>
   <version>4.2.0</version>
</dependency>

创建会话

 String connStr = "192.168.66.100:2181";
    CuratorFramework cur= CuratorFrameworkFactory.builder()
         .connectString(connStr)
         .connectionTimeoutMs(5000)
         .retryPolicy(new ExponentialBackoffRetry(1000,3))
         .build();
    cur.start();//连接

创建节点

cur.create().withMode(CreateMode.PERSISTENT)
         .forPath("/root", "jjy".getBytes());

删除数据节点

cur.delete().forPath("/root");

注意:
此方法只能删除叶子节点,否则会抛出异常。

删除一个节点,并且递归删除其所有的子节点

cur.delete().deletingChildrenIfNeeded().forPath("/root");

删除一个节点,强制指定版本进行删除

cur.delete().withVersion(10086).forPath("path");

删除一个节点,强制保证删除

cur.delete().guaranteed().forPath("path");

注意:
guaranteed()接口是一个保障措施,只要客户端会话有效,那么Curator会在后台持续进行删除操作,直到删除节点成功。

注意:上面的多个流式接口是可以自由组合的,例如:

cur.delete().guaranteed().deletingChildrenIfNeeded().withVersion(10086).forPath("/root");

读取数据节点数据

读取一个节点的数据内容

cur.getData().forPath("/root");

注意:
此方法返的返回值是byte[ ];

读取一个节点的数据内容,同时获取到该节点的stat

Stat stat = new Stat();
client.getData().storingStatIn(stat).forPath("path");

更新数据节点数据
更新一个节点的数据内容

client.setData().forPath("path","data".getBytes());

注意:
该接口会返回一个Stat实例;

更新一个节点的数据内容,强制指定版本进行更新

client.setData().withVersion(10086).forPath("path","data".getBytes());

检查节点是否存在

client.checkExists().forPath("path");

注意:
该方法返回一个Stat实例,用于检查ZNode是否存在的操作. 可以调用额外的方法(监控或者后台处理)并在最后调用forPath()指定要操作的ZNode

获取某个节点的所有子节点路径

client.getChildren().forPath("path");

测试

package com.jjy;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.NodeCache;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.CreateMode;

import java.util.List;

public class CuratorMain {
    public static void main(String[] args) throws Exception {
        //创建会话
        String connStr = "192.168.66.100:2181,192.168.66.110:2181,192.168.66.120:2181";
        CuratorFramework cur= CuratorFrameworkFactory.builder()
                .connectString(connStr)
                .connectionTimeoutMs(5000)
                .retryPolicy(new ExponentialBackoffRetry(1000,3))
                .build();
        //连接
        cur.start();//连接
        //创建节点
        cur.create().withMode(CreateMode.PERSISTENT).forPath("/node3","3".getBytes());

        //获取数据
        byte[] bytes = cur.getData().forPath("/node3");
        System.out.println(new String(bytes));

        //删除结点
        cur.delete().forPath("/node3");

        //删除的结点有子节点
        cur.delete().deletingChildrenIfNeeded().forPath("/root");
        //修改结点
        cur.setData().forPath("/node3","jjy".getBytes());
        //获取某个结点的所有子节点
        List<String> strings = cur.getChildren().forPath("/node3");
        strings.forEach(f->{System.out.println(f);});

        //监听机制
        NodeCache nodeCache = new NodeCache(cur, "/node3");
        nodeCache.getListenable().addListener(()->{
            System.out.println("被修改了");
        });
        nodeCache.start();
        Thread.sleep(Long.MAX_VALUE);


    }
}

六. Zookeeper高级

四字命令

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
之前使用stat命令来验证ZooKeeper服务器是否启动成功,这里的stat命令就是ZooKeeper 中最为典型的命令之一。ZooKeeper中有很多类似的命令,它们的长度通常都是4个英文字母,因此我们称之为“四字命令”。

添加配置
vim zoo.cfg

4lw.commands.whitelist=*

四字命令

conf

输出Zookeeper相关服务的详细配置信息,如客户端端口,数据存储路径、最大连接数、日志路径、数据同步端口、主节点推举端口、session超时时间等等。

语法结构:

echo conf| nc localhost 2181

注意:
注意,conf命令输出的配置信息仅仅是输出一些最基本的配置参数。另外,conf命令会根据当前的运行模式来决定输出的信息。如果是单机模式(standalone), 就不会输出诸如initLimit.syncLimit、electionAlg 和electionPort等集群相关的配置信息。

cons
cons 命令用于输出当前这台服务器上所有客户端连接的详细信息,包括每个客户端的客户端IP、会话ID和最后一次与服务器交互的操作类型等。

语法结构:

echo cons | nc localhost 2181

ruok

ruok命令用于输出当前ZooKeeper服务器是否正在运行。该命令的名字非常有趣,其谐音正好是“Are you ok”。执行该命令后,如果当前ZooKeeper服务器正在运行,那么返回“imok”, 否则没有任何响应输出。

语法结构:

echo ruok | nc localhost 2181

stat

stat命令用于获取ZooKeeper服务器的运行时状态信息,包括基本的ZooKeeper版本、打包信息、运行时角色、集群数据节点个数等信息,另外还会将当前服务器的客户端连接信息打印出来。

语法结构:

echo stat | nc localhost 2181

注意:
除了一些基本的状态信息外,stat命令还会输出一些服务器的统计信息,包括延迟情况、收到请求数和返回的响应数等。注意,所有这些统计数据都可以通过srst命令进行重置。

mntr

列出集群的关键性能数据,包括zk的版本、最大/平均/最小延迟数、数据包接收/发送量、连接数、zk角色(Leader/Follower)、node数量、watch数量、临时节点数。

语法结构:

echo mntr | nc localhost 2181

选举机制

2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
核心选举原则
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
选举机制流程
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式
选择机制中的概念

Serverid:服务器ID

比如有三台服务器,编号分别是1,2,3。

编号越大在选择算法中的权重越大。

Zxid:数据ID
服务器中存放的最大数据ID.

值越大说明数据越新,在选举算法中数据越新权重越大。

Epoch:逻辑时钟

或者叫投票的次数,同一轮投票过程中的逻辑时钟值是相同的。每
投完一次票这个数据就会增加,然后与接收到的其它服务器返回的
投票信息中的数值相比,根据不同的值做出不同的判断。

如果我的内容对你有帮助,请点赞,评论,收藏。创作不易,大家的支持就是我坚持下去的动力!
2.15日学习打卡----初学Zookeeper(二),每日学习,学习,zookeeper,debian,java,分布式文章来源地址https://www.toymoban.com/news/detail-825680.html

到了这里,关于2.15日学习打卡----初学Zookeeper(二)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Unity基础 -- 更新中(2.15)

    3D数学 – 基础 一些方法 插值运算 三角函数 ​ 坐标系 3D数学 – 向量 理解 常用函数 线性插值 与 Mathf.Lerp 用法相同,只是参数为Vector3 3D数学 – 四元数 看向 四元数计算 延迟函数 延迟函数 参数一:函数名 字符串 参数二:延迟时间 单位秒 注意:延迟函数无法直接调用有参

    2024年02月22日
    浏览(33)
  • mapbox 导航记录(release-v2.15分支 纯kotlin)

    初始化时使用 NavigationOptions 设置一些参数,包括accessToken、appMetaData、LocationEngine等,其它还有很多,具体可以详看 NavigationOptions 类的内部。 下面示例中 LocationEngine 使用的重演定位引擎,可以看到模拟导航的效果,关键的两个类就是 ReplayLocationEngine 和 MapboxReplayer 。 navigati

    2024年02月09日
    浏览(27)
  • 对Element UI 2.15版本的树形组件进行美化,如增加竖线、横线、图标等

    ElementUI、ElementPlus树组件功能很不错,但是官方的树形组件没有显示线条,感觉稍微不够大气。于是网上查了一些资料,找了很多也感觉也不够完美,最后找到一个还不错的实现方案,并且再美化改进一下,分享给大家。 (1)示例代码 (2)效果如下~ (1)示例代码 (2)效

    2024年02月13日
    浏览(70)
  • Zookeeper的学习笔记

    Zookeeper是一个树形目录服务,简称zk。 Zookeeper是一个分布式的、开源的分布式应用程序的协调服务 Zookeeper提供主要的功能包括:配置管理,分布式锁,集群管理 zk中的每一个节点都被称为:ZNode,每个节点上都会保存自己的数据和节点信息。节点可以拥有子节点,同时也允许

    2024年01月16日
    浏览(31)
  • ZooKeeper学习

    Apache ZooKeeper是一个高可用的分布式协调中间件。Goole Chubby的一个开源实现,主要解决分布式一致性问题,提供分布式锁服务。 分布式一致性问题 典型的拜占庭将军问题 分布式锁服务 Chubby提供了一种粗粒度的分布式锁服务,通过创建文件的形式实现,server向Chubby中创建文件

    2024年02月08日
    浏览(27)
  • Yarn与Zookeeper学习

    1.YARN是什么? yarn 分配运行资源 mapReduce的运行平台 2.YARN运行过程: 客户端与ResourceManager交互,生成临时配置文件(Application) ResourceManager根据Application信息生成Task然后生成MapReduceApplicationMaster(简称AM) AM通过和App交互申请MapTask资源,并运行MapTask任务 MapTask资源完毕,申请资源处

    2024年02月15日
    浏览(32)
  • zookeeper入门学习

    分布式 协调 组件 客户端第一次请求发给服务器2,将flag值修改为false,第二次请求被负载均衡到服务器1,访问到的flag也会是false 一旦有节点发生改变,就会通知所有监听方改变自己的值,保持数据的一致性(watch机制) = 会不会改变的太频繁了 分布式锁 后面讲述 无状态化

    2024年02月14日
    浏览(29)
  • Zookeeper学习笔记

    (1)  Zookeeper是分布式锁服务,为分布式系统提供名字服务器,分布式同步,组服务的开源高效可靠的协同工作,对集群的稳定性起到了关键作用。 (2)  一个松散耦合的分布式系统中粗粒度锁以及可靠性存储(低容量)的系统。 松散耦合:对于硬件要求不过严格 分布式:多个节

    2024年02月06日
    浏览(28)
  • zookeeper学习(二) 集群模式安装

    三台centos7服务器 三台服务器都需要安装jdk1.8以上 zookeeper安装包 在单机模式已经描述过,这里略过,有需要可以去看单机模式中的这部分,注意的是三台服务器都需要安装 当前在192.168.2.201上操作 解压zookeeper安装包 在安装目录下新建zkData目录 修改修改conf/zoo.cfg文件 修改zo

    2024年02月16日
    浏览(37)
  • zookeeper学习(三)基础数据结构

    在 zookeeper 中,可以说 zookeeper 中的所有存储的数据是由 znode 组成的,节点也称为 znode,并以 key/value 形式存储数据。 整体结构类似于 linux 文件系统的模式以树形结构存储。其中根路径以 / 开头。 进入 zookeeper 安装的 bin 目录,通过sh zkCli.sh打开命令行终端 执行 “ls /” 命令

    2024年02月14日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包