AI 助理
备案控制台
开发者社区 Java技术进阶 文章 正文

Dubbo Admin实现原理

2020-01-02 1630
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
服务治理 MSE Sentinel/OpenSergo，Agent数量 不受限
注册配置 MSE Nacos/ZooKeeper，118元/月
云原生网关 MSE Higress，422元/月
简介： 开篇 这篇文章主要用于讲解清楚Dubbo Admin的监控数据的来源，如何通过zookeeper作为注册中心来获取实际运行中的数据进行服务治理。 这篇文章主要侧重于数据方面的获取包括consumers, configurators, routers, providers，具体如何进行服务治理后面文章会具体进行分析。

开篇

  • 这篇文章主要用于讲解清楚Dubbo Admin的监控数据的来源，如何通过zookeeper作为注册中心来获取实际运行中的数据进行服务治理。
  • 这篇文章主要侧重于数据方面的获取包括consumers, configurators, routers, providers，具体如何进行服务治理后面文章会具体进行分析。
  • 文章是基于dubbo-2.6.0的版本进行分析。

注册节点

[zk] ls /dubbo/com.alibaba.dubbo.demo.DemoService
[consumers, configurators, routers, providers]

zookeeper服务树

  • Dubbo的服务树如上图所示，以服务如com.foo.BarService作为第一层节点Service层。
  • Service层包含Type层，包括consumers, configurators, routers, providers，监控数据主要是指Type层子节点的数据监控。


实现过程概述

  • 1.依次按照/dubbo，/dubbo/service，/dubbo/service/type的顺序进行发现并最终订阅/dubbo/service/type的节点。
  • 2.首次获取所有/dubbo/service/type的所有子节点并保存导数据结构registryCache当中。
  • 3.后续/dubbo/service/type的节点变更通过zookeeper事件通知机制更新到registryCache当中。
  • 4.registryCache保存了zookeeper上Dubbo服务节点上的所有信息，按照
    ConcurrentMap>>的数据结构进行保存，其中category包含providers,consumers,routers,configurators。


实现过程源码分析

dubbo-admin目录

  • dubbo-admin的目录结构如上图，RegistryServerSync作为同步数据的核心类。
  • RegistryServerSync的数据用于同步并监听zookeeper中关于Dubbo服务的数据。


RegistryServerSync的bean定义

<dubbo:application name="dubbo-admin"/>

<dubbo:registry address="${dubbo.registry.address}" check="false" file="false"/>

<dubbo:reference id="registryService" interface="com.alibaba.dubbo.registry.RegistryService" check="false"/>

<bean id="configService" class="com.alibaba.dubbo.governance.service.impl.ConfigServiceImpl"/>
<bean id="consumerService" class="com.alibaba.dubbo.governance.service.impl.ConsumerServiceImpl"/>
<bean id="overrideService" class="com.alibaba.dubbo.governance.service.impl.OverrideServiceImpl"/>
<bean id="ownerService" class="com.alibaba.dubbo.governance.service.impl.OwnerServiceImpl"/>
<bean id="providerService" class="com.alibaba.dubbo.governance.service.impl.ProviderServiceImpl"/>
<bean id="routeService" class="com.alibaba.dubbo.governance.service.impl.RouteServiceImpl"/>
<bean id="userService" class="com.alibaba.dubbo.governance.service.impl.UserServiceImpl">
    <property name="rootPassword" value="${dubbo.admin.root.password}"/>
    <property name="guestPassword" value="${dubbo.admin.guest.password}"/>
</bean>

<bean id="governanceCache" class="com.alibaba.dubbo.governance.sync.RegistryServerSync"/>
  • RegistryServerSync的定义在META-INF/spring/dubbo-admin.xml当中。


RegistryServerSync初始化订阅过程

public class RegistryServerSync implements InitializingBean, DisposableBean, NotifyListener {

    private static final Logger logger = LoggerFactory.getLogger(RegistryServerSync.class);

