09、商城业务.pdf
es主要负责的场景有两个：

  1. 负责商品的全文检索

  2. 日志的检索（ELK ES + LogStash + Kibana）

    一、es存储分析

    es是将数据存储在内存中的，所以在存储时需要分析应该存储哪些内容，同时兼顾到时间与空间的消耗。

    1.1 需要存储什么信息到es中

  3. 需要保存sku信息

  • 当搜索商品名的时候，检索到的是sku的sku_title
  • 还会通过sku的销量、标题、价格区间来进行检索
  1. 需要保存品牌分类等信息
  • 点击分类，检索分类下的所有信息
  • 点击品牌，检索品牌下的商品信息
  1. 需要保存spu的规格信息——选择规格的时候会检索共有这些规格的spu信息

    1.2 如何设计存储结构 商品Mapping

    1）、检索的时候输入名字，是需要按照 sku 的 title 进行全文检索的
    2）、检索使用商品规格，规格是 spu 的公共属性，每个 spu 是一样的
    3）、按照分类 id 进去的都是直接列出 spu 的，还可以切换。
    4）、我们如果将 sku 的全量信息保存到 es 中（包括 spu 属性）就太多量字段了。
    5）、我们如果将 spu 以及他包含的 sku 信息保存到 es 中，也可以方便检索。但是 sku 属于
    spu 的级联对象，在 es 中需要 nested 模型，这种性能差点。
    6）、但是存储与检索我们必须性能折中。
    1. {
    2.  skuId:1
    3.  spuId:11
    4.  skuTitle:"华为xx"
    5.  price:998
    6.  saleCount:99
    7.  attrs:[
    8.        {尺寸:"5寸"},
    9.        {CPU:高通945},
    10.        {分辨率:全高清}
    11.  ]
    12. }
    13. // 优点：方便检索
    14. // 缺点：会产生冗余字段，对于属于同一spu的商品，attrs字段数据会冗余
    7）、如果我们分拆存储，spu 和 attr 一个索引，sku 单独一个索引可能涉及的问题。 ```json 建一个sku索引，只保存非冗余字段 { skuId:1 spuId:11 xxxx } 再建一个attr索引 { spuId:11 attrs:[
    1.    {尺寸:"5寸"},
    2.    {CPU:高通945},
    3.    {分辨率:全高清}
    ] } // 优点：空间利用率高 // 缺点：查询attr时，会检索当前所有的spu，耗时很长 假设搜索小米， 粮食、手机、电器等有很多sku都包含有小米 10000个包含小米的sku，涉及到4000个spu，我们会找到4000个spu的attr进行聚合，通过分步查询：
  2. 查出包含小米的10000个sku，其涉及到4000个spu
  3. 查出4000个spu对应的所有可能属性 esClient：spuId：[4000个spuId] 40008=32000byte=32kb 32kb10000=320mb; 如果是百万并发会发送32GB的数据
    1. 检索商品的名字，如“手机”，对应的 spu 有很多，我们要分析出这些 spu 的所有关联属性，再做一次查询，就必须将所有 spu_id 都发出去。假设有 1 万个数据，数据传输一次就10000*4=4MB；并发情况下假设 1000 检索请求，那就是 4GB 的数据，传输阻塞时间会很长，业务更加无法继续。<br />所以，我们如下设计，这样才是文档区别于关系型数据库的地方，宽表设计，不能去考虑数据库范式。
    2. ```json
    3. PUT product
    4. {
    5. "mappings": {
    6.  "properties": {
    7.    "skuId": { "type": "long" },
    8.    "spuId": { "type": "keyword" },
    9.    "skuTitle": {
    10.      "type": "text",
    11.      "analyzer": "ik_smart"
    12.    },
    13.    "skuPrice": { "type": "keyword" },
    14.    "skuImg": {
    15.      "type": "keyword",
    16.      "index": false,
    17.      "doc_values": false    # 表示该属性不需要聚合等操作
    18.    },
    19.    "saleCount":{ "type":"long" },
    20.    "hasStock": { "type": "boolean" },
    21.    "hotScore": { "type": "long"  },
    22.    "brandId":  { "type": "long" },
    23.    "catalogId": { "type": "long"  },
    24.    "brandName": {  
    25.      "type": "keyword",
    26.      "index": false,
    27.      "doc_values": false
    28.    },
    29.    "brandImg":{    # 品牌图片，只用来查看，不用来检索和聚合
    30.      "type": "keyword",
    31.      "index": false,
    32.      "doc_values": false
    33.    },
    34.    "catalogName": {
    35.      "type": "keyword",
    36.      "index": false,
    37.      "doc_values": false
    38.    },
    39.    "attrs": {  # 这里是spu的规格属性
    40.      "type": "nested",  # 嵌入式，内部属性
    41.      "properties": {
    42.        "attrId": {"type": "long"  },
    43.        "attrName": {
    44.          "type": "keyword",
    45.          "index": false,
    46.          "doc_values": false
    47.        },
    48.        "attrValue": { "type": "keyword" }
    49.      }
    50.    }
    51.  }
    52. }
    53. }

    1.3 关于nested类型

    nested官方文档

