zookeeper学习总结

一、集群部署：

zookeeper集群部署建议为奇数台机器（比如3台，5台），这样做是为了方便Parxos算法选举出leader节点和follower节点；

现在假设有三台centerOS7的机器，IP分别为：10.103.16.207, 10.103.16.208, 10.103.16.209，现在分别在这三台机器上部署上zookeeper环境，步骤如下：

1、配置JDK环境：这个就不用多说了；

2、下载zookeeper包：

到https://archive.apache.org/dist/zookeeper/ 下载zookeeper的包文件，我这里下载的是3.4.10版本；

3、解压文件：

tar -zxvf zookeeper-3.4.10.tar.gz -C /usr/local/zookeeper

4、修改配置；

cd /usr/local/zookeeper/conf

cp zoo_sample.cfg zoo.cfg

vim zoo.cfg

在其中增加下面内容（如果项目已经存在则替换就行）：

dataDir=/usr/local/zookeeper/data

dataLogDir=/usr/local/zookeeper/logs

server.1=10.103.16.207:2888:3888

server.2=10.103.16.208:2888:3888

server.3=10.103.16.209:2888:3888

 

在zookeeper下建立目录：

mkdir data

mkdir logs

切换到data目录下，生成myid文件：

echo “1” >> /usr/local/zookeeper/data/myid

三台机器分别指定对应的ID，如果10.103.16.207上的ID为1，10.103.16.208上的ID为2，10.103.16.209上的ID为3；

5、启动zookeeper；

cd /usr/local/zookeeper/bin

./zkServer.sh start

 

启动后通过命令 ./zkServer.sh status能查看启动是否成功，该节点是leader还是follower；

通过jps命令，如果能看到一个QuorumPeerMain的进程，说明zookeeper进程启动起来了；

6、使用工具操作zookeeper；

cd /usr/local/zookeeper/bin

连接zookeeper：./zkCli.sh 或者 ./zkCli.sh 10.103.16.208:2181；连接成功后就可以进行下面的操作；

查看节点信息：ls /  或者  ls /zookeeper（/zookeeper必须为已经存在的节点）；

创建节点：create /zookeeper/subnode “this is sub node data”

查看节点内容：get /zookeeper/subnode

设置节点内容：set /zookeeper/subnode “change node data”

删除节点：delete /zookeeper/subnode

查看命令行帮助：help

退出cli工具：quit

二、Zookeeper API 使用：

1、导入jar包；

<dependency>
  <groupId>org.apache.zookeeper</groupId>
  <artifactId>zookeeper</artifactId>
  <version>3.4.5</version>
</dependency>

2、编写服务端：

public class Server {
    private static final String connectString = "10.103.16.207:2181";
    private static final int sessionTimeout = 2000;
    private static final String parentNode = "/zookeeper";
    private ZooKeeper zk = null;
    private static final String hostname = "10.103.16.214";

    /**
     * 创建到zk的客户端连接
     */
    public void getConnect() throws Exception {
        zk = new ZooKeeper(connectString, sessionTimeout, null);
    }

    /**
     * 向zk集群注册服务器信息
     */
    public void registerServer(String hostname) throws Exception {
        String create = zk.create(parentNode + "/server", hostname.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(hostname + "  is online.." + create);
    }

    /**
     * 业务功能
     *
     * @throws InterruptedException
     */
    public void handleBussiness(String hostname) throws InterruptedException {
        System.out.println(hostname + "  start working.....");
        Thread.sleep(Long.MAX_VALUE);
    }

    public static void main(String[] args) throws Exception {
        // 获取zk连接
        Server server = new Server();
        server.getConnect();
        // 利用zk连接注册服务器信息
        server.registerServer(hostname);
        // 启动业务功能
        server.handleBussiness(hostname);
    }
}

3、编写客户端：

public class Client implements Watcher {
    private static final String connectString = "10.103.16.207:2181";
    private static final int sessionTimeout = 2000;
    private static final String parentNode = "/zookeeper";
    private volatile List<String> serverList;
    private ZooKeeper zk = null;