    // admin://192.168.1.5?category=providers,consumers,routers,configurators&check=false&classifier=*&enabled=*&group=*&interface=*&version=*
    private static final URL SUBSCRIBE = new URL(Constants.ADMIN_PROTOCOL, NetUtils.getLocalHost(), 0, "",
            Constants.INTERFACE_KEY, Constants.ANY_VALUE,
            Constants.GROUP_KEY, Constants.ANY_VALUE,
            Constants.VERSION_KEY, Constants.ANY_VALUE,
            Constants.CLASSIFIER_KEY, Constants.ANY_VALUE,
            Constants.CATEGORY_KEY, Constants.PROVIDERS_CATEGORY + ","
            + Constants.CONSUMERS_CATEGORY + ","
            + Constants.ROUTERS_CATEGORY + ","
            + Constants.CONFIGURATORS_CATEGORY,
            Constants.ENABLED_KEY, Constants.ANY_VALUE,
            Constants.CHECK_KEY, String.valueOf(false));

    private static final AtomicLong ID = new AtomicLong();

    /**
     * Make sure ID never changed when the same url notified many times
     */
    private final ConcurrentHashMap<String, Long> URL_IDS_MAPPER = new ConcurrentHashMap<String, Long>();

    // ConcurrentMap<category, ConcurrentMap<servicename, Map<Long, URL>>>
    private final ConcurrentMap<String, ConcurrentMap<String, Map<Long, URL>>> registryCache = new ConcurrentHashMap<String, ConcurrentMap<String, Map<Long, URL>>>();
    @Autowired
    private RegistryService registryService;

    public ConcurrentMap<String, ConcurrentMap<String, Map<Long, URL>>> getRegistryCache() {
        return registryCache;
    }

    public void afterPropertiesSet() throws Exception {
        logger.info("Init Dubbo Admin Sync Cache...");
        registryService.subscribe(SUBSCRIBE, this);
    }
}

category参数

  • RegistryServerSync在afterPropertiesSet()方法内部执行订阅操作。
  • SUBSCRIBE变量中category=providers,consumers,routers,configurators表示我们需要订阅service下的这4类节点，其中routers和configurators就是跟服务治理相关。
  • SUBSCRIBE的check=false&classifier=&enabled=&group=&interface=&version=*等变量都是通用符*，这里我们关注下interface=*的变量，后面执行实际订阅会根据该变量做判断。


