Zookeeper之Java入门应用以及临时节点-yellowcong

Zookeeper中的节点的4种创建方式
1、CreateMode.PERSISTENT 持久化
2、CreateMode.PERSISTENT_SEQUENTIAL 持久化，带排序的操作
3、CreateMode.EPHEMERAL 临时节点，这个节点在session关闭后，创建的节点就没了，可以通过这个临时节点实现先分布式锁的方法，每次在操作共通资源的时候，可以使用get获取创建的临时节点信息，如果没有就可以操作共同资源，证明没有人操作这个资源
4、CreateMode.EPHEMERAL_SEQUENTIAL 带排序的方式

需要注意的地方
1、删除和更新操作中，版本号传递-1，表示的是修改所有的版本的信息。
2、临时节点和分布式锁的实现
3、zookeeper创建连接的时候，需要判断是否连接上，然后，再执行下一步操作，需要使用到 CountDownLatch
4、多个节点连接，需要使用 逗号分开

原生API特点

1、原生api不允许递归创建节点
2、节点要求是数组，不支持序列化
3、节点权限，使用Ids.OPEN_ACL_UNSAFF，一般这个不需要管
4、没有递归删除的方法
5、不支持递归的创建方法
6、异步创建节点，每一个方法都提供了异步的方式

环境搭建

pom.xml配置文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>yellowcong</groupId>
  <artifactId>day10_13</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>day10_13</name>
  <url>http://maven.apache.org</url>

<!-- 配置国内比较快的 阿里云的Maven仓库 -->
<repositories>
    <repository>
        <id>aliyunmaven</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </repository>
</repositories>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <!-- zookeeper开发jar包 -->  
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.10</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

案例

1、节点的CURD
2、异步CURD
3、临时节点

package com.yellowcong.zookeeper;

import java.lang.annotation.ElementType;
import java.nio.charset.Charset;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.AsyncCallback.StringCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
/**
 * @author yellowcong
 *
 */
public class Demo {

    // 连接到ZK服务，多个可以用逗号分割写
    //private static final String CONNECT_PATH = "127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183";

    private static final String CONNECT_PATH = "192.168.66.110:2181";

    //超时时间
    private static final int SESSION_TIME_OUT = 20000;

    //设定编码
    private static final Charset charset = Charset.forName("UTF-8");

    private static final CountDownLatch countDownLatch = new CountDownLatch(1);

    public static void main(String[] args) throws Exception {

        ZooKeeper  zk = new ZooKeeper(CONNECT_PATH, SESSION_TIME_OUT, new Watcher(){

            public void process(WatchedEvent event) {

                //判断是否连接
                if(event.getState()==KeeperState.SyncConnected){  
                    //连接成功
                    if(event.getType() == EventType.None){
                        countDownLatch.countDown();  
                        System.out.println("连接上");
                    }
                } 
            }
        });

        System.out.println("主线程等待");
        //主函数
        countDownLatch.await();
        System.out.println("主线程执行");

        //修改节点数据， -1表示更改所有版本的数据
        zk.setData("/", "root".getBytes(charset), -1);

        //获取节点数据
        byte [] data = zk.getData("/", true, null);
        System.out.println("获取主节点数据\t"+new String(data,charset));

        //创建节点,
        if(zk.exists("/test",true) == null){
            zk.create("/test", "test".getBytes(charset), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            data = zk.getData("/test", true, null);
            System.out.println("获取节点数据\t"+new String(data,charset));

            //删除节点 , -1表示将所有的版本都删除
            zk.delete("/test", -1);
        }

        //临时节点,回话结束的时候，就会消失，这个临时节点，可以用于做分布式锁的操作
        //CreateMode.EPHEMERAL 是临时节点的，当zk.close关闭会话，就会关闭session
        String str = zk.create("/lock","lock".getBytes(charset), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println("节点创建后的返回值\t"+str);


        //临时节点在没关闭session的时候，是可以访问到的节点数据
        data = zk.getData("/lock", true, null);
        System.out.println(new String(data,charset));

        zk.create("/syncNode", "syncNode".getBytes(), 
                Ids.OPEN_ACL_UNSAFE, 
            CreateMode.EPHEMERAL, new StringCallback() {

                public void processResult(int rc, String path, Object ctx, String arg3) {
                    //响应码 0 表示成功
                    //-4  端口连接
                    //-110 
                    //-122 session连接失败
                    System.out.println(rc); 
                    System.out.println(path);
                    //就是异步调用 外面传递的对象
                    System.out.println(ctx);//上下文环境
                }
        },"create");

        //如果不sleep一下，就直接关闭了session
        Thread.sleep(5000);
        //异步删除数据
        /*zk.delete("/syncNode", -1, new VoidCallback() {

            public void processResult(int rc, String path, Object ctx) {
                //响应码 0 -4
                System.out.println(rc); 
                System.out.println(path);
                //就是异步调用 外面传递的对象
                System.out.println(ctx);//上下文环境
            }
        }, "test");
        */

        //获取子节点信息
        List<String> childs = zk.getChildren("/mybatis", false);
        for(String node:childs){
            System.out.println(node);
        }

        zk.close();
    }
}