单机Zookeeper基础

什么Zookeeper

Zookeeper是一个分布式开源框架，提供了协调分布式应用的基本服务，它向外部应用暴露一组通用服务——分布式同步（Distributed Synchronization）、命名服务（Naming Service）、集群维护（Group Maintenance）等，简化分布式应用协调及其管理的难度，提供高性能的分布式服务。ZooKeeper本身可以以单机模式安装运行，不过它的长处在于通过分布式ZooKeeper集群（一个Leader，多个Follower），基于一定的策略来保证ZooKeeper集群的稳定性和可用性，从而实现分布式应用的可靠性。

1、zookeeper是为别的分布式程序服务的

2、Zookeeper本身就是一个分布式程序（只要有半数以上节点存活，zk就能正常服务）

3、Zookeeper所提供的服务涵盖：主从协调、服务器节点动态上下线、统一配置管理、分布式共享锁、统> 一名称服务等

4、虽然说可以提供各种服务，但是zookeeper在底层其实只提供了两个功能：

管理(存储，读取)用户程序提交的数据（类似namenode中存放的metadata）； 
并为用户程序提供数据节点监听服务；

Zookeeper集群机制

Zookeeper集群的角色： Leader 和 follower 
只要集群中有半数以上节点存活，集群就能提供服务

Zookeeper特性

1、Zookeeper：一个leader，多个follower组成的集群

2、全局数据一致：每个server保存一份相同的数据副本，client无论连接到哪个server，数据都是一致的

3、分布式读写，更新请求转发，由leader实施

4、更新请求顺序进行，来自同一个client的更新请求按其发送顺序依次执行

5、数据更新原子性，一次数据更新要么成功，要么失败

6、实时性，在一定时间范围内，client能读到最新数据

Zookeeper数据结构

1、层次化的目录结构，命名符合常规文件系统规范(类似文件系统） 

2、每个节点在zookeeper中叫做znode,并且其有一个唯一的路径标识 

3、节点Znode可以包含数据和子节点（但是EPHEMERAL类型的节点不能有子节点）

节点类型 
a、Znode有两种类型：

短暂（ephemeral）（create -e /app1/test1 “test1” 客户端断开连接zk删除ephemeral类型节点） 
持久（persistent） （create -s /app1/test2 “test2” 客户端断开连接zk不删除persistent类型节点）

b、Znode有四种形式的目录节点（默认是persistent ）

PERSISTENT 
PERSISTENT_SEQUENTIAL（持久序列/test0000000019 ） 
EPHEMERAL 
EPHEMERAL_SEQUENTIAL

c、创建znode时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护

d、在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样客户端可以通过顺序号推断事件的顺序

 zookeeper单机安装

1.安装jdk

2.安装Zookeeper. 在官网http://zookeeper.apache.org/下载zookeeper.我下载的是zookeeper-3.4.6版本。

3.解压后吧conf目录中的zoo_sample.cfg 文件复制并粘贴到当前目录下，命名zoo.cfg.

Java操作Zookeeper

Zookeeper说明
创建节点(znode) 方法:
create:
提供了两套创建节点的方法，同步和异步创建节点方式。
口
同步方式:
参数1，节点路径《名称) : InodeName (不允许递归创建节点，也就是说在父节点不存在
的情况下，不允许创建子节点)
参数2，节点内容: 要求类型是字节数组(也就是说，不支持序列化方式，如果需要实现序
列化，可使用java相关序列化框架，如Hessian、Kryo框架)
参數3，节点权限: 使用Ids.OPEN_ACL_UNSAFE开放权限即可。(这个参数一般在权展
没有太高要求的场景下，没必要关注)
参数4,节点类型: 创建节点的类型: CreateMode，提供四种首点象型

PERSISTENT                    持久化节点
PERSISTENT_SEQUENTIAL        顺序自动编号持久化节点，这种节点会根据当前已存在的节点数自动加 1
EPHEMERAL                     临时节点， 客户端session超时这类节点就会被自动删除
EPHEMERAL_SEQUENTIAL         临时自动编号节点

　　

Maven依赖信息

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

项目结构图

package cn.liuzhiw.zoo;

import org.apache.zookeeper.*;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.data.Stat;


import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Created by 刘志威 on 2018/4/25.
 */
public class ZooClient2 implements Watcher {
    //zk链接地址
    private final String PORT="127.0.0.1:2181";
    //zk会话的超时时间
    private final int SESSION_TIMEOUT=2000;
    // 信号量,阻塞程序执行,用户等待zookeeper连接成功,发送成功信号，
    private static final CountDownLatch countDownLatch = new CountDownLatch(1);
    //zk客服端
    private ZooKeeper zooKeeper;
    //创建链接
    public void crateConnection(){
        try {
            zooKeeper=new ZooKeeper(PORT,SESSION_TIMEOUT,this);
            System.out.println("zk 开始启动连接服务器....");
            //进行阻塞
            countDownLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //process() 是 Watch 接口中的回调方法。当 ZooKeeper 向客户端发送一个 Watcher 时间通知时，
    public void process(WatchedEvent watchedEvent) {
        //获取事件的状态
        KeeperState state = watchedEvent.getState();
        //获取事件的类型
        EventType type = watchedEvent.getType();
        //获取事件路径
        String path = watchedEvent.getPath();
        System.out.println("进入到process方法,事件通知 Path:" + path);
        if (KeeperState.SyncConnected == state) {
            if (EventType.None == type) {
                // 建立连接状态
                System.out.println("zk开始连接...");
                //利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，
                // 此时就可以利用CountDownLatch来实现这种功能了。
                countDownLatch.countDown();
                //等待链接解成功了才可以走下面的方法
            } else if (EventType.NodeCreated == type) {
                System.out.println("事件通知,新增note节点:" + path);
            } else if (EventType.NodeDataChanged == type) {
                System.out.println("事件通知,当前node节点" + path + "被修改....");
            } else if (EventType.NodeDeleted == type) {
                System.out.println("事件通知,当前node节点" + path + "被删除....");
            }

        }
    }
    //创建一个新的持久节点
    public boolean crateNode(String path,String data){
        //创建持久节点,开放权限
        try {
            exists(path,true);
            this.zooKeeper.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("节点创建成功, Path:" + path + ",data:" + data);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    //判断节点是否存在
    public Stat exists(String path, boolean needWatch) {
        try {
            return this.zooKeeper.exists(path, needWatch);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    //删除节点
    public boolean deleteNode(){
        return false;
    }
    //修改节点
    public boolean updateNode(String path, String data) throws KeeperException, InterruptedException {
        exists(path, true);
        this.zooKeeper.setData(path, data.getBytes(), -1);
        return false;
    }
}

　　

package cn.liuzhiw.app;

import cn.liuzhiw.zoo.ZooClient;
import cn.liuzhiw.zoo.ZooClient2;
import org.apache.zookeeper.KeeperException;

import java.io.IOException;

/**
 * 启动类
 * Created by 刘志威 on 2018/4/25.
 */
public class App {
    public static void main(String[] args) throws KeeperException, InterruptedException {
        ZooClient2 zooClient=new ZooClient2();
        zooClient.crateConnection();
        zooClient.updateNode("/liuzhiwei","刘爸爸");
    }
}

　　效果图