使用Zookeeper实现服务注册中心-《架构探险-从零开始写分布式服务框架》读书笔记

gghh2015

已于 2022-01-31 15:52:20 修改

阅读量2k

点赞数

分类专栏：分布式读书笔记文章标签： zookeeper 架构分布式

于 2018-04-06 16:38:50 首次发布

本文链接：https://blog.csdn.net/gghh2015/article/details/79834060

版权

读书笔记同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

分布式

4 篇文章 0 订阅

订阅专栏

前言

最近在看《架构探险-从零开始写分布式服务框架》，对于分布式框架的入门级选手还是挺合适的，扫盲。对分布式服务框架中的基本概念：RPC、SOA、序列化、Spring集成RPC、ZooKeeper、I/O模型、Netty、软负载、服务治理做了系统介绍。手写了RPC框架、使用ZooKeeper实现注册中心、Netty服务端和客户端，以及前面各个概念的代码实现。总之，概念讲的比较清楚，代码也比较多，容易理解，好上手。

正文

简单记一下，这部分主要的代码所实现的功能：
这里写图片描述

主要维护两个数据，一个服务方使用的提供服务的方法列表providerServiceMap，一个消费方使用的服务列表serviceMetaMap4Consume。

registerProvider()方法是服务提供方使用，把传入的服务提供者列表放入providerServiceMap中；注册到ZK对应的节点下；监听服务路径，变化时刷新providerServiceMap。
registerInvoker()方法是把节点注册到ZK对应的节点下。
initProviderMap()方法是消费方使用，调用fetchOrUpdateServiceMetaData()，从ZK中获取服务者列表，放入serviceMetaMap4Consume。
getProviderServiceMap()获取providerServiceMap。
getServiceMetaDataMap4Consume()获取serviceMetaMap4Consume。

具体代码如下：

public interface IRegisterCenter4Invoker {
    /**
     * 消费端初始化服务提供者信息本地缓存
     */
    public void initProviderMap();

    /**
     * 消费端获取服务提供者信息
     */
    public Map<String,List<ProviderService>> getServiceMetaDataMap4Consume();

    /**
     * 消费端将消费者信息注册到ZK对应的节点下
     */
    public void registerInvoker(final InvokerService invoker);
}

public interface IRegisterCenter4Provider {
    /**
     * 服务端将服务提供者信息注册到ZK对应的节点下
     */
    public void registerProvider (final List<ProviderService> serviceMetaData);

    /**
     * 服务端获取服务提供者信息
     *
     * 返回对象：key：服务提供者接口，value：服务提供者服务方法列表
     */
    public Map<String,List<ProviderService>> getProviderServiceMap();

}

package ZookeeperInterfaceImpl;

import Service.InvokerService;
import Service.ProviderService;
import ZookeeperInterface.IRegisterCenter4Invoker;
import ZookeeperInterface.IRegisterCenter4Provider;

import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.I0Itec.zkclient.IZkChildListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.serialize.SerializableSerializer;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.StringUtils;

/**
 * 注册中心实现
 *
 * @author zhangna
 * @date 2018-04-05 18:23
 */
public class RegisterCenter implements IRegisterCenter4Invoker, IRegisterCenter4Provider {

    private static RegisterCenter registerCenter = new RegisterCenter();

    //服务提供者列表，key:服务提供者接口 value:服务提供者服务方法列表
    private static final Map<String, List<ProviderService>> providerServiceMap = Maps.newConcurrentMap();

    //服务端ZK服务元信息，选择服务（第一次直接从ZK拉取，后续由ZK的监听机制主动更新）
    private static final Map<String, List<ProviderService>> serviceMetaDataMap4Consume = Maps.newConcurrentMap();

    //从配置文件中获取ZK的服务地址列表
    private static String ZK_SERVICE = PropertyConfigeHelper.getZkService();

    //从配置文件中获取ZK会话超时时间配置
    private static int ZK_SESSION_TIME_OUT = PropertyConfigeHelper.getZKSessionTimeout();

    //从配置文件中获取ZK连接超时时间配置
    private static int ZK_CONNECTION_TIME_OUT = PropertyConfigeHelper.getZKConnectionTimeout();

    //组装ZK根路径/APPKEY路径
    private static String ROOT_PATH = "/config_register/" + PropertyConfigeHelper.getAppName();
    public static String PROVIDER_TYPE = "/provider";
    public static String INVOKE_TYPE = "/consumer";
    private static volatile ZkClient zkClient = null;

    private RegisterCenter(){}

    public static RegisterCenter singleton(){
        return registerCenter;
    }

