一文搞定ZooKeeper常见用法

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

介绍

本文比较系统的梳理了ZooKeeper的常用知识点，包括文件系统、监听通知机制、单机环境搭建、集群环境搭建、常用操作命令、Java API调用和作为注册中心服务等内容，读完本文，相信能有助于我们对ZooKeeper的概念和用法有一个整体的认识。

目录

一、文件系统与监听通知机制

ZooKeeper是阿帕奇官网的一个分布式服务框架，用来解决分布式应用中经常出现的一些数据管理问题，比如统一命名服务、状态同步服务、集群管理和分布式应用配置管理等。总的来说，ZK=文件系统 + 监听通知机制

1、文件系统

ZooKeeper底层是一套树形存储结构，类似于Unix文件系统路径，也是从根节点开始，这些节点都称之为znode，可以用来保存数据（默认存储大小为1MB）。 而这些znode节点也分为四种类型

节点类型节点描述
PERSISTENT持久化目录节点，当客户端与 zookeeper 断开连接后，该节点依旧存在
PERSISTENT_SEQUENTIAL持久化顺序编号目录节点，当客户端与 zookeeper 断开连接后，该节点依旧存在，只是 Zookeeper 给该节点名称进行顺序编号
EPHEMERAL临时目录节点，当客户端与 zookeeper 断开连接后，该节点被删除
EPHEMERAL_SEQUENTIAL临时顺序编号目录节点，当客户端与 zookeeper 断开连接后，该节点被删除，只是 Zookeeper 给该节点名称进行顺 序编号

在这里插入图片描述

2、监听通知机制

ZooKeeper采用了观察者设计模式，客户端会向其关心的目录节点注册，一旦目录节点发生改变（比如数据的更新或删除、子目录节点的增加或删除），ZK服务就会通知客户端。
在这里插入图片描述

二、单机环境搭建

我们这里都是在Linux系统中搭建环境

1、安装JDK

JDK安装请参考一文搞定Linux常见用法中第八部分

2、安装ZooKeeper

1、上传安装包
使用rz命令，将从zk官网下载的压缩包上传至temp目录（这里使用的3.6版本）

[root@localhost temp]# rz

[root@localhost temp]# ll
-rw-r--r--. 1 root root  12392394 3月  31 06:49 apache-zookeeper-3.6.0-bin.tar.gz

2、解压
1）解压：使用命令tar -zxvf apache-zookeeper-3.6.0-bin.tar.gz -C /usr/local/，将zookeeper解压到/usr/local/目录下
2）重命名：mv apache-zookeeper-3.6.0-bin/ zookeeper
在这里插入图片描述
3、配置文件处理
ZooKeeper 启动时默认的去 conf 目录下读取zoo.cfg配置文件，但是这个文件其实不存在，只有一个zoo_sample.cfg参考文件，所以我们先要使用 cp zoo_sample.cfg zoo.cfg复制一份实际配置

-rw-r--r--. 1 1000 mysql  535 2月  25 14:36 configuration.xsl
-rw-r--r--. 1 1000 mysql 3435 2月  25 14:36 log4j.properties
-rw-r--r--. 1 root root  1148 6月   7 02:19 zoo.cfg
-rw-r--r--. 1 1000 mysql 1148 2月  25 14:36 zoo_sample.cfg

4、创建数据缓存目录
为了方便缓存数据管理，我们在zookeeper目录下执行mkdir data，创建data文件夹
在这里插入图片描述
并且将zoo.cfg中缓存数据目录修改为dataDir=/usr/local/zookeeper/data
5、启动服务
进入到bin目录下，执行./zkServer.sh start命令

[root@localhost bin]# ./zkServer.sh start
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeeper/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED

使用./zkServer.sh status可查看服务状态，默认端口为2181，Mode:standalone表示为单机模式

[root@localhost bin]# ./zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeeper/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Mode: standalone

停止服务使用./zkServer.sh stop

3、客户端连接ZooKeeper

在bin目录下，执行./zkCli.sh -server ip:port命令，ip和port分布为需要连接的zk服务的地址和端口。如果只是连接本机zk，且使用的默认端口2181，则使用./zkCli.sh即可。连接成功后会进入到客户端模式，Crtl + C可退出

