Dubbo 系列（07-5）集群容错 - Mock

Dubbo 系列（07-5）集群容错 - Mock

[toc]

Spring Cloud Alibaba 系列目录 - Dubbo 篇

1. 背景介绍

相关文档推荐：

  1. Dubbo 实战 - 服务降级
  2. Dubbo 实战 - 本地伪装
  3. Dubbo 实战 - 本地存根

Dubbo 的集群容错中默认会组装 MockClusterWrapper，它实现了 Dubbo 的服务降级和本地伪装。

1.1 服务降级

服务降级配置方式，更多参考官网 Dubbo 实战 - 服务降级

<dubbo:reference interface="com.foo.BarService" mock="force:return+null"/>

或向注册中心写入动态配置覆盖规则：

"override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"
  • mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  • mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

1.2 本地伪装

本地伪装配置方式，更多参考官网 Dubbo 实战 - 本地伪装

<dubbo:reference interface="com.foo.BarService" mock="true"/>
<dubbo:reference interface="com.foo.BarService" mock="com.foo.BarServiceMock"/>
<dubbo:reference interface="com.foo.BarService" mock="return null"/>
<dubbo:reference interface="com.foo.BarService" mock="throw com.foo.MockException" />

以上几种方式，和 mock=fail:return+null 一样，表示消费方对该服务的方法调用在失败后，执行 mock 配置的代码。

2. 源码分析

2.1 原理分析

在上一篇讲解 Dubbo Cluster 时可以看到， Dubbo 默认会将 Cluster#join 生成的 ClusterInvoker 对象包装 MockClusterInvoker。

图1 Dubbo Mock原理图

graph LR
MockClusterWrapper -- join --> MockClusterInvoker
MockClusterInvoker -- selectMockInvoker --> MockInvokersSelector
MockInvokersSelector -- route --> MockProtocol
MockProtocol -- refer --> MockInvoker

总结： Dubbo Mock 主要流程如下：

  1. MockClusterWrapper：由于这个类是 Cluster 的包装类，所以 Dubbo 默认装配 MockClusterWrapper，对 ClusterInvoker 进行包装。
  2. MockClusterInvoker：核心类，对 ClusterInvoker 进行包装，主要功能：一是判断是否需要开启 Mock 机制；二是根据 MockInvokersSelector 过滤出对应的 Mock Invoker；三是执行 MockInvoker。
  3. MockInvokersSelector：Mock 路由策略，由于是 @Activate 修辞，因此会自动装配。当不开启 Mock 时返回正常的 Invoker，当开启了 Mock 后返回 Mock Invoker。
  4. MockProtocol：创建 MockInvoker。这个 MockProtocol 只能引用，不能暴露。
  5. MockInvoker：核心类，真正执行服务降级，处理 mock="return null"、mock="throw com.foo.MockException"、mock="com.foo.BarServiceMock" 。

2.2 MockClusterInvoker

MockClusterInvoker 的主要功能是判断是否需要开启 Mock 机制，如果开启 Mock 则需要过滤出 MockInvoker 后执行服务降级。MockClusterWrapper 和 MockClusterInvoker 位于 dubbo-cluster 工程下。

2.2.1 MockClusterWrapper

MockClusterWrapper 是包装类，按 Dubbo SPI 机制，会将默认的 Cluster 进行包装。

public class MockClusterWrapper implements Cluster {
    private Cluster cluster;
    public MockClusterWrapper(Cluster cluster) {
        this.cluster = cluster;
    }

    @Override
    public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
        return new MockClusterInvoker<T>(directory, this.cluster.join(directory));
    }
}

总结： Dubbo 默认的 Cluster 是 FailoverCluster，也就是说 MockClusterWrapper 会对 FailoverCluster 进行包装。接下来看一下 Mock 的核心 MockClusterInvoker 执行过程。

MockClusterInvoker 是 Dubbo Mock 的核心类，主要功能有三个：

  1. 判断是否需要开启 Mock 机制，由 invoke 方法完成。
  2. 根据 MockInvokersSelector 过滤出对应的 Mock Invoker，由 selectMockInvoker 完成，实际是委托给 MockInvokersSelector 完成路由。
  3. 执行 MockInvoker，由 doMockInvoke方法完成，实际是委托给 MockInvoker。

