深入理解Dubbo原理系列（二）- Dubbo注册中心Zookeeper

最新推荐文章于 2023-11-23 23:25:37 发布
最新推荐文章于 2023-11-23 23:25:37 发布
阅读量571 收藏 1
点赞数 1
分类专栏： Dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zong_0915/article/details/113540058
版权

深入理解Dubbo原理系列（二）- Dubbo注册中心Zookeeper

一. Zookeeper注册中心

1.1 Zookeeper原理概述

首先，注册中心是Dubbo的核心组件之一，而Dubbo一般而言用的都是Nacos或者Zookeeper，这里以Zookeeper为例来进行说。（Nacos我有过相关的原理文章，Zookeeper确实还没有写过，这里写个大概）

Zookeeper是一个树形结构的注册中心，每个节点的类型分为：

  • 持久节点：服务注册后保证节点不会丢失，注册中心重启时也会存在。
  • 持久顺序节点：在持久节点特性的基础上增加了节点先后顺序的能力。
  • 临时节点：服务注册后连接丢失或者Session超时的话，注册的节点会自动被移除。
  • 临时顺序节点：在临时节点特性的基础上增加了节点先后顺序的能力。

对于Dubbo相关节点的创建，只会创建两种节点：持久节点和临时节点，Dubbo结合Zookeeper后，创建的数据树为：
在这里插入图片描述
xxxService代表服务暴露的接口，这里是该接口的全路径地址，例如下图中的com.pro.service.UserService：

在这里插入图片描述
树形结构的关系：

  1. 树的根节点是注册中心分组。下面有多个服务接口，分组值来自用户配置的<dubbo:registry>中的group属性，默认是/dubbo。

  2. 每个服务接口下包含4类子目录，分别是providers、consumers、configurators、routers。该路径是持久节点。

  3. 服务提供者目录/xxx/providers/下包含的接口中存在多个服务者URL元数据的信息，该路径下是临时节点。，若服务没有启动，数据如下：
    在这里插入图片描述
    若服务启动了，数据如下：
    在这里插入图片描述

  4. 服务消费者目录/xxx/consumers/下包含的接口有多个消费者URL元数据的信息，同理，是个临时节点。

  5. 路由配置目录/xxx/routers/下包含多个用于消费者路由策略URL元数据信息。

  6. 动态配置目录/xxx/configurators/下包含多个用于服务者动态配置URL元数据信息。

二. Zookeeper订阅/发布

既然说注册中心是Dubbo的核心组件之一，那么，对于注册中心而言，其订阅发布功能又是他的一个核心关注点。

在使用RPC调用的时候，服务提供者的上下线需要发布出去，从而订阅者才能够调用服务，同时避免服务调用已经下线的节点。而这就需要订阅发布功能的实现，并且该过程也是全自动的。对于Dubbo而言，Dubbo抽象了这么一个工作流程，同时可以有不同的实现，这里主要从Zookeeper的实现来讲。
从官网下载Dubbo的源码，可以看到有这么一个maven项目（附带Test自动化，改一下自己的IP地址即可，很方便测试）：在这里插入图片描述

2.1 发布源码分析

1.其中有一个类叫做ZookeeperRegistry，它主要负责服务的一个注册，看下他的继承关系：
在这里插入图片描述
我们再来看下AbstractRegistry类中的几个重要属性：

// 保存注册的服务
private final Set<URL> registered = new ConcurrentHashSet<URL>();
// 保存订阅url的通知事件
private final ConcurrentMap<URL, Set<NotifyListener>> subscribed = new ConcurrentHashMap<URL, Set<NotifyListener>>();
// 保存通知的url列表，其实是内存中的服务缓存对象
private final ConcurrentMap<URL, Map<String, List<URL>>> notified = new ConcurrentHashMap<URL, Map<String, List<URL>>>();
// 注册中心的url
private URL registryUrl;

紧接着我们从Test类出发：

public class ZookeeperRegistryTest {
    private TestingServer zkServer;
    private ZookeeperRegistry zookeeperRegistry;
    private String service = "org.apache.dubbo.test.injvmServie";
    private URL serviceUrl = URL.valueOf("zookeeper://192.168.237.130/" + service + "?notify=false&methods=test1,test2");
    private URL anyUrl = URL.valueOf("zookeeper://192.168.237.130/*");
    private URL registryUrl;
    private ZookeeperRegistryFactory zookeeperRegistryFactory;

