dubbo自定义集群策略扩展

最新推荐文章于 2025-06-17 01:00:00 发布
最新推荐文章于 2025-06-17 01:00:00 发布
阅读量1.6k 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： dubbo 文章标签： dubbo cluster clusterInvoker 自定义集群策略 demo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ywlmsm1224811/article/details/98637525
本文介绍如何在Dubbo框架中实现自定义集群策略，通过扩展源码解决动态请求路由问题，实现根据请求参数选择不同服务节点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

背景

最近项目中使用dubbo遇到了这样一个问题，dubbo invoke 要通过请求参数来动态决定，即不同的参数对应 dubbo 请求转到指定的机器上去。

集群策略源码

要实现背景中提到的问题，就必须先了解一下 dubbo 的源码

1、首先从配置入手，如果配置中可以灵活设置自定义的集群策略，就可以通过扩展源码来实现，下面看一下配置：

dubbo配置：

dubbo 源码：

通过上述图可以得出，dubbo 配置中可以使用任意的集群策略，那么dubbo中具体有哪些集群策略呢？下面通过源码看一下

2、dubbo 源码集群策略

Failover Cluster

这是dubbo中默认的集群容错模式，失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过retries=”2”来设置重试次数(不含第一次)

Failfast Cluster

快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster

失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster

失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster

并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过forks=”2”来设置最大并行数。

Broadcast Cluster

广播调用所有提供者，逐个调用，任意一台报错则报错。(2.1.0开始支持)通常用于通知所有提供者更新缓存或日志等本地资源信息。

Failover 是dubbo 的默认集群策略，通过 Cluster 的 @SPI 注解可以看出，如下：

3、分析学习一下 FailoverCluster 的源码

FailoverCluster  实现了 Cluster 接口，其具体实现是在 FailoverClusterInvoker 中的 doInvoke 方法中

这里最重要的就是选择某种策略获取到具体的 invoker

解决方案

通过阅读了 dubbo 中的部分源码，我们有了启发，只需要在消费者端自定义实现一个 Cluster 和对应的 ClusterInvoker，重写 ClusterInvoker 中的 doInvoke 方法即可

下面通过在消费者端拓展 Cluster 来解决此问题

1、先在resources 目录下创建 META-INF/dubbo 目录，该目录下创建  com.alibaba.dubbo.rpc.cluster.Cluster 文件，此文件产生参照dubbo源码中的 META-INF/dubbo/interal/com.alibaba.dubbo.rpc.cluster.Cluster 文件,内容如下：

custom=com.springboot.dubbo.cluster.CustomCluster

如下图所示：

2、创建  CustomCluster 和  CustomClusterInvoker 类，代码分别如下：

CustomCluster 对象：

package com.springboot.dubbo.cluster;

import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.RpcException;
import com.alibaba.dubbo.rpc.cluster.Cluster;
import com.alibaba.dubbo.rpc.cluster.Directory;

/**
 * 自定义集群策略
 **/
public class CustomCluster implements Cluster {
    public final static String NAME = "custom";

    @Override
    public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
        return new CustomClusterInvoker<>(directory);
    }
}

CustomClusterInvoker 对象：

package com.springboot.dubbo.cluster;

import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.Version;
import com.alibaba.dubbo.common.utils.NetUtils;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Result;
import com.alibaba.dubbo.rpc.RpcContext;
import com.alibaba.dubbo.rpc.RpcException;
import com.alibaba.dubbo.rpc.cluster.Directory;
import com.alibaba.dubbo.rpc.cluster.LoadBalance;
import com.alibaba.dubbo.rpc.cluster.support.AbstractClusterInvoker;
import com.springboot.common.util.StringUtil;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import lombok.extern.log4j.Log4j2;

/**
 * 自定义集群invoker
 **/
@Log4j2
public class CustomClusterInvoker<T> extends AbstractClusterInvoker<T> {
    public static final String BIND_IP_KEY = "bind_ip_key";

    public CustomClusterInvoker(Directory<T> directory) {
        super(directory);
    }