2.2.2 invoke 执行入口

invoke 判断是否需要开启 Mock 机制，如果需要开启，则调用 doMockInvoke 进行服务降级。

@Override
public Result invoke(Invocation invocation) throws RpcException {
    Result result = null;
    String value = directory.getUrl().getMethodParameter(invocation.getMethodName(),
		MOCK_KEY, Boolean.FALSE.toString()).trim();
    if (value.length() == 0 || value.equalsIgnoreCase("false")) {
        //no mock
        result = this.invoker.invoke(invocation);
    } else if (value.startsWith("force")) {
        //force:direct mock
        result = doMockInvoke(invocation, null);
    } else {
        //fail-mock
        try {
            result = this.invoker.invoke(invocation);
        } catch (RpcException e) {
            if (e.isBiz()) {
                throw e;
            }
            result = doMockInvoke(invocation, e);
        }
    }
    return result;
}

总结： **invoke 关注一个问题，是否需要开启 Mock，如果开启 Mock 调用 doMockInvoke 执行。**代码注释已经很清楚了，分别对 no mock:(正常流程)、force:(强制mock)、fail:(失败mock，默认) 分别处理。如果 mock=false 则正常处理，如果配置 mock="return null" 和 mock="fail:return+null" 处理流程是一样的。

2.2.3 doMockInvoke

doMockInvoke 执行服务降级。

private Result doMockInvoke(Invocation invocation, RpcException e) {
    Result result = null;
    Invoker<T> minvoker;

    // 1. 过滤可以用 mockInvokers
    List<Invoker<T>> mockInvokers = selectMockInvoker(invocation);
    // 2. 如果没有，创建 MockInvoker
    if (CollectionUtils.isEmpty(mockInvokers)) {
        minvoker = (Invoker<T>) new MockInvoker(directory.getUrl(), directory.getInterface());
    } else {
        minvoker = mockInvokers.get(0);
    }
    // 3. 执行服务降级 mockInvoker
    try {
        result = minvoker.invoke(invocation);
    } catch (RpcException me) {
        if (me.isBiz()) {
            result = AsyncRpcResult.newDefaultAsyncResult(me.getCause(), invocation);
        } else {
            throw new RpcException(me.getCode(), getMockExceptionMessage(e, me), me.getCause());
        }
    } catch (Throwable me) {
        throw new RpcException(getMockExceptionMessage(e, me), me.getCause());
    }
    return result;
}

总结： doMockInvoke 最终调用 minvoker.invoke(invocation) 进行服务降级，其中需要关注的是 selectMockInvoker(invocation) 过滤缓存中的 MockInvoker，如果没有就需要创建新的 MockInvoker。

2.2.4 selectMockInvoker

selectMockInvoker 方法很奇怪，没有看到真正的 MockInvoker 过滤到底是怎么完成的。实际上 Dubbo 的默认路由策略就包含了 MockInvokersSelector，由这个类完成规则路由。

private List<Invoker<T>> selectMockInvoker(Invocation invocation) {
   List<Invoker<T>> invokers = null;
   if (invocation instanceof RpcInvocation) {
       // 1. 设置invocation.need.mock=true
       ((RpcInvocation) invocation).setAttachment(INVOCATION_NEED_MOCK, Boolean.TRUE.toString());
       // 2. 调用 MockInvokersSelector 路由规则过滤服务列表
       invokers = directory.list(invocation);
       ...
   }
   return invokers;
}

总结： selectMockInvoker 方法偷偷在将 invocation 的 invocation.need.mock 属性设置为 false，这个参数在 MockInvokersSelector 中就很有用了。然后通过 directory.list(invocation) 方法重新获取服务列表，在 Dubbo 系列（07-1）集群容错 - 服务字典 分析 RegisterDirectory 源码时，我们知道 list 方法会调用 routeChain.route 路由规则过滤服务。 下面看一下 MockInvokersSelector 代码。

2.3 MockInvokersSelector

MockInvokersSelector 在未开启 Mock 时返回正常的 Invokers，开启后返回 MockInvoker。

