curator使用自增长znode生成id

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_29493353/article/details/85780839

public class CuratorTest {

        static Object ob = new Object();
        private static CuratorFramework curatorFrameworkClient;

        private static RetryPolicy retryPolicy;

        private static ExecutorService executorService;

        private static String IP_TOSTRING = "192.168.0.170:2181";

        private static String ROOT = "/curtor";

        private static String NODE_NAME = "id-generator";

        static {
            retryPolicy = new ExponentialBackoffRetry(1000, 3);
            curatorFrameworkClient = CuratorFrameworkFactory
                    .builder()
                    .connectString(IP_TOSTRING)
                    .sessionTimeoutMs(5000)
                    .connectionTimeoutMs(5000)
                    .retryPolicy(retryPolicy)
                    .build();
            curatorFrameworkClient.start();
            //添加监听事件
            curatorFrameworkClient.getCuratorListenable().addListener( new CuratorListener(){

                @Override
                public void eventReceived(CuratorFramework client, CuratorEvent event) throws Exception {
                    //do you job
                }
            } );

            try {
                executorService = Executors.newFixedThreadPool(10);
                //请先判断父节点/root节点是否存在
                Stat stat = curatorFrameworkClient.checkExists().forPath(ROOT);
                if (stat == null) {
                    curatorFrameworkClient.create().withMode(CreateMode.PERSISTENT).forPath(ROOT, null);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public String generateId() {
            String backPath = "";

            String fullPath = ROOT.concat("/").concat(NODE_NAME);
            try {
                // 关键点：创建持久顺序节点
                backPath = curatorFrameworkClient.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath(fullPath, null);
                //为防止生成的节点浪费系统资源，故生成后异步删除此节点
                String finalBackPath = backPath;
                executorService.execute(() -> {
                    try {
                        curatorFrameworkClient.delete().forPath(finalBackPath);
                        synchronized (ob) {
                            ob.notifyAll();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                String ID = this.splitID(backPath);
                System.out.println("生成的ID=" + ID);

            } catch (Exception e) {
                e.printStackTrace();
            }
            return backPath;
        }

        public String splitID(String path) {
            int index = path.lastIndexOf(NODE_NAME);
            if (index >= 0) {
                index += NODE_NAME.length();
                return index <= path.length() ? path.substring(index) : "";
            }
            return path;

        }

        public  static void main(String[] args){
            CuratorTest tst = new CuratorTest();
            tst.generateId();
            try {
                synchronized (ob) {
                    ob.wait();
                }
                executorService.shutdown();
                curatorFrameworkClient.close();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }


}

源码解析:

1.入口类
 curatorFrameworkClient = CuratorFrameworkFactory
                    .builder()
                    .connectString(IP_TOSTRING)
                    .sessionTimeoutMs(5000)
                    .connectionTimeoutMs(5000)
                    .retryPolicy(retryPolicy)
                    .build();
2.CuratorFrameworkFactory.builder()
    使用内部类 public static class Builder()

3.build()方法
    返回 new CuratorFrameworkImpl(this); this代表builder类

4.CuratorFrameworkImpl类
     //zk客户端实现类
     this.client = new CuratorZookeeperClient(localZookeeperFactory, builder.getEnsembleProvider(), builder.getSessionTimeoutMs(), builder.getConnectionTimeoutMs(), new Watcher()
        {
            @Override
            public void process(WatchedEvent watchedEvent)
            {
                CuratorEvent event = new CuratorEventImpl(CuratorFrameworkImpl.this, CuratorEventType.WATCHED, watchedEvent.getState().getIntValue(), unfixForNamespace(watchedEvent.getPath()), null, null, null, null, null, watchedEvent, null);
                processEvent(event);
            }
        }, builder.getRetryPolicy(), builder.canBeReadOnly());
        //监听
        listeners = new ListenerContainer<CuratorListener>();
        //不能解决的错误监听
        unhandledErrorListeners = new ListenerContainer<UnhandledErrorListener>();
        //后台的一些操作
        backgroundOperations = new DelayQueue<OperationAndData<?>>();
        namespace = new NamespaceImpl(this, builder.getNamespace());
        //自己不配置线程池的话 使用自带的线程池
        threadFactory = getThreadFactory(builder);
        //connectionState管理器 就是zk connection的状态管理器
        connectionStateManager = new ConnectionStateManager(this, builder.getThreadFactory());
        //压缩器
        compressionProvider = builder.getCompressionProvider();
        //权限控制器
        aclProvider = builder.getAclProvider();
        //CuratorFramework状态管理 通过cas控制状态eumn
        state = new AtomicReference<CuratorFrameworkState>(CuratorFrameworkState.LATENT);

5. new CuratorZookeeperClient()
    //主要的成员变量
    private final ConnectionState                   state;
    private final AtomicReference<RetryPolicy>      retryPolicy = new AtomicReference<RetryPolicy>();
    //构造器
     state = new ConnectionState(zookeeperFactory, ensembleProvider, sessionTimeoutMs, connectionTimeoutMs, watcher, tracer, canBeReadOnly);
        setRetryPolicy(retryPolicy);

    --ConnectionState.class
        //主要成员变量
          private final HandleHolder zooKeeper;
           private final Queue<Watcher> parentWatchers = new ConcurrentLinkedQueue<Watcher>();
        //构造函数
         if ( parentWatcher != null )
        {
            parentWatchers.offer(parentWatcher);
        }

        zooKeeper = new HandleHolder(zookeeperFactory, this, ensembleProvider, sessionTimeoutMs, canBeReadOnly);

        --HandleHolder.class
            //zookeeperFactory生成工厂
            private final ZookeeperFactory zookeeperFactory;
            //watcher
            private final Watcher watcher;
  

6. curatorFrameworkClient.start();

connectionStateManager.start(); // 连接管理器（用于管理zkclient session关断状态）

final ConnectionStateListener listener = new ConnectionStateListener()
{
    @Override
    public void stateChanged(CuratorFramework client, ConnectionState newState)
    {
        if ( ConnectionState.CONNECTED == newState || ConnectionState.RECONNECTED == newState )
        {
            logAsErrorConnectionErrors.set(true);
        }
    }
};

this.getConnectionStateListenable().addListener(listener);

client.start();//zk客户端连接

executorService = Executors.newFixedThreadPool(2, threadFactory);  // 1 for listeners, 1 for background ops

executorService.submit(new Callable<Object>()
{
    @Override
    public Object call() throws Exception
    {
        backgroundOperationsLoop();
        return null;
    }
});