    @Override
    protected Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
        List<Invoker<T>> copyinvokers = invokers;
        checkInvokers(copyinvokers, invocation);
        int len = getUrl().getMethodParameter(invocation.getMethodName(), Constants.RETRIES_KEY, Constants.DEFAULT_RETRIES) + 1;
        if (len <= 0) {
            len = 1;
        }
        // retry loop.
        RpcException le = null;
        // last exception.
        List<Invoker<T>> invoked = new ArrayList<>(copyinvokers.size());
        // invoked invokers.
        Set<String> providers = new HashSet<>(len);
        for (int i = 0; i < len; i++) {
            //Reselect before retry to avoid a change of candidate `invokers`.
            //NOTE: if `invokers` changed, then `invoked` also lose accuracy.
            if (i > 0) {
                checkWhetherDestroyed();
                copyinvokers = list(invocation);
                // check again
                checkInvokers(copyinvokers, invocation);
            }
            Invoker<T> invoker = getInvokerByParam(loadbalance,invocation,copyinvokers,invoked,invokers);
            invoked.add(invoker);
            RpcContext.getContext().setInvokers((List) invoked);
            try {
                Result result = invoker.invoke(invocation);
                if (le != null && log.isWarnEnabled()) {
                    log.warn("Although retry the method " + invocation.getMethodName()
                            + " in the service " + getInterface().getName()
                            + " was successful by the provider " + invoker.getUrl().getAddress()
                            + ", but there have been failed providers " + providers
                            + " (" + providers.size() + "/" + copyinvokers.size()
                            + ") from the registry " + directory.getUrl().getAddress()
                            + " on the consumer " + NetUtils.getLocalHost()
                            + " using the dubbo version " + Version.getVersion() + ". Last error is: "
                            + le.getMessage(), le);
                }
                return result;
            } catch (RpcException e) {
                if (e.isBiz()) {
                    // biz exception.
                    throw e;
                }
                le = e;
            } catch (Throwable e) {
                le = new RpcException(e.getMessage(), e);
            } finally {
                providers.add(invoker.getUrl().getAddress());
            }
        }
        throw new RpcException(le != null ? le.getCode() : 0, "Failed to invoke the method "
                + invocation.getMethodName() + " in the service " + getInterface().getName()
                + ". Tried " + len + " times of the providers " + providers
                + " (" + providers.size() + "/" + copyinvokers.size()
                + ") from the registry " + directory.getUrl().getAddress()
                + " on the consumer " + NetUtils.getLocalHost() + " using the dubbo version "
                + Version.getVersion() + ". Last error is: "
                + (le != null ? le.getMessage() : ""), le != null && le.getCause() != null ? le.getCause() : le);
    }

    /**
     * 根据参数动态获取invoker
     * 
     * @param loadbalance 
     * @param invocation
     * @param copyinvokers
     * @param invoked
     * @param originInvokers
     * @return
     */
    private Invoker<T> getInvokerByParam(LoadBalance loadbalance, Invocation invocation, List<Invoker<T>> copyinvokers, List<Invoker<T>> invoked, List<Invoker<T>> originInvokers) {
        // 获取消费者处设置的参数
        String host = RpcContext.getContext().getAttachment(BIND_IP_KEY);
        if (StringUtil.isEmpty(host)) {
            return select(loadbalance, invocation, copyinvokers, invoked);
        }
        // 移除绑定的参数
        RpcContext.getContext().removeAttachment(BIND_IP_KEY);
        for (Invoker<T> invoker : originInvokers) {
            if (host.equals(invoker.getUrl().getHost())) {
                // 获取到了匹配的host的invoker
                return invoker;
            }
        }

        return select(loadbalance, invocation, copyinvokers, invoked);
    }
}

3、dubbo配置中设置自定义集群策略，如下图：

4、具体的消费者处设置dubbo上下文参数，以便于  CustomClusterInvoker 的 doInvoke 方法解析选择host

具体的host对应关系我保存到了 zookeeper 中，如下图：

请求id 若是奇数，则 host 为 192.168.1.235 ，若是偶数， 则 host 为 192.168.1.247

