dubbo中的mock实现机制

最新推荐文章于 2024-07-10 09:44:55 发布
最新推荐文章于 2024-07-10 09:44:55 发布
阅读量6.3k 收藏 1
点赞数 1
分类专栏： java dubbo/rpc框架/负载均衡 秒扒Dubbo

Mock是SOA之中的一个很有用的功能，不仅可以用来进行服务降级，也可以用来在测试中模拟服务调用的各种异常情况。dubbo框架里面的mock是在服务使用者这一端实现的，下面对实现机制进行分析：

1. Mock的植入

很显然，既然提供了mock机制，那么mock应该作为一个环节插入到服务使用者的整个处理流程之中，而dubbo的设计基本采用了装饰器模式，一层一层的进行包装，这个具体的植入点就在RegistryProctocol通过Cluster来创建ClusterInvoker的时候：

RegistryProctocol的doRefer方法：

[java] view plain copy

  1. return cluster.createClusterInvoker(registryDirectory);  

 cluster的类型为Cluster$Adaptive，这实际上是一个通用的代理类，它会根据regsitryDirectory的getConsumerUrl方法返回的Url中的cluster参数的值来定位到实际的Cluster的实现类上，如果Url之中没有指定cluster，那么会采用Cluster的SPI注解上配置的默认值FailoverCluster.NAME，也就是默认情况下会调用ExtensionLoader<Clsuter>内部的key为failover的实例：

   