RegistryServerSync执行订阅过程

  • 参见ZookeeperRegistry#doSubscribe
    protected void doSubscribe(final URL url, final NotifyListener listener) {
        try {
            // admin订阅过程中，首次传入参数interface的值为*，所以走的这个分支
            if (Constants.ANY_VALUE.equals(url.getServiceInterface())) {
                String root = toRootPath();
                ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
                if (listeners == null) {
                    zkListeners.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, ChildListener>());
                    listeners = zkListeners.get(url);
                }
                ChildListener zkListener = listeners.get(listener);
                if (zkListener == null) {
                    listeners.putIfAbsent(listener, new ChildListener() {
                        public void childChanged(String parentPath, List<String> currentChilds) {
                            for (String child : currentChilds) {
                                child = URL.decode(child);
                                if (!anyServices.contains(child)) {
                                    anyServices.add(child);
                                    subscribe(url.setPath(child).addParameters(Constants.INTERFACE_KEY, child,
                                            Constants.CHECK_KEY, String.valueOf(false)), listener);
                                }
                            }
                        }
                    });
                    zkListener = listeners.get(listener);
                }
                zkClient.create(root, false);
                // 获取 /dubbo目录的子节点，返回service层所有service接口
                // 如/dubbo/com.alibaba.dubbo.demo.DemoServiceEcho
                List<String> services = zkClient.addChildListener(root, zkListener);
                if (services != null && services.size() > 0) {
                    for (String service : services) {
                        service = URL.decode(service);
                        anyServices.add(service);
                        // 针对每个service进行subscribe操作
                        subscribe(url.setPath(service).addParameters(Constants.INTERFACE_KEY, service,
                                Constants.CHECK_KEY, String.valueOf(false)), listener);
                    }
                }
            } else {
                List<URL> urls = new ArrayList<URL>();
                // 获取service下的category，consumers, configurators, routers, providers
                // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/providers
                // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/consumers
                // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/routers
                // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/configurators
                for (String path : toCategoriesPath(url)) {
                    ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
                    if (listeners == null) {
                        zkListeners.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, ChildListener>());
                        listeners = zkListeners.get(url);
                    }
                    ChildListener zkListener = listeners.get(listener);
                    if (zkListener == null) {
                        listeners.putIfAbsent(listener, new ChildListener() {
                            public void childChanged(String parentPath, List<String> currentChilds) {
                                ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
                            }
                        });
                        zkListener = listeners.get(listener);
                    }
                    zkClient.create(path, false);
                    // 针对每个service的监听以下节点
                    // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/providers
                    // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/consumers
                    // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/routers
                    // /dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/configurators
                    List<String> children = zkClient.addChildListener(path, zkListener);
                    if (children != null) {
                        urls.addAll(toUrlsWithEmpty(url, path, children));
                    }
                }
                // urls为某个服务下所有的子节点内容
                // dubbo://172.17.32.8:20880/com.alibaba.dubbo.demo.DemoServiceEcho?anyhost=true&application=demo-provider&bean.name=com.alibaba.dubbo.demo.DemoServiceEcho&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.DemoServiceEcho&methods=sayHello&pid=79153&side=provider&timestamp=1577783208090
                // empty://192.168.1.5/com.alibaba.dubbo.demo.DemoServiceEcho?category=consumers&check=false&classifier=*&enabled=*&group=*&interface=com.alibaba.dubbo.demo.DemoServiceEcho&version=*
                // route://0.0.0.0/com.alibaba.dubbo.demo.DemoServiceEcho?category=routers&dynamic=false&enabled=true&force=true&name=com.alibaba.dubbo.demo.DemoServiceEcho blackwhitelist&priority=0&router=condition&rule=consumer.host+%3D+1.1.1.1+%3D%3E+false&runtime=false
                // override://192.168.1.5/com.alibaba.dubbo.demo.DemoServiceEcho?category=configurators&dynamic=false&enabled=true&weight=12
                // override://192.168.1.5/com.alibaba.dubbo.demo.DemoServiceEcho?category=configurators&dynamic=false&enabled=true&weight=12
                // override://1.1.1.1/com.alibaba.dubbo.demo.DemoServiceEcho?category=configurators&dynamic=false&enabled=true&weight=13
                notify(url, listener, urls);
            }
        } catch (Throwable e) {
            throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }
  • 订阅的过程是一个逐层发现并订阅的过程。
  • 获取根节点/dubbo下的所有service节点集合，如/dubbo/com.alibaba.dubbo.demo.DemoServiceEcho。
  • 针对每个service节点获取该节点的所有子节点(描述方便用type表示)，包括providers,consumers,routers,configurators。
  • 针对每个type如/dubbo/com.alibaba.dubbo.demo.DemoServiceEcho/providers进行监听。
  • 首次启动会获取每个type节点下的所有子节点进行第一轮初始化过程，后续的变更都是通过type节点本身的监听回调进行实现。
  • 首次启动会把每个service下所有的type下的所有的子节点合并成urls后进行notify动作。


RegistryServerSync回调分组过程

  • 参见AbstractRegistry#notify
public abstract class AbstractRegistry implements Registry {

    protected void notify(URL url, NotifyListener listener, List<URL> urls) {
        if (url == null) {
            throw new IllegalArgumentException("notify url == null");
        }
        if (listener == null) {
            throw new IllegalArgumentException("notify listener == null");
        }
        if ((urls == null || urls.size() == 0)
                && !Constants.ANY_VALUE.equals(url.getServiceInterface())) {
            logger.warn("Ignore empty notify urls for subscribe url " + url);
            return;
        }
        if (logger.isInfoEnabled()) {
            logger.info("Notify urls for subscribe url " + url + ", urls: " + urls);
        }
        // 根据category进行分组，包括consumers, configurators, routers, providers
        Map<String, List<URL>> result = new HashMap<String, List<URL>>();
        for (URL u : urls) {
            if (UrlUtils.isMatch(url, u)) {
                String category = u.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
                List<URL> categoryList = result.get(category);
                if (categoryList == null) {
                    categoryList = new ArrayList<URL>();
                    result.put(category, categoryList);
                }
                categoryList.add(u);
            }
        }
        if (result.size() == 0) {
            return;
        }
        Map<String, List<URL>> categoryNotified = notified.get(url);
        if (categoryNotified == null) {
            notified.putIfAbsent(url, new ConcurrentHashMap<String, List<URL>>());
            categoryNotified = notified.get(url);
        }
        for (Map.Entry<String, List<URL>> entry : result.entrySet()) {
            String category = entry.getKey();
            List<URL> categoryList = entry.getValue();
            categoryNotified.put(category, categoryList);
            saveProperties(url);
            // 按照分组的结果进行回调通知
            listener.notify(categoryList);
        }
    }
}
  • RegistryServerSync的回调过程中根据category进行分组，分组包括consumers, configurators, routers, providers。
  • 依次针对分组后的结果进行回调通知，执行RegistryServerSync的notify动作。