image.png

  1. # 这里我们想寸的文档user属性里面包含了两个人：John Smith和Alice White
  2. PUT my_index/_doc/1
  3. {
  4.   "group" : "fans",
  5.   "user" : [ 
  6.     {
  7.       "first" : "John",
  8.       "last" :  "Smith"
  9.     },
  10.     {
  11.       "first" : "Alice",
  12.       "last" :  "White"
  13.     }
  14.   ]
  15. }
  17. # 因为没有设置type为nested，es扁平化处理后，把first跟last分别放在一起了
  18. # 这样就产生了笛卡尔积，共有四种组合
  19. {
  20.   "group" :        "fans",
  21.   "user.first" : [ "alice", "john" ],
  22.   "user.last" :  [ "smith", "white" ]
  23. }
  25. # 如果现在查询first为Alice，last为Smith的就会有对应document，实际上是没有的
  26. GET my_index/_search
  27. {
  28.   "query": {
  29.     "bool": {
  30.       "must": [
  31.         { "match": { "user.first": "Alice" }},
  32.         { "match": { "user.last":  "Smith" }}
  33.       ]
  34.     }
  35.   }
  36. }

二、商品上架功能

2.1 创建es存储的实体类

  1. package com.atguigu.common.to.es;
  3. import lombok.Data;
  5. import java.math.BigDecimal;
  6. import java.util.List;
  8. /**
  9.  * es进行文档存储的实体类
  10.  * @author mrlinxi
  11.  * @create 2022-03-17 22:42
  12.  */
  13. @Data
  14. public class SkuEsModel {
  15.     private Long skuId;
  16.     private Long spuId;
  17.     private String skuTitle;
  18.     private BigDecimal skuPrice;
  19.     private String skuImg;
  20.     private Long saleCount;
  22.     /**
  23.      * 是否有库存
  24.      */
  25.     private Boolean hasStock;
  26.     /**
  27.      * 热度
  28.      */
  29.     private Long hotScore;
  31.     private Long brandId;
  32.     private Long catalogId;
  33.     private String brandName;
  34.     private String brandImg;
  35.     private String catalogName;
  36.     private List<Attrs> attrs;
  38.     @Data
  39.     public static class Attrs {
  40.         private Long attrId;
  41.         private String attrName;
  42.         private String attrValue;
  43.     }
  44. }

2.2 实现上架业务接口

  1. /**
  2.  * 商品上架
  3.  */
  4. // /product/spuinfo/{spuId}/up
  5. @PostMapping("/{spuId}/up")
  6. public R spuUp(@PathVariable("spuId") Long spuId) {
  7.     spuInfoService.up(spuId);
  8.     return R.ok();
  9. }

2.2.1 获取spuId对应的sku

skuInfoService.getSkusBySpuId(spuId)

  1. /**
  2.  * 通过SpuId找出所有对应的sku信息
  3.  * @param spuId
  4.  * @return
  5.  */
  6. List<SkuInfoEntity> getSkusBySpuId(Long spuId);
  1. /**
  2.  * 根据spuid查出所有对应的sku信息
  3.  * @param spuId
  4.  * @return
  5.  */
  6. @Override
  7. public List<SkuInfoEntity> getSkusBySpuId(Long spuId) {
  8.     List<SkuInfoEntity> skus = this.list(new QueryWrapper<SkuInfoEntity>().eq("spu_id", spuId));
  9.     return skus;
  10. }

