微服务架构—自动化测试全链路设计

Posted 深度训练

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了微服务架构—自动化测试全链路设计相关的知识，希望对你有一定的参考价值。

  • 背景

  • 被忽视的软件工程环节 - DEVTESTOPS

  • 微服务架构下测试复杂度和效率问题

  • 开发阶段 unitTest mock 外部依赖

  • 连调阶段 mock 外部依赖

  • 自动化测试阶段 mock 需求

  • autoTest Mock Gateway 浮出水面

  • 轻量级版本实现 

    • 整体逻辑架构

    • 将 mock parameter 纳入服务框架标准 request contract

    • 使用 AOP + RestEasy HttpClientRequest SPI 初步实现 Mock

  • 总结

背景

从 SOA 架构到现在大行其道的微服务架构，系统越拆越小，整体架构的复杂度也是直线上升，我们一直老生常谈的微服务架构下的技术难点及解决方案也日渐成熟（包括典型的数据一致性，系统调用带来的一致性问题，还是跨节点跨机房复制带来的一致性问题都有了很多解决方案），但是有一个环节我们明显忽略了。

在现在的微服务架构趋势下，微服务在运维层面和自动化部署方面基本上是比较完善了。从我个人经验来看，上层的开发、测试对微服务架构带来的巨大变化还在反应和学习中。

开发层面讨论微服务的更多是框架、治理、性能等，但是从完整的软件工程来看我们严重缺失分析、设计知识，这也是我们现在的工程师普遍缺乏的技术。

我们经常会发现一旦你想重构点东西是多么的艰难，就是因为在初期构造这栋建筑的时候严重缺失了通盘的分析、设计，最终导致这个建筑慢慢僵化最后人见人怕，因为他逐渐变成一个怪物。（比如，开发很少写 unitTest ，我们总是忽视单元测试背后产生的软件工程的价值。）

被忽视的软件工程环节 — DEVTESTOPS

我们有没有发现一个现象，在整个软件过程里，测试这个环节容易被忽视。任何一种软件工程模型都有 QA 环节，但是这个环节似乎很薄很弱，目前我们绝大多数工程师、架构师都严重低估了这个环节的力量和价值，还停留在无技术含量，手动功能测试低级效率印象里。

这主要是测试这个角色整个技术体系、工程化能力偏弱，一部分是客观大环境问题，还有一部分自身问题，没有让自己走出去，多去学习整个工程化的技术，多去了解开发的技术，生产上的物理架构，这会有助于测试放大自己的声音。

导致测试环节在国内整个设计创新薄弱的原因还有一个主要原因就是，开发工程师普遍没有完整的工程基础。在国外IT发达国家，日本、美国等，一个合格的开发工程师、测试工程师都是边界模糊的，自己开发产品自己测试，这需要切换思维模式，需要同时具备这两种能力，但是这才是整个软件工程的完整流程。

我们有没有想过一个问题，为什么现在大家都在谈论 DevOps，而不是 DevTestOps，为什么偏偏跳过测试这个环节，难道开发的系统需要具备良好的可运维性就不需要可测试性吗，开发需要具备运维能力，运维需要具备开发能力，为什么测试环节忽略了。

我们对 QA 环节的轻视，对测试角色的不重视其实带来的副作用是非常大的。

微服务架构下测试复杂度和效率问题

微服务的拆分粒度要比 SOA 细了很多，从容器化镜像自动部署来衡量，是拆小了之后很方便，但是拆小了之后会给整个开发、测试环节增加很大的复杂度和效率问题。

在 SOA 时期，契约驱动 这个原则在微服务里也一样适用，跨部门需求定义好契约你就可以先开发上线了。但是这个里面最大的问题就是当前系统的部分连调问题和自动化回归问题，如果是新系统上线还需要做性能压测，这外部的依赖如何解决。

也许我们会说，不是应该依赖方先ready，然后我们紧接着进行测试、发布吗。如果是业务、架构合理的情况下，这种场景最大的问题就是我们的项目容易被依赖方牵制，这会带来很多问题，比如，研发人员需要切换出来做其他事情，branch 一直挂着，不知道哪天突然来找你说可以对接了，也许这已经过去一个月或者更久，这种方式一旦养成习惯性研发流程就很容易产生线上 BUG 。