RegistryServerSync保存回调结果

  • 参见RegistryServerSync#notify
public class RegistryServerSync implements InitializingBean, DisposableBean, NotifyListener {
    /**
     * Make sure ID never changed when the same url notified many times
     */
    private final ConcurrentHashMap<String, Long> URL_IDS_MAPPER = new ConcurrentHashMap<String, Long>();

    // ConcurrentMap<category, ConcurrentMap<servicename, Map<Long, URL>>>
    // servicename=groupName/serviceName:versionNum
    private final ConcurrentMap<String, ConcurrentMap<String, Map<Long, URL>>> registryCache = new ConcurrentHashMap<String, ConcurrentMap<String, Map<Long, URL>>>();


    public void notify(List<URL> urls) {
        if (urls == null || urls.isEmpty()) {
            return;
        }
        // Map<category, Map<servicename, Map<Long, URL>>>
        final Map<String, Map<String, Map<Long, URL>>> categories = new HashMap<String, Map<String, Map<Long, URL>>>();
        String interfaceName = null;
        for (URL url : urls) {
            String category = url.getParameter(Constants.CATEGORY_KEY, Constants.PROVIDERS_CATEGORY);
            // 针对empty的情况，移出已经消失的服务
            if (Constants.EMPTY_PROTOCOL.equalsIgnoreCase(url.getProtocol())) { // NOTE: group and version in empty protocol is *
                ConcurrentMap<String, Map<Long, URL>> services = registryCache.get(category);
                if (services != null) {
                    String group = url.getParameter(Constants.GROUP_KEY);
                    String version = url.getParameter(Constants.VERSION_KEY);
                    // NOTE: group and version in empty protocol is *
                    if (!Constants.ANY_VALUE.equals(group) && !Constants.ANY_VALUE.equals(version)) {
                        services.remove(url.getServiceKey());
                    } else {
                        for (Map.Entry<String, Map<Long, URL>> serviceEntry : services.entrySet()) {
                            String service = serviceEntry.getKey();
                            if (Tool.getInterface(service).equals(url.getServiceInterface())
                                    && (Constants.ANY_VALUE.equals(group) || StringUtils.isEquals(group, Tool.getGroup(service)))
                                    && (Constants.ANY_VALUE.equals(version) || StringUtils.isEquals(version, Tool.getVersion(service)))) {
                                services.remove(service);
                            }
                        }
                    }
                }
            } else {
                // 添加服务到全局的registryCache变量当中
                if (StringUtils.isEmpty(interfaceName)) {
                    interfaceName = url.getServiceInterface();
                }
                // 用于保存局部变量的categories
                Map<String, Map<Long, URL>> services = categories.get(category);
                if (services == null) {
                    services = new HashMap<String, Map<Long, URL>>();
                    categories.put(category, services);
                }
                // service=groupName/interfaceName:versionNum
                String service = url.getServiceKey();
                Map<Long, URL> ids = services.get(service);
                if (ids == null) {
                    ids = new HashMap<Long, URL>();
                    services.put(service, ids);
                }

                // Make sure we use the same ID for the same URL
                if (URL_IDS_MAPPER.containsKey(url.toFullString())) {
                    ids.put(URL_IDS_MAPPER.get(url.toFullString()), url);
                } else {
                    long currentId = ID.incrementAndGet();
                    ids.put(currentId, url);
                    URL_IDS_MAPPER.putIfAbsent(url.toFullString(), currentId);
                }
            }
        }
        if (categories.size() == 0) {
            return;
        }

        // 本次category对应的数据不为空进行添加动作
        for (Map.Entry<String, Map<String, Map<Long, URL>>> categoryEntry : categories.entrySet()) {
            String category = categoryEntry.getKey();
            ConcurrentMap<String, Map<Long, URL>> services = registryCache.get(category);
            if (services == null) {
                services = new ConcurrentHashMap<String, Map<Long, URL>>();
                registryCache.put(category, services);
            } else {
                Set<String> keys = new HashSet<String>(services.keySet());
                // 移出已经不存在的数据，同一个接口但是不在本次的回调数据当中
                for (String key : keys) {
                    if (Tool.getInterface(key).equals(interfaceName) && !categoryEntry.getValue().entrySet().contains(key)) {
                        services.remove(key);
                    }
                }
            }
            // 用最新的数据进行覆盖
            services.putAll(categoryEntry.getValue());
        }
    }
}
  • RegistryServerSync的notify()方法的urls参数是/dubbo/service/type下的子节点。
  • Dubbo的服务树的数据最终通过ConcurrentMap>>的数据结构进行保存，保存的对象为registryCache，servicename=groupName/serviceName:versionNum的格式保存。
  • registryCache保存的Zookeeper上的Dubbo的服务节点内容。所有的服务治理操作依据的数据都在registryCache当中，任何服务节点的变更都会导致registryCache的数据更新。
  • registryCache是整个服务治理的数据核心。