2.2.2 查询当前spu能检索的属性

attrService.selectSearchAttrIds(List<Long> spuAttrIds);

  1. /**
  2.  * 在指定属性集合中，找出可检索的属性
  3.  *
  4.  * @param spuAttrIds
  5.  * @return
  6.  */
  7. List<Long> selectSearchAttrIds(List<Long> spuAttrIds);
  1. /**
  2.  * 在指定的属性集合中，找出可检索的属性
  3.  *
  4.  * @param spuAttrIds
  5.  * @return
  6.  */
  7. @Override
  8. public List<Long> selectSearchAttrIds(List<Long> spuAttrIds) {
  9.     // SELECT `attr_id` FROM `pms_attr` WHERE `attr_id` IN spuAttrIds AND `search_type` = 1;
  10.     return baseMapper.selectSearchAttrIds(spuAttrIds);
  11. }

AttrDao中定义接口，写Mapper文件

  1. <select id="selectSearchAttrIds" resultType="java.lang.Long">
  2.     SELECT `attr_id` FROM `pms_attr` WHERE `attr_id` IN
  3.     <foreach collection="spuAttrIds" item="attrId" separator="," open="(" close=")">
  4.         #{attrId}
  5.     </foreach>
  6.     AND `search_type` = 1
  7. </select>

2.2.3 远程查询库存

我们希望将当前supId对应的所有skuId一次性发送给库存服务，查询其全部的库存信息，这样就不需要分次查询，以减少远程调用的消耗，提升性能降低延迟。

gulimall-ware服务中定义查询库存接口&实现&Mapper映射文件

  1. package com.atguigu.gulimall.gulimallware.vo;
  2. import lombok.Data;
  3. @Data
  4. public class SkuHasStockVo {
  5.     private Long skuId;
  6.     private Boolean hasStock;
  7. }
  1. package com.atguigu.common.utils;
  3. public class R<T> extends HashMap<String, Object> {
  4.     private static final long serialVersionUID = 1L;
  5.     private T data;
  7.     public T getData() {
  8.         return data;
  9.     }
  11.     public void setData(T data) {
  12.         this.data = data;
  13.     }
  14. }
  1. /**
  2.  * 查询sku是否有库存
  3.  */
  4. @PostMapping("/hasStock")
  5. public R<List<SkuHasStockVo>> getSkuHasStock(@RequestBody List<Long> skuIds) {
  6.     // 返回每个sku的id跟是否有库存(hasStock)
  7.     List<SkuHasStockVo> vos = wareSkuService.getSkuHasStock(skuIds);
  8.     R<List<SkuHasStockVo>> ok = R.ok();
  9.     ok.setData(vos);
  10.     return ok;
  11. }
  1. /**
  2.  * 检查sku是否有库存
  3.  * @param skuIds
  4.  * @return
  5.  */
  6. @Override
  7. public List<SkuHasStockVo> getSkuHasStock(List<Long> skuIds) {
  8. //        SELECT sku_id, SUM(`stock` - `stock_locked`) FROM `wms_ware_sku` GROUP BY sku_id;
  10.     List<SkuHasStockVo> collect = skuIds.stream().map(skuId -> {
  11.         SkuHasStockVo skuHasStockVo = new SkuHasStockVo();
  12.         skuHasStockVo.setSkuId(skuId);
  13.         // 查询当前sku的总库存量
  14.         // SELECT SUM(`stock` - `stock_locked`) FROM `wms_ware_sku` WHERE `sku_id` = ?;
  15.         Long stock = baseMapper.getSkuStock(skuId);
  16.         skuHasStockVo.setHasStock(stock > 0);
  17.         return skuHasStockVo;
  18.     }).collect(Collectors.toList());
  19.     return collect;
  20. }
  1. <select id="getSkuStock" resultType="java.lang.Long">
  2.     SELECT SUM(`stock` - `stock_locked`) FROM `wms_ware_sku` WHERE `sku_id` = #{skuId}
  3. </select>

gulimall-product调用ware服务

