Zookeeper入门：第三天

最新推荐文章于 2023-04-23 18:27:42 发布
最新推荐文章于 2023-04-23 18:27:42 发布
阅读量559 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44406146/article/details/109027353
版权

Zookeeper开源客户端ZKClient和Curator简介

  • Zookeeper客户端提供了基本的操作，比如，创建会话、创建节点、读取节点、更新数据、删除节点和检查节点是否存在等。但对于开发人员来说，Zookeeper提供的基本操纵还是有一些不足之处。

Zookeeper API不足之处

  • Zookeeper的Watcher是一次性的，每次触发之后都需要重新进行注册；
  • Session超时之后没有实现重连机制；
  • 异常处理繁琐，Zookeeper提供了很多异常，对于开发人员来说可能根本不知道该如何处理这些异常信息；
  • 只提供了简单的byte[]数组的接口，没有提供针对对象级别的序列化；
  • 创建节点时如果节点存在抛出异常，需要自行检查节点是否存在；
  • 删除节点无法实现级联删除；

ZkClient简介

  • ZkClient是一个开源客户端，在Zookeeper原生API接口的基础上进行了包装，更便于开发人员使用。内部实现了Session超时重连，Watcher反复注册等功能。像dubbo等框架对其也进行了集成使用。

虽然ZkClient对原生API进行了封装，但也有它自身的不足之处：

  • 几乎没有参考文档；
  • 异常处理简化（抛出RuntimeException）；
  • 重试机制比较难用；
  • 没有提供各种使用场景的实现；

Curator简介

  • Curator是Netflix公司开源的一套Zookeeper客户端框架，和ZkClient一样，解决了非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等。目前已经成为Apache的顶级项目。另外还提供了一套易用性和可读性更强的Fluent风格的客户端API框架。

  • 除此之外，Curator中还提供了Zookeeper各种应用场景（Recipe，如共享锁服务、Master选举机制和分布式计算器等）的抽象封装。

curator特点

  • 解决session会话超时重连
  • watcher反复注册
  • 简化开发api
  • 遵循Fluent风格API
    <!-- Zookeeper -->
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.10</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>2.6.0</version>
        <exclustions>
            <exclustion>
               <groupId>org.apache.zookeeper</groupId>
               <artifactId>zookeeper</artifactId>
            </exclustion>
        </exclustions>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>2.6.0</version>
    </dependency>

基础连接

    public static void main(String[] args) {
        // 工厂创建，fluent风格
        CuratorFramework client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点
                .namespace("create")
                .build();
        client.start();
        
        System.out.println(client.getState());
        client.close();

    }
  • session重连策略
    • RetryPolicy retryPolicy = new RetryOneTime(3000);
      • 说明：三秒后重连一次，只重连一次
    • RetryPolicy retryPolicy = new RetryNTimes(3,3000);
      • 说明：每三秒重连一次，重连三次
    • RetryPolicy retryPolicy = new RetryUntilElapsed(1000,3000);
      • 说明：每三秒重连一次，总等待时间超过个10秒后停止重连
    • RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3)
      • 说明：这个策略的重试间隔会越来越长
        • 公式：baseSleepTImeMs * Math.max(1,random.nextInt(1 << (retryCount + 1)))
          • baseSleepTimeMs = 1000 例子中的值
          • maxRetries = 3 例子中的值

创建

public class curatorGettingStart {
    public static CuratorFramework client;

    // ids权限
    public static void create1() throws Exception {
        // 新增节点
        client.create()
                // 节点的类型
                .withMode(CreateMode.EPHEMERAL)
                // 节点的acl权限列表
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                // arg1：节点路径，arg2：节点数据
                .forPath("/node1",new byte[0]);
    }
    // 自定义权限
    public static void create2() throws Exception {
        ArrayList<ACL> acls = new ArrayList<>();
        Id id = new Id("world", "anyone");
        acls.add(new ACL(ZooDefs.Perms.READ,id));
        // 新增节点
        client.create()
                // 节点的类型
                .withMode(CreateMode.EPHEMERAL)
                // 节点的acl权限列表
                .withACL(acls)
                // arg1：节点路径，arg2：节点数据
                .forPath("/node2",new byte[0]);
    }
    // 递归创建
    public static void create3() throws Exception {
        // 新增节点
        client.create()
                // 递归创建
                .creatingParentsIfNeeded()
                // 节点的类型
                .withMode(CreateMode.EPHEMERAL)
                // 节点的acl权限列表
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                // arg1：节点路径，arg2：节点数据
                .forPath("/node2/nodex",new byte[0]);
    }
    // 递归创建
    public static void create4() throws Exception {
        // 新增节点
        System.out.println(1);
        client.create()

                .creatingParentsIfNeeded()
                // 节点的类型
                .withMode(CreateMode.EPHEMERAL)
                // 节点的acl权限列表
                .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                // 异步
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        System.out.println("异步创建成功");
                    }
                })
                // arg1：节点路径，arg2：节点数据
                .forPath("/node2/nodex",new byte[0]);
        System.out.println(2);
    }
    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        CuratorFramework client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点
                .namespace("create")
                .build();
        client.start();
