注册中心

在orz框架中(对就是我们在做的这个框架的名字orz~), 消费者是写死生产者地址的, 为了后面支持集群扩展(真的么...), 我们这次搞一个注册中心, orz是抄..咳咳..借鉴dubbo的产品(产品...), 所以我们使用zookeeper来作为注册中心. 现在先简单了解下注册中心, 帮助还不熟悉的同学(me~).

下面是zk官方文档的一些翻译, 斜体是翻译, 粗体是个人理解

zookeeper

Design Goals 设计目标

zk允许分布式进程互相协作, 通过一个共享的分层命名空间, 该空间简单的组织为一个标准的文件系统. 命名空间包括了数据注册器, 在zk中称作znode, 它们跟文件系统中的文件和目录很像. 不同于为了存储传统的文件系统, zk的数据是在内存中的, 也就是说zk的有高吞吐量和低延迟.

zk实现在高性能, 高可用性, 严格顺序性上做的非常出色. 高性能可以支持在大型分布式系统中使用. 高可用性可以保证在单点挂掉时还可以使用. 严格的顺序性可以让客户端实现复杂的同步功能.

zk是一个类似于文件系统的系统, 它可以协调分布式系统间的工作; 高性能没啥说的; 高可用性,这里后面可以关注下是如何做到的; 严格的顺序性, 这个是比较有用的功能, 可以帮助客户端实现一个同步的功能, 类似mq

就像其他分布式系统一样, zk自己也会复制多份host, 叫做ensemble.
zk服务必须互相知道对方. 它们会维护一个状态表在内存中, 通过事物日志和持久化的快照. 所以只要大部分服务可用, zk就可用.
客户端连接到某一个单独的zk服务器. 客户端会维护一个tcp链接, 并使用该链接发送请求和接收响应, 事件以及发送心跳. 如果该链接断了, 那么客户端会连接到不同的服务器上.

image

zk会使用数字标记每一次更新, 数字反映了zk事务的顺序. 后续操作可以根据这个顺序实现一个更高级的抽象, 比如同步操作.

在以读取操作为主的场景下, zk的速度特别快. zk运行在多台机子上, 当它读取多于写操作时表现的会很好, 比例10:1(读:写)为最佳.

再次强调严格的顺序性; 读取速度比写快, 大部分系统都这样, 后面可以关注下, 这里还特别提到当读操作比例是写的10倍的时候性能最佳,恩~不应该是读越多性能越好么?

Data model and the hierarchical namespace 数据模型和层级命名空间

zk提供的命名空间特别像一个标准的文件系统. 名称就是一系列斜杠"/"分割的路径元素. zk中的每一个节点的名称都是以路径命名的.

image

Nodes and ephemeral nodes 节点和临时节点

不同于标准的文件系统, zk中的每一个节点可以同时拥有数据和子节点. 就像是一个目录同时用于数据.(zk被设计来存储协调数据: 状态信息, 配置信息, 地址信息等等. 所以存储到节点的数据一般都很小, 大概是字节到千字节)我们使用znode来表示我们讨论的zk数据节点.
znode维护一个状态结构, 包含了一些状态修改的版本号, 包括数据修改, ACL(Access Control List 访问控制表)修改, 时间戳修改, 来支持内存校验和协调更新. 每次znode数据改变都会将版本号增加. 比如, 无论何时客户端接收到一条数据, 同时还会接收到该数据的版本.
存储在znode中的数据支持原子读和写. 读取会获取znode的所有相关的数据, 写操作会替换所有znode数据. 每一个节点都有一个acl. 它记录了谁有权限来做这些事.
zk也有临时节点的概念. 临时节点随着会话创建而创建随着会话销毁而删除. 临时节点经常被用来实现tbd(?)

zk的文件系统与传统文件系统最大的区别就是"目录"不仅有子文件还可以存储数据(想到B树和B+树~), 每一个节点都保存了状态以及权限等信息, 用于保证数据的一致性. zk也提供了不同的节点类型, 比如临时节点, 在会话结束的时候就会销毁, 提问~这里的tbd到底是什么?