	// 在Test方法执行之前先执行该方法setUp
    @BeforeEach
    public void setUp() throws Exception {
        int zkServerPort = NetUtils.getAvailablePort();
        this.zkServer = new TestingServer(zkServerPort, true);
        this.zkServer.start();

        this.registryUrl = URL.valueOf("zookeeper://192.168.237.130:" + 2181);
        // 初始化一个Zookeeper注册工厂
        zookeeperRegistryFactory = new ZookeeperRegistryFactory();
        zookeeperRegistryFactory.setZookeeperTransporter(new CuratorZookeeperTransporter());
        // 从注册工厂中获得一个Zookeeper注册器
        this.zookeeperRegistry = (ZookeeperRegistry) zookeeperRegistryFactory.createRegistry(registryUrl);
    }

	// 测试方法完成后执行的方法
    @AfterEach
    public void tearDown() throws Exception {
        zkServer.stop();
    }
    
    @Test
    public void testRegister() {
        Set<URL> registered;

        for (int i = 0; i < 2; i++) {
        	// 进行注册，传入的参数值：zookeeper://192.168.237.130/org.apache.dubbo.test.injvmServie?methods=test1,test2&notify=false
            zookeeperRegistry.register(serviceUrl);
            registered = zookeeperRegistry.getRegistered();
            assertThat(registered.contains(serviceUrl), is(true));
        }

        registered = zookeeperRegistry.getRegistered();
        assertThat(registered.size(), is(1));
    }
}

2.从zookeeperRegistry.register（）方法开始：

// ZookeeperRegistry是FailbackRegistry的子类
// 此时调用的是其父类FailbackRegistry重写的register（）方法
public abstract class FailbackRegistry extends AbstractRegistry {
	@Override
    public void register(URL url) {
    	// 检查URL的合法性
        if (!acceptable(url)) {
            logger.info("URL " + url + " will not be registered to Registry. Registry " + url + " does not accept service of this protocol type.");
            return;
        }
        // 调用AbstractRegistry的register（）方法，往registryUrl集合中添加一条URL数据
        super.register(url);
        // 删除失败的已经注册过的URL
        removeFailedRegistered(url);
        // 删除失败的未注册过的URL
        removeFailedUnregistered(url);
        try {
            // 发送一个注册请求
            doRegister(url);
        } catch (Exception e) {
            // ..若失败的处理逻辑
        }
    }
}

3.看下doRegister(url)这个发送注册请求的方法，其有4种实现，进入ZookeeperRegistry类：
在这里插入图片描述

public class ZookeeperRegistry extends FailbackRegistry {
	private final ZookeeperClient zkClient;// Zookeeper客户端
	