//        create1();
//        create2();
//        create3();
        create4();

        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

删除

public class curatorGettingStart {
    public static CuratorFramework client;
    public static void delete1() throws Exception {
        // 删除节点
        client.delete()
                .forPath("node1");
    }

    public static void delete2() throws Exception {
        // 删除节点
        client.delete()
                // 版本
                .withVersion(1)
                .forPath("node2");
    }

    public static void delete3() throws Exception {
        // 删除节点
        client.delete()
                // 递归删除
                .deletingChildrenIfNeeded()
                .withVersion(-1)
                .forPath("node3");
    }

    public static void delete4() throws Exception {
        // 删除节点
        client.delete()
                .withVersion(-1)
                // 异步
                .inBackground(new BackgroundCallback() {
                    @Override
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        if (curatorEvent.getType() == CuratorEventType.DELETE)
                            System.out.println(curatorEvent.getPath() + "    " + curatorEvent.getType());
                    }
                })
                .forPath("node3");

    }


    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点,可选操作
                .namespace("delete")
                .build();
        client.start();
        //        delete1();
        //        delete2();
        //        delete3();
        // delete4();
        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

读取节点

public class curatorGettingStart {
    public static CuratorFramework client; 
    public static void get1() throws  Exception {
        // 获取数据
        byte[] bytes = client.getData()
                .forPath("/node");
        System.out.println(new String((bytes)));
    }
    public static void get2() throws  Exception {
        Stat stat = new Stat();
        // 获取数据
        byte[] bytes = client.getData()
                .storingStatIn(stat)
                .forPath("/node");;
        System.out.println(new String((bytes)));
        System.out.println(stat.getVersion());
        System.out.println(stat.getCzxid());
    }
    public static void get3() throws  Exception {
        System.out.println(1);
        // 获取数据
        client.getData()
                .inBackground((CuratorFramework curatorFramework, CuratorEvent curatorEvent) -> {
                    System.out.println(curatorEvent.getPath() + "  " + curatorEvent.getType());
                })
                .forPath("/node");;
        System.out.println(2);
    }


    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点,可选操作
                .namespace("get")
                .build();
        client.start();
        get1();
        get2();
        get3();

        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

读取子节点

 public class curatorGettingStart {
    public static CuratorFramework client;  
    public static void getChildren1() throws  Exception {
        // 获取数据
        List<String> strings = client.getChildren()
                .forPath("/get");
        strings.forEach(System.out::println);
        System.out.println("------------");
    }
    public static void getChildren2() throws  Exception {
        System.out.println(1);
        // 获取数据
        client.getChildren()
                .inBackground((curatorFramework, curatorEvent) -> {
                    curatorEvent.getChildren().forEach(System.out::println);
                    System.out.println("------------");
                })
                .forPath("/get");
        System.out.println(2);
        System.out.println("------------");
    }


    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点,可选操作
//                .namespace("get")
                .build();
        client.start();

        getChildren1();
        getChildren2();

        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

watcher

public class WatcherTest {
    static CuratorFramework client;

    public static void watcher1() throws Exception {
        // arg1 curator的客户端
        // arg2 监视的路径
        NodeCache nodeCache = new NodeCache(client, "/watcher");
        // 启动
        nodeCache.start();
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            // 节点变化时的回调方法
            public void nodeChanged() throws Exception {
                // 路径
                System.out.println(nodeCache.getCurrentData().getPath() + "  " + nodeCache.getCurrentData().getStat());
                // 输出节点内容
                System.out.println(new String(nodeCache.getCurrentData().getData()));
            }
        });
        System.out.println("注册完成");
        // 时间窗内可以一直监听
        //        TimeUnit.SECONDS.sleep(1000);
        //关 闭
        nodeCache.close();
    }