省略....
WATCHER::

WatchedEvent state:SyncConnected type:None path:null
[zk: 192.168.xx.xxx:2181(CONNECTED) 0]

三、集群环境搭建

1、角色概念

ZooKeeper 集群中的角色主要有三类：领导者（Leaner）、跟随者（Follower）和观察者（ObServer），后两者也叫学习者（Learner）

角色类型角色描述
领导者（Leaner）领导者负责进行投票的发起和决议，更新系统状态
跟随者（Follower）跟随者负责接收客户端请求并返回结果，在选举过程中参与投票
观察者（ObServer）观察者负责接收客户端连接，并将写请求转发给领导者节点。它不参与投票，只同步领导者的状态。其作用是为扩展系统，提高读的速度

在这里插入图片描述

2、集群搭建

zk集群最小安装需要3个节点，我们这里搭建伪集群（伪集群简单理解就是在一个Linux环境中创建多个zk服务，实际生产环境中我们肯定使用真实集群）
1、新建目录
在/usr/local目录下mkdir zookeepercluster创建一个目录，方便管理3个zk服务
2、创建3个zk服务
按照之前单机版的安装方式，在zookeepercluster目录下分别创建zookeeper01、zookeeper02、zookeeper03
解压：tar -zxvf apache-zookeeper-3.6.0-bin.tar.gz -C /usr/local/zookeepercluster/
重命名：mv apache-zookeeper-3.6.0-bin/ zookeeper01
复制：cp -r zookeeper01/ zookeeper02、cp -r zookeeper01/ zookeeper03

[root@localhost zookeepercluster]# ll
drwxr-xr-x. 8 root root 157 6月   7 04:19 zookeeper01
drwxr-xr-x. 8 root root 157 6月   7 04:19 zookeeper02
drwxr-xr-x. 8 root root 157 6月   7 04:19 zookeeper03

然后再分别复制zoo.cfg和创建data目录
3、dataDir配置修改
改为指定路径，如zookeeper01

dataDir=/usr/local/zookeepercluster/zookeeper01/data

4、提供应用唯一标识
在 zk 集群中需要为每个节点创建一个唯一标识（自然数），就是在我们之前创建的data/目录中创建一个myid 文件，并写入一个1或2的自然数（只要数字不同就行），那我们在zookeepercluster目录下执行如下命令，分别为3个节点创建1、2、3三个唯一标识

[root@localhost zookeepercluster]# echo 1 >> zookeeper01/data/myid
[root@localhost zookeepercluster]# echo 2 >> zookeeper02/data/myid
[root@localhost zookeepercluster]# echo 3 >> zookeeper03/data/myid

5、增加集群配置
zk集群除了本身客户端监听端口外，还需要使用投票端口和选举端口，我们这里如下分配
客户端监听端口分别为：2181、2182、2183
投票端口分别为：2184、2185、2186
选举端口分别为：2187、2188、2189
然后在每个zk的zoo.cfg中修改对应clientPort，再加上如下配置即可（ip要改）

server.1=ip:2184:2187
server.2=ip:2185:2188
server.3=ip:2186:2189

server.后面的数字指myid

3、服务启停

方式一：
每个节点执行./zkServer.sh start即可
方式二：
创建startall.sh和stopall.sh启停脚本，内容分别如下

zookeeper01/bin/zkServer.sh start
zookeeper02/bin/zkServer.sh start
zookeeper03/bin/zkServer.sh start

zookeeper01/bin/zkServer.sh stop
zookeeper02/bin/zkServer.sh stop
zookeeper03/bin/zkServer.sh stop

对两个脚本授权：
chmod 777 st*（777 表示文件可读可写可执行）
启动服务（记得先停掉之前单机版2181端口服务，避免端口冲突）

[root@localhost zookeepercluster]# ./startall.sh 
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeepercluster/zookeeper01/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeepercluster/zookeeper02/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
ZooKeeper JMX enabled by default
Using config: /usr/local/zookeepercluster/zookeeper03/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED

4、客户端连接

在任意一个zk节点的bin目录下，执行./zkCli.sh -server ip:port命令即可

四、常用操作命令

1、ls命令

ls命令查看节点，格式：ls /path
查看根节点