	@Override
    public void doRegister(URL url) {
        try {
        	//url:zookeeper://192.168.237.130/org.apache.dubbo.test.injvmServie?methods=test1,test2&notify=false
        	// toUrlPath（）方法主要是将url进行一个数据的格式化，比如 ”:“转变成 “%3A”
            zkClient.create(toUrlPath(url), url.getParameter(DYNAMIC_KEY, true));
        } catch (Throwable e) {
            throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }
}

4.ZookeeperClient是一个接口，其接口方法由抽象子类AbstractZookeeperClient来实现，即zkClient.create（）方法实则调用的是AbstractZookeeperClient.create（）方法。（注意看注释的顺序）

// ZookeeperClient是一个接口，其接口方法由抽象子类AbstractZookeeperClient来实现
public abstract class AbstractZookeeperClient<TargetDataListener, TargetChildListener> implements ZookeeperClient {
	// 已经注册的服务集合
	private final Set<String>  persistentExistNodePath = new ConcurrentHashSet<>();
	@Override
    public void create(String path, boolean ephemeral) {
    	// 1.如果说是保存为持久节点，那么先进入下面的递归调用，ephemeral默认传入的是true
    	//   1.1若第一次调用，那么举个path路径的例子，此时为：/dubbo/org.apache.dubbo.test.injvmServie/providers/zookeeper%3A%2F%2F192.168.237.130%2Forg.apache.dubbo.test.injvmServie%3Fmethods%3Dtest1%2Ctest2%26notify%3Dfalse
    	//   2.1第二次通过递归调用时，path变为：/dubbo/org.apache.dubbo.test.injvmServie/providers，
    	//   2.2此时传入的参数ephemeral==false
        if (!ephemeral) {
        	// 3.此时检查注册过的节点中是否已经存在该节点，若存在则return
            if(persistentExistNodePath.contains(path)){
                return;
            }
            if (checkExists(path)) {
                persistentExistNodePath.add(path);
                return;
            }
        }
        // 2.获取path路径中，从后往前第一个字符为/的下标
        int i = path.lastIndexOf('/');
        if (i > 0) {
        	// 2.递归再次调用create（）方法
            create(path.substring(0, i), false);
        }
        // 4. 递归结束，创建临时节点，调用createEphemeral（）方法
        if (ephemeral) {
            createEphemeral(path);
        } else {
        	// 否则创建持久节点，调用createPersistent（）方法
            createPersistent(path);
            persistentExistNodePath.add(path);
        }
    }
}

此时可以看看Zookeeper上的数据树（还未创建节点）：
在这里插入图片描述

5.以创建默认的临时节点为例，即查看createEphemeral(path)方法，该方法最终执行了CuratorZookeeperClient类中的createEphemeral（）：

public class CuratorZookeeperClient extends AbstractZookeeperClient<CuratorZookeeperClient.CuratorWatcherImpl, CuratorZookeeperClient.CuratorWatcherImpl> {
	@Override
    public void createEphemeral(String path) {
        try {
            client.create().withMode(CreateMode.EPHEMERAL).forPath(path);
        } 
        // ...
    }
}

执行完该方法后，再次查看Zookeeper上的数据树，可以发现path已经注册成功：
在这里插入图片描述
到这里，服务的注册（发布）也就成功了，本质上也就是对Zookeeper上数据的一个添加而已（若注册中心上有，那么就用已存在的），而较为复杂的功能则是订阅。接下来来看看订阅的代码。

2.2 订阅源码分析

订阅通常有Pull和Push两种方式：

  • Pull：客户端定时轮询注册中心拉取配置。
  • Push：注册中心主动推送数据给客户端。

目前Dubbo采用的是：第一次启动采用拉取，后续接收事件重新拉取数据。在服务暴露的时候，服务端会订阅configurators，用于监听动态配置，在消费端启动的时候，消费端则订阅providers、routers、configurators三个Zookeeper目录，分别对应服务提供者、路由、动态配置变更通知。

无论是服务的提供者还是消费者、服务治理中心，任何一个节点连接到Zookeeper注册中心上都需要一个客户端。，而Dubbo就封装了两种Zookeeper的客户端接口：

  1. Apache Curator。（默认，所以我们发布代码中，最终的create（）方法用的是CuratorZookeeperClient类下的）
  2. zkClient
    用户可以在<dubbo:registry>中的client属性设置curator、zkclient来使用不同的客户端实现。默认是curator。

订阅的原理如下：