    public static void watcher2() throws Exception {
        // arg1 客户端
        // arg2 路径
        // arg3 事件钟是否可以获取节点数据
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/watcher", true);
        // 启动
        pathChildrenCache.start();
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            // 节点变化时的回调方法
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                if (pathChildrenCacheEvent != null) {
                    // 获取子节点数据
                    System.out.println(new String(pathChildrenCacheEvent.getData().getData()));
                    // 路径
                    System.out.println(pathChildrenCacheEvent.getData().getPath());
                    // 事件类型
                    System.out.println(pathChildrenCacheEvent.getType());
                }
            }
        });
        // 时间窗内可以一直监听
        TimeUnit.SECONDS.sleep(1000);
        //关 闭
        pathChildrenCache.close();

    }


    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点,可选操作
                //                .namespace("get")
                .build();
        client.start();

//        watcher1();
        watcher2();

        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

分布式锁

  • InterProcessMutex：分布式可重入排它锁
  • InterProcessReadWriteLock：分布式读写锁
public class CuratorDistributeLock {
    public static CuratorFramework client;

    public static void interProcessMutex() throws Exception {
        System.out.println("排他锁");
        // 获取一个分布式排他锁
        InterProcessMutex lock = new InterProcessMutex(client, "/lock1");
        // 开启两个进程测试，会发现：如果一个分布式排它锁获取了锁，那么直到锁释放为止数据都不会被侵扰
        System.out.println("获取锁中");
        lock.acquire();
        System.out.println("操作中");
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.release();
        System.out.println("释放锁");
    }

    public static void interProcessReadWriteLock1() throws Exception {
        System.out.println("写锁");
        // 分布式读写锁
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client, "/lock1");
        // 开启两个进程测试，观察到写写互斥，特性同排它锁
        System.out.println("获取锁中");
        lock.writeLock().acquire();
        System.out.println("操作中");
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.writeLock().release();
        System.out.println("释放锁");
    }

    public static void interProcessReadWriteLock2() throws Exception {
        System.out.println("读锁");
        // 分布式读写锁
       // (连接对象，节点路径)
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client, "/lock1");
        // 开启两个进程测试，观察得到读读共享，两个进程并发进行，注意并发和并行是两个概念，(并发是线程启动时间段不一定一致，并行是时间轴一致的)
        // 再测试两个进程，一个读，一个写，也会出现互斥现象
        System.out.println("获取锁中");
        lock.readLock().acquire();
        System.out.println("操作中");
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.readLock().release();
        System.out.println("释放锁");
    }


    public static void main(String[] args) throws Exception {
        // 工厂创建，fluent风格
        client = CuratorFrameworkFactory.builder()
                // ip端口号
                .connectString("192.168.133.133:2181,192.168.133.133:2182,192.168.133.133:2183")
                // 会话超时
                .sessionTimeoutMs(5000)
                // 重试机制，这里是超时后1000毫秒重试一次
                .retryPolicy(new RetryOneTime(1000))
                // 名称空间，在操作节点的时候，会以这个为父节点,可选操作
                //                .namespace("get")
                .build();
        client.start();
        //        interProcessMutex();
//                interProcessReadWriteLock1();
        interProcessReadWriteLock2();


        System.out.println(client.getState() + "操作完成");
        TimeUnit.SECONDS.sleep(20);
        client.close();
    }
}

字监控命令/配置属性

  • zookeeper支持某些特定的四字命令与其的交互。它们大多数是查询命令，用来获取zookeeper服务的当前状态及相关信息。用户再客户端可以通过telnet或nc向zookeeper提交相应的命令。zookeeper常用四字命令见下表所示：

telnet

  • yum install -y telnet
  • telnet 192.168.133.133 2181(进入终端)
    • mntr(现在可以看到信息)

nc

  • yum install -y nc
    • echo mntr | nc 192.168.133.133:2181
