Zookeeper框架基础学习

最新推荐文章于 2023-09-18 15:07:01 发布

OrangeNickChen

最新推荐文章于 2023-09-18 15:07:01 发布

阅读量144

点赞数

文章标签： java-zookeeper zookeeper 学习

本文链接：https://blog.csdn.net/Anicka/article/details/128306321

版权

Zookeeper

ZooKeeper 是一个树形目录服务,其数据模型和Unix的文件系统目录树很类似，拥有一个层次化结构。
这里面的每一个节点都被称为: ZNode,每个节点上都会保存自己的数据和节点信息。节点可以拥有子节点，同时也允许少量(1MB) 数据存储在该节点之下。

Zookeeper节点

节点可以分为四大类:
●PERSISTENT 持久化节点
●EPHEMERAL临时节点: -e
●PERSISTENT SEQUENTIAL持久化顺序节点：-s
●EPHEMERAL SEQUENTIAL临时顺序节点: -es

Zookeeper服务器端命令

启动ZooKeeper服务: ./zkServer.sh start
查看ZooKeeper服务状态: ./zkServer.sh status
停止ZooKeeper服务: ./zkServer.sh stop
重启ZooKeeper服务: ./zkServer.sh restart

Zookeeper客户端端命令

连接Zookeeper服务器：./zkClient.sh -server ip:port
断开连接：quit
查看帮助：help
显示指定目录下节点：ls 目录
创建节点：create /节点path value
获取节点值：get /节点path
设置节点值：set /节点path value
删除单个节点：delete /节点path
删除带有子节点的节点：deleteall /节点path

创建临时节点：create -e /节点path value
创建顺序节点：create -s /节点path value
查询节点详情：ls -s /节点path

Curator API

1. 连接

 		RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
// 创建连接对象
        CuratorFramework client= CuratorFrameworkFactory.builder()
                // IP地址端口号
                .connectString("192.168.109.129:2181,192.168.109.129:2182")
                // 会话超时时间
                .sessionTimeoutMs(5000)
                // 重连机制
                .retryPolicy(retryPolicy)
                // 命名空间
                .namespace("create")
                // 构建连接对象
                .build();
        // 打开连接
        client.start();
        System.out.println(client.isStarted());
        // 关闭连接
        client.close();

2. 创建

// 新增节点
       client.create()
               // 节点的类型
               .withMode(CreateMode.PERSISTENT)
               // 节点的权限列表 world:anyone:cdrwa
               .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
               // arg1:节点的路径
               // arg2:节点的数据
               .forPath("/node1", "node1".getBytes());
       System.out.println("结束");

// 自定义权限列表
       // 权限列表
       List<ACL> list = new ArrayList<ACL>();
       // 授权模式和授权对象
       Id id = new Id("ip", "192.168.60.130");
       list.add(new ACL(ZooDefs.Perms.ALL, id));
       client.create().withMode(CreateMode.PERSISTENT).withACL(list).forPath("/node2", "node2".getBytes());
       System.out.println("结束");

// 递归创建节点树
       client.create()
               // 递归节点的创建
               .creatingParentsIfNeeded()
               .withMode(CreateMode.PERSISTENT)
               .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
               .forPath("/node3/node31", "node31".getBytes());
       System.out.println("结束");

// 异步方式创建节点
       client.create()
               .creatingParentsIfNeeded()
               .withMode(CreateMode.PERSISTENT)
               .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
               // 异步回调接口
               .inBackground(new BackgroundCallback() {
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        // 节点的路径
                        System.out.println(curatorEvent.getPath());
                        // 时间类型
                        System.out.println(curatorEvent.getType());
                    }
       })
               .forPath("/node4","node4".getBytes());
       Thread.sleep(5000);
       System.out.println("结束");

3. 获取

// 读取节点数据
      byte [] bys=client.getData()
               // 节点的路径
              .forPath("/node1");
      System.out.println(new String(bys));

// 读取数据时读取节点的属性
      Stat stat=new Stat();
      byte [] bys=client.getData()
              // 读取属性
              .storingStatIn(stat)
              .forPath("/node1");
      System.out.println(new String(bys));
      System.out.println(stat.getVersion());

// 异步方式读取节点的数据
       client.getData()
                .inBackground(new BackgroundCallback() {
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        // 节点的路径
                        System.out.println(curatorEvent.getPath());
                        // 事件类型
                        System.out.println(curatorEvent.getType());
                        // 数据
                        System.out.println(new String(curatorEvent.getData()));
                    }
                })
               .forPath("/node1");
       Thread.sleep(5000);
       System.out.println("结束");