    public void registerProvider(final List<ProviderService> serviceMetaData) {
        if(CollectionUtils.isEmpty(serviceMetaData)){
            return;
        }

        //连接ZK，注册服务
        synchronized (RegisterCenter.class){
            for(ProviderService provider : serviceMetaData){
                //获得接口名称
                String serviceItfKey = provider.getServiceItf().getName();
                //获得提供者列表
                List<ProviderService> providers = providerServiceMap.get(serviceItfKey);
                if(providers == null){
                    providers = Lists.newArrayList();
                }
                providers.add(provider);
                providerServiceMap.put(serviceItfKey,providers);
                if(zkClient == null){
                    zkClient = new ZkClient(ZK_SERVICE,ZK_SESSION_TIME_OUT,ZK_CONNECTION_TIME_OUT,new SerializableSerializer());
                }
                //创建ZK命名空间/当前部署应用APP命名空间
                boolean exist= zkClient.exists(ROOT_PATH);
                if(!exist){
                    zkClient.createPersistent(ROOT_PATH,true);
                }
                //创建服务提供者节点，将服务提供者信息作为ZK子节点写入ZK
                for(Map.Entry<String,List<ProviderService>> entry : providerServiceMap.entrySet()){
                    //创建服务提供者节点
                    String serviceNode = entry.getKey();
                    String servicePath = ROOT_PATH + "/" + serviceNode + PROVIDER_TYPE;
                    exist = zkClient.exists(servicePath);
                    if(!exist){
                        zkClient.createPersistent(servicePath,true);
                    }
                    //创建当前服务器节点
                    int serverPort = entry.getValue().get(0).getServerPort();
                    String localIp = IPHelper.localIP();
                    String currentServiceIpNode = servicePath + "/" + localIp + "|" + serverPort;
                    exist = zkClient.exists(currentServiceIpNode);
                    if(!exist){
                        //注意，这里创建的是临时节点
                        zkClient.createEphemeral(currentServiceIpNode);
                    }
                    //监听注册服务的变化(将子节点路径注册监听器)，同时更新数据到本地缓存
                    zkClient.subscribeChildChanges(servicePath, new IZkChildListener() {
                        @Override
                        public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
                            if(currentChilds == null){
                                currentChilds = Lists.newArrayList();
                            }
                            //存活的服务IP列表
                            List<String> activityServiceIPList = Lists.newArrayList(
                                    Lists.transform(currentChilds,new Function<String,String>(){
                                        @Override
                                        public String apply(String input){
                                            return StringUtils.split(input,"|")[0];
                                        }
                                    }));
                            //更新本地服务者缓存信息
                            refreshActivityService(activityServiceIPList);
                        }
                    });
                }
            }
        }
    }

    @Override
    public void initProviderMap() {
        if(MapUtils.isEmpty(serviceMetaDataMap4Consume)){
            serviceMetaDataMap4Consume.putAll(fetchOrUpdateServiceMetaData());
        }
    }

    @Override
    public Map<String, List<ProviderService>> getServiceMetaDataMap4Consume() {
        return serviceMetaDataMap4Consume;
    }

    @Override
    public Map<String, List<ProviderService>> getProviderServiceMap() {
        return providerServiceMap;
    }

    @Override
    public void registerInvoker(InvokerService invoker) {
        if(invoker == null){
            return;
        }
        //连接ZK，注册服务
        synchronized (RegisterCenter.class){
            if(zkClient == null){
                zkClient = new ZkClient(ZK_SERVICE,ZK_SESSION_TIME_OUT,ZK_CONNECTION_TIME_OUT,new SerializableSerializer());
            }
            //创建ZK命名空间/当前部署应用APP命名空间
            boolean exist = zkClient.exists(ROOT_PATH);
            if(!exist){
                zkClient.createPersistent(ROOT_PATH,true);
            }
            //创建服务消费者节点
            String serviceNode = invoker.getServiceItf().getName();
            String servicePath = ROOT_PATH + "/" +serviceNode + INVOKE_TYPE;

            exist = zkClient.exists(servicePath);
            if(!exist){
                zkClient.createPersistent(servicePath);
            }
            //创建当前服务器节点
            String localIp = IpHelper.localIp();
            String currentServiceIpNode = servicePath + "/" +localIp;
            exist = zkClient.exists(currentServiceIpNode);
            if(!exist){
                //注意，这里创建的是临时节点
                zkClient.createEphemeral(currentServiceIpNode);
            }
        }
    }

    //利用ZK自动刷新当前存活的服务提供者列表数据
    private void refreshActivityService(List<String> serviceIpList){
        if(serviceIpList == null){
            serviceIpList = Lists.newArrayList();
        }
        Map<String,List<ProviderService>> currentServiceMetaDataMap = Maps.newHashMap();
        for(Map.Entry<String,List<ProviderService>> entry : providerServiceMap.entrySet()){
            String key = entry.getKey();
            List<ProviderService> providerServices = entry.getValue();
            List<ProviderService> serviceMetaDataModelList = currentServiceMetaDataMap.get(key);
            if(serviceMetaDataModelList == null){
                serviceMetaDataModelList = Lists.newArrayList();
            }
            for(ProviderService serviceMetaData : providerServices){
                if(serviceIpList.contains(serviceMetaData.getServerIp())){
                    serviceMetaDataModelList.add(serviceMetaData);
                }
            }
            currentServiceMetaDataMap.put(key,serviceMetaDataModelList);
        }
        providerServiceMap.putAll(currentServiceMetaDataMap);
    }

    //刷新服务员数据列表（与上个方法唯一不同的地方是把数据putAll到serviceMetaDataMap4Consume）
    private void refreshServiceMetaDataMap(List<String> serviceIpList){
        if(serviceIpList == null){
            serviceIpList = Lists.newArrayList();
        }
        Map<String,List<ProviderService>> currentServiceMetaDataMap = Maps.newHashMap();
        for(Map.Entry<String,List<ProviderService>> entry:serviceMetaDataMap4Consume.entrySet()){
            String serviceItfKey = entry.getKey();
            List<ProviderService> serviceList = entry.getValue();
            List<ProviderService> providerServiceList = currentServiceMetaDataMap.get(serviceItfKey);
            if(providerServiceList == null){
                providerServiceList = Lists.newArrayList();
            }
            for(ProviderService serviceMetaData : serviceList){
                if(serviceIpList.contains(serviceMetaData.getServerIp())){
                    providerServiceList.add(serviceMetaData);
                }
            }
            currentServiceMetaDataMap.put(serviceItfKey,providerServiceList);
        }
        serviceMetaDataMap4Consume.putAll(currentServiceMetaDataMap);
        System.out.println("serviceMetaDataMap4Consume:" + JSON.toJSONString(serviceMetaDataMap4Consume);
    }


    private Map<String,List<ProviderService>> fetchOrUpdateServiceMetaData(){
        final Map<String,List<ProviderService>> providerServiceMap = Maps.newConcurrentMap();
        //连接ZK
        synchronized (RegisterCenter.class){
            if(zkClient == null){
                zkClient = new ZkClient(ZK_SERVICE,ZK_SESSION_TIME_OUT,ZK_CONNECTION_TIME_OUT,new SerializableSerializer());
            }
        }
        //从ZK获取服务提供者列表
        String providePath = ROOT_PATH;
        List<String> providerServices = zkClient.getChildren(providePath);
        for(String serviceName : providerServices){
            String servicePath = providePath + "/" + serviceName + PROVIDER_TYPE;
            List<String> ipPathList = zkClient.getChildren(servicePath);
            for(String ipPath : ipPathList){
                String serverIp = StringUtils.split(ipPath,"|")[0];
                String serverPort = StringUtils.split(ipPath,"|")[1];
                List<ProviderService> providerServiceList = providerServiceMap.get(serviceName);
                if(providerServiceList == null){
                    providerServiceList = Lists.newArrayList();
                }
                ProviderService providerService = new ProviderService();
                try{
                    providerService.setServiceItf(ClassUtils.getClass(serviceName));
                }catch (ClassNotFoundException e){
                    throw new RuntimeException(e);
                }
                providerService.setServerIp(serverIp);
                providerService.setServerPort(Integer.parseInt(serverPort));
                providerServiceList.add(providerService);
                providerServiceMap.put(serviceName,providerServiceList);
            }
            //监听注册服务的变化，同时更新数据到本地缓存
            zkClient.subscribeChildChanges(servicePath, new IZkChildListener() {
                @Override
                public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
                    if(currentChilds == null){
                        currentChilds = Lists.newArrayList();
                    }
                    currentChilds = Lists.newArrayList(Lists.transform(currentChilds, new Function<String, String>() {
                        @Override
                        public String apply(String input) {
                            return StringUtils.split(input,"|")[0];
                        }
                    }));
                }
            });
        }
        return providerServiceMap;
    }
}

另外，两个容易记忆模糊的关键字：
final的使用（Java编程思想）：
修饰基本类型：使数值恒定不变。
修饰对象应用：使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象，然而，对象其自身却是可以被修改的。
修饰参数：无法在方法中更改参数引用所指向的对象。

volatile的使用：
Java内部两种同步机制，一种是synchronized另一种是volatile。线程能够自动发现volatile变量的最新值。（https://www.ibm.com/developerworks/cn/java/j-jtp06197.html）

gghh2015

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
使用Zookeeper实现服务注册中心-《架构探险-从零开始写分布式服务框架》读书笔记

前言最近在看《架构探险-从零开始写分布式服务框架》，对于分布式框架的入门级选手还是挺合适的，扫盲。对分布式服务框架中的基本概念：RPC、SOA、序列化、Spring集成RPC、ZooKeeper、I/O模型、Netty、软负载、服务治理做了系统介绍。手写了RPC框架、使用ZooKeeper实现注册中心、Netty服务端和客户端，以及前面各个概念的代码实现。总之，概念讲的比较清楚，代码也比较多，...
复制链接

扫一扫

专栏目录