[zk: 192.168.xx.xxx:2181(CONNECTED) 0] ls /
[zookeeper]

path不能少，否则无法执行（这点与linux不一样）

[zk: 192.168.xx.xxx:2181(CONNECTED) 1] ls
ls [-s] [-w] [-R] path

2、create命令

create命令创建节点，格式：create [-e] [-s] /path [data]，-e表示临时节点，-s表示带顺序，/path表示路径，data表示写入节点的数据。
持久化无序号节点：create /path data（退出客户端后数据仍然存在）

[zk: 192.168.xx.xxx:2181(CONNECTED) 3] create /testnodeA helloA
Created /testnodeA
[zk: 192.168.xx.xxx:2181(CONNECTED) 4] ls /
[testnodeA, zookeeper]

持久化有序号节点：create -s /path data

[zk: 192.168.xx.xxx:2181(CONNECTED) 5] create -s /testnodeB helloB
Created /testnodeB0000000002
[zk: 192.168.xx.xxx:2181(CONNECTED) 6] ls /
[testnodeA, testnodeB0000000002, zookeeper]

临时的无序号节点：create -e /path data（退出客户端后数据会自动删除【有延时】）

[zk: 192.168.xx.xxx:2181(CONNECTED) 7] create -e /tempnodeA helloA
Created /tempnodeA
[zk: 192.168.xx.xxx:2181(CONNECTED) 8] ls /
[tempnodeA, testnodeA, testnodeB0000000002, zookeeper]

临时的有序号解决：create -e -s /path data

[zk: 192.168.xx.xxx:2181(CONNECTED) 2] create -e -s /tempnode helloB
Created /tempnode0000000004
[zk: 192.168.xx.xxx:2181(CONNECTED) 3] ls /
[tempnode0000000004, testnodeA, testnodeB0000000002, zookeeper]

3、get命令

get命令获取节点数据，格式：get [-s] /path，-s表示获取详细信息
获取数据：get /path

[zk: 192.168.xx.xxx:2181(CONNECTED) 4] get /testnodeA
helloA

获取详细信息：get -s /path

[zk: 192.168.xx.xxx:2181(CONNECTED) 5] get -s /testnodeA
helloA
cZxid = 0x200000008
ctime = Sun Jun 07 07:48:56 GMT 2020
mZxid = 0x200000008
mtime = Sun Jun 07 07:48:56 GMT 2020
pZxid = 0x200000008
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 6
numChildren = 0

详细信息说明

名称描述
helloA数据本身
cZxid创建时 zxid(znode 每次改变时递增的事务 id)
ctime创建时间
mZxid最近一次更近的 zxid
mtime最新更新时间
pZxid子节点的 zxid，如果没有子节点，则就是本身节点的值
cversion子节点更新次数
dataversion节点数据更新次数
aclVersion节点 ACL(授权信息)的更新次数
ephemeralOwner如果该节点为 ephemeral 节点(临时，生命周期与session一样)，ephemeralOwner 值表示与该节点绑定的sessionid。 如果该节点不是 ephemeral 节点，ephemeralOwner值为0

4、set命令

set命令往无数据节点写入数据或修改节点中的数据，格式：set /path [data]
往无数据节点写入数据

[zk: 192.168.xx.xxx:2181(CONNECTED) 7] create /testnodeB
Created /testnodeB
[zk: 192.168.xx.xxx:2181(CONNECTED) 8] get /testnodeB
null
[zk: 192.168.xx.xxx:2181(CONNECTED) 9] set /testnodeB haha
[zk: 192.168.xx.xxx:2181(CONNECTED) 10] get /testnodeB
haha

修改节点中的数据

[zk: 192.168.xx.xxx:2181(CONNECTED) 11] set /testnodeB heihei
[zk: 192.168.xx.xxx:2181(CONNECTED) 12] get /testnodeB
heihei

5、delete命令

delete删除节点命令，格式：delete /path

[zk: 192.168.xx.xxx:2181(CONNECTED) 13] delete /testnodeB
[zk: 192.168.xx.xxx:2181(CONNECTED) 14] ls /
[tempnode0000000004, testnodeA, testnodeB0000000002, zookeeper]

五、Java API调用ZooKeeper（实现节点增删改查）