  1. 客户端在第一次连接上Zookeeper注册中心时，会获取对应目录下全量的数据。
  2. 同时在订阅的节点上注册一个Watcher，客户端和注册中心之间保持TCP的长连接。
  3. 后续每个节点发生任何的数据变化时，注册中心则根据Watcher的回调来主动通知客户端（一次事件通知）。
  4. 客户端接收到通知，把对应节点下的全量数据再进行一次拉取（全量）。

备注：
Zookeeper的每个节点都有一个版本号，只有某个节点的数据发生变化（事务操作）时，该节点的版本号才会发生变化，并触发Watcher事件，推送给订阅方。

说了这么多，接下来从源码角度再来看看：

1.在客户端启动的时候，订阅获取全量数据，会执行到ZookeeperRegistry.doSubscribe（）方法：

@Override
public void doSubscribe(final URL url, final NotifyListener listener) {
    try {
        // 1.处理所有服务的订阅，客户端第一次连接上注册中心上时，进行全量数据的拉取
        if (ANY_VALUE.equals(url.getServiceInterface())) {
            String root = toRootPath();
            // 2.获取URL的所有监听器，若url对应的监听器为空，那么初始化一个监听器返回  zkListeners是一个监听器集合
            ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.computeIfAbsent(url, k -> new ConcurrentHashMap<>());
            // 3.获取ChildListener，若第一次连接时为空，根据computeIfAbsent（）方法肯定会新建一个ChildListener
            ChildListener zkListener = listeners.computeIfAbsent(listener, k -> (parentPath, currentChilds) -> {
                // 4.遍历所有的子节点，
                for (String child : currentChilds) {
                    child = URL.decode(child);
                    // 5.若有新增服务，那么发起对这个服务的订阅。
                    if (!anyServices.contains(child)) {
                        anyServices.add(child);
                        subscribe(url.setPath(child).addParameters(INTERFACE_KEY, child,
                                Constants.CHECK_KEY, String.valueOf(false)), k);
                    }
                }
            });
            // 6.创建持久化节点，订阅持久化节点的子节点
            zkClient.create(root, false);
            List<String> services = zkClient.addChildListener(root, zkListener);
            // 7.获取到全量service，对每一个service进行订阅
            if (CollectionUtils.isNotEmpty(services)) {
                for (String service : services) {
                    service = URL.decode(service);
                    // anyServices是一个接口全名集合，订阅整个Service层
                    anyServices.add(service);
                    subscribe(url.setPath(service).addParameters(INTERFACE_KEY, service,
                            Constants.CHECK_KEY, String.valueOf(false)), listener);
                }
            }
        } else {
            // 1.客户端非第一次连接上注册中心，对于具体的服务进行订阅
            List<URL> urls = new ArrayList<>();
            // 2.根据URL的类别，获取一组要订阅的路径，类别：providers、routers、consumers、configurators
            for (String path : toCategoriesPath(url)) {
                // 3.获取url对应的监听器，没有则创建
                ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.computeIfAbsent(url, k -> new ConcurrentHashMap<>());
                // 4.获取ChildListener，没有则创建，并且在子节点数据发生变更时则调用notify方法进行通知这个listener
                ChildListener zkListener = listeners.computeIfAbsent(listener, k -> (parentPath, currentChilds) -> ZookeeperRegistry.this.notify(url, k, toUrlsWithEmpty(url, parentPath, currentChilds)));
                // 5.创建type的持久化节点，且对于这个节点进行订阅
                zkClient.create(path, false);
                // 6.订阅，返回该节点下的子路径并且保存
                List<String> children = zkClient.addChildListener(path, zkListener);
                if (children != null) {
                    urls.addAll(toUrlsWithEmpty(url, path, children));
                }
            }
            // 7.回调，更新本地缓存信息
            notify(url, listener, urls);
        }
    } catch (Throwable e) {
        throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
    }
}

2.来看下回调方法notify（）：

protected void notify(URL url, NotifyListener listener, List<URL> urls) {
    // ...
    // 用于分类URL
    Map<String, List<URL>> result = new HashMap<>();
    for (URL u : urls) {
        if (UrlUtils.isMatch(url, u)) {
            String category = u.getParameter(CATEGORY_KEY, DEFAULT_CATEGORY);
            List<URL> categoryList = result.computeIfAbsent(category, k -> new ArrayList<>());
            categoryList.add(u);
        }
    }
    if (result.size() == 0) {
        return;
    }
    // 1.获取url在notified集合中的数据,若notified无则创建一个且放入
    Map<String, List<URL>> categoryNotified = notified.computeIfAbsent(url, u -> new ConcurrentHashMap<>());
    for (Map.Entry<String, List<URL>> entry : result.entrySet()) {
        String category = entry.getKey();
        List<URL> categoryList = entry.getValue();
        categoryNotified.put(category, categoryList);
        // 2.对于所有url进行分类的通知
        listener.notify(categoryList);
        // 3.将url进行缓存，因为当我们的注册表由于网络抖动而出现订阅失败时，我们可以返回现有的缓存URL。
        saveProperties(url);
    }
}

3.再回到doSubscribe（）方法，可以看到其中传入了一个参数类型是NotifyListener，一旦发生了数据的变更，则发生通知，而消费者则会去进行一次数据拉取：

public interface NotifyListener {

