Zookeeper基本实践

增删改查节点

package com.org.zookeeper.crud;

import com.org.zookeeper.ClientFactory;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.CuratorFramework;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;

import java.util.List;

@Slf4j
public class NodeOperation {
    public static final String ZK_ADDRESS = "127.0.0.1:2181";

    public static final String ZK_PATH = "/test/CURD/node-1";

    public static final String PARENT_PATH = "/test";


    /**
     * 创建节点
     */
    public void createNode() {
        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {
            //启动客户端
            client.start();

            //创建一个ZNode节点，数据为payload
            String data = "hello";
            byte[] payload = data.getBytes("UTF-8");

            /**
             * 1.返回构造者实例
             * 2.如有必要，创建父节点
             * 3.选择节点类型：PERSISTENT、PERSISTENT_SEQUENTIAL、EPHEMERAL、EPHEMERAL_SEQUENTIAL
             * 4.实际创建节点，传入路径与数据
             */
            client.create()
                    .creatingParentsIfNeeded()
                    .withMode(CreateMode.PERSISTENT)
                    .forPath(ZK_PATH, payload);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }

    }

    /**
     * 读取节点
     */
    public void readNode() {
        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {
            client.start();
            //判断节点是否存在
            Stat stat = client.checkExists().forPath(ZK_PATH);
            //节点存在
            if (stat != null) {
                //读取节点数据
                byte[] payload = client.getData().forPath(ZK_PATH);
                String data = new String(payload, "UTF-8");
                log.info("read data:" + data);

                //获取父节点的所有子节点，分别打印
                List<String> children = client.getChildren().forPath(PARENT_PATH);
                children.forEach(child -> log.info("child: " + children));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }

    /**
     * 更新节点
     */
    public void updateNode() {
        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {
            client.start();
            String data = "hello world";
            byte[] payload = data.getBytes("UTF-8");

            client.setData().forPath(ZK_PATH, payload);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }

    /**
     * 异步更新节点
     */
    public void updatNodeAsync() {
        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {
            //异步完成更新，回调此实例
            AsyncCallback.StringCallback callback = new AsyncCallback.StringCallback() {
                //回调方法
                @Override
                public void processResult(int i, String s, Object o, String s1) {
                    log.info(
                            "i = " + i + " | " +
                            "s = " + s + " | " +
                            "o = " + o + " | " +
                            "s1 = " + s1
                    );
                }
            };

            client.start();
            String data = "hello world!";
            byte[] payload = data.getBytes("UTF-8");
            client.setData()
                    .inBackground(callback)
                    .forPath(ZK_PATH, payload);

            Thread.sleep(1000);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.start();
        }
    }

    /**
     * 删除节点
     */
    public void deleteNode() {
        CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

        try {
            client.start();
            //删除节点
            client.delete().forPath(ZK_ADDRESS);

            //查看删除结果
            List<String> children = client.getChildren().forPath(PARENT_PATH);
            for (String child : children) {
                log.info("child: " + child);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }


}

分布式ID生成器

package com.org.zookeeper.distributeIdgenerator;

import com.org.zookeeper.ClientFactory;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.CuratorFramework;
import org.apache.zookeeper.CreateMode;

@Slf4j
/**
 * id生成器
 */
public class IDMaker {

    public static final String ZK_ADDRESS = "";
    CuratorFramework client = ClientFactory.createSimple(ZK_ADDRESS);

    /**
     * 创建临时顺序节点
     *
     * @param pathPerfix 节点路径
     * @return 创建后的完整路径名称
     */
    private String createSeqNode(String pathPerfix) {
        try {
            client.start();
            String destPath = client.create()
                    .creatingParentsIfNeeded()
                    .withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                    .forPath(pathPerfix);

            return destPath;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            client.close();
        }

        return null;
    }

    public String makeId(String nodeName) {
        String str = createSeqNode(nodeName);
        if (null == str) {
            return null;
        }

        //取得zk节点的末尾序号
        int index = str.lastIndexOf(nodeName);
        if (index > 0) {
            index += str.length();
            return index <= str.length() ? str.substring(index) : "";
        }

        return str;
    }

}

分布式锁

package com.org.zookeeper.distributelock;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
@Getter
@Setter
@Slf4j
public class ZkLock implements AsyncCallback.StringCallback, AsyncCallback.Children2Callback, Watcher {
    ZooKeeper zk;
    CountDownLatch cd = new CountDownLatch(1);
    String ZK_PATH = "/lock";
    String lockName;
    String threadName;

    public void tryLock() {

        try {
            zk.create(ZK_PATH, threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,
                    this, threadName);
            cd.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void unlock() {
        try {
            zk.delete("/" + lockName, -1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    //create
    @Override
    public void processResult(int i, String path, Object ctx, String name) {
        //单个线程启动后创建锁，然后get锁目录的所有子节点，不注册watch所在目录
        log.info(ctx.toString() + " create path: " + name);
        lockName = name.substring(1);
        zk.getChildren("/", false, this, ctx);
    }

    //getChildren
    @Override
    public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
        //获得锁目录的所有有序节点，然后排序，取自己在有序list中的index
        if (children == null) {
            log.error(ctx.toString() + "children null");
        } else {
            try {
                Collections.sort(children);
                int i = children.indexOf(lockName);
                if (i < 1) {
                    log.info(threadName + " is first...");
                    zk.setData("/", threadName.getBytes(), -1);
                    cd.countDown();
                } else {
                    //监听前一个节点的变化
                    log.info(threadName + " watch " + children.get(i -1));
                    zk.exists("/" + children.get(i - 1), this);
                }
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }

    //exists
    @Override
    public void process(WatchedEvent watchedEvent) {
        Event.EventType type = watchedEvent.getType();
        switch (type) {
            case NodeDeleted:
                zk.getChildren("/", false, this, "");
            case NodeChildrenChanged:
                break;
        }

    }
}