1、引入pom依赖

这里要注意引入的版本，因为我安装的3.6.0的zk，所有引入的也是这个版本的依赖

	<!-- 引入zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.6.0</version>
		</dependency>

2、创建节点

新建一个TestZK测试类，这里主要有三个步骤
第一，实现Watcher 接口事件通知回调方法
第二，创建ZooKeeper 连接对象，里面需要3个参数，connectString是zk服务连接串（集群逗号隔开），sessionTimeout 是连接超时时间
第三，编写创建节点的createNode()方法，第一个参数为节点名称，第二为写入节点的数据，第四个指定节点类型（这里是持久化顺序编号节点）

package com.example.demo.utils;

import org.apache.zookeeper.*;

/**
 * zookeeper节点增删改成操作
 */
public class TestZK implements Watcher {

    /**
     * 事件通知回调方法
     * @param watchedEvent
     */
    @Override
    public void process(WatchedEvent watchedEvent) {
        if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
            System.out.println("connection success");
        }
    }

    public static void main(String[] args) throws Exception{

        //1.创建连接对象
        String connectString = "192.168.xx.xxx:2181,192.168.xx.xxx:2182,192.168.xx.xxx:2183"; //服务连接串，集群逗号隔开
        int sessionTimeout = 150000;//连接超时时间 （毫秒）
        ZooKeeper zooKeeper = new ZooKeeper(connectString, sessionTimeout, new TestZK());

       //2.创建一个znode节点
        createNode( zooKeeper);
    }


    /**
     * 创建一个znode节点
     * 在根节点下创建一个 javaTest 节点，写入数据 hello
     * @param zooKeeper
     */
    public static void createNode(ZooKeeper zooKeeper) throws Exception{
        String path = zooKeeper.create("/javaTest","hello".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println(path);
    }

}

启动mian方法之前，要先开启3zk服务的端口防火墙，否则连不上，命令如下

[root@localhost zookeepercluster]# firewall-cmd --zone=public --add-port=2181-2183/tcp --permanent
success
[root@localhost zookeepercluster]# firewall-cmd --reload
success

测试，控制台打印connection success，并输出新建的节点路径/javaTest0000000008

connection success
19:50:33.632 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20006, packet:: clientPath:null serverPath:null finished:false header:: 1,1  replyHeader:: 1,8589934623,0  request:: '/javaTest,#68656c6c6f,v{s{31,s{'world,'anyone}}},2  response:: '/javaTest0000000008 
/javaTest0000000008

查看zk服务中的节点，javaTest0000000008已创建成功

[zk: 192.168.xx.xxx:2181(CONNECTED) 5] ls /
[javaTest0000000008, testnodeA, testnodeB0000000002, zookeeper]

3、查询节点

1、查询指定节点数据
创建getOneNode()方法，查询javaTest0000000008节点的数据

/**
     * 查询指定节点数据
     * @param zooKeeper
     * @throws Exception
     */
    public static void getOneNode(ZooKeeper zooKeeper) throws Exception{
        byte[] data= zooKeeper.getData("/javaTest0000000008",new TestZK(),new Stat());
        System.out.println(new String(data));
    }

在main方法中调用

getOneNode(zooKeeper);

效果如下，获得了hello值