    /**
     * 当收到服务变更通知时触发。
     * <p>
     * 通知需处理契约：<br>
     * 1. 总是以服务接口和数据类型为维度全量通知，即不会通知一个服务的同类型的部分数据，用户不需要对比上一次通知结果。<br>
     * 2. 订阅时的第一次通知，必须是一个服务的所有类型数据的全量通知。
     * 3. 中途变更时，允许不同类型的数据分开通知，比如：providers, consumers, routers, overrides，允许只通知其中一种类型，但该类型的数据必须是全量的，不是增量的。
     * 4. 如果一种类型的数据为空，需通知一个empty协议并带category参数的标识性URL数据。
     * 5. 通知者(即注册中心实现)需保证通知的顺序，比如：单线程推送，队列串行化，带版本对比。
     *
     * @param urls 已注册信息列表，总不为空，含义同{@link com.alibaba.dubbo.registry.RegistryService#lookup(URL)}的返回值。
     */
    void notify(List<URL> urls);
    //..
}

小总结

总的来说，对于Zookeeper的发布流程：

  1. 若发现注册中心上已经注册了某个需要发布的URL，那么返回。
  2. 若没注册，则对需要发布的URL进行一定程度上的格式转换。（/、：等符号的转化）
  3. 根据用户配置的client属性，选择用curator或者zkclient客户端向Zookeeper上创建一个临时节点（即订阅者的相关数据）。

对于Zookeeper的订阅流程：

  1. 客户端第一次启动，会针对/.../providers/这个路径，全量的获取每一个子节点并进行订阅。
  2. 后续则根据URL的具体类别，获取要订阅的路径，通过不同类型的监听器来进行监听，若数据发生了变化，则通过NotifyListener这个监听器的notify（）方法进行回调。
  3. notify（）则进行分类通知，并且将URL进行本地缓存，同时消费者进行数据的拉取。

对于Zookeeper的订阅，说白了就是对xxx/providers进行监听，一旦数据发生变更，则执行回调函数，让消费者自己去拉取一遍数据。

这里只是一个普通的服务发布即服务订阅的大致流程，对于具体服务的暴露、远程服务的调用则放在后续的博客来讲。

三 缓存

其实1.2小节有提及：

  1. 回调的时候，会对URL进行一次缓存，避免因为网络波动等原因获取不到URL。
  2. 说明消费者或服务治理中心获取注册信息后会做本地缓存。

首先，在服务进行初始化的时候，AbstractRegistry构造函数里会从本地磁盘文件中把持久化的注册数据读到Properties对象里，并加载到内存缓存中。再来看下AbstractRegistry类中的几个重要属性：

// 内存中的服 务缓存对象，URL是消费者的URL，内层Map的key是分类，包括providers、consumers等
// value则对应的服务列表，对于没有服务提供者提供服务的URL,它会以特殊的empty:// 前缀开头。
private final ConcurrentMap<URL, Map<String, List<URL>>> notified = new ConcurrentHashMap<>();
// 盘文件服务缓存对象
private File file;

3.1 缓存的加载

缓存的加载依赖于AbstractRegistry的构造，来看下：

public AbstractRegistry(URL url) {
    // ....
    // 启动订阅中心时，我们需要读取本地缓存文件，以便将来进行注册表容错处理
    loadProperties();
    // ....
}

private void loadProperties() {
    // ....
   	// 读取磁盘上的文件并加载
    in = new FileInputStream(file);
    // 保存服务提供者的URL，key：URL#serviceKey()。value：提供者列表、 路由规则列表、配置规则列表等
    properties.load(in);
    // ....
    }
}

3.2 缓存的保存和更新

缓存的保存有同步和异步两种方式。异步会使用线程池异步保存，如果线程在执行过程中出现异常，则会再次调用线程池不断重试，前面说过，订阅流程中最后一步会对URL进行缓存，也就是调用了saveProperties(url)方法：