令描述
conf输出相关服务配置的详细信息。比如端口号、zk数据以及日志配置路径、最大连接数，session超时、serverId等
cons列出所有连接到这台服务器的客户端连接/会话的详细信息。包括"接收/发送"的包数量、sessionId、操作延迟、最后的操作执行等信息
crst重置当前这台服务器所有连接/会话的统计信息
dump列出未经处理的会话和临时节点，这仅适用于领导者
envi处理关于服务器的环境详细信息
ruok测试服务是否处于正确运行状态。如果正常返回"imok"，否则返回空
stat输出服务器的详细信息：接收/发送包数量、连接数、模式(leader/follower)、节点总数、延迟。所有客户端的列表
srst重置server状态
wchs列出服务器watchers的简洁信息：连接总数、watching节点总数和watches总数
wchc通过session分组，列出watch的所有节点，它的输出是一个与watch相关的会话的节点信息，根据watch数量的不同，此操作可能会很昂贵（即影响服务器性能），请小心使用
mntr列出集群的健康状态。包括"接收/发送"的包数量、操作延迟、当前服务模式(leader/follower)、节点总数、watch总数、临时节点总数

conf

  • 输出相关服务配置的详细信息
属性含义
clientPort客户端端口号
dataDir数据快照文件目录，默认情况下10w次事务操作生成一次快照
dataLogDir事务日志文件目录，生产环节中放再独立的磁盘上
tickTime服务器之间或客户端与服务器之间维持心跳的时间间隔(以毫秒为单位)
maxClientCnxns最大连接数
minSessionTimeout最小session超时minSessionTimeout=tickTime*2 ，即使客户端连接设置了会话超时，也不能打破这个限制
maxSessionTimeout最大session超时maxSessionTimeout=tickTime*20，即使客户端连接设置了会话超时，也不能打破这个限制
serverId服务器编号
initLimit集群中follower服务器(F)与leader服务器(L)之间初始连接时能容忍的最多心跳数，实际上以tickTime为单位，换算为毫秒数
syncLimit集群中follower服务器(F)与leader服务器(L)之间请求和应答之间能容忍的最大心跳数，实际上以tickTime为单位，换算为毫秒数
electionAlg0：基于UDP的LeaderElection1：基于UDP的FastLeaderElection2：基于UDP和认证的FastLeaderElection3：基于TCP的FastLeaderElection在3.4.10版本中，默认值为3，另外三种算法以及被弃用，并且有计划在之后的版本中将它们彻底删除且不再支持
electionPort选举端口
quorumPort数据通信端口
peerType是否为观察者 1为观察者

cons

  • 列出所有连接到这台服务器的客户端连接/会话的详细信息
属性含义
ipIP地址
port端口号
queued等待被处理的请求数，请求缓存在队列中
received收到的包数
sent发送的包数
sid会话id
lop最后的操作 GETD-读取数据 DELE-删除数据 CREA-创建数据
est连接时间戳
to超时时间
lcxid当前会话的操作id
lzxid最大事务id
lresp最后响应时间戳
llat最后/最新 延迟
minlat最小延时
maxlat最大延时
avglat平均延时

crst

重置当前这台服务器所有连接/会话的统计信息

dump

列出临时节点信息，适用于leader

envi

输出关于服务器的环境详细信息

属性含义
zookeeper.version版本
host.namehost信息
java.versionjava版本
java.vendor供应商
java.home运行环境所在目录
java.class.pathclasspath
java.library.path第三方库指定非Java类包的为止(如：dll，so)
java.io.tmpdir默认的临时文件路径
java.compilerJIT编辑器的名称
os.nameLinux
os.archamd64
os.version3.10.0-1062.el7.x86_64
user.namezookeeper
user.home/opt/zookeeper
user.dir/opt/zookeeper/zookeeper2181/bin

ruok

测试服务是否处于正确运行状态，如果目标正确运行会返回imok（are you ok | I’m ok）

stat

输出服务器的详细信息与srvr相似(srvr这里不举例了，官网有一点描述)，但是多了每个连接的会话信息

属性含义
zookeeper version版本
Latency min/avg/max延时
Received收包
Sent发包
Connections当前服务器连接数
Outstanding服务器堆积的未处理请求数
Zxid最大事务id
Mode服务器角色
Node count节点数

srst

重置server状态

wchs

列出服务器watches的简洁信息

属性含义
connectsions连接数
watch-pathswatch节点数
watcherswatcher数量

wchc

通过session分组，列出watch的所有节点，它的输出是一个与watch相关的会话的节点列表

问题

wchc is not executed because it is not in the whitelist

解决办法

# 修改启动指令zkServer.sh
# 注意找到这个信息
else
	echo "JMX disabled by user request" >&2
	ZOOMAIN="org.apache.zookeeper.server.quorum.QuorumPeerMain"
fi
# 下面添加如下信息
ZOOMAIN="-Dzookeeper.4lw.commands.whitelist=* ${ZOOMAIN}"