@Override
public <T> List<Invoker<T>> route(final List<Invoker<T>> invokers,
		URL url, final Invocation invocation) throws RpcException {
    if (CollectionUtils.isEmpty(invokers)) {
        return invokers;
    }

    if (invocation.getAttachments() == null) {
        // 1. 返回 -> 非MockedInvoker
        return getNormalInvokers(invokers);
    } else {
        String value = invocation.getAttachments().get(INVOCATION_NEED_MOCK);
        if (value == null) {
            return getNormalInvokers(invokers);
        // 2. invocation.need.mock=true则返回 -> MockedInvoker(MockProtocol)
        } else if (Boolean.TRUE.toString().equalsIgnoreCase(value)) {
            return getMockedInvokers(invokers);
        }
    }
    // 3. invocation.need.mock=false则返回 -> 非MockedInvoker + MockedInvoker
    // ???
    return invokers;
}

**总结：**directory.list 调用 MockInvokersSelector.route 时，有三种情况：

  1. attachments 为 null 或 invocation.need.mock 为 null，则返回 非MockedInvoker。
  2. invocation.need.mock=true 则返回 MockedInvoker。
  3. invocation.need.mock=false 则返回 非MockedInvoker + MockedInvoker ???

2.4 MockInvoker

MockProtocol 和 MockInvoker 位于 dubbo-rpc-api 工程下。

在 MockClusterInvoker#doMockInvoke 方法中，如果 directory.list 过滤出的 MockedInvoker 为空，则会直接创建一个 MockedInvoker，代码如下：

 minvoker = (Invoker<T>) new MockInvoker(directory.getUrl(), directory.getInterface());

其实 Mock 也是一种协议，可以在注册中心 /dubbo/com.foo.BarService/providers 目录下写入：

"mock://192.168.139.101/com.foo.BarService"

这样消费者订阅 com.foo.BarService 服务后会根据 MockProtocol 协议创建对应的 MockedInvoker。

2.4.1 MockProtocol

MockProtocol 只能通过 reference 引入，不能通过 export 暴露服务。其实也就是直接创建了一个 MockInvoker。

final public class MockProtocol extends AbstractProtocol {
    @Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> Invoker<T> protocolBindingRefer(Class<T> type, URL url) throws RpcException {
        return new MockInvoker<>(url, type);
    }
}

总结： MockProtocol 非常简单，就不多说了。下面看一下 MockInvoker 代码。

2.4.2 MockInvoker

MockInvoker 执行服务降级。在 MockClusterInvoker 判断是否需要开启 Mock 后，MockInvokersSelector 过滤出可用的 MockInvoker，最后执行服务降级。

  1. 根据服务降级配置，执行对应的服务降级，如 return、throw、xxxServiceMock
  2. 直接 return 需要解析返回参数：parseMockValue
  3. 执行 xxxServiceMock 需要查找对应的实现类：getInvoker。

先看一下整体的执行流程 invoke 方法。

@Override
public Result invoke(Invocation invocation) throws RpcException {
    // 1. 获取mock值，URL 中 methodname.mock 或 mock 参数
    String mock = getUrl().getParameter(invocation.getMethodName() + "." + MOCK_KEY);
    if (invocation instanceof RpcInvocation) {
        ((RpcInvocation) invocation).setInvoker(this);
    }
    if (StringUtils.isBlank(mock)) {
        mock = getUrl().getParameter(MOCK_KEY);
    }

    if (StringUtils.isBlank(mock)) {
        throw new RpcException(new IllegalAccessException("mock can not be null. url :" + url));
    }

    // 2. 对mock字符串进行处理，比如去除 `force:`、`fail:` 前缀
    mock = normalizeMock(URL.decode(mock));
    // 3. return
    if (mock.startsWith(RETURN_PREFIX)) {
        mock = mock.substring(RETURN_PREFIX.length()).trim();
        try {
            Type[] returnTypes = RpcUtils.getReturnTypes(invocation);
            Object value = parseMockValue(mock, returnTypes);
            return AsyncRpcResult.newDefaultAsyncResult(value, invocation);
        } catch (Exception ew) {
            throw new RpcException(ew);
        }
    // 3. throw
    } else if (mock.startsWith(THROW_PREFIX)) {
        mock = mock.substring(THROW_PREFIX.length()).trim();
        if (StringUtils.isBlank(mock)) {
            throw new RpcException("mocked exception for service degradation.");
        } else { // user customized class
            Throwable t = getThrowable(mock);
            throw new RpcException(RpcException.BIZ_EXCEPTION, t);
        }
    // 5. xxxServiceMock
    } else { //impl mock
        try {
            Invoker<T> invoker = getInvoker(mock);
            return invoker.invoke(invocation);
        } catch (Throwable t) {
            throw new RpcException("Failed to create mock implementation class " + mock, t);
        }
    }
}