具体消费者处设置的dubbo上下文参数代码如下：

package com.springboot.dubbo.consumer;

import com.alibaba.dubbo.rpc.RpcContext;
import com.alibaba.fastjson.JSONObject;
import com.springboot.common.util.StringUtil;
import com.springboot.dubbo.cluster.CustomClusterInvoker;
import com.springboot.dubbo.param.request.QueryUserParam;
import com.springboot.dubbo.param.request.UserInParam;
import com.springboot.dubbo.param.response.UserOutParam;
import com.springboot.dubbo.service.UserService;
import com.springboot.zookeeper.ZookeeperConfigService;
import java.util.List;
import java.util.Map;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 用户消费者
 **/
@Log4j2
@Service
public class UserConsumer {
    @Autowired
    private UserService userService;
    @Autowired
    private ZookeeperConfigService zookeeperConfigService;

    public List<UserOutParam> getUsers(Integer id) {
        QueryUserParam param = new QueryUserParam();
        param.setId(id);
        log.warn("userServiceProvider selectUsers 请求参数：{}", param);
        String host = getHostByUserId(id);
        if (StringUtil.isNotEmpty(host)) {
            RpcContext.getContext().setAttachment(CustomClusterInvoker.BIND_IP_KEY, host);
        }
        List<UserOutParam> userList = userService.selectUsers(param);
        log.warn("userServiceProvider selectUsers 请求结果：{}", JSONObject.toJSONString(userList));
        return userList;
    }

    private String getHostByUserId(Integer id) {
        String id2Host = zookeeperConfigService.getValue("id_to_host");
        if (StringUtil.isEmpty(id2Host) || id == null) {
            return null;
        }
        Map<String, String> hostMap = JSONObject.parseObject(id2Host, Map.class);
        if (id % 2 == 0) {
            // 偶数
            return hostMap.get("evenNumber");
        }

        // 奇数
        return hostMap.get("oddNumber");
    }
}

5、代码写好之后，消费者项目启动之后，通过 consumer 的 url 可以看出是否应用了我们自定义的集群策略，如下图：

上图中可以看出 consumer 的 URL 中有 cluster=custom 这句话，表明了当前使用的是我们自定义的集群策略了

6、请求代码测试

请求id=2 时，rpc 请求落到了 192.168.1.247 这个机器上，如下图：

请求id=3 时，rpc 请求落到了 192.168.1.235 这个机器上，如下图：

总结

当我们使用第三方包做开发时，遇到了第三方包目前无法解决我们的需求使用时，只能靠阅读第三方包的部分源码，阅读源码之后通过扩展方式来实现自己的项目需求。

这也是阅读源码的好处之一

 