文章标签：
微服务引擎
Java
应用服务中间件
监控
Dubbo
Spring
关键词：
Dubbo实现原理
Dubbo admin
相关实践学习
基于MSE实现微服务的全链路灰度
通过本场景的实验操作，您将了解并实现在线业务的微服务全链路灰度能力。
晴天哥
目录
相关文章
mikechen的互联网架构
|
4天前
|
负载均衡 监控 Dubbo
Dubbo 实现原理详解，一文吃透！
本文深入解析Dubbo的底层实现原理，涵盖远程方法调用、智能容错和负载均衡、服务注册和发现三大核心功能，详解其架构设计和调用流程。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
20 1
Dubbo 实现原理详解，一文吃透！
朱季谦
|
缓存 Dubbo Java
Dubbo2.7的Dubbo SPI实现原理细节
Dubbo2.7的Dubbo SPI实现原理细节
朱季谦
49 0
编程达人
|
Dubbo 数据可视化 应用服务中间件
带你读《Apache Dubbo微服务开发从入门到精通》—— 一、 Admin可视化控制台（上）
带你读《Apache Dubbo微服务开发从入门到精通》—— 一、 Admin可视化控制台（上）
编程达人
215 9
中间件兴趣圈
|
Dubbo Java 应用服务中间件
源码分析Dubbo 泛化调用与泛化实现原理
源码分析Dubbo 泛化调用与泛化实现原理
中间件兴趣圈
301 0
源码分析Dubbo 泛化调用与泛化实现原理
王小明hit
|
存储 设计模式 缓存
Dubbo SPI 实现原理
Dubbo SPI 实现原理
王小明hit
134 0
Dubbo SPI 实现原理
danny_idea
|
Dubbo 应用服务中间件 数据安全/隐私保护
通俗易懂的Dubbo学习（二）如何搭建dubbo的admin平台
通俗易懂的Dubbo学习（二）如何搭建dubbo的admin平台
danny_idea
118 0
中间件兴趣圈
|
Dubbo 算法 应用服务中间件
源码分析Dubbo tps过滤器器实现原理
源码分析Dubbo tps过滤器器实现原理
中间件兴趣圈
142 0
游客a74jvhcp7vclg
|
存储 缓存 开发框架
Dubbo系列讲解之扩展点实现原理分析【2万字分享】
Apache Dubbo 是一款微服务开发框架，它提供了 RPC通信 与 微服务治理 两大关键能力。这意味着，使用 Dubbo 开发的微服务，将具备相互之间的远程发现与通信能力， 同时利用 Dubbo 提供的丰富服务治理能力，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。同时 Dubbo 是高度可扩展的，用户几乎可以在任意功能点去定制自己的实现，以改变框架的默认行为来满足自己的业务需求
游客a74jvhcp7vclg
273 0
Dubbo系列讲解之扩展点实现原理分析【2万字分享】
中间件小哥
|
Dubbo 测试技术 应用服务中间件
Dubbo 生态添新兵，Dubbo Admin 发布 v0.1
为了提升 Dubbo 里程碑版本2.7.0的使用体验，我们于去年年中启动了 Dubbo Admin 的重构计划，并作为Dubbo生态的子项目，于近期发布了v0.1，重构后的项目在结构上的变化如下： 将后端框架从webx替换成spring boot 前端采用Vue和Vuetify.js作为开发框架 移除velocity模板 集成swagger，提供api管理功能 当前版本的Dubbo Admin包含了之前版本中的绝大部分功能，包括服务治理，服务查询等，同时支持了Dubbo2.7中服务治理的新特性。
中间件小哥
3545 12
晴天哥
|
Dubbo IDE Java
Dubbo Admin 2.7.X 初探
开篇 为了统一不同配置中心（如Zookeeper、Nacos、Etcd等）对于服务治理规则的实现，Dubbo2.7.3及之后的版本针对2.7.0以来的配置中心的部分实现进行了重构。 从实际代码来看，Dubbo Admin针对应用纬度的配置的实际生效需要在Dubbo 2.7.3及以后的版本，为了方便debug建议Dubbo的版本是dubbo-2.7.4.1。
晴天哥
4007 0
Dubbo Admin 2.7.X 初探