总结： invoke 执行服务降级，首先获取 mock 参数，并对 mock 参数进行处理，如去除 force:、fail: 前缀。Dubbo 服务降级有三种处理情况：

  1. return：直接返回，可以是 empty、null 、true 、false 、json 格式，由方式 parseMockValue 进行解析。
  2. throw：直接抛出异常。如果没有指定异常，抛出 RpcException，否则抛出指定的 Exception。
  3. xxxServiceMock：执行 xxxServiceMock 方法。如果 mock=true 或 mock=defalut 则查找 xxxServiceMock 方法后执行，如果 mock=com.dubbo.testxxxService 则执行指定的方法。

getInvoker 方法查找指定对流的 Invoker。

private Invoker<T> getInvoker(String mockService) {
    // 1. 缓存命中
    Invoker<T> invoker = (Invoker<T>) MOCK_MAP.get(mockService);
    if (invoker != null) {
        return invoker;
    }

    // 2. 根据serviceType查找mock的实现类，默认为 xxxServiceMock
    Class<T> serviceType = (Class<T>) ReflectUtils.forName(url.getServiceInterface());
    T mockObject = (T) getMockObject(mockService, serviceType);
    // 3. 包装成Invoker
    invoker = PROXY_FACTORY.getInvoker(mockObject, serviceType, url);
    if (MOCK_MAP.size() < 10000) {
        MOCK_MAP.put(mockService, invoker);
    }
    return invoker;
}

public static Object getMockObject(String mockService, Class serviceType) {
    // mock=true或default时，查找 xxxServiceMock
    if (ConfigUtils.isDefault(mockService)) {
        mockService = serviceType.getName() + "Mock";
    }
	// mock=testxxxService，指定Mock实现类
    Class<?> mockClass = ReflectUtils.forName(mockService);
    ...
    return mockClass.newInstance();
}

总结： Dubbo 如果不指定 Mock 实现类，默认查找 xxxServiceMock。如果存在该实现类，则将其包装成 Invoker 后返回。


每天用心记录一点点。内容也许不重要，但习惯很重要！

原文地址：https://www.cnblogs.com/binarylei/p/11703192.html

时间： 2024-09-28 17:12:47

Dubbo 系列（07-5）集群容错 - Mock的相关文章

初识Dubbo 系列之8-Dubbo 集群容错