定义ware的远程调用接口，@PostMapping中一定要写完整路径！完整路径！完整路径！

  1. /**
  2.  * @author mrlinxi
  3.  * @create 2022-03-18 13:50
  4.  */
  5. @FeignClient("gulimall-ware")
  6. public interface WareFeignService {
  7.     /**
  8.      * 1.R在设计的时候可以加上泛型
  9.      * 2.直接返回我们想要的结果
  10.      * 3.自己封装解析结果
  11.      * @param skuIds
  12.      * @return
  13.      */
  14.     @PostMapping("/gulimallware/waresku/hasStock")
  15.     R<List<SkuHasStockVo>> getSkuHasStock(@RequestBody List<Long> skuIds);
  16. }

因为我们想获取到ware返回的List，如果通过R.ok.put()，就需要自己行进解析。为了方便，我们复制SkuHasStockVo到common的to包下，这样product中就不需要自行封装。

2.2.4 将数据发给es保存

调用es保存数据是search服务的功能，我们需要在product服务中调用search服务。需要在search服务中完成存储业务实现。

gulimall-search服务实现索引接口

search服务中新建一个es常量类

  1. package com.atguigu.gulimall.gulimallsearch.constant;
  3. /**
  4.  * es常量类
  5.  * @author mrlinxi
  6.  * @create 2022-03-18 15:55
  7.  */
  8. public class EsConstant {
  9.     public static final String PRODUCT_INDEX = "product";  // sku数据在es中的索引
  11. }
  1. @Slf4j
  2. @RestController
  3. @RequestMapping("/gulimallsearch/save")
  4. public class ElasticSaveController {
  5.     @Autowired
  6.     ProductSaveService productSaveService;
  7.     /**
  8.      * 上架商品
  9.      */
  10.     @PostMapping("/product")
  11.     public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModels) {
  12.         boolean status = false;
  13.         try {
  14.             // 如果status为true则表示没有发生错误
  15.             status = productSaveService.productStatusUp(skuEsModels);
  16.         } catch (IOException e) {
  17.             log.error("ElasticSaveController.productStatusUp 商品上架远程调用ware服务发生错误:{}", e);
  18.             return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
  19.         }
  20.         return status ? R.ok() : R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
  22.     }
  23. }
  1. @Service("productSaveService")
  2. @Slf4j
  3. public class ProductSaveServiceImpl implements ProductSaveService {
  4.     @Autowired
  5.     private RestHighLevelClient restHighLevelClient;
  7.     /**
  8.      * 将商品信息存储到es中
  9.      *
  10.      * @param skuEsModels
  11.      */
  12.     @Override
  13.     public boolean productStatusUp(List<SkuEsModel> skuEsModels) throws IOException {
  14.         //将数据保存到es中
  15.         // 1.给es中建立一个索引，建立好映射关系
  16.         // 2.给es中保存这些数据
  17.         // BulkRequest bulkRequest, RequestOptions options
  18.         BulkRequest bulkRequest = new BulkRequest();
  19.         for (SkuEsModel skuEsModel : skuEsModels) {
  20.             // 构造保存请求
  21.             IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
  22.             indexRequest.id(skuEsModel.getSkuId().toString());
  23.             String jsonString = JSON.toJSONString(skuEsModel);  // 将对象转为JSON字符串
  24.             indexRequest.source(jsonString, XContentType.JSON);
  25.             bulkRequest.add(indexRequest);
  26.         }
  27.         // bulk表示批量操作，类似于jdbc的batch操作
  28.         BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
  29.         // TODO 1.如果发生错误，需要对错误进行处理
  30.         // 如果发生错误，那么返回true，否则返回false
  31.         boolean hasFailures = bulkResponse.hasFailures();
  32.         List<String> collect = Arrays.stream(bulkResponse.getItems()).map(item -> item.getId()).collect(Collectors.toList());
  33.         log.info("商品上架成功:{}", collect);
  35.         return !hasFailures;
  36.     }
  37. }

gulimall-product调用search服务

  1. @FeignClient("gulimall-search")
  2. public interface SearchFeignService {
  3.     @PostMapping("//gulimallsearch/save/product")
  4.     R productStatusUp(@RequestBody List<SkuEsModel> skuEsModels);
  5. }

