Dubbo 自定义路由

已于 2023-03-30 09:19:34 修改
阅读量1.3k 收藏 3
点赞数
分类专栏： 框架 文章标签： dubbo java
于 2023-03-30 09:11:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HDF734839030/article/details/129850587
版权

Dubbo 自定义路由

Dubbo 提供了丰富的流量管控策略:

  • 地址发现与负载均衡，地址发现支持服务实例动态上下线，负载均衡确保流量均匀的分布到每个实例上。
  • 基于路由规则的流量管控，路由规则对每次请求进行条件匹配，并将符合条件的请求路由到特定的地址子集。

服务发现保证调用方看到最新的提供方实例地址，服务发现机制依赖注册中心 (Zookeeper、Nacos、Istio 等)
实现。在消费端，Dubbo 提供了多种负载均衡策略，如随机负载均衡策略、一致性哈希负载、基于权重的轮询、最小活跃度优先、P2C
等。

Dubbo
的流量管控规则可以基于应用、服务、方法、参数等粒度精准的控制流量走向，根据请求的目标服务、方法以及请求体中的其他附加参数进行匹配，符合匹配条件的流量会进一步的按照特定规则转发到一个地址子集。流量管控规则有以下几种：

  • 条件路由规则
  • 标签路由规则
  • 脚本路由规则
  • 动态配置规则

说明

由于体验dubbo admin，当前对不具备生产使用的能力。线上误操作容易错。本章节对其成熟稳定的功能进行测试。

  • 标签路由：静态打标的方式
  • 自定义路由：日常我们所需的就近路由。

静态标签路由

provider配置标签，只能有一个。默认场景下会自动找到按标签匹配。

原理逻辑在TagStateRouter，如果未找到默认会找不携带 tag 的provider.

dubbo:
  provider:
    tag: tag-1

consumer配置

dubbo:
  consumer:
    tag: tag-1

实际作为消费者有时候需要强制路由到对应tag。可以添加dubbo.tag.force: true的parameters参数。

按dubbo parameters参数设计，可以放到application ，consumer，reference 节点。

dubbo:
  application:
    name: ${spring.application.name}
    # wait ms
    shut-wait: 30000
  registry:
    address: nacos://localhost:8848
    parameters:
      # 纯消费者时候可以注册上去
      register-consumer-url: true
  consumer:
    # ms
    timeout: 2000
    retries: 0
    # 优先级比parameters高，但实际使用通常针对单个provider设置
    tag: tag-1
  reference:
    com.seezoon.protocol.user.server.domain.UserService:
      # 直连使用url
      #url: tri://192.168.1.28:9000
      parameters:
        dubbo.tag: tagxxx
        dubbo.force.tag: true

consumer也可以通过编程方式设置tag

// 优先级高
RpcContext.getContext().setAttachment(Constants.TAG_KEY,"tag1");
RpcContext.getContext().setAttachment(Constants.FORCE_USE_TAG,"true");

自定义路由

和插件扩展原理一样，创建文件META-INF/dubbo/org.apache.dubbo.rpc.cluster.router.state.StateRouterFactory
放入文本文件

metaRouter=com.seezoon.dubbo.router.MetaStateRouterFactory

主要是继承CacheableStateRouterFactory

/**
 * 元数据路由
 *
 * @author dfenghuang
 * @date 2023/3/27 23:40
 */
@Activate
public class MetaStateRouterFactory extends CacheableStateRouterFactory {

    @Override
    protected <T> StateRouter<T> createRouter(Class<T> interfaceClass, URL url) {
        Map<String, String> routerMetas = url.getParameters(v -> v.startsWith("router.meta"));
        RouterMeta routerMeta = new RouterMeta();
        Map<String, String> customMeta = new HashMap<>(routerMetas.size());
        routerMetas.forEach((k, v) -> {
            if (RouterMeta.CONSUMER_SET_KEY.equals(k)) {
                routerMeta.setSet(v);
            } else if (RouterMeta.CONSUMER_IDC_KEY.equals(k)) {
                routerMeta.setIdc(v);
            } else if (RouterMeta.CONSUMER_CITY_KEY.equals(k)) {
                routerMeta.setCity(v);
            } else if (RouterMeta.NEARBY_ROUTE_KEY.equals(k)) {
                routerMeta.setNearbyRoute(
                        StringUtils.isNotEmpty(v) ? Boolean.parseBoolean(v) : true);
            } else {
                customMeta.put(k.substring(RouterMeta.ROUTER_PREFIX.length()), v);
            }
        });
        routerMeta.setCustomMeta(customMeta);
        routerMeta.setNearbyMetaEmpty(StringUtils.isEmpty(routerMeta.getSet())
                && StringUtils.isEmpty(routerMeta.getIdc())
                && StringUtils.isEmpty(routerMeta.getCity()));
        routerMeta.setEmpty(routerMeta.isNearbyMetaEmpty() && customMeta.isEmpty());
        return new MetaStateRouter(routerMeta, url);
    }
}

