Zookeeper-05-ZK的分布式配置实例（watch监控）

最新推荐文章于 2024-07-24 10:02:34 发布
最新推荐文章于 2024-07-24 10:02:34 发布
阅读量473 收藏
点赞数
分类专栏： # zookeeper 文章标签： zookeeper 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694906/article/details/124642802
版权

文章目录

1：何为分布式配置监控

在这里插入图片描述
如图：当我们在分布式系统中，如果多个客户端（服务器）同时采用某些配置。那么当配置更改时，我们需要通过心跳等方式来主动监测它。那么有没有一种方式是当数据改变时主动通知我们；那么zookeeper就可以办到；

2：实例编码

1：开发分析

1：场景，开发一个测试程序，模拟客户端监控数据，当某个数据存在时不断输出，当数据更改时，输出最新值，当数据丢失时，线程阻塞。
2：此次开发采用响应式编程
3：此次开发的前提是你已经知道了zk客户端的基本使用；如果不会，建议读取这篇文章Zookeeper-04-ZK的API基本使用
4:开发程序类目录说明
在这里插入图片描述
5：因为采用响应式编程，异步处理来回跳转比较烧脑，我尽量每一步把所有的代码都粘贴出来；希望不要因为代码太多影响大家观感；

2：创建zk实例

1：创建测试类，测试类前置调用获取zk实例

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");
    }
}

2：zk实例由ZKUtils封装的静态方法获取，因为zk连接是异步的，此处利用CountDownLatch 来实现同步阻塞

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Description:获取zk实例
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class ZKUtils {

    private  static ZooKeeper zk;
    //在端口号后边加/testConfig,表示后续在程序中使用的根节点为testConfig
    private static String adress = "192.168.138.128:2181/testConfig";
    private static int timeout = 3000;

    private  static  DefaultWatch defaultWatch = new DefaultWatch();
    private static CountDownLatch downLatch = new CountDownLatch(1);

    public static ZooKeeper getZK(){
        try {
            zk = new ZooKeeper(adress,timeout,defaultWatch);
            defaultWatch.setCd(downLatch);
            //因为zk连接是异步的，此处采用CountDownLatch
            downLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return zk;
    }
}

3：因为zk实例连接时要设置监听器，正好在监听器中设置countDown

package com.example.zookeeperdemo.zookeeper.confog_wkl;

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

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class DefaultWatch implements Watcher {

    CountDownLatch cd;

    public CountDownLatch getCd() {
        return cd;
    }

    public void setCd(CountDownLatch cd) {
        this.cd = cd;
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        switch (watchedEvent.getState()) {
            case Unknown:
                break;
            case Disconnected:
                break;
            case NoSyncConnected:
                break;
            case SyncConnected:
                System.out.println("zk连接成功了");
                //成功建立连接后放行
                cd.countDown();
                break;
            case AuthFailed:
                break;
            case ConnectedReadOnly:
                break;
            case SaslAuthenticated:
                break;
            case Expired:
                break;
        }
    }
}

在这里插入图片描述

3:查看当前节点是否存在

 package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");

        //因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的
        WatchCallBack watchCallBack = new WatchCallBack();

        //查看当前节点是否存在,参数需要一个监控器和异步回调器
        zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
    }
}

因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class WatchCallBack implements Watcher, AsyncCallback.StatCallback, AsyncCallback.DataCallback {

    ZooKeeper zk;

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    //查询状态回调器
    @Override
    public void processResult(int i, String s, Object o, Stat stat) {
        if(stat !=null){
            //不等于null，代表有数据
            zk.getData("/AppConf",this,this,"ABC");
        }
    }

    //监控器
    @Override
    public void process(WatchedEvent watchedEvent) {

    }

    //获取数据回调器
    @Override
    public void processResult(int i, String s, Object o, byte[] bytes, Stat stat) {

    }
}

4:当监控存在时，读取数据

当该节点存在时，从该节点读取数据

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");

        //因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的
        WatchCallBack watchCallBack = new WatchCallBack();
        MyConf myConf = new MyConf();

        watchCallBack.setZk(zk);
        watchCallBack.setConf(myConf);
        CountDownLatch countDownLatch = new CountDownLatch(1);


        //查看当前节点是否存在,参数需要一个监控器和异步回调器
        zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
        watchCallBack.setCountDownLatch(countDownLatch);
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

		zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
		countDownLatch.await();
		
        
    }
}

并将该数据存入myconf这个类中

package com.example.zookeeperdemo.zookeeper.confog_wkl;