还有一种情况也是合理的情况就是平台提供方需要调用业务方的接口，这里面有一般调用的 callback 接口、交易链路上的 marketing 接口、配送 routing 接口等。

这里给大家分享我们目前正在进行中的 marketing-cloud (营销云) 规则引擎 项目。

marketing-cloud 提供了一些营销类业务，有 团购、优惠券、促销 等，但是我们的业务方需要有自己个性化的营销活动玩法，我们需要在 marketing-cloud 规则引擎 中抽象出业务方营销活动的返回信息，同时打通个性化营销活动与公共交易、结算环节，形成一个完整的业务流。


这是一个 marketing-cloud 逻辑架构图，跟我们主题相关的就是 营销规则引擎 ，他就是我们这里所说的合理的业务场景。

在整个正向下单过程中，营销规则引擎要肩负起既要提供 marketing-cloud 内的共用营销活动，还需要桥接外部营销中心的各类营销玩法，外部的营销中心会有多个，目前我们主要有两个。

由于这篇文章不是介绍营销平台怎么设计，所以这里不打算扩展话题。主要是起到抛砖引玉的目的，平台型的业务会存在各种各样的对外系统依赖的业务场景。文章接下来的部分将展开 marketing-cloud 规则引擎 在打通测试链路上的实践。

开发阶段 unitTest mock 外部依赖

在开发阶段，我们会经常性的编写单元测试来测试我们的逻辑，在编写 unitTest 的时候都需要 mock 周边的依赖，mock 出来的对象分为两种类型，一种是不具有 Assert 逻辑的 stub 桩 对象，还有一种就是需要支持 Assert 的 mocker 模拟对象。

但是我们也不需要明显区分他们，两者的区别不是太明显，在编码规范内可能需要区分。

我们关心的是如何解决对象之间的依赖问题，各种 mock 框架其实提供了很多非常好用的工具，我们可以很轻松的 mock 周边的依赖。

 
   
   
 
    
  
    
    
  
  1. given(marketingService.mixMarketingActivity(anyObject())).willReturn(stubResponse);
    2. 
  
    
    
  
  2. RuleCalculateResponse response = this.ruleCalculatorBiz.ruleCalculate(request);
    3.

这里我们 mock 了 marketingService.mixMarketingActivity() 方法。

Java 世界里提供了很多好用的 mock 框架，比较流行好用的框架之一 mockito 可以轻松 mock Service 层的依赖，当然除了 mockito 之外还有很多优秀的 mock 框架。

这些框架大同小异，编写 unitTest 最大的问题就是如何重构逻辑使之更加便于测试，也就是代码是否具备很好的可测试性，是否已经消除了绝大多数 private 方法，private 方法是否有某些指责是我们没有捕捉到业务概念。

连调阶段 mock 外部依赖

在我们完成了所有的开发，完善的单元测试保证了我们内部的逻辑是没有问题的（当然这里不讨论 unitTest 的 case 的设计是否完善情况）。

现在我们需要对接周边系统开发进行连调了，这个周边系统还是属于本平台之类的其他支撑系统。比如我们的 marketing-cloud 规则引擎系统 与 下单系统 之间的关系。在开发的时候我们编写 unitTest 是顺利的完成了开发解决的验证工作，但是现在面对连调问题。

系统需要正式的跑起来，但是我们缺乏对外部营销中心的依赖，我们怎么办。其实我们也需要在连调阶段 mock 外部依赖，只不过这个 mock 的技术和方法不是通过 unitTest 框架来支持，而是需要我们自己来设计我们的整个服务的开发架构。

首先要能识别本次 request 是需要 mock 的，那就需要某种 mock parameter 参数来提供识别能力。

我们来看下 marketing-cloud 营销规则引擎 在这块的一个初步尝试。

 
   
   
 
    
  
    
    
  
  1. public interface CCMarketingCentralFacade {
    2. 
  
    
    
  
  2.     CallResponse callMarketingCentral(CallRequest request);
    3. 
  
    
    
  
  3. }
    4. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public interface ClassMarketingCentralFacade {
    2. 
  
    
    
  
  2.     CallResponse callMarketingCentral(CallRequest request);
    3. 
  
    
    
  
  3. }
    4.

营销规则引擎使用 RestEasy client api 作为 rest 调用框架。这两个 Facade 是营销平台对 CCTalk 、沪江网校 沪江两大子公司营销中心发起调用的 Facade。