Java技术进阶

热门文章

最新文章

  • 1
    SpringBoot开发案例之整合Dubbo提供者(一)
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    Dubbo的Zookeeper单机配置和Zookeeper集群配置
  • 4
    Dubbo入门
  • 5
    高并发架构系列：如何从0到1设计一个类Dubbo的RPC框架
  • 6
    SpringBoot开发案例之整合Dubbo消费者
  • 7
    Dubbo架构介绍
  • 8
    学习dubbo（四）： 启动时检查
  • 9
    Dubbo之——改造Dubbo，使其能够兼容Spring 4注解配置
  • 10
    Apache Dubbo 被曝出“高危”远程代码执行漏洞
  • 1
    Dubbo背景和简介
    49
  • 2
    理解java的springboot+mybatisplus+dubbo+nacos+kafka这一套技术栈
    88
  • 3
    Spring Boot 调用 Dubbo 接口与编写 Dubbo 接口实战
    625
  • 4
    分布式系统面试全集通第一篇（dubbo+redis+zookeeper----分布式+CAP+BASE+分布式事务+分布式锁）
    105
  • 5
    Dubbo怎么配置监控中心
    80
  • 6
    dubbo-admin安装(分离版本)
    30
  • 7
    DUBBO--基础篇（二）--监控中心
    52
  • 8
    DUBBO--基础篇（一）--简介（示意Demo）
    67
  • 9
    dubbo面试题收集
    56
  • 10
    dubbo面试题库
    44

    • 相关课程

    更多
  • Dubbo + ZooKeeper 的服务发现最佳实践
  • Dubbo 3.0 服务治理最佳实践
  • Dubbo开源、自研、商业化三位一体战略解读
  • 基于Zookeeper、Dubbo构建互联网分布式基础架构
  • Dubbo分布式服务治理实战
  • 微服务实战-服务注册与发现 - Nacos Discovery

    • 相关电子书

    更多
  • Dubbo开源现状与2.7规划
  • Dubbo分布式服务治理实战
  • 《Dubbo 3.0 前瞻》

    • 相关实验场景

    更多
  • 快速玩转Dubbo生态之一致性事务篇（Seata）
  • 快速玩转Dubbo生态之限流降级篇（Sentinel）
  • 快速上手使用Dubbo进行远程调用
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
    • 下一篇
    阿里云OSS设置跨域访问