每一个客户端的连接的watcher信息都会被收集起来，并且监控的路径都会被展示出来（代价高，消耗性能）

[root@localhost bin]# echo wchc | nc 192.168.133.133 2180
0x171be6c6faf0000
        /node2
        /node1
0x171be6c6faf0001
        /node3

wchp

通过路径分组，列出所有的watch的session id 信息

配置同wchc

mntr

列出服务器的健康状态

属性含义
zk_version版本
zk_avg_latency平均延时
zk_max_latency最大延时
zk_min_latency最小延时
zk_packets_received收包数
zk_packets_sent发包数
zk_num_alive_connections连接数
zk_outstanding_requests堆积请求数
zk_server_stateleader/follower状态
zk_znode_countznode数量
zk_watch_countwatch数量
zk_ephemerals_countl临时节点(znode)
zk_approximate_data_size数据大小
zk_open_file_descriptor_count打开的文件描述符数量
zk_max_file_descriptor_count最大文件描述符数量
一年而已
关注
专栏目录
ZooKeeper入门-初体验
Junds0的博客
02-12 5406
本关的测试需要用户在右侧的命令行下完成，用户只需将需要完成的命令在右侧命令行下直接操作即可，然后点击评测按钮，平台会自动验证用户是否按照要求去检测结果。本关的测试需要用户在右侧的命令行下完成，用户只需将需要完成的命令在右侧命令行下直接操作即可，然后点击评测按钮，平台会自动验证用户是否按照要求去检测结果。本关任务是使用命令行，将最大用户连接数设置为100,并启动服务器（启动服务器之前确保服务器处于关闭状态，可通过status查看服务器状态）。本关任务：初次体验ZooKeeper的下载安装和服务器的启动停止。
Zookeeper : 源码入门
syh121的博客
09-09 314
一. 前言 出于对集群选举流程的好奇 , 所以把 Zookeeper 源码拉下来跑了一下 , 这篇文档对这个过程做一个简单的记录. 要想看懂任何源码 , 第一步就是要跑起来 . 这一篇主要介绍 , 如果快速的跑源码 ,同时简单介绍其中的关键点 , 便于处理 二 . 源码的运行 2.1 主启动流程 // Step 1 : Git 拉取 https://github.com/apache/zookeeper.git // Step 2 : 本地运行 (Intellij) 1. 找到 zookeep
Zookeeper(二)
weixin_43946848的博客
06-03 410
一、Zookeeper集群 1、小集群部署 首先copy多个zookeeper文件并以具体的端口为结尾命名文件 进入各自的zookeeper文件中并修改conf文件夹里面zoo.cfg文件： ①修改dataDir文件的路径为各自相应路径 ②修改相应端口号 ③添加集群配置文件 其中server.__=_ :_: _ 分别对应此服务器编号、此服务器ip地址、Zookeeper服务器之间的通信端口、Leader选举的端口 在data文件夹里面创建myid文件，里面添加是上一步在zoo.cfg文件中设置
Zookeeper 初体验之——JAVA API 初探
weixin_33716154的博客
07-19 190
简介 Apache Zookeeper 是由 Apache Hadoop 的 Zookeeper 子项目发展而来，现在已经成为了 Apache 的顶级项目。Zookeeper 为分布式系统提供了高效可靠且易于使用的协同服务，它可以为分布式应用提供相当多的服务，诸如统一命名服务，配置管理，状态同步和组服务等。 Zookeeper 接口简单，开发人员不必过多地纠结在分布式系统编程难于处理的同步和...
Hadoop大数据从入门到实战（三）ZooKeeper入门-初体验
最新发布
m0_58236171的博客
04-23 8087
（2）修改“ZOO_LOG_DIR”，修改后：ZOO_LOG_DIR="/opt/zookeeper-3.4.12"（2）为了能够顺利地运行Zookeeper，需要用户创建配置文件。本关任务：了解ZooKeeper的配置并根据需求正确配置ZooKeeper。本关任务是使用命令行，开启ZooKeeper服务器，查看服务器状态。本关任务：初次体验ZooKeeper的下载安装和服务器的启动停止。,并启动服务器（启动服务器之前确保服务器处于关闭状态，可通过。的连接（启动服务器之前确保服务器处于关闭状态，可通过。
Zookeeper-api基础教程
姚先生的全栈之路
05-04 1548
第一关、创建会话与关闭 【题目来自头歌enducoder平台，有帮助的话，不忘点个赞、关注哟！】 import java.io.IOException; import org.apache.zookeeper.WatchedEvent; import org.apache.zookeeper.Watcher; import org.apache.zookeeper.ZooKeeper; public class test1 { // 初始化 ZooKeeper 实例 privat
zookeeper系列1：入门
05-03
**Zookeeper系列1：入门** Zookeeper是一款分布式协调服务，由Apache基金会开发，广泛应用于分布式系统中的数据共享、配置管理、命名服务、集群同步等场景。它的设计目标是简化分布式环境下的复杂问题，提供高可用...
第6章 Zookeeper 2 6.1. Zookeeper入门 2 6.1.1. 概述 2 6.1.2. 特点 3 6.1.3
05-21
6.1. Zookeeper入门 2 6.1.1. 概述 2 6.1.2. 特点 3 6.1.3. 数据结构 4 6.1.4. 应用场景 4 6.1.5. 下载地址 6 6.2. Zookeeper安装 7 6.2.1. 本地模式安装部署 7 6.2.2. 配置参数解读 9 6.3. Zookeeper实战（开发重点...
Zookeeper入门篇
m0_49853352的博客
12-21 1387
第一部分 初识zookeeper？ 1，什么是zookeeper？ 1，高可用、高性能、开源的分布式协调服务。为分布式应用提供一致性服务，可以实现发布/订阅，负载均衡，分布式协调/通知，集群管理等 2，目标是封装好复杂易出错的关键服务，提供给用户 3，ZooKeeper保证了分布式一致性（顺序一致性、原子性、单一视图、可靠性、实时性/最终一致性） 4，客户端的读请求 5，有序性，所有更新都是全局有序的 2，zookeeper的linux环境搭建 官网下载地址Apache ZooKeeper 步骤： 因为
zookeeper初体验
piaoniu_1985的专栏
04-11 2896
Apache ZooKeeper 初体验
Zookeeper API基础
哈
03-09 680
环境搭建 第一步：创建一个Maven工程，添加Maven依赖： <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> &...
zookeeper的初体验
weixin_33788244的博客
05-30 460
2019独角兽企业重金招聘Python工程师标准>>> ...
第1关：ZooKeeper初体验
qq_61604164的博客
11-17 4990
ZooKeeper入门-初体验 第1关：ZooKeeper初体验
dubbo+zookeeper初体验 ——致敬狂神
qq_38697228的博客
07-08 309
一、环境搭建 zookeeper 3.4.14安装 http://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.4.14/zookeeper-3.4.14.tar.gz 解压后使用一般会有闪退的问题，加上pause，查看报错，发现是找不到 zoo.cfg的问题 到 zookeeper-3.4.14\conf 目录下发现只有zoo_simple.cfg 文件， 拷贝一份命名为zoo.cfg。 再启动就ok了。 我们再bin目录下可以分别看到 serve
ZooKeeper-API基础
qq_61604164的博客
11-28 310
第4关：异步回调函数 ZooKeeper-API基础
第4章: zookeeper 基础API使用
热门推荐
flykinghg的博客
10-09 1万+
第4章：zookeeper 基础API使用
zookeeper 入门与实践 （一）
LeAng_Lee的博客
01-01 1292
zookeeper 入门与实践 （一） 应用场景 1、可以用作复杂的集群系统的注册中心，检测服务实例的健康状态，更新健康服务实例给调用方。 2、系统集群环境下可用来做分布式锁，避免同一份资源被多个线程同时篡改，导致数据变更和预期不符。 3、配置中心，多个服务使用同一套配置，不用每个服务管理一套维护起来太麻烦，修改还得改代码，重启项目，使用zk统一管理修改方便、提高效率。 4、分布式队列，微服务中处理业务需要保证先进先出的顺序性，可以让所有待执行业务在zk上建立临时节点，按顺序执行一个删除一个。 节点类
Zookeeper 入门，看这篇就够了
留歌__36的博客
01-16 1335
Zookeeper 简介 与 集群配置 【Storm的各个组件间是通过这个组件进行通信】 简介： Zookeeper是一个开源的分布式协调服务的框架，使各个机器进行之间进行通信 1.1核心功能： 文件系统 通知机制 文件系统： 类似于linux的文件系统目录结构，从根目录（/）开始 1.每一个目录都是一个znode节点 2.每一个znode节点可直接存储数据 3.类型：持久化，持久化顺序，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值