集群容错 (+) (#) 在集群调用失败时,Dubbo提供了多种容错方案,缺省为failover重试. 各节点关系: 这里的Invoker是Provider的一个可调用Service的抽象,Invoker封装了Provider地址及Service接口信息. Directory代表多个Invoker,可以把它看成List<Invoker>,但与List不同的是,它的值可能是动态变化的,比如注册中心推送变更. Cluster将Directory中的多个Invoker伪装成一个Invoker,对上层

Dubbo 源码分析 - 集群容错之 LoadBalance

1.简介 LoadBalance 中文意思为负载均衡,它的职责是将网络请求,或者其他形式的负载"均摊"到不同的机器上.避免集群中部分服务器压力过大,而另一些服务器比较空闲的情况.通过负载均衡,可以让每台服务器获取到适合自己处理能力的负载.在为高负载的服务器分流的同时,还可以避免资源浪费,一举两得.负载均衡可分为软件负载均衡和硬件负载均衡.在我们日常开发中,一般很难接触到硬件负载均衡.但软件负载均衡还是能够接触到一些的,比如 Nginx.在 Dubbo 中,也有负载均衡的概念和相应的实现

Dubbo 源码分析 - 集群容错之 Directory

1. 简介 前面文章分析了服务的导出与引用过程,从本篇文章开始,我将开始分析 Dubbo 集群容错方面的源码.这部分源码包含四个部分,分别是服务目录 Directory.服务路由 Router.集群 Cluster 和负载均衡 LoadBalance.这几个部分的源码逻辑比较独立,我会分四篇文章进行分析.本篇文章作为集群容错的开篇文章,将和大家一起分析服务目录相关的源码.在进行深入分析之前,我们先来了解一下服务目录是什么.服务目录中存储了一些和服务提供者有关的信息,通过服务目录,服务消费者可获取

Dubbo 源码分析 - 集群容错之 Router

1. 简介 上一篇文章分析了集群容错的第一部分 – 服务目录 Directory.服务目录在刷新 Invoker 列表的过程中,会通过 Router 进行服务路由.上一篇文章关于服务路由相关逻辑没有细致分析,一笔带过了,本篇文章将对此进行详细的分析.首先,先来介绍一下服务目录是什么.服务路由包含一条路由规则,路由规则决定了服务消费者的调用目标,即规定了服务消费者可调用哪些服务提供者.Dubbo 目前提供了三种服务路由实现,分别为条件路由 ConditionRouter.脚本路由 ScriptRo

Dubbo 系列（07-3）集群容错 - 负载均衡

目录 Spring Cloud Alibaba 系列目录 - Dubbo 篇 1. 背景介绍 1.1 负载均衡算法 1.2 继承体系 2. 源码分析 2.1 AbstractLoadBalance 2.2 RandomLoadBalance 2.3 LeastActiveLoadBalance 2.4 ConsistentHashLoadBalance Dubbo 系列(07-3)集群容错 - 负载均衡 Spring Cloud Alibaba 系列目录 - Dubbo 篇 1. 背景介绍 相关

面试系列16 dubbo负载均衡策略和集群容错策略都有哪些？动态代理策略呢

(1)dubbo负载均衡策略 1)random loadbalance 默认情况下,dubbo是random load balance随机调用实现负载均衡,可以对provider不同实例设置不同的权重,会按照权重来负载均衡,权重越大分配流量越高,一般就用这个默认的就可以了. 2)roundrobin loadbalance 还有roundrobin loadbalance,这个的话默认就是均匀地将流量打到各个机器上去,但是如果各个机器的性能不一样,容易导致性能差的机器负载过高.所以此时需要调整权

14. Dubbo原理解析-集群&amp;容错之Cluster

Dubbo作为一个分布式的服务治理框架,提供了集群部署,路由,软负载均衡及容错机制 下图描述了dubbo调用过程中的对于集群,负载等的调用关系. Cluster 将Directory中的多个Invoker伪装成一个Invoker, 对上层透明,包含集群的容错机制 Cluster接口定义 @SPI(FailoverCluster.NAME) public interface Cluster { @Adaptive <T> Invoker<T>join(Directory<T&g

Dubbo之旅--集群容错和负载均衡

当我们的系统中用到Dubbo的集群环境,因为各种原因在集群调用失败时,Dubbo提供了多种容错方案,缺省为failover重试. Dubbo的集群容错在这里想说说他是因为我们实际的项目中出现了此类的问题,因为依赖的第三方项目出现异常,导致dubbo调用超时,此时使用的是默认的集群容错方式,而配置的reties='3',这样前段系统连续掉用了三次服务,结果可想而知. 先说一下各节点关系: 这里的Invoker是Provider的一个可调用Service的抽象,Invoker封装了Provider地

Dubbo点滴之集群容错

首先看来自官方文档 这里的Invoker是Provider的一个可调用Service的抽象,Invoker封装了Provider地址及Service接口信息. Directory代表多个Invoker,可以把它看成List<Invoker>,但与List不同的是,它的值可能是动态变化的,比如注册中心推送变更. Cluster将Directory中的多个Invoker伪装成一个Invoker,对上层透明,伪装过程包含了容错逻辑,调用失败后,重试另一个. Router负责从多个Invoker中按路