Curator 工具类ZKCuratorUtil

import cn.bugstack.middleware.schedule.common.Constants;
import cn.bugstack.middleware.schedule.domain.Instruct;
import com.alibaba.fastjson.JSON;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.TreeCache;
import org.apache.curator.framework.recipes.nodes.PersistentEphemeralNode;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


/**
* zk工具类 curator
*/
public class ZkCuratorUtil {
    private static Logger logger = LoggerFactory.getLogger(ZkCuratorUtil.class);
    public static CuratorFramework client;
    public static String CHARSET_NAME = "utf-8";
    
    
    public static CuratorFramework getClient(String connectString) {
        if (null != client) return client;
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
        //添加重连监听
        client.getConnectionStateListenable().addListener((curatorFramework, connectionState) -> {
            switch (connectionState) {
                //Sent for the first successful connection to the server
                case CONNECTED:
                    logger.info("middleware schedule init server connected {}", connectString);
                    break;
                //A suspended, lost, or read-only connection has been re-established
                case RECONNECTED:


                    break;
                default:
                    break;
            }
        });
        client.start();
        ZkCuratorUtil.client = client;
        return client;
    }


    //所有子节点监听
    public static void addTreeCacheListener(final ApplicationContext applicationContext, String path) throws Exception {
        TreeCache treeCache = new TreeCache(client, path);
        treeCache.start();
        treeCache.getListenable().addListener((curatorFramework, event) -> {
            if (null == event.getData()) return;
            byte[] eventData = event.getData().getData();
            if (null == eventData || eventData.length < 1) return;
            String json = new String(eventData, CHARSET_NAME);
            if ("".equals(json) || json.indexOf("{") != 0 || json.lastIndexOf("}") + 1 != json.length()) return;
            Instruct instruct = JSON.parseObject(new String(event.getData().getData(), CHARSET_NAME), Instruct.class);
            switch (event.getType()) {
                case NODE_ADDED:
                case NODE_UPDATED:
                    break;
                case NODE_REMOVED:
                    break;
                default:
                    break;
            }
        });
    }


    //创建节点
    public static void createNode(String path) throws Exception {
        List<String> pathChild = new ArrayList<>();
        pathChild.add(path);
        while (path.lastIndexOf(Constants.Global.LINE) > 0) {
            path = path.substring(0, path.lastIndexOf(Constants.Global.LINE));
            pathChild.add(path);
        }
        for (int i = pathChild.size() - 1; i >= 0; i--) {
            Stat stat = client.checkExists().forPath(pathChild.get(i));
            if (null == stat) {
                client.create().creatingParentsIfNeeded().forPath(pathChild.get(i));
            }
        }
    }


    //创建节点
    public static void createNodeSimple(String path) throws Exception {
        if (null == client.checkExists().forPath(path)) {
            client.create().creatingParentsIfNeeded().forPath(path);
        }
    }


    //删除节点
    public static void deleteNodeSimple(String path) throws Exception {
        if (null != client.checkExists().forPath(path)) {
            client.delete().deletingChildrenIfNeeded().forPath(path);
        }
    }


    //设置数据
    public static void setData(String path, String data) throws Exception {
        if(null == client.checkExists().forPath(path)) return;
        client.setData().forPath(path, data.getBytes(Constants.Global.CHARSET_NAME));
    }


    //获取数据
    public static byte[] getData(String path) throws Exception {
        return client.getData().forPath(path);
    }


    //删除数据
    public static void deleteDataRetainNode(String path) throws Exception {
        if (null != client.checkExists().forPath(path)) {
            client.delete().forPath(path);
        }
    }


    //添加临时节点数据
    public static void appendPersistentData(String path, String data) throws Exception {
        PersistentEphemeralNode node = new PersistentEphemeralNode(client, PersistentEphemeralNode.Mode.EPHEMERAL, path, data.getBytes(Constants.Global.CHARSET_NAME));
        node.start();
        node.waitForInitialCreate(3, TimeUnit.SECONDS);
    }


    public static void deletingChildrenIfNeeded(String path) throws Exception {
        if (null == client.checkExists().forPath(path)) return;
        // 递归删除节点
        client.delete().deletingChildrenIfNeeded().forPath(path);
    }


}