
tickTime=2000
dataDir=X:\\mygreensoftware\\apache-zookeeper-3.8.1-bin\\tmp\\data
dataLogDir=X:\\mygreensoftware\\apache-zookeeper-3.8.1-bin\\tmp\\logs
clientPort=2181

创建设置的目录

双击启动。。

3 排错

wc,闪卡了！！

别急我们可能是JAVA_HOME没有配置好，我们进入环境变量配置JAVA_HOME

注意这里是jdk的主路径，不带bin奥！！

ok，再次启动试试，好了，这次没有问题了

在SpringBoot中的使用

安装可视化插件

侧边

新建连接

127.0.0.1:2181

然后点击connect

依赖配置


<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.6</version>
</dependency>


zookeeper: 
  server: 127.0.0.1:2181
  timeout: 3000

配置类


package com.scm.springbootzookper.config;
 
import org.apache.zookeeper.ZooKeeper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import java.io.IOException;
 
@Configuration
public class ZookeeperConfig {
    @Value("${zookeeper.server}")
    private String server;
 
    @Value("${zookeeper.timeout}")
    private Integer timeout;
 
    @Bean
    public ZooKeeper zkClient() throws IOException {
        return new ZooKeeper(server, timeout, watchedEvent -> {});
    }
}

安装httpclient方便测试

可参照以下

https://blog.csdn.net/qq_53679247/article/details/130841001

增删查改

新建控制器


package com.scm.springbootzookper.controller;
 
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooKeeper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
@RestController
@RequestMapping("/api")
public class ZookController {
 
    @Autowired
    ZooKeeper zkClient;
 
    @GetMapping("/zookeeper")
    public String getData() throws KeeperException, InterruptedException {
        String path = "/zookeeper";
        boolean watch = true;
        byte[] data = zkClient.getData(path, watch, null);
        return new String(data);
    }
 
}

使用http client测试

创建节点

API

public String create(final String path, byte data[], List<ACL> acl, CreateMode createMode)