同时，当商品上架成功后，需要更新spu的上架信息和更新时间。新建商品上架状态枚举类：

  1. public enum PublishStatusEum {
  2.     NEW_SPU(0, "新建"), SPU_UP(1, "商品上架"), SPU_DOWN(2, "商品下架");
  3.     private int code;
  4.     private String message;
  5.     PublishStatusEum(int code, String message) {
  6.         this.code = code;
  7.         this.message = message;
  8.     }
  10.     public int getCode() {
  11.         return code;
  12.     }
  14.     public String getMessage() {
  15.         return message;
  16.     }
  17. }

声明更新spu上架状态的方法baseMapper.updateSpuStatus，写mapper映射文件。

  1. public interface SpuInfoDao extends BaseMapper<SpuInfoEntity> {
  3.     /**
  4.      * 更新spu上架状态
  5.      * @param spuId
  6.      * @param code
  7.      */
  8.     void updateSpuStatus(@Param("spuId") Long spuId, @Param("code") int code);
  9. }
  1. <update id="updateSpuStatus">
  2.     UPDATE `pms_spu_info` SET `publish_status` = #{code}, `update_time` = NOW() WHERE `id` = #{spuId};
  3. </update>

2.3 测试——必看很重要

WareSkuDao.xml中这句SQL语句，stock_locked字段在数据库中如果不指定默认是null，如果为null那么不管stock是多少，查出来都是null。所以建议将stock_locked设置默认为0。
image.png
image.png
这里stockMap拿不到R中的data数据，debugWareSkuController里的getSkuHasStock方法的时候发现data并没有放入R。
image.png
这是因为R继承了HashMap，而JackSon对于HashMap类型会有特殊的处理方式，具体来说就是会对类进行向上转型为Map，导致子类的私有属性消失。
image.png
那么我们对R添加一个setData方法，和getData方法，getData方法中我们通过JSON.parseObject将存进R的data逆转为目标对象。

  1. /**
  2.  * 使用alibaba提供的fastjson逆转
  3.  * @param typeReference
  4.  * @param <T>
  5.  * @return
  6.  */
  7. public <T> T getData(TypeReference<T> typeReference) {
  8.     Object data = get("data");
  9.     T t = JSON.parseObject(JSON.toJSONString(data), typeReference);
  10.     return t;
  11. }
  12. public R setData(Object data) {
  13.     put("data", data);
  14.     return this;
  15. }

image.png
需要修改之前用到R泛型的地方

  1. /**
  2.  * 查询sku是否有库存
  3.  */
  4. @PostMapping("/hasStock")
  5. public R getSkuHasStock(@RequestBody List<Long> skuIds) {
  6.     // 返回每个sku的id跟是否有库存(hasStock)
  7.     List<SkuHasStockVo> vos = wareSkuService.getSkuHasStock(skuIds);
  8.     return R.ok().setData(vos);
  9. }
  1. @PostMapping("/gulimallware/waresku/hasStock")
  2. R getSkuHasStock(@RequestBody List<Long> skuIds);

image.png
image.png

