基于ZooKeeper的服务注册实现

2019年6月9日 183次阅读来源: billJiang

简介

本文介绍在本地环境搭建ZooKeeper的伪集群环境的步骤，并且在Spring Boot环境下，如何使用ZooKeeper来注册服务。

本文参考了《架构探险》轻量级微服务架构这本书。

本文示例代码：zookeeper-demo

搭建ZooKeeper伪集群

下载并安装

在官网下载ZooKeeper相关包后，解压到/etc/zookeeper下，并复制3份（ZooKeeper构建集群时，官网建议部署奇数个节点）。

《基于ZooKeeper的服务注册实现》安装ZooKeeper

修改配置

将conf/zoo_sample.cfg重命名为zoo.cfg,并将节点1修改为如下配置，具体意思请百度，这里不详细展开，因为这里配置的伪集群，所以要求各端口都不一样。

注意：在路径/home/billjiang/zookeeper/zkServer1目录下需要建立一个myid文件，并在文件中写入内容1

节点1配置

# The number of milliseconds of each tick
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/home/billjiang/zookeeper/zkServer1
clientPort=2181
#cluster
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890

节点2配置

# The number of milliseconds of each tick
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/home/billjiang/zookeeper/zkServer2
clientPort=2182
#cluster
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890

节点3配置

# The number of milliseconds of each tick
tickTime=2000
initLimit=10
syncLimit=5
dataDir=/home/billjiang/zookeeper/zkServer3
clientPort=2183
#cluster
server.1=127.0.0.1:2888:3888
server.2=127.0.0.1:2889:3889
server.3=127.0.0.1:2890:3890

批量启动集群shell脚本

为了启动集群，可以一个一个启动，也可以编写shell脚本批量启动：

zookeeper_start.sh

    #!/bin/bash  
    SERVERS="zkServer1 zkServer2 zkServer3"  
      
    for SERVER in $SERVERS  
    do  
          echo "当前"$SERVER"正在启动...................."  
           #ssh root@$SERVER "source /etc/profile;/usr/apps/zookeeper-3.4.9/bin/zkServer.sh start"  
          sudo /etc/zookeeper/$SERVER/bin/zkServer.sh start
          echo $SERVER"启动结束--------------------------------------------"                                                                         
    done

当然也可以编写批量停止的shell脚本。执行批量启动命令后，如下：

《基于ZooKeeper的服务注册实现》启动ZooKeeper集群

启动集群后，可使用bin/zkCli.sh命令查看ZooKeeper的节点数据。

以上完成了ZooKeeper伪集群的搭建。

服务注册实现

为了演示服务在ZooKeeper上的注册过程，本文这里启动了一个Maven项目zookeeper-learn,项目包含三个module

core 注册的核心逻辑
client 客户端服务1
client2 客户端服务2

《基于ZooKeeper的服务注册实现》 zookeeper-learn

其中client/client2项目都依赖了core项目。在它们的pom.xml配置了该依赖

<dependency>
            <groupId>com.cnpc</groupId>
            <artifactId>core</artifactId>
            <version>0.0.1-SNAPSHOT</version>
</dependency>

core项目的核心代码

定义服务注册接口ServiceRegistry

package com.example.core;

public interface ServiceRegistry {
    /**
     * 注册服务信息
     *
     * @param serviceName    服务名称
     * @param serviceAddress 服务地址
     */
    void register(String serviceName, String serviceAddress);

}

服务注册实现ServiceRegistryImpl
该服务实现将连接ZooKeeper集群，创建节点，并把服务的调用地址作为节点的值存储在该节点上。

package com.example.core;

import org.apache.zookeeper.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.concurrent.CountDownLatch;

@Component
public class ServiceRegistryImpl implements ServiceRegistry, Watcher {
    private static Logger logger = LoggerFactory.getLogger(ServiceRegistryImpl.class);
    private static CountDownLatch latch = new CountDownLatch(1);
    private ZooKeeper zk;
    private static final int SESSION_TIMEOUT = 5000;
    public ServiceRegistryImpl() {

    }

    public ServiceRegistryImpl(String zkServers) {
        try {
            zk = new ZooKeeper(zkServers, SESSION_TIMEOUT, this);
            latch.await();
            logger.debug("connected to zookeeper");
        } catch (Exception ex) {
            logger.error("create zookeeper client failure", ex);
        }
    }