(为了尽量还原我们的工程实践干货同时需要消除一些敏感信息的情况下，整篇文章所有的代码实例，我都删除了一些不影响阅读且和本文无关的代码，同时做了一些伪编码和省略，使代码更精简更便于阅读。)

 
   
   
 
    
  
    
    
  
  1. public class CCMarketingCentralFacadeMocker implements CCMarketingCentralFacade {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     @Override
    4. 
  
    
    
  
  4.     public CallResponse callMarketingCentral(CallRequest request) {
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.         CallResponse response = ...
    7. 
  
    
    
  
  7.         MarketingResultDto marketingResultDto = ...
    8. 
  
    
    
  
  8.         marketingResultDto.setTotalDiscount(new BigDecimal("90.19"));
    9. 
  
    
    
  
  9.         marketingResultDto.setUseTotalDiscount(true);
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.         response.getData().setMarketingResult(marketingResultDto);
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.         return response;
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class ClassMarketingCentralFacadeMocker implements ClassMarketingCentralFacade {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     @Override
    4. 
  
    
    
  
  4.     public CallResponse callMarketingCentral(CallRequest request) {
    5. 
  
    
    
  
  5.         CallResponse response = ...
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.         MarketingResultDto marketingResultDto = ...
    8. 
  
    
    
  
  8.         marketingResultDto.setUseCoupon(true);
    9. 
  
    
    
  
  9.         marketingResultDto.setTotalDiscount(null);
    10. 
  
    
    
  
  10.         marketingResultDto.setUseTotalDiscount(false);
    11. 
  
    
    
  
    12. 
  
    
    
  
  12.         List<MarketingProductDiscountDto> discountDtos = ...
    13. 
  
    
    
  
    14. 
  
    
    
  
  14.         request.getMarketingProductTagsParameter().getMarketingTags().forEach(item -> {
    15. 
  
    
    
  
    16. 
  
    
    
  
  16.             MarketingProductDiscountDto discountDto = ...
    17. 
  
    
    
  
  17.             discountDto.setProductId(item.getProductID());
    18. 
  
    
    
  
  18.             ...
    19. 
  
    
    
  
  19.             discountDtos.add(discountDto);
    20. 
  
    
    
  
  20.         });
    21. 
  
    
    
  
  21. ...
    22. 
  
    
    
  
  22.         return response;
    23. 
  
    
    
  
  23.     }
    24. 
  
    
    
  
  24. }
    25.

我们定义了两个 mock 类，都是一些测试数据，就是为了解决在连调阶段的问题，也就是在 DEV 环境上的依赖问题。

有了 mock facade 之后就需要 request 定义 mock parameter 参数了。

 
   
   
 
    
  
    
    
  
  1. public abstract class BaseRequest implements Serializable {
    2. 
  
    
    
  
  2.     public MockParameter mockParameter;
    3. 
  
    
    
  
  3. }
    4. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class MockParameter {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     /**
    4. 
  
    
    
  
  4.      * mock cc 营销调用接口
    5. 
  
    
    
  
  5.      */
    6. 
  
    
    
  
  6.     public Boolean mockCCMarketingInterface;
    7. 
  
    
    
  
    8. 
  
    
    
  
  8.     /**
    9. 
  
    
    
  
  9.      * mock class 营销调用接口
    10. 
  
    
    
  
  10.      */
    11. 
  
    
    
  
  11.     public Boolean mockClassMarketingInterface;
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.     /**
    14. 
  
    
    
  
  14.      * 是否自动化测试 mock
    15. 
  
    
    
  
  15.      */
    16. 
  
    
    
  
  16.     public Boolean useAutoTestMock;
    17. 
  
    
    
  
    18. 
  
    
    
  
  18.     /**
    19. 
  
    
    
  
  19.      * 测试mock参数
    20. 
  
    
    
  
  20.      */
    21. 
  
    
    
  
  21.     public String testMockParam;
    22. 
  
    
    
  
    23. 
  
    
    
  
  23. }
    24.

我们暂且忽略通用型之类的设计，这里只是我们在赶项目的情况下做的一个迭代尝试，等我们把这整个流程都跑通了再来考虑重构提取框架。

有了输入参数，我们就可以根据参数判断来动态注入 mock facade。

自动化测试阶段 mock 需求

我们继续向前推进，过了连调阶段紧接着就进入测试环节，现在基本上大多数互联网公司都是自动化的测试，很少在有手动的，尤其是后端系统。

我们有很多微服务系统来组成一个平台，每个服务都有依赖的第三方接口，原来在自动化测试这些服务的时候都需要去了解业务方系统的接口、DB、前台入口等，因为在编写自动化脚本的时候需要同步创建测试数据，最后才能 Assert。

这个跨部门的沟通和协作效率严重低下，而且人员变动、系统变动都会直接影响上线周期，这里绝对值得创新来解决这个效率严重阻塞问题。

 
   
   
 
    
  
    
    
  
  1. @Value("${marketing.cloud.business.access.url.mock}")
    2. 
  
    
    
  
  2. private String mockUrl;
    3. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. /**
    2. 
  
    
    
  
  2.      * 自动化测试 mocker bean
    3. 
  
    
    
  
  3.      */
    4. 
  
    
    
  
  4.     @Bean("CCMarketingCentralFacadeTestMock")
    5. 
  
    
    
  
  5.     public CCMarketingCentralFacade CCMarketingCentralFacadeTestMock() {
    6. 
  
    
    
  
  6.         RestClientProxyFactoryBean<CCMarketingCentralFacade> restClientProxyFactoryBean ...
    7. 
  
    
    
  
  7.         restClientProxyFactoryBean.setBaseUri(this.mockUrl);
    8. 
  
    
    
  
  8.         ...
    9. 
  
    
    
  
  9.     }
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.     /**
    12. 
  
    
    
  
  12.      * 自动化测试 mocker bean
    13. 
  
    
    
  
  13.      */
    14. 
  
    
    
  
  14.     @Bean("ClassMarketingCentralFacadeTestMock")
    15. 
  
    
    
  
  15.     public ClassMarketingCentralFacade ClassMarketingCentralFacadeTestMock()  {
    16. 
  
    
    
  
  16.         RestClientProxyFactoryBean<ClassMarketingCentralFacade> restClientProxyFactoryBean ...
    17. 
  
    
    
  
  17.         restClientProxyFactoryBean.setBaseUri(this.mockUrl);
    18. 
  
    
    
  
  18.         ...
    19. 
  
    
    
  
  19.     }
    20.

autoTest Mock Gateway 浮出水面

比如，营销规则引擎，我们的自动化脚本在创建一个订单的时候需要预先构造好当前商品（比如，productID：101010），在获取外部营销中心提供的活动信息和抵扣信息的 response ，最后才能去 Assert 订单的金额和活动信息记录是否正确，这就是一次 autoTest context 。

微服务架构—自动化测试全链路设计

有两种方式来识别当前 autoTest context ，一种是在 case 执行的时候确定商品ID，最后通过商品ID来获取 mock 的 response 。还有一种就是支持传递 autoTest mock 参数给到 mockUrl 指定的服务，可以使用这个参数来识别当前测试上下文。

一个测试 case 可能会穿过很多微服务，这些所有的依赖服务可能都需要预设 mock response，这基本上是一劳永逸的。

所以，我们抽象出了 autoTest Mock Gateway（自动化测试mock网关服务） ，在整个自动化测试环节还有很多需要支持的工作，服务之间的鉴权，鉴权 key 的 mock，加解密，加解密 key 的 mock，自动化测试 case 交替并行执行等。

作为工程师的我们都希望用系统化、工程化的方式来解决整体问题，而不是个别点状问题。有了这个 mock gateway 我们可以做很多事情，也可以普惠所有需要的其他部门。

在一次 autoTest context 里构造好 mock response，然后通过 mock parameter 来动态识别具体的来源服务进行路由、鉴权、加解密等操作。

MockGateway 是一个支点，我相信这个支点可以撬动很多测试空间和创新能力。

轻量级版本实现

接下来我们将展示在 marketing-cloud 营销规则引擎 中的初步尝试。

整体逻辑架构

自动化脚本在每跑一个 case 的时候会创建当前 case 对应的 autoTestContext，这里面都是一些 meta data，用来表示这个 case 中所有涉及到的微服务系统哪些是需要走 mock gateway 的。

在 mockGateway 中所有的配置都是有一个 autoTestContext 所对应，如果没有 autoTestContext 说明是所有 case共用。

将 mock parameter 纳入服务框架标准 request contract

要想打通整个微服务架构中的所有通道，就需要在标准 request contract 定义 mockParameter ，这是这一切的前提。

服务与服务之间调用走标准微服务 request contract，服务与外部系统的依赖可以选择走 HTTP Header，也可以选择走标准 request ，就要看我们的整个服务框架是否已经覆盖所有的产线及一些遗留系统的问题。

 
   
   
 
    
  
    
    
  
  1. public abstract class BaseRequest implements Serializable {
    2. 
  
    
    
  
  2.     public MockParameter mockParameter;
    3. 
  
    
    
  
  3. }
    4.

BaseRequest 是所有 request 的基类，这样才能保证所有的请求能够正常的传递。

使用 AOP + RestEasy HttpClientRequest SPI 初步实现 Mock

整个系统的开发架构分层依赖是：facade->biz->service，基本的所有核心逻辑都是在 service 中，请求的 request dto 最多不能越界到 service 层，按照规范讲 request dto 顶多滞留在 biz 层，但是在互联网的世界中一些都是可以快速迭代的，并不是多么硬性规定，及时重构是偿还技术债务的主要方法。

前面我们已经讲过，我们采用的 RPC 框架是 RestEasy + RestEasy client ，我们先来看下入口的地方。

 
   
   
 
    
  
    
    
  
  1. @Component
    2. 
  
    
    
  
  2. @Path("v1/calculator/")
    3. 
  
    
    
  
  3. public class RuleCalculatorFacadeImpl extends BaseFacade implements RuleCalculatorFacade {
    4. 
  
    
    
  
  4.     @MockFacade(Setting = MockFacade.SETTING_REQUEST_MOCK_PARAMETER)
    5. 
  
    
    
  
  5.     public RuleCalculateResponse ruleCalculate(RuleCalculateRequest request)  {
    6. 
  
    
    
  
  6.     ...
    7. 
  
    
    
  
  7.     }
    8. 
  
    
    
  
  8. }
    9.

再看下 service 对象。

 
   
   
 
    
  
    
    
  
  1. @Component
    2. 
  
    
    
  
  2. public class MarketingServiceImpl extends MarketingBaseService implements MarketingService {
    3. 
  
    
    
  
  3.     @MockFacade(Setting = MockFacade.SETTING_FACADE_MOCK_BEAN)
    4. 
  
    
    
  
  4.     public MarketingResult onlyExtendMarketingActivity(Marketing..Parameter tagsParameter) {
    5. 
  
    
    
  
  5.     ...
    6. 
  
    
    
  
  6.     }
    7.

我们重点看下 @MockFacade annotation 声明。

 
   
   
 
    
  
    
    
  
  1. @Target({ElementType.METHOD})
    2. 
  
    
    
  
  2. @Retention(RetentionPolicy.RUNTIME)
    3. 
  
    
    
  
  3. public @interface MockFacade {
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     String SETTING_REQUEST_MOCK_PARAMETER = "setting_request_mock_parameter";
    6. 
  
    
    
  
  6.     String SETTING_FACADE_MOCK_BEAN = "setting_facade_mock_bean";
    7. 
  
    
    
  
    8. 
  
    
    
  
  8.     String Setting();
    9. 
  
    
    
  
  9. }
    10.

通过这个 annotation 我们的主要目的就是将 mockParameter 放到 ThreadLocal 中去和请求处理完时的清理工作。还有一个功能就是 service 层的 mock bean 处理。

 
   
   
 
    
  
    
    
  
  1. @Aspect
    2. 
  
    
    
  
  2. @Component
    3. 
  
    
    
  
  3. @Slf4j
    4. 
  
    
    
  
  4. public class MockMarketingFacadeInterceptor {
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Before("@annotation(mockFacade)")
    7. 
  
    
    
  
  7.     public void beforeMethod(JoinPoint joinPoint, MockFacade mockFacade) {
    8. 
  
    
    
  
    9. 
  
    
    
  
  9.         String settingName = mockFacade.Setting();
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.         if (MockFacade.SETTING_REQUEST_MOCK_PARAMETER.equals(settingName)) {
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.             Object[] args = joinPoint.getArgs();
    14. 
  
    
    
  
  14.             if (args == null) return;
    15. 
  
    
    
  
    16. 
  
    
    
  
  16.             List<Object> argList = Arrays.asList(args);
    17. 
  
    
    
  
  17.             argList.forEach(item -> {
    18. 
  
    
    
  
    19. 
  
    
    
  
  19.                 if (item instanceof BaseRequest) {
    20. 
  
    
    
  
  20.                     BaseRequest request = (BaseRequest) item;
    21. 
  
    
    
  
    22. 
  
    
    
  
  22.                     if (request.getMockParameter() != null) {
    23. 
  
    
    
  
  23.                         MarketingBaseService.mockParameterThreadLocal.set(request.getMockParameter());
    24. 
  
    
    
  
  24.                         log.info("----setting mock parameter:{}", JSON.toJSONString(request.getMockParameter()));
    25. 
  
    
    
  
  25.                     }
    26. 
  
    
    
  
  26.                 }
    27. 
  
    
    
  
  27.             });
    28. 
  
    
    
  
  28.         } else if (MockFacade.SETTING_FACADE_MOCK_BEAN.equals(settingName)) {
    29. 
  
    
    
  
    30. 
  
    
    
  
  30.             MarketingBaseService marketingBaseService = (MarketingBaseService) joinPoint.getThis();
    31. 
  
    
    
  
  31.             marketingBaseService.mockBean();
    32. 
  
    
    
  
  32.             log.info("----setting mock bean.");
    33. 
  
    
    
  
  33.         }
    34. 
  
    
    
  
  34.     }
    35. 
  
    
    
  
    36. 
  
    
    
  
  36.     @After("@annotation(mockFacade)")
    37. 
  
    
    
  
  37.     public void afterMethod(JoinPoint joinpoint, MockFacade mockFacade) {
    38. 
  
    
    
  
    39. 
  
    
    
  
  39.         if (MockFacade.SETTING_FACADE_MOCK_BEAN.equals(mockFacade.Setting())) {
    40. 
  
    
    
  
    41. 
  
    
    
  
  41.             MarketingBaseService marketingBaseService = (MarketingBaseService) joinpoint.getThis();
    42. 
  
    
    
  
  42.             marketingBaseService.mockRemove();
    43. 
  
    
    
  
    44. 
  
    
    
  
  44.             log.info("----remove mock bean.");
    45. 
  
    
    
  
  45.         }
    46. 
  
    
    
  
    47. 
  
    
    
  
  47.         if (MockFacade.SETTING_REQUEST_MOCK_PARAMETER.equals(mockFacade.Setting())) {
    48. 
  
    
    
  
    49. 
  
    
    
  
  49.             MarketingBaseService.mockParameterThreadLocal.remove();
    50. 
  
    
    
  
    51. 
  
    
    
  
  51.             log.info("----remove ThreadLocal. ThreadLocal get {}", MarketingBaseService.mockParameterThreadLocal.get());
    52. 
  
    
    
  
  52.         }
    53. 
  
    
    
  
  53.     }
    54. 
  
    
    
  
  54. }
    55.

这些逻辑完全基于一个约定，就是 MarketingBaseService，不具有通用型，只是在逐步的重构和提取中，最终会是一个 plugin 框架。

 
   
   
 
    
  
    
    
  
  1. public abstract class MarketingBaseService extends BaseService {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     protected ClassMarketingCentralFacade classMarketingCentralFacade;
    4. 
  
    
    
  
    5. 
  
    
    
  
  5.     protected CCMarketingCentralFacade ccMarketingCentralFacade;
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.     public static ThreadLocal<MockParameter> mockParameterThreadLocal = new ThreadLocal<>();
    8. 
  
    
    
  
    9. 
  
    
    
  
  9.     public void mockBean() {
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.         MockParameter mockParameter = mockParameterThreadLocal.get();
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.         if (mockParameter != null && mockParameter.mockClassMarketingInterface) {
    14. 
  
    
    
  
  14.             if (mockParameter.useAutoTestingMock) {
    15. 
  
    
    
  
  15.                 this.setClassMarketingCentralFacade(SpringContextHolder.getBean("ClassMarketingCentralFacadeTestMock", ClassMarketingCentralFacade.class));
    16. 
  
    
    
  
  16.             } else {
    17. 
  
    
    
  
  17.                 this.setClassMarketingCentralFacade(SpringContextHolder.getBean("ClassMarketingCentralFacadeMocker", ClassMarketingCentralFacadeMocker.class));
    18. 
  
    
    
  
  18.             }
    19. 
  
    
    
  
  19.         } else {
    20. 
  
    
    
  
  20.             this.setClassMarketingCentralFacade(SpringContextHolder.getBean("ClassMarketingCentralFacade", ClassMarketingCentralFacade.class));
    21. 
  
    
    
  
  21.         }
    22. 
  
    
    
  
    23. 
  
    
    
  
  23.         if (mockParameter != null && mockParameter.mockCCMarketingInterface) {
    24. 
  
    
    
  
  24.             if (mockParameter.useAutoTestingMock) {
    25. 
  
    
    
  
  25.                 this.setCcMarketingCentralFacade(SpringContextHolder.getBean("CCMarketingCentralFacadeTestMock", CCMarketingCentralFacade.class));
    26. 
  
    
    
  
  26.             } else {
    27. 
  
    
    
  
  27.                 this.setCcMarketingCentralFacade(SpringContextHolder.getBean("CCMarketingCentralFacadeMocker", CCMarketingCentralFacadeMocker.class));
    28. 
  
    
    
  
  28.             }
    29. 
  
    
    
  
  29.         } else {
    30. 
  
    
    
  
  30.             this.setCcMarketingCentralFacade(SpringContextHolder.getBean("CCMarketingCentralFacade", CCMarketingCentralFacade.class));
    31. 
  
    
    
  
  31.         }
    32. 
  
    
    
  
  32.     }
    33. 
  
    
    
  
    34. 
  
    
    
  
  34.     public void mockRemove() {
    35. 
  
    
    
  
  35.         mockParameterThreadLocal.remove();
    36. 
  
    
    
  
  36.     }
    37. 
  
    
    
  
  37. }
    38.

我们可以顺利的将 request 中的 mockParameter 放到 ThreadLocal 中，可以动态的通过 AOP 的方式来注入相应的 mockerBean。

现在我们还要处理的就是对 mockGateway 的调用将 mockParameter_ 中的 __autoContext 中的标示字符串放到 HTTP Header 中去。

 
   
   
 
    
  
    
    
  
  1. @Component
    2. 
  
    
    
  
  2. public class MockHttpHeadSetting implements ClientRequestFilter {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     @Override
    5. 
  
    
    
  
  5.     public void filter(ClientRequestContext requestContext) throws IOException {
    6. 
  
    
    
  
    7. 
  
    
    
  
  7.         MultivaluedMap<String, Object> header = requestContext.getHeaders();
    8. 
  
    
    
  
    9. 
  
    
    
  
  9.         MockParameter mockParameter = MarketingBaseService.mockParameterThreadLocal.get();
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.         if (mockParameter != null && StringUtils.isNotBlank(mockParameter.getTestingMockParam())) {
    12. 
  
    
    
  
  12.             header.add("Mock-parameter", mockParameter.getTestingMockParam());
    13. 
  
    
    
  
  13.         }
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16.

接着在 SPI（javax.ws.rs.ext.Providers ） 文件中配置即可

 
   
   
 
    
  
    
    
  
  1. com.hujiang.marketingcloud.ruleengine.service.MockHttpHeadSetting
    2.

总结

在整个微服务架构的实践中，工程界一直缺少探讨的就是在微服务架构的测试这块，离我们比较近的是自动化测试，因为自动化测试基本上是所有系统都需要的。

但是有一块我们一直没有重视的就是 全链路压力测试 这块，在生产上进行全链路的真实的压力测试需要解决很多问题，比较重要的就是 DB 这块，压测的时候产生的所有交易数据不能够参与结算、财务流程，这就需要借助 影子表 来解决，所有的数据都不会写入最终的真实的交易数据中去。当然还有其他地方都需要解决，一旦打开全链路压测开关，应该需要处理所有产生数据的地方，这是一个庞大的工程，但是也会非常有意思。

本篇文章只是我们在这块的一个初步尝试，我们会继续扩展下去，在下次产线全链路压测的时候我们就可以借助现在的实践架构扩展起来。


以上是关于微服务架构—自动化测试全链路设计的主要内容，如果未能解决你的问题，请参考以下文章

微服务架构下的自动化测试全链路设计思路分析

开源全链路压测平台Takin实践笔记

云原生专场分享：微服务架构下的全链路追踪

基于Pinpoint对SpringCloud微服务项目实现全链路监控 #yyds干货盘点#

银行全链路日志监控难点详解

全链路灰度新功能：MSE上线配置标签推送