商品上架业务最终业务逻辑

  1. @Autowired
  2. BrandService brandService;
  4. @Autowired
  5. CategoryService categoryService;
  7. @Autowired
  8. WareFeignService wareFeignService;
  10. /**
  11.  * 商品上架
  12.  *
  13.  * @param spuId
  14.  */
  15. @Override
  16. public void up(Long spuId) {
  17.     // 组装我们需要的数据
  18.     // 1.查出当前spuId对应的所有sku信息，品牌的名字等等
  19.     List<SkuInfoEntity> skus = skuInfoService.getSkusBySpuId(spuId);
  21.     // TODO 3.查询品牌id、品牌名、分类名
  22.     // 先查出当前spuId对应的spu信息，里面包含了brandId  catalogId
  23.     SpuInfoEntity spu = this.getById(spuId);
  24.     // 根据brandId 查出 brandName
  25.     BrandEntity brand = brandService.getById(spu.getBrandId());
  26.     // 查出CatalogName 也就是category的name
  27.     CategoryEntity category = categoryService.getById(spu.getCatalogId());
  28.     // TODO 4.查询当前spu对应的能被检索的所有属性   pms_product_attr_value pms_attr
  29.     List<ProductAttrValueEntity> spuAttrs = attrValueService.baseAttrListForSpu(spuId);
  30.     // 获取spu对应的所有属性的attrId
  31.     List<Long> spuAttrIds = spuAttrs.stream().map(ProductAttrValueEntity::getAttrId).collect(Collectors.toList());
  32.     // 筛选出可以被检索的属性
  33.     List<Long> availableAttrIds = attrService.selectSearchAttrIds(spuAttrIds);
  34.     // 这里为什么要先变为set，因为set的contains方法的效率要比list高
  35.     HashSet<Long> availableIdSet = new HashSet<>(availableAttrIds);
  36.     List<SkuEsModel.Attrs> spuSearchAttrs = spuAttrs.stream().filter(attr -> availableIdSet.contains(attr.getAttrId()))
  37.             .map(item -> {
  38.                 SkuEsModel.Attrs attrs = new SkuEsModel.Attrs();
  39.                 BeanUtils.copyProperties(item, attrs);
  40.                 return attrs;
  41.             }).collect(Collectors.toList());
  43.     // TODO 1.发送远程调用，库存系统查询是否有库存
  44.     // 我们希望远程调用一次库存服务，直接一次性查所有sku是否有库存，这里直接进行幅值，而不调用远程接口
  45.     List<Long> skuIdList = skus.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList());
  46.     Map<Long, Boolean> stockMap = null;
  47.     try {
  48.         R r = wareFeignService.getSkuHasStock(skuIdList);
  49.         TypeReference<List<SkuHasStockVo>> typeReference = new TypeReference<List<SkuHasStockVo>>() {
  50.         };
  51.         stockMap = r.getData(typeReference).stream().collect(Collectors.toMap(SkuHasStockVo::getSkuId, item -> item.getHasStock()));
  52.     } catch (Exception e) {
  53.         log.error("库存服务查询异常：" + e);
  54.     }
  56.     // 2.封装每个sku的信息
  57.     Map<Long, Boolean> finalStockMap = stockMap;
  58.     List<SkuEsModel> upProducts = skus.stream().map(sku -> {
  59.         SkuEsModel skuEsModel = new SkuEsModel();
  60.         BeanUtils.copyProperties(sku, skuEsModel);
  61.         // skuPrice skuImg
  62.         skuEsModel.setSkuPrice(sku.getPrice());
  63.         skuEsModel.setSkuImg(sku.getSkuDefaultImg());
  64.         // hasStock
  65.         skuEsModel.setHasStock(false);
  66.         // TODO 2.热度评分，默认为0  hotScore
  67.         skuEsModel.setHotScore(0L);
  68.         // 设置库存信息
  69.         if (finalStockMap == null) {
  70.             skuEsModel.setHasStock(true);
  71.         } else {
  72.             skuEsModel.setHasStock(finalStockMap.get(sku.getSkuId()));
  73.         }
  74.         // brandName brandImg catalogName
  75.         skuEsModel.setBrandName(brand.getName());
  76.         skuEsModel.setBrandImg(brand.getLogo());
  77.         skuEsModel.setCatalogName(category.getName());
  78.         // 设置检索属性 SkuEsModel：List<Attrs> attrs
  79.         skuEsModel.setAttrs(spuSearchAttrs);
  80.         return skuEsModel;
  81.     }).collect(Collectors.toList());
  83.     // TODO 5.将数据发给ES进行保存,通过gulimall-search服务
  84.     R r = searchFeignService.productStatusUp(upProducts);
  85.     if (r.getCode() == 0) {
  86.         // 远程调用成功
  87.         // 一旦上架成功，需要修改`pms_spu_info`中的 publish_status为1
  88.         baseMapper.updateSpuStatus(spuId, ProductConstant.PublishStatusEum.SPU_UP.getCode());
  89.     } else {
  90.         // 远程调用失败
  91.         // TODO 重复调用的问题？接口幂等性。比如接口调用失败了，需不需要重新调用一次？（重试机制）
  92.         // Feign调用流程  SynchronousMethodHandler.java invoke方法
  93.         // 1. 构造请求数据，讲对象转为JSON    RequestTemplate template = buildTemplateFromArgs.create(argv);
  94.         // 2. 发送请求进行执行（执行成功会解码我们的响应数据）   executeAndDecode(template, options);
  95.         // 3. 执行请求会有我们的重试机制
  96.     }
  97. }