private void saveProperties(URL url) {
    // ....
    if (syncSaveFile) {
    	// 同步保存，同时传入一个AtomicLong类型的版本号，为了保证数据是最新的。
         doSaveProperties(version);
     } else {
     	// 异步保存，通过线程池来执行，同时传入一个AtomicLong类型的版本号，为了保证数据是最新的。
         registryCacheExecutor.execute(new SaveProperties(version));
    // ....
}
Zong_0915
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Dubbo-注册中心
jerryq的博客
01-20 554
前言 本文对 Dubbo 注册中心的工作流程等进行介绍，主要关注下面3个问题。 注册中心的工作流程； Zookeeper； Dubbo 注册中心的缓存机制； 注册中心的工作流程 注册中心对于 Dubbo 而言，是对服务提供者和服务消费者的整体把控，最后的服务调用是直接发生在消费者和提供者之间的，但是如何找到提供者，如果能动性更强的选择服务，都是需要注册中心实现的。总的而言，注册中心具备以下几个...
微服务架构Dubbo之原理讲解及利用zookeeper作为注册中心进行高可用测试
XING_Gou的博客
03-27 539
前言：今天给大家给大家讲解的是Dubbp的调用原理，以及一个demo测试向大家展示Dubbo的运行过程。在前面一文中，给大家讲到了—Dubbo之Zookeeper安装测试和Zookeeper集群的搭建 ,在其中已经给大家讲到了Zookeeper集群的搭建，今天我们也要用到该集群，如果没有安装的，请先行安装，再看下文！！ 1.Dubbo原理 1.1 高性能Java RPC框架 Apache Dub...
开发dubbo应用程序(二)dubbo注册中心相关概述
weixin_30437337的博客
08-25 190
1.注册中心概述 ​ 在Dubbo微服务体系中,注册中心是其核心组件之一.Dubbo通过注册中心实现了分布式环境中各微服务之间的注册与发现,是各分布式节点之间的纽带.其主要作用如下: 动态加入。一个服务提供者通过注册中心可以动地把自己暴露给其他消费者,无序消费者逐个去更新配置文件; 动态发现。一个消费者可以动态地感知新的配置、路由规则和新的服务提供者，无需重启服务使之生效； 动态调整。...
Dubbo与zookeeper中的服务注册原理
FelixWang的博客
10-23 2161
微服务理论 Dubbo的好处 .透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。 软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。 服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。 Dubbo采用全Spring配置方式，透明化接入应用，对应用没有任何...
学习dubbo(2)：dubbo注册中心
hq091117的博客
10-22 236
学习《深入理解apache dubbo与实战》 总结：这一章，没啥内容，只是简单的介绍了一下dubbo实现注册中心,怎么使用zk，概念介绍，然后贴源码，虽然这注册中心其实没啥东西，无非就是讲服务注册到一个地方，然后好治理分配，调用这些服务，一个服务一个节点，对比Springcloud的注册中心，其实原理思想还是很多相同的 1，注册中心作用 1）动态加入，一个服务提供者通过注册中心可以动态把自...
Dubbo-zookeeper（注册中心）
vengu733的博客
10-17 2105
Dubbo目前支持4种注册中心,（multicast、zookeeper、redis、simple） ，推荐使用Zookeeper注册中心。Zookeeper 是 Apacahe Hadoop 的子项目，是一个树型的目录服务，支持变更推送，适合作为 Dubbo 服务的注册中心，工业强度较高，可用于生产环境，因此被dubbo并推荐使用。（1）Zookeeper官网：https://zookeeper.apache.org/（2）下载并解压 “apache-zookeeper-3.5.6-bin.tar.gz”
dubbo和zookeeper集成-dubbo系列一
weixin_39265427的博客
08-17 566
dubbo集成zookeeper
Dubbo (三) --------- Zookeeper 注册中心
在森林里麋了鹿
03-08 1385
目录一、注册中心概述二、注册中心工作方式三、Zookeeper 注册中心1、下载安装 Zookeeper2、配置 Zookeeper四、使用 Zookeeper1、maven pom.xml2、修改 dubbo 配置文件 一、注册中心概述 对于服务提供方，它需要发布服务，而且由于应用系统的复杂性，服务的数量、类型也不断膨胀；对于服务消费方，它最关心如何获取到它所需要的服务，而面对复杂的应用系统，需要管理大量的服务调用。 而且，对于服务提供方和服务消费方来说，他们还有可能兼具这两种角色，即需要提供服务，有需
Dubbo简介和注册中心Zookeeper
weixin_44480609的博客
07-11 855
之前学习了SpringCloud全家桶，一站式解决方案 SpringCloud从入门到入土基本上对于微服务的注册发现和远程调用都有解决方案。 但是最近在SSM项目，传智健康，这一套解决方案只能针对SpringBoot，所以Dubbo+Zookeeper还是需要学习的。 2021年阿里巴巴重新启动Dubbo，将来会不会重放光彩我们拭目以待。Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。 Dub
Dubbo3使用Zookeeper作为注册中心的方案讨论！详解DubboAdmin与PrettyZoo来监控服务的优劣！
七叔的博客
11-23 3002
本文中对Dubbo3使用Zookeeper作为注册中心的方案进行了详细讨论！并且详解DubboAdmin与PrettyZoo来监控服务的使用方式和优劣！
dubbo注册中心 zookeeper-3.4.8
12-07
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调...ZooKeeper代码版本中，提供了分布式独享锁、选举、队列的接口，代码在zookeeper-3.4.3\src\recipes。其中分布锁和队列有Java和C两个版本，选举只有Java版本。
springboot-dubbo-zookeeper-demo：弹簧靴集成dubbo和zookeeper
01-30
Spring Boot整合dubbo和zookeeper这个demo是基于写的，官方的包本身可以达到集成zookeeper的，但是官方并没有命名一个demo。准备zookeeper安装启动下载dubbo源码打包因为官方包使用的dubbo是源码的最新版本2.6.2-...
zookeeper-dubbo-seata-integration-master.zip
12-03
dubbo和zookeeper的关系，使用zookeeper+dubbo+seata搭建基础分布式应用
dubbo-zookeeper
04-05
dubbo-zookeeper
Spingboot-Dubbo-zookeeper实例-带参数
11-29
在原作者代码上增加了参数 大家可以试着区分下不同，说明下，本来想免费的，但是现在C网发布必须有资源分。。。哪位知道怎么发免费资源 可私聊，多谢！
406_智能小区管家服务系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
毕业设计+项目编程实战+基于BS架构的ASP.NET的新闻管理系统(含程序源代码+毕业设计文档)
06-02
前言……………………………………………………………………………….2 第1章 ASP简介…………………………………………………………….…..1 1.1ASP的特点………………………………………………………….1 1.2ASP的优势………………………………………………………….2 1.3 ASP与HTML……………………………………………………….3 1.4 ASP的内置对象……………………………………………………..4 1.4.1 Request对象………………………………………………….4 1.4.2 Response对象………………………………………………..4 第2章 为什么要开发一个新闻发布系统…………………………………………….6 第3章 Access数据库……………………………………………………………8 3.1 数据库概念………………………………………………………….8 3.2 Access数据库特点………………………………………………….8 3.3
prompt_toolkit-3.0.27.tar.gz
最新发布
06-02
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
庆祝传统节日，端午安康
06-02
端午节，又称为端阳节、龙舟节，是中国传统节日之一，始于战国时期，至今已有上千年的历史。每年农历五月初五这一天，人们都会举行各种庆祝活动，以祈求平安健康、驱邪避灾。
zookeeper dubbo
07-27
Dubbo Zookeeper面试题是关于Dubbo分布式框架和Zookeeper分布式协调服务的面试题。常见的问题包括： 1. Dubbo和Zookeeper的关系是什么？ Dubbo是一个分布式服务框架，而Zookeeper是一个分布式协调服务。Dubbo使用Zookeeper来实现服务注册、发现和负载均衡等功能。 2. Dubbo和Zookeeper的工作原理是什么？ Dubbo在启动时会连接到Zookeeper，并将自己的服务注册到Zookeeper上。客户端在调用服务时，会从Zookeeper上获取可用的服务列表，并根据负载均衡策略选择一个服务提供者进行调用。 3. Dubbo和Zookeeper的优缺点是什么？ Dubbo的优点是具有高性能、高可靠性和可扩展性，支持多种协议和序列化方式。Zookeeper的优点是具有高可用性、高可靠性和数据一致性，可以用于实现分布式锁、配置管理等功能。缺点是需要额外的学习成本和部署成本。 4. Dubbo和Zookeeper的常见问题有哪些？ 常见问题包括Zookeeper集群的搭建和配置、Dubbo服务注册和发现的问题、Zookeeper的数据一致性和性能问题等。 5. 如何优化Dubbo和Zookeeper的性能？ 可以采用以下方法来优化Dubbo和Zookeeper的性能：使用高性能的序列化方式、使用异步调用方式、使用连接池和线程池、优化Zookeeper的配置和集群部署等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zong_0915

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值