[java] view plain copy

  1. @SPI(FailoverCluster.NAME)  
  2. public interface Cluster  
  3. {  


在dubbo的配置文件  classpath:/META-INF/dubbo/internal/com.alibaba.dubbo.rpc.cluster.Cluster中，failover对应的是FailoverCluster类： 

[java] view plain copy

  1. mock=com.alibaba.dubbo.rpc.cluster.support.wrapper.MockClusterWrapper  
  2. failover=com.alibaba.dubbo.rpc.cluster.support.FailoverCluster  
  3. failfast=com.alibaba.dubbo.rpc.cluster.support.FailfastCluster  
  4. failsafe=com.alibaba.dubbo.rpc.cluster.support.FailsafeCluster  
  5. failback=com.alibaba.dubbo.rpc.cluster.support.FailbackCluster  
  6. forking=com.alibaba.dubbo.rpc.cluster.support.ForkingCluster  
  7. available=com.alibaba.dubbo.rpc.cluster.support.AvailableCluster  
  8. switch=com.alibaba.dubbo.rpc.cluster.support.SwitchCluster  
  9. mergeable=com.alibaba.dubbo.rpc.cluster.support.MergeableCluster  
  10. broadcast=com.alibaba.dubbo.rpc.cluster.support.BroadcastCluster  


但是ExtensionLoader在实例化对象时，有个比较特殊的地方，那就是在实例化完成之后，会自动套上当前的ExtensionLoader中的Wrapper类，上面的mock所对应的MockClusterWrapper就是这样的一个Wrapper：

 

[java] view plain copy

  1. private T wrapInstance(T instance) throws IllegalArgumentException, SecurityException, ...  
  2. {  
  3.     Set<Class<?>> wrapperClassesToUse = wrapperClasses;  
  4.     T wrapper=instance;  
  5.     if (CollectionUtils.isNotEmpty(wrapperClassesToUse))  
  6.     {  
  7.         for (Class<?> wrapperClassToUse : wrapperClassesToUse)   
  8.         {  
  9.         wrapper=(T) wrapperClassToUse.getConstructor(type).newInstance(wrapper);  
  10.         wrapper = injectDependentExtension(wrapper);  
  11.         }  
  12.     }  
  13.     return wrapper;  
  14. }  


 

也就是实例化出来的FailoverCluster会被套上一层MockClusterWrapper，总结一下就是：

Cluster$Adaptive -> 定位到内部key为failover的对象 ->FailoverCluster->外部套上MockClusterWrapper ，

这样RegistryProctocol的doRefer方法中的：

[java] view plain copy

  1. return cluster.createClusterInvoker(registryDirectory);  


实际上调用的是MockClusterWrapper 的 createClusterInvoker方法，MockClusterWrapper 的 createClusterInvoker方法如下：

[java] view plain copy

  1. public class MockClusterWrapper implements Cluster   
  2. {  
  3.     private Cluster cluster;  
  4.     public MockClusterWrapper(Cluster cluster)  
  5.     {  
  6.          this.cluster = cluster;  
  7.     }  
  8.      @Override  
  9.      public <T> Invoker<T> createClusterInvoker(Directory<T> directory) throws RpcException  
  10.      {  
  11.       return new MockClusterInvoker<T>(directory,  
  12.         this.cluster.createClusterInvoker(directory));  
  13.      }  
  14. }  


 

也就是实际创建的ClusterInvoker是封装了FailoverClusterInvoker的MockClusterInvoker，这样就成功地在Invoker之中植入了Mock机制。

  那么，最终就是服务使用者的接口代理-> MockClusterInvoker -> FailoverClusterInvoker。

 

2. Mock的执行

   mock的执行主要由MockClusterInvoker完成，MockClusterInvoker的invoke方法的执行逻辑如下：

   (1)如果在没有配置之中没有设置mock，那么直接把方法调用转发给实际的Invoker(也就是FailoverClusterInvoker)

 

[java] view plain copy

  1. @Override  
  2. public Result invoke(Invocation invocation) throws RpcException  
  3. {  
  4. ult result = null;  
  5.       
  6.     String mockValue = directory.getUrl().getMethodParameter(  
  7.         invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();   
  8.     if (mockValue.length() == 0 || mockValue.equalsIgnoreCase("false"))  
  9.     {  
  10.         //no mock  
  11.         result = this.invoker.invoke(invocation);  
  12.     }  


 (2)如果配置了强制执行Mock，比如发生服务降级，那么直接按照配置执行mock之后返回：

[java] view plain copy

  1. else if (mockValue.startsWith("force"))  
  2. {  
  3.       if (logger.isWarnEnabled())  
  4.       {  
  5.          logger.info("force-mock: " + invocation.getMethodName() + " force-mock enabled , url: " +  directory.getUrl());  
  6.        }  
  7.       //force:direct mock  
  8.        result = doMockInvoke(invocation, null);  
  9. }  


(3) 如果是其它的情况，比如只是配置的是mock=fail:return null，那么就是在正常的调用出现异常的时候按照配置执行mock：

[java] view plain copy

  1. //fail-mock  
  2.  try   
  3.  {  
  4.     result = this.invoker.invoke(invocation);  
  5.  }  
  6.  catch (RpcException rpcException)   
  7.  {  
  8.      if (rpcException.isBiz())  
  9.      {  
  10.     throw rpcException;  
  11.      }   
  12.      else  
  13.      {  
  14.     if (logger.isWarnEnabled())  
  15.     {  
  16.     logger.info("fail-mock: " + invocation.getMethodName() + " fail-mock enabled , url : "   
  17.      +  directory.getUrl(), rpcException);  
  18.         }  
  19.     result = doMockInvoke(invocation, rpcException);  
  20.      }  
  21.  }  


(2)和(3)最终都会通过调用doMockInvoke来完成mock调用，doMockInvoke方法会首先尝试调用selectMockInvoker方法来看看用户有没有配置过MockInvoker：

[java] view plain copy

  1. private Result doMockInvoke(Invocation invocation,RpcException actualRpcException)  
  2. {  
  3.         List<Invoker<T>> mockInvokers = selectMockInvoker(invocation);  

 

 selectMockInvoker的代码如下，依靠在Invocation的attachment里面做个标记来告诉directory的list方法应该返回MockInvoker，代码的注释里面说这么做是临时之举，未来会修改：

 

[java] view plain copy

  1. private List<Invoker<T>> selectMockInvoker(Invocation invocation)  
  2. {  
  3.     //TODO generic invoker？  
  4.    if (invocation instanceof RpcInvocation)  
  5.    {  
  6.          //存在隐含契约(虽然在接口声明中增加描述，但扩展性会存在问题.同时放在attachement中的做法需要改进  
  7.       ((RpcInvocation)invocation).setAttachment(Constants.INVOCATION_NEED_MOCK, Boolean.TRUE.         toString());  
  8.       //directory根据invocation中attachment是否有Constants.INVOCATION_NEED_MOCK，来判断获取的是nor       //mal invokers or mock invokers  
  9.        List<Invoker<T>> invokers = directory.list(invocation);  
  10.        return invokers;  
  11.    }  
  12.    else   
  13.    {  
  14.        return null ;  
  15.    }  
  16. }  

一般情况下，directory是RegistryDirectory，RegistryDirectory的list方法里面与mock有关的部分主要是router，RegistryDirectory在初始化内部的routers的时候，会人为的加上一个MockInvokerRouter，

AbstractDirectory的setRouters方法：

 

[java] view plain copy

  1. protected void setRouters(List<Router> routers)  
  2. {  
  3.      // copy list  
  4.      routers = routers == null ? new  ArrayList<Router>() : new ArrayList<Router>(routers);  
  5.      // append url router  
  6.      String routerValue = url.getParameter(Constants.ROUTER_KEY);  
  7.      if (routerValue != null && routerValue.length() > 0)  
  8.       {  
  9.           RouterFactory routerFactory =   
  10.             ExtensionLoader.getExtensionLoader(RouterFactory.class).getExtension(routerValue);  
  11.           routers.add(routerFactory.getRouter(url));  
  12.       }  
  13.      // append mock invoker selector  
  14.       routers.add(new MockInvokersRouter());  
  15.       Collections.sort(routers);  
  16.       this.routers = routers;  
  17.  }  

 

RegistryDirectory的list方法最后由router来对invokers进行处理：

AbstractDirectory的list方法：

[java] view plain copy

  1. public List<Invoker<T>> list(Invocation invocation) throws RpcException  
  2. {  
  3.      if (destroyed)  
  4.      {  
  5.           throw new RpcException("Directory already destroyed .url: "+ getUrl());  
  6.      }  
  7.      List<Invoker<T>> invokers = doList(invocation);  
  8.      List<Router> routersToUse = this.routers; // local reference  
  9.      if (routersToUse != null && routersToUse.size() > 0)   
  10.      {  
  11.          for (Router router: routersToUse)  
  12.          {  
  13.             try  
  14.             {  
  15.                  if (router.getUrl() == null || router.getUrl().getParameter(  
  16.                      Constants.RUNTIME_KEY, true))  
  17.                  {  
  18.                        invokers = router.route(invokers, getConsumerUrl(), invocation);  
  19.                    }  
  20.              }   
  21.              catch (Throwable t)  
  22.              {  
  23.                   logger.error("Failed to execute router: " + getUrl() + ", cause: " +  
  24.                      t.getMessage(), t);  
  25.               }  
  26.           }  
  27.       }  
  28.       return invokers;  
  29.     }  

MockInvokersRouter的route方法如下，根据Invocation的的attachment里面是否有mock标记(这个标记在前述的MockClusterInvoker的selectMockInvoker方法里面设置)来决定是返回正常的Invoker还是MockInvoker：

 

[java] view plain copy

  1. public <T> List<Invoker<T>> route(final List<Invoker<T>> invokers,URL url, final Invocation invocation) throws RpcException  
  2. {  
  3.     if (invocation.getAttachments() == null)  
  4.     {  
  5.     return getNormalInvokers(invokers);  
  6.     }   
  7.     else  
  8.     {  
  9.     String value = invocation.getAttachments().get(Constants.INVOCATION_NEED_MOCK);  
  10.     if (value == null)   
  11.     {  
  12.         return getNormalInvokers(invokers);  
  13.     }  
  14.     else if (Boolean.TRUE.toString().equalsIgnoreCase(value))  
  15.     {  
  16.         return getMockInvokers(invokers);  
  17.     }   
  18.     }  
  19.     return invokers;  
  20. }  

负责返回MockInvoker的是下面的getMockInvokers方法，在一般的情况下，是不会配置mock协议的，所以这个方法返回null：

 

[java] view plain copy

  1. private <T> List<Invoker<T>> getMockInvokers(final List<Invoker<T>> invokers)  
  2. {  
  3.      if (! hasMockProviders(invokers))  
  4.      {  
  5.     return null;  
  6.      }  
  7.      List<Invoker<T>> resultInvokers = new ArrayList<Invoker<T>>(1);  
  8.      for (Invoker<T> invoker : invokers)  
  9.      {  
  10.     if (invoker.getUrl().getProtocol().equals(Constants.MOCK_PROTOCOL))  
  11.     {  
  12.         resultInvokers.add(invoker);  
  13.     }  
  14.      }  
  15.      return resultInvokers;  
  16. }  


这样一直返回到MockClusterInvoker的doMockInvoke方法之中，selectMockInvoker返回空，那么MockClusterInvoker的doMockInvoke方法会根据url来

构造一个MockInvoker：

[java] view plain copy

  1. private Result doMockInvoke(Invocation invocation,RpcException actualRpcException)  
  2. {  
  3.     List<Invoker<T>> mockInvokers = selectMockInvoker(invocation);  
  4.     Invoker<T> mockInvokerToUse ;  
  5.     if (mockInvokers == null || mockInvokers.size() == 0)  
  6.     {  
  7.     mockInvokerToUse = (Invoker<T>) new MockInvoker(directory.getUrl());  
  8.     }   
  9.     else   
  10.     {  
  11.     mockInvokerToUse = mockInvokers.get(0);  
  12.     }  
  13.           
  14.     Result result = null;  
  15.     try   
  16.     {  
  17.     result = mockInvokerToUse.invoke(invocation);  
  18.     }   
  19.     catch (RpcException mockRpcException)  
  20.     {  

最后在构造出来的MockInvoker上调用invoke方法来执行mock调用，invoke方法的流程比较简单，对mockValue进行处理之后就看是返回mock值还是抛出异常，或者是加载并调用Mock类：

 

[java] view plain copy

  1. public Result invoke(Invocation invocation) throws RpcException   
  2. {  
  3.         String mockValue =   
  4.             getUrl().getParameter(invocation.getMethodName()+"."+Constants.MOCK_KEY);  
  5.         if (invocation instanceof RpcInvocation)   
  6.         {  
  7.             ((RpcInvocation) invocation).setInvoker(this);  
  8.         }  
  9.         if (StringUtils.isBlank(mockValue))  
  10.         {  
  11.             mockValue = getUrl().getParameter(Constants.MOCK_KEY);  
  12.         }  
  13.           
  14.         if (StringUtils.isBlank(mockValue))  
  15.         {  
  16.             throw new RpcException(  
  17.                new IllegalAccessException("mock can not be null. url :" + url));  
  18.         }  
  19.         mockValue = normalizeMock(URL.decode(mockValue));  
  20.         if (Constants.RETURN_PREFIX.trim().equalsIgnoreCase(mockValue.trim()))  
  21.         {  
  22.             RpcResult result = new RpcResult();  
  23.             result.setValue(null);  
  24.             return result;  
  25.         }  
  26.           
  27.         if (mockValue.startsWith(Constants.RETURN_PREFIX))   
  28.         {  
  29.            ....  
  30.         }   
  31.           
  32.         if (mockValue.startsWith(Constants.THROW_PREFIX))   
  33.         {  
  34.            ....  
  35.         }  
  36.          //impl mock  
  37.         try  
  38.         {  
  39.            Invoker<T> invoker = getInvoker(mockValue);  
  40.            return invoker.invoke(invocation);  
  41.         }  
  42.         catch (Throwable t)   
  43.         {  
  44.           throw new RpcException("Failed to create mock implemention class " + mockValue , t);  
  45.         }  
  46.   
  47.     }  



最后欢迎大家访问我的个人网站：1024s

 



 

崔世勋
关注
专栏目录
SpringCloud Alibaba系列——9Dubbo的Mock原理
Eclipse_2019的博客
08-01 950
Dubbo的Mock机制
dubbo服务接口如何mock_基于 Dubbo 分布式服务框架的一种 MOCK 方式
weixin_39927861的博客
12-22 390
首先简单说一下Dubbo是什么呢？不懂的同学百度一下去吧！Dubbo目前的应用已经越来越广泛、或者基于Dubbo二次开发的也越来越多，那么应用到Dubbo的系统基本也是采用微服务架构设计的系统、或者多个系统、多个应用之间的接口是有依赖关系的，所以就会出现需要MOCK的应用场景。具体什么是MOCK，不懂的同学也百度一下吧！在Dubbo里面有两个概念:1:Provider暴露服务的服务提供方(接口提供...
dubbo中的Mock实现机制
热门推荐
chengl04的专栏
09-17 1万+
Mock是SOA之中的一个很有用的功能，不仅可以用来进行服务降级，也可以用来在测试中模拟服务调用的各种异常情况。dubbo框架里面的mock是在服务使用者这一端实现的，下面对实现机制进行分析： Mock的植入 很显然，既然提供了mock机制，那么mock应该作为一个环节插入到服务使用者的整个处理流程之中，而dubbo的设计基本采用了装饰器模式，一层一层的进行包装，这个具体的植入点就在R
Java中的Mock框架使用: 颠覆你对单元测试的认知
最新发布
weixin_46372265的博客
07-10 897
在软件开发的道路上，我们难免会遇到各种坑，其中最让人头疼的莫过于测试了。你是不是也有过这种感受：测试代码比写业务代码还累？特别是当我们需要测试一些依赖外部服务的功能时，简直让人抓狂。这时候，Mock框架就成了我们的救命稻草。今天，我就带大家一起来探讨Java中的Mock框架使用，颠覆你对单元测试的认知。Mock框架在单元测试中扮演着重要角色，通过它我们可以轻松模拟外部依赖，编写高效、可靠的测试代码。希望通过这篇文章，大家能对Java中的Mock框架有一个深入的了解，并在实际项目中灵活运用。
Dubbo——Mock
吴声子夜歌的博客
07-02 3596
Mock 在Cluster中，还有最后一个MockClusterWrapper，由它实现了Dubbo的本地伪装。这个功能的使用场景较多，通常会应用在以下场景中：服务降级；部分非关键服务全部不可用，希望主流程继续进行；在下游某些节点调用异常时，可以以Mock的结果返回。 Mock常见的使用方法 Mock只有在拦截到RpcException的时候会启用，数异常容错方式的一种。业务层面其实也可以用try-catch来实现这种功能，如果使用下沉到框架中的Mock机制，则可以让业务的实现更优雅 常见配置如下： //配
基于Dubbo,本地Mock方案
青蛙的博客
04-06 1045
基于Dubbo,本地Mock方案 起因 ​ 分布式系统中，由于系统之间相互依赖。导致开发人员对一个功能需要进行本地测试的时候，极有可能由于依赖的系统过多导致需要本地启动很多服务，这样严重影响我们的自测效率 ​ 虽然dubbo提供了mock,但是在spring环境下该mock是配置在xml里面的，有可能导致不小心提交了xml mock到生产环境，从而导致生产环境调用使用了mock数据，从而引发不可预...
dubbo服务接口如何mock_基于动态代理 Mock dubbo 服务的实现方案
weixin_39832829的博客
12-22 522
序言背景概述公司目前 Java 项目提供服务都是基于 Dubbo 框架的，而且 Dubbo 框架已经成为大部分国内互联网公司选择的一个基础组件。在日常项目协作过程中，其实会碰到服务不稳定、不满足需求场景等情况，很多开发都会通过在本地使用 Mocktio 等单测工具作为自测辅助。那么，在联调、测试等协作过程中怎么处理？其实，Dubbo 开发者估计也是遇到了这样的问题，所以提供了一个提供泛化服务注册的...
Dubbo Stub与Mock
liyong1028826685的专栏
05-17 296
前言 大家好，今天开始给大家分享 — Dubbo 专题之 Dubbo Stub和Mock。在前一个章节中我们介绍了 Dubbo 事件通知，以及我们也例举了常见的使用场景并且进行了源码解析来分析其实现原理，同时知道 Dubbo 中的事件通知可以在某个服务调用之前、调用之后、异常发生时触发回调事件，我们可以通过回调事件做一些额外的工作。我们在 Dubbo 服务开发过程中可能遇到我们调用的服务方并没有编写完成，那我们是不是需要等待服务提供方开发完成我们才能开始测试呢？那么在本章节我们会通过介绍 Dubbo Stu
Dubbo中服务容错机制解析与实战案例
在本章节中，我们将对Dubbo中的服务容错机制进行概述，包括其定义、作用和常见的策略。 ### 1.1 什么是Dubbo服务容错机制 Dubbo服务容错机制是指在分布式架构中，当服务提供者出现故障或不可用时，消费者能够通过...
Dubbo降级&容错机制
blackball1998的博客
07-24 613
Dubbo降级&容错机制 在分布式环境中，由于所有的服务不在同一台服务器中，就涉及到服务之间的调用，而远程调用涉及到网络，网络是不可靠的，这就导致了有时候远程调用会失败，这时候就需要容错机制 而服务降级机制，是指在流量特别大的情况下，我们主动关闭一些不重要的服务，将资源向核心服务倾斜，被关闭的服务就会做服务降级 服务降级 服务降级就是我们将一些不重要的服务屏蔽掉，当有别的服务对被降级的服务发起远程调用时，不发起调用，而是执行本地的服务降级逻辑 首先我们构建一个提供者服务，用于获取用户的地址 @Ser
DUBBO 动态发布服务 mock rpc接口
qq_26784015的博客
07-13 918
dubbo 动态发布服务并且mock服务
dubbo-mock:dubbo模拟Web服务器
05-14
DUBBO MOCK SERVER 使用说明 DUBBO MOCK SERVER 是一个基于web的dubbo服务的mock平台，可以通过可视化界面，采用groovy脚本语言动态配置mock规则，并且提供了对groovy脚本配置是否正确的自我检查测试的功能。 选择数据库数据库按照路径(如果有需要) 更新mock_web模块resources中db-connection.properties mysql.url=jdbc:sqlite:sql.db 发布文件 执行mvn命令 mvn package -DskipTests=true 发布mock_web.war 配置注册中心 协议 地址 超时时间(毫秒) zookeeper 127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183 500000 配置协议 协议 端口 dubbo 8835 配置DUBBO服务 配
dubbo-easy-mock:针对Dubbo接口的Mock解决方案
05-30
这个框架的作用 在自动测试中，针对dubbo接口进行mock的框架 原理 利用dubbo的扩展点自动包装，通过EasyMockClusterWrapper将原本的rpc请求改写为http请求转发到mock服务器返回我们对应mock结果 使用 1. 添加依赖 mvn clean package install (deploy) -Dmaven.test.skip=true 编译安装依赖到本地/远程仓库 <dependency> <groupId>com.cmt</groupId> <artifactId>dubbo-easy-mock</artifactId> <version>1.1.0</version> <exclusions> <exclusion> <groupId>org.apache.dubbo</grou
dubbo自动化测试
01-03
dubbo自动化测试
protobuf协议_gRPC 使用 protobuf 构建微服务
weixin_39915267的博客
11-27 178
gRPC 使用 protobuf 构建微服务 发表于 2018-05-02 | 阅读次数: 2997 | 字数统计: 1,805gRPC 使用 protobuf 通信构建微服务本文目录：微服务架构单一的代码库以前使用 Laravel 做 web 项目时，是根据 MVC 去划分目录结构的，即 Controller 层处理业务逻辑，Model 层处理数据库的 CURD，View 层处理数据渲染与页面交...
dubbo服务接口如何mock_针对Dubbo接口Mock的解决方案
weixin_39984578的博客
12-22 793
背景为了提升减轻测试回归压力，提高项目开发交付质量，我们开发和测试团队合作在部分项目内执行自动化测试。为了更好的理解，我们对mock的需要，先来看下wiki上对自动化测试的解释。在软件测试中， 自动化测试指的是使用独立于待测软件的其他软件来自动执行测试、比较实际结果与预期并生成测试报告这一过程。我们的自动化测试是按照我们预设的流程执行的，我们不希望受到第三方服务的影响(上下线，接口返回错误数据),...
Dubbo 实战 - Mock 调用
nimo10050的博客
11-15 4398
前言 Dubbo 的 mock 特性既可以用作服务降级处理， 即当服务提供者出错时（抛出 RpcException），进行 mock 调用；同时也可以用于本地测试，用服务消费者端配置的 mock 服务替代要调用的远程服务，亦或者是对某个服务消费者屏蔽服务提供者，不让其进行远程调用。 下面通过举例说明 mock 的作用和使用方式，文中测试代码所使用的 Dubbo 版本为 2.7.7。本文会通过 xml 的方式进行配置。 另外，早期 dubbo 版本的 mock 功能可能有bug，或者功能不够完善。 正文 要使
Dubbo-Mock：为微服务测试提供强大模拟工具
gitblog_00003的博客
04-07 331
Dubbo-Mock：为微服务测试提供强大模拟工具 dubbo-mockdubbo mock web server项目地址:https://gitcode.com/gh_mirrors/du/dubbo-mock Dubbo-Mock 是一个开源项目（），它旨在简化基于 Dubbo 架构的服务在开发和测试过程中的模拟工作。该项目利用了 Dubbo 的 SPI 扩展机制，使开发者能够快速创建模拟服...
java实现dubbo接口mock
06-13
手动mock需要开发者自己编写Mock类，实现dubbo接口，并在测试代码中使用Mock类替换掉真正的dubbo服务，这样在测试时就可以正常运行而不会依赖于真实的dubbo服务。这种方式比较灵活，但需要开发者自己编写Mock类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值