【Dubbo】服务消费端使用自定义Cluster
gossip博客
01-22 666
一. 概述 Dubbo使用Cluster接口定义容错集群，默认有下面几种实现 failover 失败后选择另外一台服务提供者进行重试，重试次数可配置，通常适合实现幂等服务的场景。 failfast 快速失败，失败后立即返回错误。 failsafe 调用失败后打印错误日志，返回成功，通常用于记录审计日志等场景。 failback 调用失败后，返回成功，但会在后台定时无限次重试，重启后不再重试。 forking 并发调用，收到第一...
Dubbo 的自定义集群策略
FireFox1997
07-23 1113
Dubbo 是一个高性能的 Java RPC 框架，广泛用于构建分布式系统。在 Dubbo 的架构中，集群策略是决定如何选择服务提供者的重要机制。集群策略通过不同的策略和算法来处理请求的路由、负载均衡、容错等问题。虽然 Dubbo 内置了多种集群策略，如“随机”、“轮询”、“最少活跃”等，但在一些特定场景中，可能需要根据业务需求自定义集群策略。本文将探讨如何在 Dubbo 中实现和使用自定义集群策略。集群策略在 Dubbo 中用于决定如何选择和调用服务提供者。随机集群策略：随机选择一个服务提供者进行调用。
Dubbo分析之Cluster层
weixin_34072857的博客
11-22 169
2019独角兽企业重金招聘Python工程师标准>>> ...
【dubbo源码解析】 --- dubbo集群容错(cluster）、负载均衡(loadbalance)底层原理探析 + 扩展自己的集群容错、负载均衡组件（转载）
Solomwn的博客
08-06 271
文章目录 1 集群容错和负载均衡的概念 2 dubbo集群容错 + 负载均衡底层原理 3 简单测试 4 自己扩展一个dubbo集群容错组件和负载均衡组件 4.1 扩展一个集群容错组件(Cluster) 4.2 扩展一个loadbalance组件 4.3 不要忘了在MATE-INF/dubbo文件夹下指定这些SPI扩展组件 4.3 测试 1 集群容错和负载均衡的概念 摘自dubbo官方博客：http://dubbo.apache.org/zh-cn/blog/dubbo-loadbalance.html 在这
Dubbo调度机制解析(cluster扩展或者路由扩展)
qq838642798的博客
11-13 1418
1.      更详细的duboo的集群路由和负载均衡机制分析 首先进入XXClusterInvoker类: invoke(final Invocation invocation)-> Directory.list(invocation) 进入XXDirectory（RegistryDirectory）类： list(invocation)->doList(Invocation invoc
【dubbo源码解析】 --- dubbo集群容错(cluster）、负载均衡(loadbalance)底层原理探析 + 扩展自己的集群容错、负载均衡组件
nrsc
07-20 1361
本文对应源码地址：https://github.com/nieandsun/dubbo-study 文章目录1 集群容错和负载均衡的概念2 dubbo集群容错 + 负载均衡底层原理3 简单测试4 自己扩展一个dubbo集群容错组件和负载均衡组件4.1 扩展一个集群容错组件(Cluster)4.2 扩展一个loadbalance组件4.3 不要忘了在MATE-INF/dubbo文件夹下指定这些SPI扩展组件4.3 测试 1 集群容错和负载均衡的概念 摘自dubbo官方博客：http://dubbo.
Dubbo|基础知识之dubbo自定义标签解析
星空下的程序猿
11-14 892
上一篇博文了解到dubbo框架有15个自定义标签，那么每个标签代表什么含义，标签有什么作用，标签内部都有哪些元素等问题还都未知，所以这篇博文就来学习15个自定义标签的含义吧。 所以通过这篇博文可以获取以下几点知识： dubbo框架15个标签的概念及作用 dubbo框架15个标签对应的实体类结构 通过15个标签窥探dubbo框架的整体流程 备注：此处dubbo版本为2.7.1，不同版本标签个数不...
Dubbo源码分析与扩展详解：从架构设计到自定义扩展
最新发布
weixin_42593797的博客
06-17 819
本文深入剖析了Apache Dubbo微服务框架的核心架构与源码实现。首先解析了Dubbo的分层架构设计和服务调用流程，包含服务暴露、注册、订阅等关键环节。重点分析了SPI扩展机制、远程调用实现和注册中心等核心组件的源码，包括ExtensionLoader加载机制、Invoker调用链和Zookeeper注册实现。最后通过自定义协议扩展和负载均衡的实战案例，展示了Dubbo强大的扩展能力。该分析为开发者深入理解Dubbo微服务框架提供了源码级的参考。
Java中实现dubbo集群容错的策略与实践
2. Dubbo集群容错机制：在Dubbo框架中，集群容错是通过集群扩展点来实现的。Dubbo提供了多种集群策略，例如 Failover Cluster（失败自动切换）、Failfast Cluster（快速失败）、Failsafe Cluster（安全失败）、...
Dubbo 负载均衡（Load Balance）
FireFox1997
07-13 1296
随机负载均衡策略是通过随机算法从服务提供者列表中选取一个节点进行调用。每次请求到达时，系统都会随机选择一个服务节点，无需考虑之前的请求情况。轮询负载均衡策略是按照固定的顺序依次轮流选择服务节点进行调用。每次请求到达时，系统选择下一个节点，当到达列表末尾时重新从头开始。一致性哈希负载均衡策略通过哈希算法将请求映射到固定的服务节点，确保相同参数的请求始终由同一个服务节点处理。此策略特别适用于需要会话粘性或数据分片的场景。Dubbo 提供了多种负载均衡策略，帮助开发者根据不同的业务场景选择合适的方案。
Dubbo—Cluster剖析
qq_30051265的博客
09-20 1931
概述 本文将介绍以下内容： 集群容错 集群容错模式 自定义扩展集群 集群容错 集群容错 在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。 各节点关系： 这里的 Invoker 是 Provider 的一个可调用 Service 的抽象，Invoker 封装了 Provider 地址及 Service 接口信息 Directory 代表多个 Invoker，...
Dubbo的集群容错与负载均衡策略及自定义
weixin_30361641的博客
09-16 364
Dubbo的集群容错策略 正常情况下，当我们进行系统设计时候，不仅要考虑正常逻辑下代码该如何走，还要考虑异常情况下代码逻辑应该怎么走。当服务消费方调用服务提供方的服务出现错误时候，Dubbo提供了多种容错方案，缺省模式为failover，也就是失败重试。 Dubbo提供的集群容错模式 下面看下Dubbo提供的集群容错模式： Failover Cluster：失败重试 当服务消费...
dubbo集群之Cluster模块
weixin_34088838的博客
05-08 261
Cluster 模块的目标是暴露 Invoker 对象，实现统一的调用入口 @SPI(FailoverCluster.NAME) //默认扩展点 public interface Cluster { @Adaptive//基于 Directory ，创建 Invoker 对象 <T> Invoker<T> join(Directory<T> di...
分布式进阶（十七）——分布式框架之可扩展：Dubbo基本原理
smart_an的专栏
04-07 773
本章，我介绍了Dubbo这一分布式RPC框架的基本架构和底层原理。
dubbo源码深度解读六之cluster模块
KilluaZoldyck的博客
08-01 1210
前言：这是集群模块，将多个服务提供方伪装为一个提供方，包括：负载均衡, 容错，路由等，集群的地址列表可以是静态配置的，也可以是由注册中心下发。下图描述了dubbo调用过程中的对于集群，负载等的调用关系，根据该图一步步进行解读。 一，Cluster 将Directory中的多个Invoker伪装成一个Invoker, 对上层透明，包含集群的容错机制@SPI(FailoverCluster.NAME
Dubbo服务调用扩展点学习及实践
qq_42070135的博客
08-02 384
Dubbo 拦截器扩展自定义实现
【Dubbo】Cluster 层集群容错
菜鸡也有大佬梦
05-11 548
主要内容 ： • 集群容错总体实现 ； • 普通容错策略的实现 ； • Directory 的实现原理 ； • Router 的实现原理 ； • LoadBalance 的实现原理 ； • Merger 的实现原理 ； • Mock 的实现原理 。 首先介绍整个集群容错层的总体结构与实现 ， 让读者对集群容错层有一个整体的了解 。 然后讲解该层中的每个重要组件 ， 包括普通容错策略的实现原理 ， 如 Failover> Failfast 等策略 ； 整个集群容错过程都会使用的 Directory &g
dubbo-cluster结构简述
icool_ali的博客
07-31 1360
 dubbo的集群子项目结构 dubbo容错，路由及负载均衡策略 （确定cluster 类型，从directory中获取注册信息，router根据规则来过滤list&lt;Invoker&gt; ，然后loadBalance 做负载，抽取 invoker） Cluster(集群容错类型)   Directory(集群服务提供者目录，StaticDirectory中的Static...
14. Dubbo原理解析-集群&容错之Cluster
热门推荐
斩秋的专栏
12-03 1万+
Dubbo作为一个分布式的服务治理框架，提供了集群部署，路由，软负载均衡及容错机制   下图描述了dubbo调用过程中的对于集群，负载等的调用关系。   Cluster 将Directory中的多个Invoker伪装成一个Invoker, 对上层透明，包含集群的容错机制 Cluster接口定义 @SPI(FailoverCluster.NAME) public interf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值