zookeeper练习

命令行操作

配置环境变量：vi /etc/profile

 
 

  
  export ZOOKEEPER_HOME=/root/hd/zookeeper-3.4.10

 
 
 
 

  
  export PATH=
  
  $ZOOKEEPER_HOME/bin:
  
  $PATH

 
 

声明环境变量：source /etc/profile
发送到其他机器
scp /etc/profile hsiehchou122:/etc/
scp /etc/profile hsiehchou123:/etc/
scp /etc/profile hsiehchou124:/etc/
启动zookeeper
zkServer.sh start
查看zookeeper状态
zkServer.sh status

1)启动客户端
bin/zkCli.sh

2)连接其它机器客户端操作
没有太大必要，每台机器内容都一样
connect hsiehchou122:2181
connect hsiehchou123:2181
connect hsiehchou124:2181

3)查看历史操作记录
history

4)查看当前节点的内容
ls /

5)存储：创建节点
create /hsiehchou 10(存储的数据)

6)查看节点的值
get /hsiehchou

 
 

  
  10

 
 
 
 

  
  cZxid = 0x400000004

 
 
 
 

  
  ctime = Sat Feb 23 20:05:58 PST 2019

 
 
 
 

  
  mZxid = 0x400000004

 
 
 
 

  
  mtime = Sat Feb 23 20:05:58 PST 2019

 
 
 
 

  
  pZxid = 0x400000004

 
 
 
 

  
  cversion = 0

 
 
 
 

  
  dataVersion = 0

 
 
 
 

  
  aclVersion = 0

 
 
 
 

  
  ephemeralOwner = 0x0

 
 
 
 

  
  dataLength = 2

 
 
 
 

  
  numChildren = 0

 
 

7)创建节点的可选项

 
 

  
  create [-s] [-e] 
  
  path 
  
  data acl

 
 

[-p]永久节点–默认
[-e] 短暂节点
[-s] 带序号

create -e /re hm
注意：此时-e创建的是临时的短暂节点，退出客户端后消失。退出客户端：quit

create -s /re hm
注意：此时-s创建是带序号的节点，可以创建节点名相同的，序号依次累加

 
 

  
  [
  
  zk: localhost:2181(
  
  CONNECTED) 
  
  1] create -s /mm hm

 
 
 
 

  
  Created /mm0000000002

 
 
 
 

  
  [
  
  zk: localhost:2181(
  
  CONNECTED) 
  
  2] create -s /mm hm

 
 
 
 

  
  Created /mm0000000003

 
 
 
 

  
  [
  
  zk: localhost:2181(
  
  CONNECTED) 
  
  3] create -s /mm hm

 
 
 
 

  
  Created /mm0000000004

 
 
 
 

  
  [
  
  zk: localhost:2181(
  
  CONNECTED) 
  
  4] create  /re hm  

 
 
 
 

  
  Created /re

 
 
 
 

  
  [
  
  zk: localhost:2181(
  
  CONNECTED) 
  
  5] create  /re hm

 
 
 
 

  
  Node already exists: /re

 
 

创建短暂带序号节点
create -e -s /tt bt

8)修改节点值
set path data [version]
例如：set /re hm2 1
[version] 版本
注意：设置版本号 必须从0开始

9)删除节点
delete path
[zk: localhost:2181(CONNECTED) 12] ls /
[mm0000000004, re, zookeeper, mm0000000002, mm0000000003, hsiehchou]
[zk: localhost:2181(CONNECTED) 13] delete /mm0000000002
[zk: localhost:2181(CONNECTED) 14] ls /
[mm0000000004, re, zookeeper, mm0000000003, hsiehchou]

10)创建子节点
create /re/pa qi

11)递归删除
rmr /re

12)监听
获得监听（文件）：get path watch
获得当前节点下增减变化（文件夹）：ls path watch

13)查看当前节点的状态
stat /hsiehchou

节点状态信息

czxid：zookeeper事务id
ctime：节点创建时间
mZxid：最后更新的czxid
mtime：最后修改的时间*
pZxid：最后更新子节点的czxid
cversion：子节点的变化号、子节点修改次数
dataVersion：数据变化号
aclVersion：访问控制列表的变化号
ephemeralOwner：临时节点判断
dataLength：节点数据长度
numChildren：子节点个数

JAVA-API 练习

