<dependencies>

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

			<version>RELEASE</version>

		</dependency>

		<dependency>

			<groupId>org.apache.logging.log4j</groupId>

			<artifactId>log4j-core</artifactId>

			<version>2.8.2</version>

		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->

		<dependency>

			<groupId>org.apache.zookeeper</groupId>

			<artifactId>zookeeper</artifactId>

			<version>3.5.7</version>

		</dependency>

</dependencies>

log4j.rootLogger=INFO, stdout  

log4j.appender.stdout=org.apache.log4j.ConsoleAppender  

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  

log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  

log4j.appender.logfile=org.apache.log4j.FileAppender  

log4j.appender.logfile.File=target/spring.log  

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  

log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

private static String connectString ="hadoop102:2181,hadoop103:2181,hadoop104:2181";

	private static int sessionTimeout = 2000;

	private ZooKeeper zkClient = null;

	@Before

	public void init() throws Exception {

		zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {

			@Override

			public void process(WatchedEvent event) {

				// 收到事件通知后的回调函数（用户的业务逻辑）

				System.out.println(event.getType() + "--" + event.getPath());

				// 再次启动监听

				try {

					zkClient.getChildren("/", true);

				} catch (Exception e) {

					e.printStackTrace();

				}

			}

		});

	}

}

// 创建子节点

@Test

public void create() throws Exception {

		// 参数 1：要创建的节点的路径； 参数 2：节点数据 ； 参数 3：节点权限 ；参数 4：节点的类型

	String nodeCreated = zkClient.create("/miyazono", "jinlian".getBytes(),Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

}

// 获取子节点

@Test

public void getChildren() throws Exception {

		List<String> children = zkClient.getChildren("/", true);

		for (String child : children) {

			System.out.println(child);

		}

		// 延时阻塞

		Thread.sleep(Long.MAX_VALUE);

}

// 判断 znode 是否存在

@Test

public void exist() throws Exception {

	Stat stat = zkClient.exists("/eclipse", false);

	System.out.println(stat == null ? "not exist" : "exist");

}

package com.miyazono.zkcase;

package com.miyazono.zookeeper;

import org.apache.zookeeper.*;

import org.apache.zookeeper.data.Stat;

import java.io.IOException;

/**

 *  当服务器上线后， 将当前服务器对应的信息写到 zk 中

 */

public class Server {

    private String connectionString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";

    private int sessionTimeOut = 10000;

    private ZooKeeper zkClient = null ;

    private String  parentNode = "/servers";

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

        Server server = new Server ();

        //1. 初始化 zk 客户端对象

        server.init();

        //2. 判断 zk 中存储服务器信息的 Znode 是否存在

        server.parentNodeExists();

        //3. 将服务器的信息写入到 zk 中

        server.writeServer(args);

        //4. 保持线程不结束

        Thread.sleep(Long.MAX_VALUE);

    }

    /**

     * args 中包含两个数据:

     *  1. server 的名字

     *  2. server 的信息

     * @param args

     */

    private void writeServer(String [] args) throws KeeperException, InterruptedException {

        String s =

                zkClient.create(parentNode + "/" + args[0], args[1].getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        System.out.println("*********** "+ s +"is on line  ************");

    }

 //2. 判断 zk 中存储服务器信息的 Znode 是否存在

    private void parentNodeExists() throws KeeperException, InterruptedException {

        Stat stat = zkClient.exists(parentNode, false);

        if(stat == null){

            // 创建节点

            zkClient.create(parentNode,"servers".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);

        }

    }

	//1. 初始化 zk 客户端对象

    private void init() throws IOException {

        zkClient = new ZooKeeper(connectionString, sessionTimeOut, new Watcher() {

            @Override

            public void process(WatchedEvent event) {

            }

        });

    }

}

package com.miyazono.zkcase;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.apache.zookeeper.WatchedEvent;

import org.apache.zookeeper.Watcher;

import org.apache.zookeeper.ZooKeeper;

public class DistributeClient {

	private static String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";

	private static int sessionTimeout = 2000;

	private ZooKeeper zk = null;

	private String parentNode = "/servers";

	// 创建到 zk 的客户端连接

	public void getConnect() throws IOException {

		zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {

			@Override

			public void process(WatchedEvent event) {

				// 再次启动监听

				try {

					getServerList();

				} catch (Exception e) {

					e.printStackTrace();

				}

			}

		});

	}

	// 获取服务器列表信息

	public void getServerList() throws Exception {

		// 1 获取服务器子节点信息，并且对父节点进行监听

		List<String> children = zk.getChildren(parentNode, true);

        // 2 存储服务器信息列表

		ArrayList<String> servers = new ArrayList<>();

        // 3 遍历所有节点，获取节点中的主机名称信息

		for (String child : children) {

			byte[] data = zk.getData(parentNode + "/" + child, false, null);

			servers.add(new String(data));

		}

        // 4 打印服务器列表信息

		System.out.println(servers);

	}

	// 业务功能

	public void business() throws Exception{

		System.out.println("client is working ...");

Thread.sleep(Long.MAX_VALUE);

	}

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

		// 1 获取 zk 连接

		DistributeClient client = new DistributeClient();

		client.getConnect();

		// 2 获取 servers 的子节点信息，从中获取服务器信息列表

		client.getServerList();

		// 3 业务进程启动

		client.business();

	}

}