    @Override
    public void process(WatchedEvent event) {
        System.out.println(event.getType() + "-------->"  + event.getPath());

        try {
            getServerList();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建到zk的客户端连接
     */
    public void getConnect() throws Exception {
        zk = new ZooKeeper(connectString, sessionTimeout, this);
    }

    /**
     * 获取服务器信息列表
     */
    public void getServerList() throws Exception {
        // 获取服务器子节点信息，并且对父节点进行监听
        List<String> children = zk.getChildren(parentNode, true);
        System.out.println(children);
    }

    /**
     * 业务功能
     */
    public void handleBussiness() throws InterruptedException {
        System.out.println("client start working.....");
        Thread.sleep(Long.MAX_VALUE);
    }

    public static void main(String[] args) throws Exception {
        // 获取zk连接
        Client client = new Client();
        client.getConnect();
        // 业务线程启动
        client.handleBussiness();
    }
} 

需要注意的是zookeeper API这里有个Bug，每次watcher执行后就自动失效了，需要重新绑定watcher一次，而在这个demo中，通过调用zk.getChildren时watch参数传入true来再次绑定（或者调用其他需要传入boolean watch参数的方法来绑定watcher）；

三、zkClient使用：

• 导入jar包；

<dependency>
  <groupId>com.github.sgroschupf</groupId>
  <artifactId>zkclient</artifactId>
  <version>0.1</version>
</dependency>

• 编写服务端：

public class Server {
    private static final String connectString = "10.103.16.207:2181,10.103.16.208:2181,10.103.16.209:2181";
    private static final int sessionTimeout = 2000;
    private static final String parentNode = "/zookeeper";
    private ZkClient zkClient = null;

    private static final String hostname = "10.103.16.214";

    public void getConnect() {
        zkClient = new ZkClient(connectString);
    }

    public void registerServer(String hostname) {
        String create = zkClient.create(parentNode + "/child", "hello, child node", CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(hostname + "  is online.." + create);
    }

    public void handleBusiness(String hostname) throws InterruptedException {
        System.out.println(hostname + "  start working.....");
        Thread.sleep(Long.MAX_VALUE);
    }

    public static void main(String[] args) throws InterruptedException {
        // 获取zk连接
        Server server = new Server();
        server.getConnect();
        // 利用zk连接注册服务器信息
        server.registerServer(hostname);
        // 启动业务功能
        server.handleBusiness(hostname);
    }
}

• 编写客户端：

public class Client implements IZkChildListener, IZkDataListener, IZkStateListener {
    private static final String connectString = "10.103.16.207:2181,10.103.16.208:2181,10.103.16.209:2181";
    private static final int sessionTimeout = 2000;
    private static final String parentNode = "/zookeeper";
    private volatile List<String> serverList;

    private static ZkClient zkClient = null;

    @Override
    public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
        System.out.println("-----------child change: " + parentPath + "         " + currentChilds);
    }

    @Override
    public void handleDataChange(String dataPath, Object data) throws Exception {
        System.out.println("-----------data change: " + dataPath + "           " + data);
    }

    @Override
    public void handleDataDeleted(String dataPath) throws Exception {
        System.out.println("-----------data delete: " + dataPath);
    }

    @Override
    public void handleStateChanged(Watcher.Event.KeeperState state) throws Exception {
        System.out.println("-----------state change: " + state);
    }

    @Override
    public void handleNewSession() throws Exception {
        System.out.println("-----------new session***********");
    }

    public void getConnect() {
        zkClient = new ZkClient(connectString);

        zkClient.subscribeChildChanges(parentNode, this);
        zkClient.subscribeDataChanges(parentNode, this);
        zkClient.subscribeStateChanges(this);

    }

    public void handleBussiness() throws InterruptedException {
        System.out.println("client start working.....");
        Thread.sleep(Long.MAX_VALUE);
    }

    public static void main(String[] args) throws InterruptedException {
        // 获取zk连接
        Client client = new Client();
        client.getConnect();
        // 业务线程启动
        client.handleBussiness();
    }
}

四、Curator使用：

• 导入jar包；

  <dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>2.7.0</version>
  </dependency>

• 编写服务端：

  public class Server1 {
      private static final String connectString = "10.103.16.207:2181,10.103.16.208:2181,10.103.16.209:2181";
      private static final int sessionTimeout = 2000;
      private static final String parentNode = "/zookeeper";
      private CuratorFramework client = null;
  
      private static final String hostname = "10.103.16.214";
  
      public void getConnect() {
          client = CuratorFrameworkFactory.newClient(
                  connectString,
                  new RetryNTimes(10, 5000)
          );
          client.start();
      }
  
      public void registerServer(String hostname) throws Exception {
          PersistentEphemeralNode node = new PersistentEphemeralNode(client, PersistentEphemeralNode.Mode.EPHEMERAL,
                  parentNode + "/" + hostname, "临时节点".getBytes());
          node.start();
      }
  
      public void handleBusiness(String hostname) throws InterruptedException {
          System.out.println(hostname + "  start working.....");
          Thread.sleep(Long.MAX_VALUE);
      }
  
      public static void main(String[] args) throws Exception {
          // 获取zk连接
          Server1 server = new Server1();
          server.getConnect();
          // 利用zk连接注册服务器信息
          server.registerServer(hostname);
          // 启动业务功能
          server.handleBusiness(hostname);
      }
  }

• 编写客户端：

  public class Client1 {
      private static final String connectString = "10.103.16.207:2181,10.103.16.208:2181,10.103.16.209:2181";
      private static final int sessionTimeout = 2000;
      private static final String parentNode = "/zookeeper";
      private CuratorFramework client = null;
  
      private static final String hostname = "10.103.16.214";
  
      public void getConnect() {
          client = CuratorFrameworkFactory.newClient(
                  connectString,
                  new RetryNTimes(10, 5000)
          );
          client.start();
      }
  
      public void registerServer(String hostname) throws Exception {
          TreeCache watcher = new TreeCache(client,  parentNode + "/" + hostname);
          watcher.getListenable().addListener((client1, event) -> {
              ChildData data = event.getData();
              if (data == null) {
                  System.out.println("No data in event[" + event + "]");
              } else {
                  System.out.println("Receive event: "
                          + "type=[" + event.getType() + "]"
                          + ", path=[" + data.getPath() + "]"
                          + ", data=[" + new String(data.getData()) + "]"
                          + ", stat=[" + data.getStat() + "]");
              }
          });
          watcher.start();
      }
  
      public void handleBusiness(String hostname) throws InterruptedException {
          System.out.println(hostname + "  start working.....");
          Thread.sleep(Long.MAX_VALUE);
      }
  
      public static void main(String[] args) throws Exception {
          // 获取zk连接
          Client1 client = new Client1();
          client.getConnect();
          // 利用zk连接注册服务器信息
          client.registerServer(hostname);
          // 启动业务功能
          client.handleBusiness(hostname);
      }
  }

五、常见问题：

1、集群部署时，配置好各节点参数后，启动zookeeper总是失败：

在BIN目录下有一个zookeeper.out文件记录了zookeeper启动中的日志，通过查看这个日志可以看到在连接其他节点时失败导致的报错，在确定网络没有问题的情况下，就应该是防火墙的原因导致的，只需要关闭掉防火墙就可以了；

在centerOS7下关闭防火墙：

systemctl stop firewalld.service；

在centerOS7下禁止掉防火墙（下次重启系统时也不再启动防火墙）：

systemctl disable firewalld.service；

2、连接zookeeper太久的问题：启动ZK后查看启动状态需要好久才能看到是leader还是follwer，java中使用API连接时卡住比较长时间或者有时经常连接失败的问题：

这个应该是系统的host解析问题导致的，在centerOS7系统中，编辑hosts文件（vim /etc/hosts），删掉127.0.0.1的那一行，重启网卡（/etc/rc.d/init.d/network restart），再次启动zookeeper即可发现连接快了很多；

六、参考资料：

• 书籍：《从PAXOS到ZOOKEEPER分布式一致性原理与实践》；
• https://blog.csdn.net/shuxing520/article/details/79988167

　　　　https://blog.csdn.net/u012152619/article/category/6470028

　　　　https://blog.csdn.net/u012152619/article/details/53053634

　　　　https://www.cnblogs.com/leesf456/p/6036548.html

　　　　https://www.jianshu.com/p/24dbc4e7cc0d

　　　　https://blog.csdn.net/Regan_Hoo/article/details/78773817

　　　　https://blog.csdn.net/gs80140/article/details/51496925

• Curator资料：　　　　

　　　　https://www.cnblogs.com/seaspring/p/5536338.html
　　　　https://blog.csdn.net/qq_15370821/article/details/73692288
　　　　https://www.cnblogs.com/sigm/p/6749228.html