pom.xml

 
 

  
  <?xml version="1.0" encoding="UTF-8"?>

 
 
 
 

  
  <project xmlns="http://maven.apache.org/POM/4.0.0"

 
 
 
 

  
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 
 
 
 

  
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

 
 
 
 
    
  
  <modelVersion>4.0.0
  
  </modelVersion>

 
 
 
 
    
  
  <groupId>com.hsiehchou
  
  </groupId>

 
 
 
 
    
  
  <artifactId>ZKTest
  
  </artifactId>

 
 
 
 
    
  
  <version>1.0-SNAPSHOT
  
  </version>

 
 
 
 
    
  
  <dependencies>

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

 
 
 
 
        
  
  <dependency>

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

 
 
 
 
            
  
  <artifactId>zookeeper
  
  </artifactId>

 
 
 
 
            
  
  <version>3.4.10
  
  </version>

 
 
 
 
        
  
  </dependency>

 
 
 
 
        
  
  <dependency>

 
 
 
 
            
  
  <groupId>junit
  
  </groupId>

 
 
 
 
            
  
  <artifactId>junit
  
  </artifactId>

 
 
 
 
            
  
  <version>RELEASE
  
  </version>

 
 
 
 
            
  
  <scope>compile
  
  </scope>

 
 
 
 
        
  
  </dependency>

 
 
 
 
    
  
  </dependencies>

 
 
 
 

  
  </project>

 
 

练习1