import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class WatchCallBack implements Watcher, AsyncCallback.StatCallback, AsyncCallback.DataCallback {

    ZooKeeper zk;
    MyConf conf ;
    CountDownLatch countDownLatch;

    public MyConf getConf() {
        return conf;
    }

    public void setConf(MyConf conf) {
        this.conf = conf;
    }

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    //查询状态回调器
    @Override
    public void processResult(int i, String s, Object o, Stat stat) {
        if(stat !=null){
            //不等于null，代表有数据
            zk.getData("/AppConf",this,this,"ABC");           

        }
    }

    //监控器
    @Override
    public void process(WatchedEvent watchedEvent) {

    }

    //获取数据回调器
    @Override
    public void processResult(int i, String s, Object o, byte[] bytes, Stat stat) {
        if(bytes!=null){
            String data = new String(bytes);
            //将数据存入myconf
            conf.setName(data);
            //当拿到数据后，countDown
            countDownLatch.countDown();
        }
    }
}


package com.example.zookeeperdemo.zookeeper.confog_wkl;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class MyConf {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

5:写监控程序

代码中读取数据和查看节点都是用了同一个监控，那么我们可以同一个监控，对不同的监控类型做出处理，此处采用在节点数据改变和没有发现节点时，在此调用getData方法，这个方法可以可以一直循环监控数据

 //监控器
    @Override
    public void process(WatchedEvent watchedEvent) {
        switch (watchedEvent.getType()) {
            case None:
                break;
            case NodeCreated:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeDeleted:
                //容忍性
                conf.setName("");
                countDownLatch = new CountDownLatch(1);
                break;
            case NodeDataChanged:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeChildrenChanged:
                break;
        }
    }

6:优化代码-当无值的时候直接持续查询是否有值

我们优化一下代码，当myConf中没有值得时候让线程阻塞等待，等待有值得时候直接输出

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");

        //因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的
        WatchCallBack watchCallBack = new WatchCallBack();
        MyConf myConf = new MyConf();

        watchCallBack.setZk(zk);
        watchCallBack.setConf(myConf);
        CountDownLatch countDownLatch = new CountDownLatch(1);


        //查看当前节点是否存在,参数需要一个监控器和异步回调器
        zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
        watchCallBack.setCountDownLatch(countDownLatch);
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        while (true){
            if(myConf.getName()==""){
                zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                System.out.println("读取的节点数据："+myConf.getName());
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

7:进行测试

1：事先创建根节点testConfig和AppConf
在这里插入图片描述
2：启动程序，读取appcong节点数据
在这里插入图片描述
3：更改节点新的值后：
在这里插入图片描述

8：最后优化，将所有方法包装起来，值暴露给业务类方法类

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");

        //因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的
        WatchCallBack watchCallBack = new WatchCallBack();
        MyConf myConf = new MyConf();

        watchCallBack.setZk(zk);
        watchCallBack.setConf(myConf);
        CountDownLatch countDownLatch = new CountDownLatch(1);


//        //查看当前节点是否存在,参数需要一个监控器和异步回调器
//        zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
//        watchCallBack.setCountDownLatch(countDownLatch);
//        try {
//            countDownLatch.await();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//
//        while (true){
//            if(myConf.getName()==""){
//                zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
//                try {
//                    countDownLatch.await();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                try {
//                    countDownLatch.await();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }else {
//                System.out.println("读取的节点数据："+myConf.getName());
//            }
//
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }



        //查看当前节点是否存在,参数需要一个监控器和异步回调器
        watchCallBack.aWait();
        //1，节点不存在
        //2，节点存在

        while(true){

            if(myConf.getName().equals("")){
                System.out.println("conf diu le ......");
                watchCallBack.aWait();
            }else{
                System.out.println(myConf.getName());

            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package com.example.zookeeperdemo.zookeeper.confog_wkl;


import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class WatchCallBack implements Watcher, AsyncCallback.StatCallback, AsyncCallback.DataCallback {

    ZooKeeper zk;
    MyConf conf ;
    CountDownLatch countDownLatch = new CountDownLatch(1) ;

    public CountDownLatch getCountDownLatch() {
        return countDownLatch;
    }

    public void setCountDownLatch(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    public MyConf getConf() {
        return conf;
    }

    public void setConf(MyConf conf) {
        this.conf = conf;
    }

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    public void aWait(){
        zk.exists("/AppConf",this,this ,"ABC");
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //查询状态回调器
    @Override
    public void processResult(int i, String s, Object o, Stat stat) {
//        System.out.println("是否查询到值："+stat);
        if(stat !=null){
            //不等于null，代表有数据
            zk.getData("/AppConf",this,this,"ABC");

        }
    }

    //监控器
    @Override
    public void process(WatchedEvent watchedEvent) {
        switch (watchedEvent.getType()) {
            case None:
                break;
            case NodeCreated:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeDeleted:
                //容忍性
                conf.setName("");
                countDownLatch = new CountDownLatch(1);
                break;
            case NodeDataChanged:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeChildrenChanged:
                break;
        }
    }

    //获取数据回调器
    @Override
    public void processResult(int i, String s, Object o, byte[] bytes, Stat stat) {
//        System.out.println("是否读取到值："+new String(bytes));
        if(bytes!=null){
            String data = new String(bytes);
            //将数据存入myconf
            conf.setName(data);
            //当拿到数据后，countDown
            countDownLatch.countDown();
        }
    }
}

3:附录：全部代码

响应式难度到时不难，就是编程太绕了，我贴上全部代码，希望能帮助大家看懂；与君共勉！
在这里插入图片描述

TestZk测试类

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:10
 * author:     wangkanglu
 * version:    V1.0
 */
public class TestZk {

    ZooKeeper zk;

    //前置程序主要是为了获得zk连接
    @Before
    public void conn(){
        zk=ZKUtils.getZK();
    }

    @After
    public void colse(){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test(){
        System.out.println("start----------");

        //因为zk获取数据和查询数据都需要一个监控器和回调器，干脆做成一个公共的
        WatchCallBack watchCallBack = new WatchCallBack();
        MyConf myConf = new MyConf();

        watchCallBack.setZk(zk);
        watchCallBack.setConf(myConf);
        CountDownLatch countDownLatch = new CountDownLatch(1);


//        //查看当前节点是否存在,参数需要一个监控器和异步回调器
//        zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
//        watchCallBack.setCountDownLatch(countDownLatch);
//        try {
//            countDownLatch.await();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//
//        while (true){
//            if(myConf.getName()==""){
//                zk.exists("/AppConf",watchCallBack,watchCallBack ,"ABC");
//                try {
//                    countDownLatch.await();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                try {
//                    countDownLatch.await();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }else {
//                System.out.println("读取的节点数据："+myConf.getName());
//            }
//
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }



        //查看当前节点是否存在,参数需要一个监控器和异步回调器
        watchCallBack.aWait();
        //1，节点不存在
        //2，节点存在

        while(true){

            if(myConf.getName().equals("")){
                System.out.println("conf diu le ......");
                watchCallBack.aWait();
            }else{
                System.out.println(myConf.getName());

            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

ZKUtils：获取zk实例

package com.example.zookeeperdemo.zookeeper.confog_wkl;

import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Description:获取zk实例
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class ZKUtils {

    private  static ZooKeeper zk;
    //在端口号后边加/testConfig,表示后续在程序中使用的根节点为testConfig
    private static String adress = "192.168.138.128:2181/testConfig";
    private static int timeout = 3000;

    private  static  DefaultWatch defaultWatch = new DefaultWatch();
    private static CountDownLatch downLatch = new CountDownLatch(1);

    public static ZooKeeper getZK(){
        try {
            zk = new ZooKeeper(adress,timeout,defaultWatch);
            defaultWatch.setCd(downLatch);
            //因为zk连接是异步的，此处采用CountDownLatch
            downLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return zk;
    }
}

DefaultWatch：默认连接zk时的监控类

package com.example.zookeeperdemo.zookeeper.confog_wkl;

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

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class DefaultWatch implements Watcher {
    
    CountDownLatch cd;

    public CountDownLatch getCd() {
        return cd;
    }

    public void setCd(CountDownLatch cd) {
        this.cd = cd;
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        switch (watchedEvent.getState()) {
            case Unknown:
                break;
            case Disconnected:
                break;
            case NoSyncConnected:
                break;
            case SyncConnected:
                System.out.println("zk连接成功了");
                //成功建立连接后放行
                cd.countDown();
                break;
            case AuthFailed:
                break;
            case ConnectedReadOnly:
                break;
            case SaslAuthenticated:
                break;
            case Expired:
                break;
        }
    }
}

MyConf：存储信息的类

package com.example.zookeeperdemo.zookeeper.confog_wkl;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class MyConf {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

WatchCallBack:核心工具类

package com.example.zookeeperdemo.zookeeper.confog_wkl;


import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.concurrent.CountDownLatch;

/**
 * Description:
 * Date:       2022/5/8 - 上午 4:17
 * author:     wangkanglu
 * version:    V1.0
 */
public class WatchCallBack implements Watcher, AsyncCallback.StatCallback, AsyncCallback.DataCallback {

    ZooKeeper zk;
    MyConf conf ;
    CountDownLatch countDownLatch = new CountDownLatch(1) ;

    public CountDownLatch getCountDownLatch() {
        return countDownLatch;
    }

    public void setCountDownLatch(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    public MyConf getConf() {
        return conf;
    }

    public void setConf(MyConf conf) {
        this.conf = conf;
    }

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    public void aWait(){
        zk.exists("/AppConf",this,this ,"ABC");
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //查询状态回调器
    @Override
    public void processResult(int i, String s, Object o, Stat stat) {
//        System.out.println("是否查询到值："+stat);
        if(stat !=null){
            //不等于null，代表有数据
            zk.getData("/AppConf",this,this,"ABC");

        }
    }

    //监控器
    @Override
    public void process(WatchedEvent watchedEvent) {
        switch (watchedEvent.getType()) {
            case None:
                break;
            case NodeCreated:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeDeleted:
                //容忍性
                conf.setName("");
                countDownLatch = new CountDownLatch(1);
                break;
            case NodeDataChanged:
                zk.getData("/AppConf",this,this,"sdfs");
                break;
            case NodeChildrenChanged:
                break;
        }
    }

    //获取数据回调器
    @Override
    public void processResult(int i, String s, Object o, byte[] bytes, Stat stat) {
//        System.out.println("是否读取到值："+new String(bytes));
        if(bytes!=null){
            String data = new String(bytes);
            //将数据存入myconf
            conf.setName(data);
            //当拿到数据后，countDown
            countDownLatch.countDown();
        }
    }
}
苍煜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Zookeeper ---- ZooKeeper分布式锁案例
在人间负债^
11-01 629
什么叫做分布式锁呢？比如说"进程 1"在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其他进程来获得锁，那么通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫做分布式锁。
Zookeeper-06-ZK的分布式锁实现
苍煜
05-08 232
文章目录1:Zookeeper分布式锁分析1.zookeeper实现分布式锁方案2.Redis实现分布式锁方案3.对比zookeeper与redis分布式锁的实现方案2：zookeeper锁的实现1：获取zk实例的工具类2:测试类3：核心业务实现类 1:Zookeeper分布式锁分析 1.zookeeper实现分布式锁方案 a.争抢锁，只有一个人能获得锁 b.获得锁，客户端出现问题，临时节点（session） c.锁被释放，删除，如何通知其他客户端 c-1: 主动轮询，心跳：弊端：延迟，压力 c-2: wa
Zookeeper--08---zk实现分布式锁、案例
时光里的博客
01-06 1154
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录zk实现分布式锁1.zk中锁的种类：2.zk如何上读锁3.zk如何上写锁4.⽺群效应可以调整成链式监听。解决这个问题。5.curator实现读写锁 zk实现分布式锁 1.zk中锁的种类： 读锁：⼤家都可以读，要想上读锁的前提：之前的锁没有写锁 写锁：只有得到写锁的才能写。要想上写锁的前提是，之前没有任何锁。 2.zk如何上读锁 1.创建⼀个临时序号节点，节点的数据是read，表示是读锁 2.获取当前zk中序号⽐⾃⼰⼩的所有节点
zookeeper-3.案例：分布式配置注册发现、分布式锁、ractive模式编程
飘然渡沧海的博客
03-01 107
zookeeper ZooKeeper是做分布式协调的，那它协调啥？ 配置写在哪里？难道运维人员要登录到每一台机器一台一台地改吗？ 可以将配置文件放在一个共享的位置中，比如redis，比如数据库，比如zk，任何一个地方。 zk具有回调机制，就不需要轮询了。 分布式锁的实现，这个zk也可以做，面试常问，虽然可能用不到，但是这道题可以带出很多知识点。 使用ZooKeeper实现分布式配置中心 思路：我们将所有的配置数据用data配置到zk中去，在客户端我们既可以get它，也可以watch它。 一旦外界对这个数据
Zookeeper-分布式锁
养歌的博客
12-30 1449
由于在多线程环境下上下文的切换，数据可能出现不一致的情况，我们需要保证数据安全，所以我们能想到的第一个就是加锁，所谓加锁是当一个线程访问某个数据时，进行限制，其他线程不能进行访问，直到该线程读取完，其他线程才可使用。 这里我们以 Redis 秒杀为例： 首先我们把库存预热到了Redis缓存中，库存为1。 A 服务去 Redis 查询库存发现为 1，说明商品存在，我去抢并且准备减 1 ，这时候库存还没有减。 这时 B 服务也去查询库存发现也是 1，这时 B 服务也抢到了，那也减 1。 C 服务同上。 等所有
ZooKeeper应用---分布式锁
weixin_44489428的博客
03-22 4445
zookeeper通过临时有序节点结合API中的回调和监听机制实现分布式锁
zookeeper (五) zookeeper 实现分布式配置注册&分布式锁
weixin_44244088的博客
04-20 2015
分布式锁 分布式注册中心
分布式协调服务--zookeeper
杀神lwz的博客
05-25 1341
zookeeper官网zookeeper官网学习1、zookeeper有两种运行状态1、有leader模型2、无leader模型即：不可用状态官方压测：从无主模型恢复到有主模型时间在200毫秒内从这张图中可以看出一些重要的观察结果。首先，如果追随者失败并迅速恢复，那么ZooKeeper能够在失败的情况下保持高吞吐量。但也许更重要的是，领导人选举算法允许系统足够快地恢复，以防止吞吐量大幅下降。根据我们的观察，ZooKeeper只需要不到200毫秒的时间就可以选出新的领导者。
zookeeper-1.3 JAVA分布式锁的实现及watch代码实现封装
weixin_43463147的博客
03-06 2136
zk的代码实现-JAVA分布式锁和watch代码封装
zookeeper-3.4.12.tar.gz.zip
12-05
Apache ZooKeeper是一款开源的分布式协调服务，它为分布式应用提供了一种简单、高效且可靠的命名服务、配置管理、集群同步、分布式锁等机制。在3.4.12版本中，Zookeeper继续展现了其稳定性和健壮性，成为了众多企业...
zookeeper-3.4.14.tar.gz
03-19
Apache ZooKeeper，作为一款开源的分布式协调服务，广泛应用于大数据、云计算等领域，为分布式应用提供了一种简单有效的命名服务、配置管理、组服务、分布式同步以及分发等功能。在本篇文章中，我们将围绕Zookeeper ...
apache-zookeeper-3.5.9-bin.tar.gz
03-13
Apache ZooKeeper 是一个分布式协调服务，它为分布式应用程序提供了一个高效、可靠的系统来管理命名空间、配置信息以及分协调任务。在Linux环境下部署和使用ZooKeeper是许多分布式系统的基础，比如Hadoop、Kafka等。...
zookeeper-3.5.2-alpha.zip
05-31
- `bin`目录提供了启动和管理Zookeeper的脚本，如`zkServer.sh`用于启动服务器，`zkCli.sh`则是命令行客户端，可用于交互式操作Zookeeper。 - `data`目录用于存储Zookeeper的数据，包括服务实例的注册信息。 - `logs...
apache-zookeeper-3.6.1 (1).tar.gz
07-02
Apache ZooKeeper 是一个分布式协调服务，它为分布式应用程序提供了简单有效的命名、配置管理、组服务、分布式锁和领导选举等功能。ZooKeeper 的设计目标是简单、高效且高可用，被广泛应用于大数据、微服务等领域。 ...
kafka集群搭建-使用zookeeper
m0_37735176的博客
07-23 481
去官网下载，或者使用如下仓库地址下载，本次使用的时kafka_2.13-3.6.1.tgz ，即3.6.1版本，前面的2.13是scala版本，该版本是较新的版本，可以使用zookeeper，也可以不使用zookeeper搭建集群，本次记录使用了zk，zk集群的部署可以参考上一篇记录。在上面3台服务器上分别执行wget下载，或者本地下载后上传，本次使用的环境为堡垒机接入，如果使用的是宿主机账密登陆，可以下载配置一台，其余使用SCP命令拷贝过去即可。此时可以看到2个消费者模拟客户端都受到了消息：hello。
ZooKeeper 部署
北_鱼的博客
07-20 747
记录 ZooKeeper 环境部署步骤。
Window下安装Zookeeper
予怀的博客
07-23 381
本文介绍了在window下安装zookeeper
第13周 简历职位功能开发与Zookeeper实战
最新发布
与海
07-24 304
参考案例group by分组后会返回每组一条数据over窗口函数配合聚合函数使用,在分组的基础上,返回所有行数据并将聚合函数结果作为新列返回。
CentOS6.5上搭建Hadoop-2.7.3+Zookeeper-3.4.8分布式环境教程
"这篇文档详细介绍了如何在四台运行CentOS 6.5的服务器上搭建基于hadoop-2.7.3、zookeeper-3.4.8和hadoop-2.7.3的分布式环境，作者王三旗亲测安装成功。涉及的组件包括Hadoop、ZooKeeper以及HBase，所有安装包的下载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苍煜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值