    private static final String REGISTRY_PATH = "/registry";

    @Override
    public void register(String serviceName, String serviceAddress) {
        try {
            String registryPath = REGISTRY_PATH;
            if (zk.exists(registryPath, false) == null) {
                zk.create(registryPath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                logger.debug("create registry node:{}", registryPath);
            }
            //创建服务节点（持久节点）
            String servicePath = registryPath + "/" + serviceName;
            if (zk.exists(servicePath, false) == null) {
                zk.create(servicePath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                logger.debug("create service node:{}", servicePath);
            }
            //创建地址节点
            String addressPath = servicePath + "/address-";
            String addressNode = zk.create(addressPath, serviceAddress.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            logger.debug("create address node:{} => {}", addressNode, serviceAddress);
        } catch (Exception e) {
            logger.error("create node failure", e);
        }
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (watchedEvent.getState() == Event.KeeperState.SyncConnected)
            latch.countDown();
    }
}

客户端注册服务

客户端在启动时，会将自身服务节点注册到ZooKeeper集群中。

application.properties配置

server.address=127.0.0.1
server.port=8080
registry.servers=127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183

服务注册配置RegistryConfig
这样客户端可以读取appliaction.properties的ZooKeeper配置

package com.example.client;

import com.example.core.ServiceRegistry;
import com.example.core.ServiceRegistryImpl;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
@ConfigurationProperties(prefix = "registry")
public class RegistryConfig {

    private String servers;

    @Bean
    public ServiceRegistry serviceRegistry() {
        return new ServiceRegistryImpl(servers);
    }

    public void setServers(String servers) {
        this.servers = servers;
    }
}

用来测试的服务接口：TestController

@RestController
public class TestController {

    @RequestMapping(name="HelloService",method = RequestMethod.GET,path = "/hello")
    public String hello(){
        return "Hello";
    }
}

在项目启动的时候会将注解中name属性有值的方法注册到ZooKeeper集群中，

package com.example.client;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import com.example.core.ServiceRegistry;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.util.Map;

@Component
public class WebListener implements ServletContextListener {

    @Value("${server.address}")
    private String serverAddress;

    @Value("${server.port}")
    private int serverPort;

    @Autowired
    public ServiceRegistry serviceRegistry;


    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext servletContext=sce.getServletContext();
        ApplicationContext applicationContext= WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
        RequestMappingHandlerMapping mapping=applicationContext.getBean(RequestMappingHandlerMapping.class);
        Map<RequestMappingInfo,HandlerMethod> infoMap=mapping.getHandlerMethods();
        for (RequestMappingInfo info : infoMap.keySet()) {
            String serviceName=info.getName();
            System.out.println("-----------------"+serviceName);
            if(serviceName!=null){
                //注册服务
                serviceRegistry.register(serviceName,String.format("%s:%d",serverAddress,serverPort));
            }
        }

    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}

同样在client2项目中，相同的代码，唯一的区别就是client2的application.properties的server.port=8082

同时启动两个client2项目后，通过bin/zkCli.sh命令，连接到任意的一台ZooKeeper节点（因为ZooKeeper几点之间数据会保持同步）。显示如下信息：

[zk: localhost:2181(CONNECTED) 18] ls /registry/HelloService
[address-0000000004, address-0000000003]

使用get查看子节点的值

get /registry/HelloService/address-0000000003
127.0.0.1:8080
cZxid = 0x100000026
ctime = Wed Aug 09 18:00:56 CST 2017
mZxid = 0x100000026
mtime = Wed Aug 09 18:00:56 CST 2017
pZxid = 0x100000026
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x15dc5782fe8000d
dataLength = 14
numChildren = 0

get /registry/HelloService/address-0000000004
127.0.0.1:8081
cZxid = 0x100000028
ctime = Wed Aug 09 18:03:05 CST 2017
mZxid = 0x100000028
mtime = Wed Aug 09 18:03:05 CST 2017
pZxid = 0x100000028
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x15dc5782fe8000e
dataLength = 14
numChildren = 0

当停掉一台客户端client后，再次使用ls 命令，只显示address-0000000004

以上代码完成了ZooKeeper的服务注册。

    原文作者：billJiang
    原文地址: https://www.jianshu.com/p/0dfac0ad266f
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。