connection success
20:02:13.384 [main-SendThread(192.168.xx.128:2182)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x20000dc561e0001, packet:: clientPath:null serverPath:null finished:false header:: 1,4  replyHeader:: 1,8589934625,0  request:: '/javaTest0000000008,T  response:: #68656c6c6f,s{8589934623,8589934623,1591530633906,1591530633906,0,0,0,0,5,0,8589934623} 
hello

2、查询某个节点下所有子节点数据
创建getNodeList()方法，查询根节点下所有子节点中的数据

/**
     * 查询某个节点下所有子节点数据
     * @param zooKeeper
     * @throws Exception
     */
    public static void getNodeList(ZooKeeper zooKeeper) throws Exception{
        List<String> list = zooKeeper.getChildren("/",new TestZK());
        for(String path :list){
            byte[] data= zooKeeper.getData("/"+path,new TestZK(),null);
            System.out.println(new String(data));
        }
    }

效果如下，获得了多个节点的值

connection success
20:04:40.692 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20007, packet:: clientPath:null serverPath:null finished:false header:: 1,8  replyHeader:: 1,8589934627,0  request:: '/,T  response:: v{'zookeeper,'testnodeA,'testnodeB0000000002,'javaTest0000000008} 
20:04:40.711 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20007, packet:: clientPath:null serverPath:null finished:false header:: 2,4  replyHeader:: 2,8589934627,0  request:: '/zookeeper,T  response:: ,s{0,0,0,0,0,-2,0,0,0,2,0} 

20:04:40.717 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20007, packet:: clientPath:null serverPath:null finished:false header:: 3,4  replyHeader:: 3,8589934627,0  request:: '/testnodeA,T  response:: #68656c6c6f41,s{8589934600,8589934600,1591516136816,1591516136816,0,0,0,0,6,0,8589934600} 
helloA
20:04:40.722 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20007, packet:: clientPath:null serverPath:null finished:false header:: 4,4  replyHeader:: 4,8589934627,0  request:: '/testnodeB0000000002,T  response:: #68656c6c6f42,s{8589934601,8589934601,1591516195796,1591516195796,0,0,0,0,6,0,8589934601} 
helloB
20:04:40.727 [main-SendThread(192.168.xx.128:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply session id: 0x10000dc55e20007, packet:: clientPath:null serverPath:null finished:false header:: 5,4  replyHeader:: 5,8589934627,0  request:: '/javaTest0000000008,T  response:: #68656c6c6f,s{8589934623,8589934623,1591530633906,1591530633906,0,0,0,0,5,0,8589934623} 
hello

4、修改节点

创建setNode()方法，将/javaTest0000000008节点中的值更新为update hello

/**
     * 设置node中的值
     * @param zooKeeper
     * @throws Exception
     */
    public static void setNode(ZooKeeper zooKeeper) throws Exception{
        Stat stat = zooKeeper.setData("/javaTest0000000008","update hello".getBytes(),-1);
        System.out.println(stat);
    }

效果如下，值已被更新

[zk: 192.168.xx.128:2181(CONNECTED) 7] get /javaTest0000000008
update hello

5、删除节点

创建deleteNode()方法，删除/javaTest0000000008节点

/**
     * 删除节点
     * @param zooKeeper
     * @throws Exception
     */
    public static void deleteNode(ZooKeeper zooKeeper) throws Exception{
        zooKeeper.delete("/javaTest0000000008",-1);
    }

6、完整代码

package com.example.demo.utils;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.util.List;

/**
 * zookeeper节点增删改成操作
 * pdfox
 */
public class TestZK implements Watcher {

    /**
     * 事件通知回调方法
     * @param watchedEvent
     */
    @Override
    public void process(WatchedEvent watchedEvent) {
        if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
            System.out.println("connection success");
        }
    }

    public static void main(String[] args) throws Exception{

        //1.创建连接对象
        String connectString = "192.168.xx.128:2181,192.168.xx.128:2182,192.168.xx.128:2183"; //服务连接串，集群逗号隔开
        int sessionTimeout = 150000;//连接超时时间 （毫秒）
        ZooKeeper zooKeeper = new ZooKeeper(connectString, sessionTimeout, new TestZK());

        //2.创建一个znode节点
        createNode( zooKeeper);

        //3.查询指定节点数据
//        getOneNode(zooKeeper);

        //4.查询某个节点下所有子节点数据
//        getNodeList(zooKeeper);

        //5.设置node中的值
//        setNode(zooKeeper);

        //6.删除节点
//        deleteNode(zooKeeper);

    }


    /**
     * 创建一个znode节点
     * 在根节点下创建一个 javaTest 节点，写入数据 hello
     * @param zooKeeper
     */
    public static void createNode(ZooKeeper zooKeeper) throws Exception{
        String path = zooKeeper.create("/javaTest","hello".getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println(path);
    }

    /**
     * 查询指定节点数据
     * @param zooKeeper
     * @throws Exception
     */
    public static void getOneNode(ZooKeeper zooKeeper) throws Exception{
        byte[] data= zooKeeper.getData("/javaTest0000000008",new TestZK(),new Stat());
        System.out.println(new String(data));
    }


    /**
     * 查询某个节点下所有子节点数据
     * @param zooKeeper
     * @throws Exception
     */
    public static void getNodeList(ZooKeeper zooKeeper) throws Exception{
        List<String> list = zooKeeper.getChildren("/",new TestZK());
        for(String path :list){
            byte[] data= zooKeeper.getData("/"+path,new TestZK(),null);
            System.out.println(new String(data));
        }
    }

    /**
     * 设置node中的值
     * @param zooKeeper
     * @throws Exception
     */
    public static void setNode(ZooKeeper zooKeeper) throws Exception{
        Stat stat = zooKeeper.setData("/javaTest0000000008","update hello".getBytes(),-1);
        System.out.println(stat);
    }

    /**
     * 删除节点
     * @param zooKeeper
     * @throws Exception
     */
    public static void deleteNode(ZooKeeper zooKeeper) throws Exception{
        zooKeeper.delete("/javaTest0000000008",-1);
    }
}

六、ZooKeeper实现注册中心服务（实例）

1、示例说明

在本例中，我们将使用 ZooKeeper 作为注册中心，实现客户端与服务端之间的RPC调用。

2、创建服务端

创建一个zkserver的maven项目作为服务端，它将提供一个getFromZkserver()查询接口，并且将接口发布到zk注册中心。（这里也要先引入zk的pom依赖）
ITestService接口

package service;

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * Remote表示定义了此接口为远程调用接口
 */
public interface ITestService extends Remote {

    /**
     * 模拟一个测试查询方法，给zkclient调用
     * @param s
     * @return
     * @throws RemoteException
     */
    String getFromZkserver(String s) throws RemoteException;

}

TestServiceImpl实现类

package service.impl;

import service.ITestService;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class TestServiceImpl extends UnicastRemoteObject implements ITestService {

    public TestServiceImpl() throws RemoteException {
    }

    public String getFromZkserver(String s) throws RemoteException {
        return "response from zkserver : request[" + s +"]";
    }
}

ServerApp主入口

import org.apache.zookeeper.*;
import service.ITestService;
import service.impl.TestServiceImpl;

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

/**
 * 服务端主入口
 */
public class ServerApp implements Watcher {

    /**
     * 事件通知回调方法
     * @param watchedEvent
     */
    public void process(WatchedEvent watchedEvent) {
        if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
            System.out.println("connection success !");
        }
    }

    /**
     * 主方法
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception{
        ITestService service = new TestServiceImpl();
        //1.通过LocateRegistry在本机上创建Registry
        LocateRegistry.createRegistry(8866);
        String url ="rmi://localhost:8866/getMsg";

        //2。使用Naming 绑定需要远程调用的方法。RMI(Remote Method Invocation) 远程方法调用
        Naming.bind(url,service);

        //3.创建连接对象
        ZooKeeper zooKeeper = new ZooKeeper("192.168.xx.128:2181,192.168.xx.128:2182,192.168.xx.128:2183"
                ,150000,new ServerApp());

        //4.将url信息放到zookeeper的节点中
        zooKeeper.create("/zkregister/testService",url.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        System.out.println("服务发布至zk注册中心成功");
    }
}

3、创建客户端

创建一个zkclient的maven项目作为客户端，它也定义了一个名为getFromZkserver()的查询接口，将从zk注册中心查询zkserver发布的接口实现。
ITestService接口

package service;

public interface ITestService {

    String getFromZkserver(String s);

}

ClientApp主入口

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

import java.rmi.Naming;

/**
 * 客户端主入口
 */
public class ClientApp implements Watcher {
    /**
     * 事件通知回调方法
     * @param watchedEvent
     */
    public void process(WatchedEvent watchedEvent) {
        if(watchedEvent.getState() == Event.KeeperState.SyncConnected){
            System.out.println("connection success !");
        }
    }

    /**
     * 主方法
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //1.创建连接对象
        ZooKeeper zooKeeper = new ZooKeeper("192.168.xx.128:2181,192.168.xx.128:2182,192.168.xx.128:2183",150000,new ClientApp());

        //2.通过指定节点获取zkserver中接口提供的url信息
        byte[] bytes = zooKeeper.getData("/zkregister/testService",new ClientApp(),null);
        String url = new String(bytes);

        //3.通过url找到zkserver中的远程调用对象
        ITestService usersService = (ITestService) Naming.lookup(url);

        //4.调用对象的方法
        String result = usersService.getFromZkserver("client request hello");
        System.out.println(result);

    }
}

4、调用验证

启动zkserver，接口服务成功发布到zk注册中心

connection success !
服务发布至zk注册中心成功

查看zk集群中的节点，可见节点和数据已经创建成功

[zk: 192.168.xx.128:2181(CONNECTED) 14] get /zkregister/testService
rmi://localhost:8866/getMsg

启动zkclient，调用zkserver中getFromZkserver()接口成功

connection success !
response from zkserver : request[client request hello];

至此，说明客户端与服务端之间已经可以通过zk注册中心进行正常RPC调用了。

结语

读到了这里，那我们对于ZooKeeper常见用法应该已经有整体性的认识了~

为谁攀登
关注
专栏目录
zookeeper简单使用
weixin_43313629的博客
02-29 257
zookeeper简介 端口：2181 功能：注册， 监听事件 回调函数 zookeeper模型 zk对外提供服务使用主从模型 redis的增删改都是在主节点 但是zk上客户端可以给follower送要求，但是从节点不能做决定，leader做决定，leader 广播命令是否执行，由follower投票，投票超过半数，则会真正执行。leader给follower发确认需求的时候，是先放在消息队列...
Zookeeper基本使用
風雨无阻
07-13 5878
Zookeeper基本使用1、Zookeeper系统模型2、Zookeeper命令行操作3、Zookeeper原生api使用4、Zookeeper开源客户端 1、Zookeeper系统模型 ZooKeeper数据模型Znode 在ZooKeeper中，数据信息被保存在⼀个个数据节点上，这些节点被称为znode。 ZNode 是Zookeeper 中最⼩数据单位，在 ZNode 下⾯⼜可以再挂 ZNode，这样⼀层层下去就形成了⼀个层次化命名空间 ZNode 树，我们称为 ZNode Tree，它采⽤了类似⽂
java zookeeper_Java学习之——Zookeeper
weixin_32620249的博客
02-12 629
一、 ZooKeeper 简介顾名思义 zookeeper 就是动物园管理员，他是用来管 hadoop(大象)、Hive(蜜蜂)、pig(小 猪)的管理员， Apache Hbase 和 Apache Solr 的分布式集群都用到了 zookeeper；Zookeeper: 是一个分布式的、开源的程序协调服务，是 hadoop 项目下的一个子项目。他提供的主要功 能包括：配置管理、名字服务、分布式...
【ZooKeeper】ZooKeeper快速入门
最新发布
Arcus
08-04 1118
主要是重新整理了整个zookeeper的重要知识点。
ZooKeeper的使用
xhh198781的专栏
09-13 6593
Zookeeper 作为一个分布式的服务框架，主要用来解决分布式集群中应用系统的一致性问题，它能提供基于类似于文件系统的目录节点树方式的数据存储，但是 Zookeeper 并不是用来专门存储数据的，它的作用主要是用来维护和监控你存储的数据的状态变化。通过监控这些数据状态的变化，从
七、ZooKeeper使用方式和常用解决方案
u011277123的博客
05-05 891
iscoder 2017-05-02 19:35 ZK高级实现指南 此文包含使用ZK实现高级定制功能的指南，所有这些功能都是在客户端实现的，而且并不需要ZK的特殊修改。希望社区可以看到这些客户端方面的的约定，使ZK的使用更优雅，并促使这成为一种标准。 关于ZK，一个最有意思的事情就是ZK使用异步通知，但是却可以构建同步一致性操作应用，例如队列和锁。如你所见，这是可行的，因为ZK更新时
RabbitMQ集群，kafka介绍，搭建ZooKeeper集群，zookeeper常见用法，部署kafka集群
qq_43798084的博客
04-16 2022
RabbitMQ集群 RabbitMQ本身是基于Erlang编写的，Erlang天生支持分布式（通过同步Erlang集群各节点的cookie来实现），因此不需要像Kafka那样通过ZooKeeper来实现分布式集群。 元数据 RabbitMQ内部有各种基础构件，包括队列、交换器、绑定、虚拟主机等，他们组成了AMQP协议消息通信的基础，而这些构件以元数据的形式存在 内存节点与磁...
zookeeper常见面试题
03-15
下面是关于 ZooKeeper 的一些常见面试题和知识点。 ZooKeeper 的使用场景 1. 分布式协调：ZooKeeper 可以实现分布式系统之间的协调工作，例如，在分布式系统中，A 系统发送请求到消息队列，然后 B 系统消费消息...
一文彻底理解ZooKeeper分布式锁的实现原理
01-20
《彻底理解ZooKeeper分布式锁实现原理》 ZooKeeper，简称zk，作为一个高可用的分布式协调服务，常被用于构建分布式系统中的各种组件，如分布式锁。在本篇文章中，我们将深入探讨如何利用Curator这个流行的开源框架...
zookeeper常见应用场景简单实现及ppt
03-26
1、master选举：mastersel 2、数据的发布和订阅：subscribe 3、负载均衡：balance 4、分布式锁：lock 5、分布式队列：queue 6、命名服务：nameservice 演示代码下载(代码来自极客学院演示demo)：
一文了解Zookeeper
南国的技术栈
04-26 664
前言 一直想找时间好好写一篇关于Zookeeper的博客，今夜窗外听取蛙声一片 既上一篇写到了分布式锁的几种实现方式。这里 整理自己的一些理解，写下一篇关于Zookeeper的博文。话不多说，干货送上~ Zookeeper概览 Zookeeper，中文名是动物园管理员。它是一个开源的分布式协调服务，ZooKeeper 框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。...
ZooKeeper 基本概念、使用方法、实践场景
08-22
ZooKeeper 基本概念、使用方法、实践场景ZooKeeper 基本概念、使用方法、实践场景
zookeeper基本使用
m0_65385133的博客
07-09 1248
zookeeper允许用户在指定节点上注册一些watcher,并且在一些特定事件触发的时候,zookeeper服务端会将时间通知到感兴趣的客户端上去,该机制是zookeeper实现分布式协调服务的重要特性。在进行单机应用开发的时候,涉及到并发同步的时候,我们使用synchronized或者lock的方式啦解决多线程代码同步问题,这里的多线程在同一个jvm之下,zookeeper引入了watche机制来实现了发布/定略功能,能够让多个定略者,同时监听某一个对象,当一个对象自身状态变化时,会通知到定略者。
Zookeeper的使用
weixin_42679286的博客
08-30 1564
分布式协调框架，小型的树形结构数据共享储存系统。zookeeper的应用场景集群管理注册中心配置中心发布者将数据发布到ZooKeeper一系列节点上面，订阅者进行数据订阅，当数据有变化时，可及时得到数据的变化通知。数据的发布/订阅分布式锁分布式队列负载均衡负载均衡是通过负载均衡算法，客户端负载均衡。
一文彻底搞懂Zookeeper
一个有趣、有料、有内涵的地方!
11-12 3848
本文是基于CentOS ...
Zookeeper简单使用
qq_51552268的博客
10-13 3104
zookeeper的简单使用
zookeeperAPI的常用方法
weixin_30307921的博客
10-12 127
zookeeper支持三种部署方式： 1 单机 2 集群 3 伪集群 删除节点 zkClient.delete(path); 转载于:https://www.cnblogs.com/domi22/p/9780733.html
zookeeper使用方法
letgoDream的博客
07-23 515
zookeeper安装 下载与配置 》http://mirrors.hust.edu.cn/apache/zookeeper 下载一个版本 》解压 》找到目录conf 下创建 zoo.cfg 文件，默认就是加载这个文件,然后修改些东西 #zoo.cfg 的内容 # 心跳检查的时间 2秒 tickTime=2000 # 初始化时 连接到服务器端的间...
Zookeeper-使用篇
qq_56571862的博客
01-19 2359
zookeeper+dubbo远程调用
zookeeper常见问题
05-05
以下是一些Zookeeper常见问题： 1. ZooKeeper是什么？ ZooKeeper是一个开源的分布式协调服务，可以用于管理和协调分布式应用程序的配置，元数据，状态等。 2. ZooKeeper如何工作？ ZooKeeper使用ZAB协议...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值