Conditional updates and watches

*zk支持监控概念. 客户端可以给znode设置监控watch. 当znode改变时watch可以被触发和删除. 当watch被触发, 客户端会接收到消息报, 通知它znode被修改了. 如果客户端和zk某一个服务器断开链接, 客户端会接收到本地通知. 这些可以被用来实现tbd. *

zk提供的监控功能对于实现配置中心或者其他消息订阅功能很有帮助

Guarantees

zk很快使用也很简单, 但是作为构建多种复杂服务(同步)的基础设施, zk提供了一系列保证:
1 顺序一致性 - 客户端发送的更新操作会按照他们的发送顺序执行.
2 可靠性 - 一旦更新操作被执行, 那么在客户端覆盖这个更新操作之前, 该操作的会一直有效.
3 及时性 - 在一定时间范围内, zk保证客户端所看到的系统是最新的.

Simple API

zk目标之一就是提供一套简单的操作接口, 所以zk只提供了如下操作:
create : 在树形结构中创建一个节点
delete : 删除一个节点
exists : 测试一个节点是否存在
get data : 从一个节点获取数据
set data : 写数据到一个节点
get children : 获取一个节点的子节点列表
sync : 等待数据有效时传递.

Implementation

下图展示了zk服务的抽象层组成元素. 除了请求处理器, 服务中的每个元素都会复制自己的副本.

image

复制的数据库是在内存中, 并且包含完整的数据树. 更新操作会被记录到硬盘, 以便后面回复, 写操作在应用到内存数据库之前会被写到硬盘.
每一个zk服务器都会为客户端提供服务. 客户端实际每次只连接一个服务器去提交请求. 处理请求的数据是来自本地复制的其他所有的数据库.
请求处理和发送请求都使用一致的协议.
协议中要求, 客户端发送的所有写请求都必须发送到一个服务器, 这个服务器称作leader, 其他的服务器称作follower, follower接收leader的建议消息并且在消息发送上协调一致. 消息发送层会关注leader由于错误挂掉后的替换, 并且会同步给follower.
zk使用一个自定义的具有原子性的消息传递协议. 因为消息传递是原子性的, 所以当leader接收到一个写请求, 它会计算该请求处理后系统的状态, 然后会将这次的新状态记录在事务中.

实现原理后面专门来讨论

Uses

zk特别的提供了简答的api, 但是使用zk可以实现高级的操作, 比如同步操作, 锁等.

以上就是zk官方文档的一些翻译, 让大家有个初步的了解, 推荐一篇 文章

概念明白了, 我们来跑些例子, zookeeper提供的api非常简单, 下面是java代码, 主要包括crud, 以及节点的检查.
环境
jdk 1.8
zookeeper 版本 3.4.14
客户端maven

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

我们可以使用客户端命令行操作zookeeper, 或者也可以通过ui客户端操作

image

public class ZooMain implements Watcher {

    private static ZooKeeper zooKeeper;