4. 修改

client.setData()
               // 指定版本号
               .withVersion(2)
               .forPath("/node1", "node1111".getBytes());
       System.out.println("结束");

// 更新节点
        client.setData()
                // arg1:节点的路径
                // arg2:节点的数据
                .forPath("/node1", "node11".getBytes());
        System.out.println("结束");

 // 异步方式修改节点数据
        client.setData()
                .withVersion(-1).inBackground(new BackgroundCallback() {
            public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                // 节点的路径
                System.out.println(curatorEvent.getPath());
                // 事件的类型
                System.out.println(curatorEvent.getType());
            }
        }).forPath("/node1", "node1".getBytes());
        Thread.sleep(5000);
        System.out.println("结束");

5. 删除

// 删除节点
       client.delete()
               // 节点的路径
               .forPath("/node1");
       System.out.println("结束");

client.delete()
               // 版本号
               .withVersion(0)
               .forPath("/node1");
       System.out.println("结束");

//删除包含字节点的节点
       client.delete()
               .deletingChildrenIfNeeded()
               .withVersion(-1)
               .forPath("/node1");
       System.out.println("结束");

// 异步方式删除节点
       client.delete()
               .deletingChildrenIfNeeded()
               .withVersion(-1)
               .inBackground(new BackgroundCallback() {
                   public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                       // 节点路径
                       System.out.println(curatorEvent.getPath());
                       // 事件类型
                       System.out.println(curatorEvent.getType());
                   }
               })
               .forPath("/node1");
       Thread.sleep(5000);
       System.out.println("结束");

6. 是否存在节点

  // 判断节点是否存在
       Stat stat= client.checkExists()
                 // 节点路径
                .forPath("/node2");
        System.out.println(stat.getVersion());

 // 异步方式判断节点是否存在
        client.checkExists()
                 .inBackground(new BackgroundCallback() {
                     public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                         // 节点路径
                         System.out.println(curatorEvent.getPath());
                         // 事件类型
                         System.out.println(curatorEvent.getType());
                         System.out.println(curatorEvent.getStat().getVersion());
                     }
                 })
                .forPath("/node2");
        Thread.sleep(5000);
        System.out.println("结束");

7. 获取子节点

 // 读取子节点数据
        List<String> list = client.getChildren()
                // 节点路径
                .forPath("/get");
        for (String str : list) {
            System.out.println(str);
        }

   // 异步方式读取子节点数据
        client.getChildren()
                .inBackground(new BackgroundCallback() {
                    public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                        // 节点路径
                        System.out.println(curatorEvent.getPath());
                        // 事件类型
                        System.out.println(curatorEvent.getType());
                        // 读取子节点数据
                        List<String> list=curatorEvent.getChildren();
                        for (String str : list) {
                            System.out.println(str);
                        }
                    }
                })
                .forPath("/get");
        Thread.sleep(5000);
        System.out.println("结束");

Zookeeper分布式锁原理

分布式锁可以保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。

分布式锁的实现方式有：

数据库实现分布式锁：原理简单，性能较差

Redis分布式锁：性能最好

Zookeeper分布式锁：可靠性最好

Zookeeper分布式锁原理：

核心思想:当客户端要获取锁，则创建节点,使用完锁,则删除该节点。
1.客户端获取锁时，在lock节点下创建临时顺序节点。
2.然后获取lock下面的所有子节点，客户端获取到所有的子节点之后,如果发现自己创建的子节点序号最小，那么就认为该
客户端获取到了锁。使用完锁后，将该节点删除。
3.如果发现自己创建的节点并非lock所有子节点中最小的，说明自己还没有获取到锁，此时客户端需要找到比自己小的那个节点，同时对其注册事件监听器，监听删除事件。
4.如果发现比自己小的那个节点被删除，则客户端的Watcher会收到相应通知，此时再次判断自己创建的节点是否是lock子节点中序号最小的，如果是则获取到了锁，如果不是则重复以上步骤继续获取到此自己小的一个节点并注册监听。

 // 读写锁
        InterProcessReadWriteLock interProcessReadWriteLock=new InterProcessReadWriteLock(client, "/lock1");
        // 获取读锁对象
        InterProcessLock interProcessLock=interProcessReadWriteLock.readLock();
        System.out.println("等待获取锁对象!");
        // 获取锁
        interProcessLock.acquire();
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(3000);
            System.out.println(i);
        }
        // 释放锁
        interProcessLock.release();
        System.out.println("等待释放锁!");