主要继承AbstractStateRouter

/**
 * 元数据路由
 * </p>
 *
 * <pre>
 * 1. 如果设置了自定义的元数据，元数据需要严格匹配；
 * 2. 如果设置了就近路由元数据，按set->idc->city的维度逐步找
 * 3. 如果关闭就近路由，就近的元数据存在的话，也需要严格匹配到
 * </pre>
 *
 * @author dfenghuang
 * @date 2023/3/27 23:42
 */
@Slf4j
public class MetaStateRouter<T> extends AbstractStateRouter<T> {

    private static final int size = 5;
    private final RouterMeta routerMeta;

    public MetaStateRouter(RouterMeta routerMeta, URL url) {
        super(url);
        this.routerMeta = routerMeta;
    }

    @Override
    protected BitList<Invoker<T>> doRoute(BitList<Invoker<T>> invokers, URL url,
            Invocation invocation,
            boolean needToPrintMessage, Holder<RouterSnapshotNode<T>> routerSnapshotNodeHolder,
            Holder<String> messageHolder) throws RpcException {
        if (routerMeta.isEmpty()) {
            return invokers;
        }
        if (log.isDebugEnabled()) {
            log.debug("consumer:{},router meta:{}", url, routerMeta);
        }
        int minSize = Math.min(size, invokers.size());
        List<Invoker<T>> result = new ArrayList<>(invokers.size());
        List<Invoker<T>> setResult = new ArrayList<>(minSize);
        List<Invoker<T>> idcResult = new ArrayList<>(minSize);
        List<Invoker<T>> cityResult = new ArrayList<>(minSize);
        String consumerSet = invocation.getAttachment(RouterMeta.CONSUMER_SET_KEY,
                routerMeta.getSet());
        String consumerIdc = invocation.getAttachment(RouterMeta.CONSUMER_IDC_KEY,
                routerMeta.getIdc());
        String consumerCity = invocation.getAttachment(RouterMeta.CONSUMER_CITY_KEY,
                routerMeta.getCity());
        for (Invoker<T> invoker : invokers) {
            Map<String, String> parameters = invoker.getUrl().getParameters();
            // 自定义的元数据必须匹配
            boolean customMetaMatched = true;
            for (Entry<String, String> entry : routerMeta.getCustomMeta().entrySet()) {
                if (!Objects.equals(entry.getValue(), parameters.get(entry.getKey()))) {
                    customMetaMatched = false;
                }
            }
            if (!customMetaMatched) {
                continue;
            }
            if (routerMeta.isNearbyMetaEmpty()) {
                continue;
            }
            String providerSet = parameters.get(RouterMeta.SET);
            String providerIdc = parameters.get(RouterMeta.IDC);
            String providerCity = parameters.get(RouterMeta.CITY);
            // 不开就近，就需要全匹配
            if (!routerMeta.isNearbyRoute()) {
                if (StringUtils.isNotEmpty(consumerSet) && !Objects.equals(consumerSet,
                        providerSet)) {
                    continue;
                }
                if (StringUtils.isNotEmpty(consumerIdc) && !Objects.equals(consumerIdc,
                        providerIdc)) {
                    continue;
                }
                if (StringUtils.isNotEmpty(consumerCity) && !Objects.equals(consumerCity,
                        providerCity)) {
                    continue;
                }
                result.add(invoker);
                continue;
            }
            if (StringUtils.isNotEmpty(consumerSet) && Objects.equals(consumerSet,
                    providerSet)) {
                setResult.add(invoker);
                continue;
            }
            if (StringUtils.isNotEmpty(consumerIdc) && Objects.equals(consumerIdc,
                    providerIdc)) {
                idcResult.add(invoker);
                continue;
            }
            if (StringUtils.isNotEmpty(consumerCity) && Objects.equals(consumerCity,
                    providerCity)) {
                cityResult.add(invoker);
            }
        }
        // 如果不开就近
        if (!routerMeta.isNearbyRoute()) {
            return new BitList<>(result);
        }
        // 或者距离标签配置则返回全量
        if (routerMeta.isNearbyMetaEmpty()) {
            return new BitList<>(result);
        }

        // 就近路由
        if (!setResult.isEmpty()) {
            log.debug("use set nearby meta:{}", consumerSet);
            return new BitList<>(setResult);
        }
        if (!idcResult.isEmpty()) {
            log.debug("use idc nearby meta:{}", consumerIdc);
            return new BitList<>(idcResult);
        }
        if (!cityResult.isEmpty()) {
            log.debug("use city nearby meta:{}", consumerCity);
            return new BitList<>(cityResult);
        }
        log.debug("can not find any nearby provider");
        return new BitList<>(result);
    }