    public ZooMain(String host, int timeout) {
        try {
            zooKeeper = new ZooKeeper(host, timeout, this);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建节点
     *
     * @param node
     * @param data
     */
    public void createNode(String node, byte[] data) {
        try {
            zooKeeper.create(node, data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除节点
     *
     * @param node
     * @param version
     */
    public void delete(String node, int version) {

        try {
            zooKeeper.delete(node, version);
        } catch (InterruptedException | KeeperException e) {
            e.printStackTrace();
        }
    }

    /**
     * 更新节点
     *
     * @param node
     * @param data
     * @param version
     */
    public void update(String node, byte[] data, int version) {

        try {
            zooKeeper.setData(node, data, version);
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查询节点
     *
     * @param node
     * @return
     */
    public String select(String node) {

        try {
            byte[] data = zooKeeper.getData(node, this, null);
            return new String(data, StandardCharsets.UTF_8);
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 版本信息
     *
     * @param node
     * @return
     */
    public int version(String node) {

        try {
            return zooKeeper.exists(node, true).getVersion();
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }

        return -1;
    }

    /**
     * 检查是否存在
     *
     * @param node
     * @param watch
     * @return
     */
    public boolean exists(String node, boolean watch) {

        try {
            Stat stat = zooKeeper.exists("/fff", watch);
            return stat != null;
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();

            throw new RuntimeException();
        }
    }

    /**
     * 监听事件
     *
     * @param event
     */
    @Override
    public void process(WatchedEvent event) {

        if (event.getType() == Event.EventType.NodeDataChanged) { // 节点变换
            System.out.println("changed");
            System.out.println(select("/java"));
        }
    }
}

如果你在执行exists方法报类似错误 "KeeperErrorCode = ConnectionLoss for /node-name", 网上有各种解决办法, 如果你尝试了都不行, 那你可以尝试根据服务端更换下jar包, 比如我用的zookeeper是3.4.14, 我的客户端版本是3.5就会报错, 修改为3.4.14后就正常了, 这个原因我们记一下, 持续关(bu)注(guan)...

关于监听watch

1 监听是一次性的, one-time trigger, 如果需要持续监听, 需要我们在监听到变化后继续设置监听达到持续监听.
2 监听只能在读取操作的时候getData getChildren exists 才有可能设置监听

实现监听

需要实现Watcher接口并实现下面的方法
public void process(WatchedEvent event);
WatchedEvent数据结构包括三部分

final private KeeperState keeperState;
final private EventType eventType;
private String path;

keeperState

zookeeper的session状态: Disconnected 关闭, SyncConnected 同步连接, AuthFailed 权限失败, ConnectedReadOnly 只读连接, SaslAuthenticated, or Expired 过期.

eventType

NodeCreated 节点创建

创建一个nodeCreated监听通过执行exists方法.

NodeDeleted 节点删除

通过exists和getData创建监听

NodeDataChanged 节点数据改变

通过exists和getData创建监听

NodeChildrenChanged 节点子节点改变

通过getChildren创建监听, 上面三个都是针对单一节点, 这个监听针对的是多个子节点. 只针对第一级子节点.

none

使用none表示zookeeper的session被改变了

znodePath

如果eventType不是none的话, znodePath存在, 表示znode路径; 如果监听的是子节点, 返回的是父节点的路径, 也就是说, 这里返回的肯定是设置的监听节点路径

监听使用

public byte[] getData(final String path, Watcher watcher, Stat stat);
public byte[] getData(String path, boolean watch, Stat stat);

api提供很多类似这样的方法, 第一个参数就是操作的节点路径; 第二个参数是关于监听的, 第一个方法就是使用一个新的监听, 第二个方法如果传递true表示使用默认的监听器, 默认监听器是我们在初始化zookeeper客户端的时候设置的. 第三个参数是一个zookeeper的一个状态信息, 如果设置了, 会在方法执行完成后将zookeeper相关信息复制到stat中, 客户端可以通过这个方法获取其中的信息.

zookeeper在3.4及以前删除监听的方法:
1 监听执行了process(一次性)
2 session关闭或者过期
zookeeper在3.5之后可以通过执行removeWatches方法删除

我的注册中心

以上是学习zookeeper的一些基础知识, 后面可能(never)会继续深入学习, 现在我们根据以上所有实现我们自己的注册中心. 在我们之前的文章中已经实现了服务的扫描工作, 所以注册就是将扫描到的服务存储到zookeeper上, 然后客户端通过服务找到服务器并进行远程调用.

注册

那么首先是注册操作. 注册之前首先得知道zookeeper的地址, 如果你是一个敏感的男银, 肯定会发现, 在之前的代码中很多参数都是写死在代码中的, 包括zookeeper地址等(不写死代码就被代码写死_.). 这次本着我们高大上的原则, 当然要从配置文件中读取了. 主要代码如下

初始化properties工具类

private static final String configName = "application.properties";

public void init() {

    properties = new Properties();
    InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(configName);
    if (inputStream != null) {
        try {
            properties.load(inputStream);
        } catch (IOException e) {

            log.error("failed to read properties: [{}]", configName, e);
        }
    }
}

简单读取方法

public String read(String key) {

    if (properties == null) {
        log.error("failed to read key [{}] from properties: [{}]", key, configName);
        throw new NullPointerException("properties is null");
    }

    log.info(properties.getProperty(key));

    return properties.getProperty(key);
}

public int readInt(String key) {

    String value = read(key);
    return Integer.parseInt(value);
}

服务初始化阶段增加配置初始化和注册初始化和注册操作
(以后注释用英文了_.)

public static void init() throws Exception {

    log.info("PRC server init...");
    // config init
    ConfigUtil.instance().init();
    // register init
    Register.instance().init();
    TwoTuples<String, String> twoTuples = ContextUtil.findRoot(classPath());
    // scan service implement
    ContextUtil.scanAndLoad(twoTuples);
    // register sign in service
    Register.instance().signIn();
    start();

    log.info("PRC server init end...");
}

注册类的初始化和注册

public void init() {

    ConfigUtil configUtil = ConfigUtil.instance();
    host = configUtil.read("register.host");
    port = configUtil.readInt("register.port");
    log.info("register init...");
    orzZooKeeper = new OrzZooKeeper(host + ":" + port, timeout);
    log.info("register init end");
}

public void signIn() {

    Map<Key, String> implMap = ServiceContext.INSTANCE.getAllServiceImpls();
    if (orzZooKeeper.notExists(root, false)) {
        orzZooKeeper.createNode(root);
    }

    implMap.forEach((k, v) -> {

        orzZooKeeper.createDeepNode("", k.orzName(), ip() + ":" + RPCServer.port);
    });
}

OrzZooKeeper是操作zookeeper的工具类, 包括最基本的增删改查等操作, 具体代码就不贴了, 跟上面学习zookeeper中例子差不多.
执行后zookeeper中存储如图

image

获取注册服务

服务端注册好服务后, 客户端在执行远程调用时就需要去获取提供服务的地址. 这里我们主要对RPCClient类改造, 初始化方法如下

private static RPCClient client = new RPCClient();

private boolean initOk = false;

public static RPCClient instance() {
    return client;
}

public void init() {

    if (initOk)
        return;

    ConfigUtil.instance().init();
    Register.instance().init();

    initOk = true;
}

配置类和注册中心的初始化和服务端是一样的.
之前RPCClient启动先执行一个static块代码, 创建和服务端的Socket连接(地址写死的), 这回使用注册中心, 这里发送的逻辑需要修改

public Object sendMsg(String msg, Key key) throws IOException {

    PrintStream out = outputStream(key);
    BufferedReader input = inputStream(key);
    out.println(msg);

    String ret = input.readLine();
    log.info("服务器端返回过来的是: " + ret);

    out.close();
    input.close();

    return ret;
}

public PrintStream outputStream(Key key) {

    if (outMap.get(key) != null)
        return outMap.get(key);

    buildSocket(key);

    return outMap.get(key);
}

private void buildSocket(Key key) {

    ServiceAddress address = Register.instance().scan(key);
    Socket socket;
    try {
        socket = new Socket(address.getHost(), address.getPort());
        BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream out = new PrintStream(socket.getOutputStream());
        inputMap.put(key, input);
        outMap.put(key, out);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

代码很简单, 就是发送消息前会先获取和服务端的连接, 服务端地址来源于注册中心:

public ServiceAddress scan(Key key) {

    String node = root + "/" + key.orzName();

    List<String> children = orzZooKeeper.selectChildren(node);

    return loadStrategy(children);
}

/**
 * @param children
 * @return
 */
private ServiceAddress loadStrategy(List<String> children) {
    // TODO taiyn 2020/4/11
    if (CollectionUtil.isEmpty(children))
        throw new IllegalArgumentException();

    String[] address = children.get(0).split(":");
    return new ServiceAddress(address[0], Integer.parseInt(address[1]));
}

总结

本次加入了注册中心, 顺便学习了一些zookeeper的知识. orz差的东西还很多, 下一篇会学习下dubbo的注册过程. 下下篇是netty的加入, 下下下篇就是dubbo中网络通信的学习. 先安排到这_.