path ZNode路径
data ZNode存储的数据
acl ACL权限控制
createMode ZNode类型


    @GetMapping("/addNode/{nodename}/{data}")
    public String addNode(@PathVariable("nodename")String nodename, @PathVariable("data") String data1){
        // 创建节点的路径
        String path = "/"+nodename;
        // 节点数据
        String data =data1;
        // 权限控制
        List<ACL> aclList = ZooDefs.Ids.OPEN_ACL_UNSAFE;
        // 创建节点的类型
        CreateMode createMode = CreateMode.PERSISTENT;
 
        String result = null;
        try {
            result = zkClient.create(path, data.getBytes(), aclList, createMode);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return result;
    }

httpclent 环境数据


{
  "dev": {
    "name": "value",
    "test": "test",
    "nodename": "node1",
    "data": "我是测试数据1"
  }
}

查询节点


    @GetMapping("/getData/{nodename}")
    public String getData(@PathVariable("nodename") String nodename){
        //数据的描述信息，包括版本号，ACL权限，子节点信息等等
        Stat stat = new Stat();
        //返回结果是byte[]数据，getData()方法底层会把描述信息复制到stat对象中
        byte[] bytes;
        String path="/"+nodename;
        try {
            bytes = zkClient.getData(path, false, stat);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        //打印结果
        System.out.println("ZNode的数据data:" + new String(bytes));//Hello World
        System.out.println("获取到dataVersion版本号:" + stat.getVersion());//默认数据版本号是0
        return new String(bytes);
    }

更新节点

删除和更新操作，必须获取到版本号才能进行修改


    @GetMapping("/setData/{nodename}/{data}")
    public String setData(@PathVariable("nodename")String nodename, @PathVariable("data") String data1){
        String path = "/"+nodename;
        String data = data1;
        int version = 0;
 
        Stat stat = null;
        try {
            stat = zkClient.setData(path, data.getBytes(), version);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return stat.toString();
    }

删除节点


    
    @GetMapping("/deleteNode/{nodename}")
    public String deleteNode(@PathVariable("nodename")String nodename){
        String path = "/"+nodename;
        int version = 0;
        try {
             zkClient.delete(path, version);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return "OK!";
    }

使用监听

新建监听器


package com.scm.springbootzookper.watch;
 
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.springframework.stereotype.Component;
 
@Component
public class MyWatcher implements Watcher {
    @Override
    public void process(WatchedEvent watchedEvent) {
        Event.KeeperState state = watchedEvent.getState();
        Event.EventType type = watchedEvent.getType();
        System.out.println("检测到节点发生变化.....");
        System.out.println("节点名称:"+state.name());
        System.out.println("事件类型:"+type.name());
        System.out.println("节点路径"+watchedEvent.getPath());
 
    }
}

更改控制器中的方法。


    @GetMapping("/setData/{nodename}/{data}")
    public String setData(@PathVariable("nodename")String nodename, @PathVariable("data") String data1) throws InterruptedException, KeeperException {
        String path = "/"+nodename;
        zkClient.exists(path, new MyWatcher());
        String data = data1;
        // 这里必须先拿到版本号才能更新
        int version =5;
 
        Stat stat = null;
        try {
            stat = zkClient.setData(path, data.getBytes(), version);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return stat.toString();
    }

使用httpclient请求，结果如下

注意事项

需要注意的是，注册一次监听器只能使用一次，使用完就失效了。

串行执行。客户端Watcher回调的过程是一个串行同步的过程，这是为了保证顺序。

业务使用

判断通知时节点的更改类型，进行其他操作。


package com.scm.springbootzookper.watch;
 
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.springframework.stereotype.Component;
 
@Component
public class MyWatcher implements Watcher {
    @Override
    public void process(WatchedEvent watchedEvent) {
        Event.KeeperState state = watchedEvent.getState();
        Event.EventType type = watchedEvent.getType();
        if (Event.EventType.NodeDataChanged.getIntValue()==type.getIntValue()) {
            System.out.println("节点被修改了！");
        }
        if (Event.EventType.NodeDeleted.getIntValue()==type.getIntValue()) {
            System.out.println("节点被删除了！");
        }
        System.out.println("检测到节点发生变化.....");
        System.out.println("节点名称:"+state.name());
        System.out.println("事件类型:"+type.name());
        System.out.println("节点路径"+watchedEvent.getPath());
 
    }
}

可以进行一些业务操作。

以下是Watch接口的源码，我们可以注意到其中的枚举类型，


//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
 
package org.apache.zookeeper;
 
public interface Watcher {
    void process(WatchedEvent var1);
 
    public interface Event {
        public static enum EventType {
            None(-1),
            NodeCreated(1),
            NodeDeleted(2),
            NodeDataChanged(3),
            NodeChildrenChanged(4);
 
            private final int intValue;
 
            private EventType(int intValue) {
                this.intValue = intValue;
            }
 
            public int getIntValue() {
                return this.intValue;
            }
 
            public static EventType fromInt(int intValue) {
                switch (intValue) {
                    case -1:
                        return None;
                    case 0:
                    default:
                        throw new RuntimeException("Invalid integer value for conversion to EventType");
                    case 1:
                        return NodeCreated;
                    case 2:
                        return NodeDeleted;
                    case 3:
                        return NodeDataChanged;
                    case 4:
                        return NodeChildrenChanged;
                }
            }
        }
 
        public static enum KeeperState {
            /** @deprecated */
            @Deprecated
            Unknown(-1),
            Disconnected(0),
            /** @deprecated */
            @Deprecated
            NoSyncConnected(1),
            SyncConnected(3),
            AuthFailed(4),
            ConnectedReadOnly(5),
            SaslAuthenticated(6),
            Expired(-112);
 
            private final int intValue;
 
            private KeeperState(int intValue) {
                this.intValue = intValue;
            }
 
            public int getIntValue() {
                return this.intValue;
            }
 
            public static KeeperState fromInt(int intValue) {
                switch (intValue) {
                    case -112:
                        return Expired;
                    case -1:
                        return Unknown;
                    case 0:
                        return Disconnected;
                    case 1:
                        return NoSyncConnected;
                    case 3:
                        return SyncConnected;
                    case 4:
                        return AuthFailed;
                    case 5:
                        return ConnectedReadOnly;
                    case 6:
                        return SaslAuthenticated;
                    default:
                        throw new RuntimeException("Invalid integer value for conversion to KeeperState");
                }
            }
        }
    }
}

END.........

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/blog/article/detail/53994

ZooKeeper快速入门学习+在springboot中的应用+监听机制的业务使用_zookeeper在spring项目中的应用

前言

基础知识

一、什么是ZooKeeper

二、为什么使用ZooKeeper

三、数据结构

四、监听通知机制

五、选举机制

使用

1 下载zookeeper

2 修改