zookeeper -- 第六章 zookeeper java client讲解 （上）

1、创建

package com.demo;

import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;

public class ZKDemo {

    private static final String connectString = "";
    private static final int sessionTimeout = 0;
    private static Watcher watcher;
    private static Boolean canBeReadOnly = false;
    private static long sessionId;
    private static byte[] sessionPasswd;

    public static void main(String[] args) throws IOException {
        ZooKeeper zooKeeper1 = new ZooKeeper(connectString,sessionTimeout,watcher);
        ZooKeeper zooKeeper2 = new ZooKeeper(connectString,sessionTimeout,watcher,canBeReadOnly);
        ZooKeeper zooKeeper3 = new ZooKeeper(connectString,sessionTimeout,watcher,sessionId,sessionPasswd);
        ZooKeeper zooKeeper4 = new ZooKeeper(connectString,sessionTimeout,watcher,sessionId,sessionPasswd,canBeReadOnly);
    }
}

客户端与服务端会话的建立是一个异步的过程，即

• 完成客户端的初始化就返回，此时连接并没有真正的建立起来

• 当连接真正建立起来后，客户端会收到一个时间通知

2、ZK构造方法参数说明

3、创建会话

package com.demo;

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

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

public class ZKCreateSample implements Watcher{

    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static final String connectString = "127.0.0.1:2181";
    private static final int sessionTimeout = 6000;

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

        ZooKeeper zooKeeper = new ZooKeeper(connectString,sessionTimeout,new ZKCreateSample());

        System.out.println("begin state = "+ zooKeeper.getState());

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();

            System.out.println("end state = "+zooKeeper.getState());
        }

        System.out.println("end state= "+zooKeeper.getState());
    }

    @Override
    public void process(WatchedEvent event) {

        System.out.println("receive watched event: "+ event);

        if(Event.KeeperState.SyncConnected == event.getState()){
            countDownLatch.countDown();
        }
    }
}

4、创建节点

• String create(final String path, byte data[], List<ACL> acl,CreateMode createMode)

• void create(final String path, byte data[], List<ACL> acl,CreateMode createMode, StringCallback cb, Object ctx) 以异步的方式创建节点

• 无论 是上面的同步或者异步，都不支持递归创建节点

• 当节点存在时，抛出异常NodeExistsException

1、zk create api 参数说明

2、创建节点时的ACL

• 通过接口Ids可以有预先定义的几种scheme模式

1、OPEN_ACL_UNSAFE : 相当于 world : anyone : cdrwa

2、CREATOR_ALL_ACL : 相当于anth : 用户名 : 密码 ，但是需要通过Zookeeper的addAuthInfo添加对应的用户和密码

3、READ_ACL_UNSAFE : 相当于world : anyone : r ,即所有人拥有读权限

3、 可以自己定义，比如：

package com.demo;

import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;

import java.util.ArrayList;
import java.util.List;

public class ZKOPSample {
    public static void main(String[] args) {

    }

    /**
     * 添加digest权限
     * @return
     */
    public List<ACL> getDigestAcl() {
        List<ACL> acls = new ArrayList<ACL>();
        Id digestId = new Id("digest","javaclient2:CGf2ylBdcKMdCYuzd08lQfOPvN0=");
        acls.add(new ACL(ZooDefs.Perms.ALL, digestId));
        return acls;
    }
}

5、删除节点

package com.demo;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ZKOPSample {

    private ZooKeeper zk = null;

    public ZKOPSample(String connectString) {
        try {
            zk = new ZooKeeper(connectString, 1000, null);
        } catch (IOException e) {
            e.printStackTrace();
            if (zk != null) {
                try {
                    zk.close();
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ZKOPSample zks = new ZKOPSample("127.0.0.1:2181");
        //zks.getDigestAcl();

        // 所有人都可以访问的节点
//		zks.testCreateNode("/javaclient/node3","java".getBytes(),
//                ZooDefs.Ids.OPEN_ACL_UNSAFE);

        // 同步删除节点
//        zks.deleteNode("/javaclient/node1",0);
        // 异步删除节点
//        String ctx = "上下文测试对象";
//        zks.deleteAsyncNode("/javaclient/node3",0,new DeleteAsyncCallback(),ctx);
//        Thread.sleep(3000);
    }

    /**
     * 同步删除节点
     * @param path
     * @param version
     */
    public void deleteNode(String path,int version){
        try {
            zk.delete(path,version);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    /**
     * 异步删除节点
     *
     * @param path
     * @param version
     * @param voidCallback
     * @param ctx
     */
    public void deleteAsyncNode(String path, int version, AsyncCallback.VoidCallback voidCallback, Object ctx){
        zk.delete(path,version,voidCallback,ctx);
    }



    /**
     * 创建节点
     *
     * @param path
     * @param data
     * @param acls
     * @return
     */
    public String testCreateNode(String path, byte[] data, List<ACL> acls) {
        String res = "";
        try {
            // zk.addAuthInfo("auth", "javaclient1:111111".getBytes());
            res = zk.create(path, data, acls, CreateMode.PERSISTENT);
            System.out.println("创建节点" + res + "成功");
        } catch (KeeperException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return res;
    }

    /**
     * 添加digest权限
     * @return
     */
    public List<ACL> getDigestAcl() {
        List<ACL> acls = new ArrayList<ACL>();
        Id digestId = new Id("digest","javaclient2:CGf2ylBdcKMdCYuzd08lQfOPvN0=");
        acls.add(new ACL(ZooDefs.Perms.ALL, digestId));
        return acls;
    }

    public ZooKeeper getZk() {
        return zk;
    }

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

异步删除回调方法

package com.demo;

import org.apache.zookeeper.AsyncCallback;

/**
 * 异步删除节点回调类
 */
public class DeleteAsyncCallback implements AsyncCallback.VoidCallback {

    @Override
    public void processResult(int rc, String path, Object ctx) {

        System.out.println("执行回调方法");
        System.out.println("rc: "+rc);
        System.out.println("path: "+path);
        System.out.println("ctx "+ ctx);
    }
}