Spring Boot 搭配 zookeeper使用_zookeeper springboot 高级

导入jar包

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

普通方式连接：

package com.example.demo01.service;
​
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
​
import java.util.concurrent.CountDownLatch;
​
public class test1 {
    public static void main(String[] args) throws Exception {
    
        //计数器对象（初始值为1）
        CountDownLatch countDownLatch = new CountDownLatch(1);
        
        //创建zookeeper连接对象（地址:端口,超时自动关闭时间,重写监视器接口）
        ZooKeeper zookeeper = new ZooKeeper("192.168.17.119:2181", 3000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
            
                //判断event.getState()连接的状态是否为3
                //Event.KeeperState.SyncConnected的值为3
                if (event.getState() == Event.KeeperState.SyncConnected) {
                
                    System.out.println("连接成功");
                    
                    //计数器对象加1
                    countDownLatch.countDown();
                }
                
            }
        });
        
        // 等待zookeeper对象创建完成后执行
        countDownLatch.await();
        
        //获取zookeeper会话id
        System.out.println(zookeeper.getSessionId());
        
        //关闭zookeeper连接
        zookeeper.close();
    }
}

运行结果如下：

连接成功
72057788494839812

利用Watcher接口的实现类连接：

package com.example.demo01.service;
​
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.springframework.stereotype.Service;
​
import java.util.List;
import java.util.concurrent.CountDownLatch;
​
@Service
public class ZookeeperService implements Watcher{
​
    //zookeeper对象
    private ZooKeeper zookeeper;
    //超时时间
    private static final int SESSION_TIME_OUT = 5000;
    //计数器对象（初始值为1）
    private CountDownLatch countDownLatch = new CountDownLatch(1);
​
    @Override
    public void process(WatchedEvent event) {
        if (event.getState() == Event.KeeperState.SyncConnected) {
            System.out.println("连接成功！！！");
            // 计时器对象+1
            countDownLatch.countDown();
        }
    }
​
    //连接zookeeper(地址)
    public void connectZookeeper(String host) throws Exception{
        /*
        * host = 地址
        * SESSION_TIME_OUT = 超时关闭时间
        * this = 当前实现的Watcher监听端口
        * */
        zookeeper = new ZooKeeper(host, SESSION_TIME_OUT, this);
        // 主线程阻塞，等待连接对象创建成功
        countDownLatch.await();
    }
​
    /**
     * 创建节点
     * path = /node节点
     * data = data数据
     */
    public String createNode(String path,String data) throws Exception{
        /*
        * path = 地址
        * data.getBytes() = 将数据转换为字节数组格式
        * ZooDefs.Ids.OPEN_ACL_UNSAFE = 设置权限默认anyone
        * CreateMode.PERSISTENT = 创建新式
        * PERSISTENT = 永久节点
        * EPHEMERAL = 临时节点
        * PERSISTENT_SEQUENTIAL = 临时无序列节点
        * EPHEMERAL_SEQUENTIAL = 临时有序节点
        * */
        //返回创建的节点名称
        return this.zookeeper.create(path,data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
    }
​
    /**
     * 获取路径下所有子节点
     * path = /node节点
     */
    public List<String> getChildren(String path) throws KeeperException, InterruptedException{
        /*
        * path = /node节点
        * false = 不启用监视
        * true = 启用监视
        * */
        List<String> children = zookeeper.getChildren(path, false);
        //返回该节点下的所有子节点，返回值类型为list
        return children;
    }
​
    /**
     * 获取节点的数据
     * path = /node节点
     */
    public String getData(String path) throws KeeperException, InterruptedException{
        /*
        * path = /node节点
        * false = 不启用监视
        * true = 启用监视
        * new Stat() = 括号里面设置参数就获取对应的节点信息
        * */
        byte[] data = zookeeper.getData(path, false, new Stat());
        //判断返回的”[B@2af46afd“是否为空
        if (data == null) {
            //为空就renturn
            return "";
        }
        //返回经过string处理的值[B@2af46afd，结果为节点的参数（llh）
        return new String(data);
    }
​
    /**
     * 设置节点信息
     * path = 路径
     * data = 数据
     */
    public Stat setData(String path,String data) throws KeeperException, InterruptedException{
        /*
        * path = /node节点
        * data.getBytes() = 将数据转换为字节数组格式
        * -1 = 代表修改的版本号
        * */
        Stat stat = zookeeper.setData(path, data.getBytes(), -1);
        // 返回获取该节点的值
        return stat;
    }
​
    /**
     * 删除节点
     * path = /node节点
     */
    public void deleteNode(String path) throws InterruptedException, KeeperException{
        /*
         * path = /node节点
         * -1 = 代表修改的版本号
         * */
        zookeeper.delete(path, -1);
    }
​
    /**
     * 获取创建时间
     * path = /node节点
     */
    public String getCTime(String path) throws KeeperException, InterruptedException{
        /*
        * path = /node节点
        * false = 不启用监视
        * true = 启用监视
        * */
        //返回的是一个stat对象，stat对象包含的-s的信息
        Stat stat = zookeeper.exists(path, false);
        //返回根据stat信息对象获取创建时间
        return String.valueOf(stat.getCtime());
    }
​
    /**
     * 获取某个路径下孩子的数量
     * path = /node节点
     */
    public Integer getChildrenNum(String path) throws KeeperException, InterruptedException{
        /*
         * path = /node节点
         * false = 不启用监视
         * true = 启用监视
         * */
        // 返回，一个获取该节点的，所有子字节的，一个list集合，然后点size()方法就可以获取到list长度信息
        return zookeeper.getChildren(path, false).size();
    }
​
    /**
     * 关闭连接
     * @throws InterruptedException
     */
    public void closeConnection() throws InterruptedException{
        // 判断zookeeper连接对象是否为空，为空就关闭
        if (zookeeper != null) {
            zookeeper.close();
        }
    }
}

​注：

new Stat()对象包含参数入下:
    private long czxid;
    private long mzxid;
    private long ctime;
    private long mtime;
    private int version;
    private int cversion;
    private int aversion;
    private long ephemeralOwner;
    private int dataLength;
    private int numChildren;
    private long pzxid;

测试实现类的方法：

package com.example.demo01;
​
import com.example.demo01.service.ZookeeperService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
​
@SpringBootTest
class Demo01ApplicationTests {
​
    @Autowired
    ZookeeperService zookeeperService;
​
    @Test
    void t1() throws Exception {
        //先连接
        zookeeperService.connectZookeeper("192.168.17.119:2181");
​
        //创建
        System.out.println(zookeeperService.createNode("/name", "llh"));
​
        //获取
        System.out.println(zookeeperService.getData("/name"));
​
        //修改
        System.out.println(zookeeperService.setData("/name", "liaolihui"));
​
        //删除
        zookeeperService.deleteNode("/name");
    }
}

​

zookeeper配置集群：

第一步
​
解压3个zookeeper.tar的文件，分别取为（zk1,zk2,zk2）
​
第二步
分别进入（zk1,zk2,zk2） 给他们创建一个data文件夹
​
第三步
分别进入（zk1,zk2,zk2）的data文件夹里面创建myid文件，依次写入[1，2，3]
​
第四步
分别进入（zk1,zk2,zk2）的conf文件夹，分别复制zoo_sample.cfg一份，取名为zoo.cfg
​
第五步
分别进入（zk1,zk2,zk2）的zoo.cfg文件，修改"端口"，和添加,
"server.myid的参数=zk服务器的ip:服务器之间通信端口:服务器之间投票选举主机端口"
​
第六步
分别启动各个服务器

注：

运行./zkServer.sh status

• Leader（主节点、领导）

• Follower（从节点、跟随者、下属）

• Observer（从节点、观察者、下属）

遇到的问题总结：

报错？

• 解决1：检查各服务器的data文件是否一致

• 解决2：尽量同时启动，因为会检索各服务器

如果主机挂了？

• 首先重新选举leader,再正常对外服务

• 大概原理：会比较zxid事务id，谁最大有几率成为主机，如果zxid相同时，则比较他们的myid的值