    @Override
    public void stop() {
        super.stop();
    }

    @Override
    public boolean isRuntime() {
        return false;
    }

    @Override
    public boolean isForce() {
        return true;
    }
}

示例

Provider 配置

dubbo: 
  provider:
    parameters:
      # 服务提供者元数据，消费者根据这个路由
      meta.set: set1  # 单元
      meta.idc: idc1  # 机房
      meta.city: city1 #城市
      meta.tenant: custom-meta

Consumer 配置

dubbo:
  consumer:
    # ms
    timeout: 2000
    retries: 0
    tag: consumerTag
    parameters:
      # 路由元数据
      router.meta.set: set1
      router.meta.idc: idc1
      router.meta.city: city1
      # 默认是true
      router.meta.nearbyRoute: false
      router.meta.tenant: custom-meta
  reference:
    com.seezoon.protocol.user.server.domain.UserService:
      parameters:
        # 路由元数据
        router.meta.set: set1
        router.meta.idc: idc1
        router.meta.city: city1
        # 默认是true
        router.meta.nearbyRoute: false
        router.meta.tenant: custom-meta

源代码

dubbo自定义就近路由

昵称不能为null
关注
专栏目录
dubbo面试题dubbo面试题
04-02
SPI（Service Provider Interface）是Dubbo的一种扩展机制，允许用户自定义实现Dubbo的某些接口，通过配置文件指定加载的实现类。 9. **Dubbo如何实现服务版本控制？** 通过在服务接口名后添加`@Version`注解，...
dubbo设置自定义路由
codeLife1993的博客
01-05 1819
1.新建路由工厂 import org.apache.dubbo.common.URL; import org.apache.dubbo.common.extension.Activate; import org.apache.dubbo.rpc.cluster.Router; import org.apache.dubbo.rpc.cluster.RouterFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /**
dubbo如何自定义路由实现？
AI乔治
01-04 1500
业务场景：由于多个业务系统都实现了同一个服务，在调用中通过读取相关配置可以知道此次调用是限制请求到哪几个服务提供者上，而不是所有提供者中任取一个，这个就需要在dubbo上自定义自己的路由规则。 具体做法：实现Router接口，重写route方法，从注册中心所有服务提供者列表中选出符合规范的提供者列表并返回即可。 public class LimitIpRouter implements Router{ private final static Logger logger = LogManage
java服务路由_Dubbo 服务路由
weixin_42492211的博客
02-24 300
1. 简介上一篇文章分析了集群容错的第一部分 — 服务目录 Directory。服务目录在刷新 Invoker 列表的过程中，会通过 Router 进行服务路由，筛选出符合路由规则的服务提供者。在详细分析服务路由的源码之前，先来介绍一下服务路由是什么。服务路由包含一条路由规则，路由规则决定了服务消费者的调用目标，即规定了服务消费者可调用哪些服务提供者。Dubbo 目前提供了三种服务路由实现，分别为...
Dubbo标签路由
nickyyu的博客
05-03 1597
适用场景：通过将一个或多个服务的提供者划分到同一个分组，约束流量只在指定分组中流转，从而实现流量隔离的目的，用于解决灰度发布、蓝绿发布问题。 基本原理：通过给服务提供方的单个或多个实例指定标签，消费方在调用服务的时候，通过匹配标签筛选出符合条件的服务列表，然后再根据负载策略进行远程服务调用。 基本使用：在使用标签路由的时候，需要对服务提供方和消费方做相应配置才可生效。 消费方可以通过设置隐式参数指定标签给自己使用，以及将标签传递给下游服务，因为下游服务也有可能再次调用其他服务，所以需要通过隐..
阿里用什么替代了dubbo_Dubbo
weixin_39627052的博客
11-19 4397
Dubbo是什么？Dubbo 是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spring 框架无缝集成。Dubbo 框架，是基于容器运行的.。容器是 Spring。 官方网站 : http://dubbo.apache.org/ 现在阿里巴巴已经将 dubbo 框架捐献给了 Apache 软件基金会 。知道了之后，就要了解什么是单体...
dubbo+cloud全链路灰度设计
03-31
5. Dubbo扩展路由：基于dubbo routerFacory spi扩展dubbo的灰度路由机制。 6. Spring Cloud扩展路由：继承ZoneAvoidanceRule类进行灰度路由的扩展。 7. 染色流量传递：将入口的灰度流量参数一路传递到每个服务，支持...
dubbo xsd
06-27
7. **其他扩展配置**：Dubbo.xsd还支持服务级别的配置，如服务质量控制、负载均衡策略、服务路由规则等，这些都可以通过自定义标签和属性进行配置。 通过合理的Dubbo XSD配置，开发者可以构建出灵活、高可用的...
dubbo源码分析系列
04-06
- 负载均衡器：探讨Dubbo内置的各种负载均衡策略，如Random、RoundRobin、LeastActive等，以及自定义负载均衡策略的方法。 - 负载均衡决策：解析在服务调用时如何选择合适的服务器实例，以及在网络抖动或故障时的...
Dubbo课程资源09240924
07-01
Dubbo的Service Provider Interface允许用户自定义扩展点，实现对Dubbo功能的灵活扩展，增强框架的可定制性。 10. **集成Spring** Dubbo可以无缝集成Spring，通过XML或注解配置，轻松实现服务的声明式调用。 本...
Dubbo——路由(Router)规则原理
庄小焱
04-09 2449
摘要 我们这次宕机的是业务逻辑层，那按照目前使用 Dubbo 轮询的负载均衡方式，不是还会有交易分发到宕机那台应用上，这些交易请求显然会异常。这是因为 Dubbo 内部会自动帮我们的摘除宕机的应用节点。 Dubbo 服务注册发现流程 我们目前使用 ZooKeeper 当做服务注册中心，ZooKeeper 可以简单理解成是一个 KV系统，内部是一个树形的数据结构。Dubbo 默认将会在 ZooKeeper 中创建一个四层的数据结构，从上到下分别为： Root Service Catego.
dubbo parameters参数用法示例
super_scan的专栏
04-20 2223
由于各种原因，目前我司有些项目还在使用dubbox2.8.4 版本，有些功能需要通过parameters参数设置才能实现，现分享如下，希望可以帮助需要的同学一、自定义路由策...
Dubbo 路由规则之标签路由
liyong1028826685的专栏
05-25 1631
前言 大家好，今天开始给大家分享 — Dubbo 专题之 Dubbo 路由规则之标签路由。在前一个章节中我们介绍了 Dubbo 路由规则之标签路由，以及我们也例举了常见的使用场景并且进行了源码解析来分析其实现原理，同时知道 Dubbo 中标签路由其本质上是通过过滤器对服务提供者列表进行规则的匹配，如果匹配不上则过滤掉服务提供者。那接下来我们解析讨论标签路由，什么是标签路由呢？有什么使用场景呢？下面就让我们快速开始吧！ 1. 标签路由简介 首先小伙伴可以通过《Dubbo 路由规则之条件路由》回归一下什么是路由
Dubbo 服务路由
m0_64201189的博客
04-08 1432
服务路由包含一条路由规则，路由规则决定了服务消费者的调用目标，即规定了服务消费者可调用哪些服务提供者。Dubbo 目前提供了三种服务路由实现，分别为条件路由 ConditionRouter、脚本路由 ScriptRouter 和标签路由 TagRouter。其中条件路由是我们最常使用的。
dubbogo如何实现路由规则功能
qq_61039408的博客
04-26 831
路由规则（ routing rule ）是为了改变网络流量所经过的途径而修改路由信息的技术，主要通过改变路由属性（包括可达性）来实现。在发起一次 RPC 调用前起到过滤目标服务器地址的作用，过滤后的地址列表，将作为消费端最终发起 RPC 调用的备选地址。
dubbo处理自定义异常
weixin_55850954的博客
05-20 2301
在实际项目中，我们不可避免地需要使用自定义的异常，一般这个异常会继承RuntimeException，然后我们通过@RestControllerAdvice注解，拦截业务异常类，做一些处理，但是在使用dubbo构建项目时，会发现provider抛出自定义异常，然后在消费者端，不会捕捉到我们的自定义异常，而是以RuntimeException的形式被捕获。
Dubbo路由规则：静态标签的使用与扩展
m0_50275872的博客
08-01 1215
Dubbo 路由静态标签的使用
Dubbo架构篇 - 服务路由
The Secret
11-17 1031
本文解析Dubbo的服务路由中的条件路由
Dubbo的路由策略剖析
最新发布
J_bean的博客
05-28 538
Dubbo的路由策略剖析和实战案例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

昵称不能为null

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

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

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

打赏作者

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

抵扣说明：

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

余额充值