ZkClient类

 
 

  
  package com.hsiehchou.zk;

 
 
 
 

  
  import org.apache.zookeeper.*;

 
 
 
 

  
  import org.apache.zookeeper.data.Stat;

 
 
 
 

  
  import org.junit.Before;

 
 
 
 

  
  import org.junit.Test;

 
 
 
 

  
  import java.io.IOException;

 
 
 
 

  
  import java.util.List;

 
 
 
 

  
  public 
  
  class ZkClient {

 
 
 
 
    
  
  private String conected = 
  
  "hsiehchou121:2181,hsiehchou122:2181,hsiehchou123:2181,hsiehchou124:2181";

 
 
 
 
    
  
  //毫秒

 
 
 
 
    
  
  private 
  
  int timeout = 
  
  2000;

 
 
 
 

  
      ZooKeeper zkCli = 
  
  null;

 
 
 
 
    
  
  //连接zookeeper集群

 
 
 
 
    
  
  @Before

 
 
 
 
    
  
  public void init() throws IOException {

 
 
 
 
        
  
  //String:连接集群的IP端口号，Int：超时设置，Watcher：监听

 
 
 
 

  
          zkCli = 
  
  new ZooKeeper(conected, timeout, 
  
  new Watcher() {

 
 
 
 
            
  
  //回调方法，显示/节点

 
 
 
 
            
  
  public void process(WatchedEvent watchedEvent) {

 
 
 
 

  
                  List<String> children;

 
 
 
 
                
  
  //获得节点信息 get

 
 
 
 
                
  
  try {

 
 
 
 

  
                      children = zkCli.getChildren(
  
  "/",
  
  true);

 
 
 
 

  
                  } 
  
  catch (KeeperException e) {

 
 
 
 

  
                      e.printStackTrace();

 
 
 
 

  
                  } 
  
  catch (InterruptedException e) {

 
 
 
 

  
                      e.printStackTrace();

 
 
 
 

  
                  }

 
 
 
 

  
              }

 
 
 
 

  
          });

 
 
 
 

  
      }

 
 
 
 
    
  
  //测试 是否连通集群  创建节点

 
 
 
 
    
  
  @Test

 
 
 
 
    
  
  public void createNode() throws KeeperException, InterruptedException {

 
 
 
 

  
          String p = zkCli.create(
  
  "/bq", 
  
  "sk".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

 
 
 
 

  
          System.out.println(p);

 
 
 
 

  
      }

 
 
 
 
    
  
  //查看子节点

 
 
 
 
    
  
  @Test

 
 
 
 
    
  
  public void getChild() throws KeeperException, InterruptedException {

 
 
 
 

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

 
 
 
 
        
  
  for(String c:children){

 
 
 
 

  
              System.out.println(c);

 
 
 
 

  
          }

 
 
 
 

  
      }

 
 
 
 
    
  
  //删除子节点数据:delete path

 
 
 
 
    
  
  @Test

 
 
 
 
    
  
  public void deleteData() throws KeeperException, InterruptedException {

 
 
 
 

  
          zkCli.delete(
  
  "/da", -
  
  1);

 
 
 
 

  
      }

 
 
 
 
    
  
  //修改数据:set path data

 
 
 
 
    
  
  @Test

 
 
 
 
    
  
  public void setData() throws KeeperException, InterruptedException {

 
 
 
 

  
          zkCli.setData(
  
  "/hsiehchou",
  
  "nihao".getBytes(),-
  
  1);

 
 
 
 
        
  
  //查看/hsiehchou

 
 
 
 
        
  
  byte[] data = zkCli.getData(
  
  "/hsiehchou", 
  
  false, 
  
  new Stat());

 
 
 
 

  
          System.out.println(
  
  new String(data));

 
 
 
 

  
      }

 
 
 
 
    
  
  //指定节点是否存在

 
 
 
 
    
  
  @Test

 
 
 
 
    
  
  public void testExist() throws KeeperException, InterruptedException {

 
 
 
 

  
          Stat exists = zkCli.exists(
  
  "/hsiehchou", 
  
  false);

 
 
 
 

  
          System.out.println(exists == 
  
  null ? 
  
  "no have":
  
  "have");

 
 
 
 

  
      }

 
 
 
 

  
  }

 
 

练习2

WatchDemo类

 
 

  
  package com.hsiehchou.watch;

 
 
 
 

  
  import org.apache.zookeeper.KeeperException;

 
 
 
 

  
  import org.apache.zookeeper.WatchedEvent;

 
 
 
 

  
  import org.apache.zookeeper.Watcher;

 
 
 
 

  
  import org.apache.zookeeper.ZooKeeper;

 
 
 
 

  
  import java.io.IOException;

 
 
 
 

  
  public 
  
  class WatchDemo {

 
 
 
 
    
  
  public 
  
  static 
  
  void main(
  
  String[] args) throws IOException, KeeperException, InterruptedException {

 
 
 
 
        
  
  String 
  
  connected = 
  
  "hsiehchou121:2181,hsiehchou122:2181,hsiehchou123:2181,hsiehchou124:2181,";

 
 
 
 
        
  
  //毫秒

 
 
 
 
        
  
  int timeout = 
  
  2000;

 
 
 
 
        
  
  //1.连接zookeeper集群

 
 
 
 

  
          ZooKeeper zkCli = 
  
  new ZooKeeper(
  
  connected, timeout, 
  
  new Watcher() {

 
 
 
 
            
  
  //监听回调

 
 
 
 
            
  
  public 
  
  void 
  
  process(WatchedEvent watchedEvent) {

 
 
 
 

  
                  System.out.
  
  println(
  
  "正在监听中.........");

 
 
 
 

  
              }

 
 
 
 

  
          });

 
 
 
 
        
  
  //2.监听： ls / watch    get / watch

 
 
 
 

  
          zkCli.getChildren(
  
  "/", 
  
  new Watcher() {

 
 
 
 
            
  
  public 
  
  void 
  
  process(WatchedEvent watchedEvent) {

 
 
 
 

  
                  System.out.
  
  println(
  
  "此时监听的路径是："+watchedEvent.getPath());

 
 
 
 

  
                  System.out.
  
  println(
  
  "此时监听的类型为："+watchedEvent.getType());

 
 
 
 

  
                  System.out.
  
  println(
  
  "有人正在修改数据！！！");

 
 
 
 

  
              }

 
 
 
 

  
          },null);

 
 
 
 

  
          Thread.sleep(Long.MAX_VALUE);

 
 
 
 

  
      }

 
 
 
 

  
  }

 
 

WatchDemo1类

 
 

  
  package com.hsiehchou.watch;

 
 
 
 

  
  import org.apache.zookeeper.KeeperException;

 
 
 
 

  
  import org.apache.zookeeper.WatchedEvent;

 
 
 
 

  
  import org.apache.zookeeper.Watcher;

 
 
 
 

  
  import org.apache.zookeeper.ZooKeeper;

 
 
 
 

  
  import java.io.IOException;

 
 
 
 

  
  public 
  
  class WatchDemo1 {

 
 
 
 
    
  
  public 
  
  static 
  
  void main(
  
  String[] args) throws IOException, KeeperException, InterruptedException {

 
 
 
 

  
          ZooKeeper zkCli = 
  
  new ZooKeeper(
  
  "hsiehchou121:2181,hsiehchou122:2181,hsiehchou123:2181,hsiehchou124:2181", 
  
  2000, 
  
  new Watcher() {

 
 
 
 
            
  
  public 
  
  void 
  
  process(WatchedEvent watchedEvent) {

 
 
 
 

  
              }

 
 
 
 

  
          });

 
 
 
 
        
  
  byte[] data = zkCli.getData(
  
  "/re", 
  
  new Watcher() {

 
 
 
 
            
  
  //具体监听的内容

 
 
 
 
            
  
  public 
  
  void 
  
  process(WatchedEvent watchedEvent) {

 
 
 
 

  
                  System.out.
  
  println(
  
  "此时监听的路径是：" + watchedEvent.getPath());

 
 
 
 

  
                  System.out.
  
  println(
  
  "此时监听的类型为：" + watchedEvent.getType());

 
 
 
 

  
                  System.out.
  
  println(
  
  "有人正在修改数据！！！");

 
 
 
 

  
              }

 
 
 
 

  
          }, null);

 
 
 
 

  
          System.out.
  
  println(
  
  new 
  
  String(data));

 
 
 
 

  
          Thread.sleep(Long.MAX_VALUE);

 
 
 
 

  
      }

 
 
 
 

  
  }

 
 

练习3

ZkClient类

 
 

  
  package com.hsiehchou.qq;

 
 
 
 

  
  import org.apache.zookeeper.KeeperException;

 
 
 
 

  
  import org.apache.zookeeper.WatchedEvent;

 
 
 
 

  
  import org.apache.zookeeper.Watcher;

 
 
 
 

  
  import org.apache.zookeeper.ZooKeeper;

 
 
 
 

  
  import java.io.IOException;

 
 
 
 

  
  import java.util.ArrayList;

 
 
 
 

  
  import java.util.List;

 
 
 
 

  
  /**

 
 
 
 

  
   * 实现对zookeeper / 的监听

 
 
 
 

  
   */

 
 
 
 

  
  public class ZkClient {

 
 
 
 
    
  
  public 
  
  static 
  
  void main(
  
  String[] args) 
  
  throws IOException, KeeperException, InterruptedException {

 
 
 
 
        
  
  //1.获取zookeeper的连接

 
 
 
 

  
          ZkClient zkCli = 
  
  new ZkClient();

 
 
 
 

  
          zkCli.getConnect();

 
 
 
 
        
  
  //2.指定监听的节点路径

 
 
 
 

  
          zkCli.getServers();

 
 
 
 
        
  
  //3.写业务逻辑，一直监听

 
 
 
 

  
          zkCli.getWatch();

 
 
 
 

  
      }

 
 
 
 
    
  
  //1.获得zookeeper连接

 
 
 
 
    
  
  private 
  
  String connected = 
  
  "hsiehchou121:2181,hsiehchou122:2181,hsiehchou123:2181,hsiehchou124:2181";

 
 
 
 
    
  
  //毫秒

 
 
 
 
    
  
  private 
  
  int timeout = 
  
  2000;

 
 
 
 

  
      ZooKeeper zkCli;

 
 
 
 
    
  
  public 
  
  void getConnect() 
  
  throws IOException {

 
 
 
 

  
          zkCli = 
  
  new ZooKeeper(connected, timeout, 
  
  new Watcher() {

 
 
 
 
            
  
  public 
  
  void process(WatchedEvent watchedEvent) {

 
 
 
 

  
                  List<
  
  String> children;

 
 
 
 
                
  
  try {

 
 
 
 

  
                      children = zkCli.getChildren(
  
  "/", 
  
  true);

 
 
 
 
                    
  
  //服务器列表

 
 
 
 

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

 
 
 
 
                    
  
  //获取每个节点的数据

 
 
 
 
                    
  
  for (
  
  String c:children){

 
 
 
 
                        
  
  byte[] data = zkCli.getData(
  
  "/" + c, 
  
  true, 
  
  null);

 
 
 
 

  
                          serverList.
  
  add(
  
  new 
  
  String(data));

 
 
 
 

  
                      }

 
 
 
 
                    
  
  //查看服务器列表

 
 
 
 

  
                      System.out.
  
  println(serverList);

 
 
 
 

  
                  } 
  
  catch (KeeperException e) {

 
 
 
 

  
                      e.printStackTrace();

 
 
 
 

  
                  } 
  
  catch (InterruptedException e) {

 
 
 
 

  
                      e.printStackTrace();

 
 
 
 

  
                  }

 
 
 
 

  
              }

 
 
 
 

  
          });

 
 
 
 

  
      }

 
 
 
 
    
  
  //2.指定监听节点路径

 
 
 
 
    
  
  public 
  
  void getServers() 
  
  throws KeeperException, InterruptedException {

 
 
 
 

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

 
 
 
 
        
  
  //存储服务器列表

 
 
 
 

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

 
 
 
 
        
  
  for (
  
  String c:children){

 
 
 
 
            
  
  byte[] data = zkCli.getData(
  
  "/" + c, 
  
  true, 
  
  null);

 
 
 
 
            
  
  //添加集合中

 
 
 
 

  
              serverList.
  
  add(
  
  new 
  
  String(data));

 
 
 
 

  
          }

 
 
 
 
        
  
  //打印服务器列表

 
 
 
 

  
          System.out.
  
  println(serverList);

 
 
 
 

  
      }

 
 
 
 
    
  
  //3.一直监听

 
 
 
 
    
  
  public 
  
  void getWatch() 
  
  throws InterruptedException {

 
 
 
 
        
  
  //循环监听

 
 
 
 

  
          Thread.sleep(Long.MAX_VALUE);

 
 
 
 

  
      }

 
 
 
 

  
  }