商品上架

接口功能详情

  • 修改spu状态为已上架

  • 保存sku信息到es中，以skuId作为文档ID 

    1.  sku默认图片
    3.  sku标题
    5.  sku价格
    7.  销量
    9.  spu允许被检索的基本规格（尺寸、CPU、分辨率）

商品json文档格式分析

方式一：

  1. 格式1：（商品索引保存sku+attr信息）【浪费空间节省时间】
  2. {
  3.     skuId:1
  4.     spuId:11
  5.     skuTitle:华为xx
  6.     price:998
  7.     attrs:[
  8.         {尺寸:5寸},
  9.         {CPU:高通945},
  10.         {分辨率:全高清}
  11.     ]
  12. }

每个商品都需要保存一个属性值，缺点是浪费空间，但检索效率更高。

  1. 格式2：（sku与attr分开保存）【节省空间浪费时间】
  2. sku索引 {
  3.     skuId:1
  4.     spuId:11
  5.     skuTitle:华为xx
  6.     price:998
  7. }
  9. attr索引 {
  10.     spuId:11
  11.     attrs:[
  12.         {尺寸:5寸},
  13.         {CPU:高通945},
  14.         {分辨率:全高清}
  15.     ]
  16. }

将商品和索引分开，优势：数据不冗余，劣势：网络带宽大
例：查询小米，会搜到粮食、手机、电器，假设会查到10000个商品，包含4000个spu，因为要汇总所有商品的属性并列出，所以需要向后台传4000个spuId查询attr索引，spuId是Long类型，假设8byte，8byte*4000=32000byte=32Kb如果此时1000,000人检索，数据传输达到32GB

最终采用方式一。

商品文档格式（nested、doc_values、analyzer）

  1. 解析：
  2.     "type": "text",// 全文检索字段
  3.     "type": "keyword",// 非全文检索字段
  4.     "index": false,// 不参与检索
  5.     "doc_values": false// 不参与聚合统计（term）
  6.     "analyzer": "ik_smart"// 使用ik分词器
  1. PUT product
  2. {
  3.   "mappings": {
  4.     "properties": {
  5.       "skuId": {
  6.         "type": "long"
  7.       },
  8.       "spuId": {
  9.         "type": "keyword"    # 关键词检索
  10.       },
  11.       "skuTitle": {
  12.         "type": "text",
  13.         "analyzer": "ik_smart"
  14.       },
  15.       "skuPrice": {
  16.         "type": "keyword"    
  17.       },
  18.       "skuImg": {
  19.         "type": "keyword",
  20.         "index": false,
  21.         "doc_values": false
  22.       },
  23.       "saleCount": {
  24.         "type": "long"
  25.       },
  26.       "hasStock": {
  27.         "type": "boolean"
  28.       },
  29.       "hotScore": {
  30.         "type": "long"
  31.       },
  32.       "brandId": {
  33.         "type": "long"
  34.       },
  35.       "catalogId": {
  36.         "type": "long"
  37.       },
  38.       "brandName": {
  39.         "type": "keyword",
  40.         "index": false,
  41.         "doc_values": false
  42.       },
  43.       "brandImg": {
  44.         "type": "keyword",
  45.         "index": false,
  46.         "doc_values": false
  47.       },
  48.       "catalogName": {
  49.         "type": "keyword",
  50.         "index": false,
  51.         "doc_values": false
  52.       },
  53.       "attrs": {
  54.         "type": "nested",
  55.         "properties": {
  56.           "attrId": {
  57.             "type": "long"
  58.           },
  59.           "attrName": {
  60.             "type": "keyword",
  61.             "index": false,
  62.             "doc_values": false
  63.           },
  64.           "attrValue": {
  65.             "type": "keyword"
  66.           }
  67.         }
  68.       }
  69.     }
  70.   }
  71. }

解释attr的 “type”: “nested”的nested值：

nested数据类型分析

未加nested数据类型的数组类型数据保存时会被es扁平化处理，导致查询的时候回出现错误，查看下例未加nested数据类型导致扁平化的案例。

商品上架 - 图1

  1. 案例：（存储一条id=1的数据）
  2. PUT my_index/_doc/1
  3. {
  4.     "group": "fans",
  5.     "user": [
  6.         {
  7.             "first": "John",
  8.             "last": "Smith"
  9.         },{
  10.             "first": "Alice",
  11.             "last": "White"
  12.         }
  13.     ]
  14. }
  16. es会处理成：
  17. {
  18.     "group": "fans",
  19.     "user.first": ["Alice", "John"],
  20.     "user.last": ["Smith", "White"]
  21. }
  23. 查询my_index索引映射
  24. GET my_index/_mapping
  25. {
  26.   "my_index" : {
  27.     "mappings" : {
  28.       "properties" : {
  29.         "group" : {
  30.           "type" : "text",
  31.           "fields" : {
  32.             "keyword" : {
  33.               "type" : "keyword",
  34.               "ignore_above" : 256
  35.             }
  36.           }
  37.         },
  38.         "user" : {
  39.           "properties" : {
  40.             "first" : {
  41.               "type" : "text",
  42.               "fields" : {
  43.                 "keyword" : {
  44.                   "type" : "keyword",
  45.                   "ignore_above" : 256
  46.                 }
  47.               }
  48.             },
  49.             "last" : {
  50.               "type" : "text",
  51.               "fields" : {
  52.                 "keyword" : {
  53.                   "type" : "keyword",
  54.                   "ignore_above" : 256
  55.                 }
  56.               }
  57.             }
  58.           }
  59.         }
  60.       }
  61.     }
  62.   }
  63. }
  65. 检索：（查询Alice+Smith也可以查到，实际应该是没有这条数据的）
  66. GET my_index/_search
  67. {
  68.     "query": {
  69.         "bool": {
  70.             "must": [
  71.                 {"match": {"user.first": "Alice"}},
  72.                 {"match": {"user.last": "Smith"}}
  73.             ]
  74.         }
  75.     }
  76. }

使用nested类型映射

  1. 上面案例的正确映射方式：（避免了es自动对数据扁平化处理）
  2. PUT my_index
  3. {
  4.     "mappings": {
  5.         "properties": {
  6.             "user": {
  7.                 "type": "nested"
  8.             }
  9.         }
  10.     }
  11. }
  13. 然后再存储数据，按照以上查询方式查询不会再查询到值
  14. 基本规格案例：
  15. "attrs": {
  16.     "type": "nested",
  17.     "properties": {
  18.     "attrId": {
  19.         "type": "long"
  20.     },
  21.     "attrName": {
  22.         "type": "keyword",
  23.         "index": false,
  24.         "doc_values": false
  25.     },
  26.     "attrValue": {
  27.         "type": "keyword"
  28.     }
  29. }

商品上架接口

产品模块上架接口要调用es模块，所以在common模块新增TO对象

  1. @Data
  2. public class SkuEsModel {
  3.     private Long skuId;
  4.     private Long spuId;
  5.     private String skuTitle;
  6.     private BigDecimal skuPrice;
  7.     private String skuImg;
  8.     private Long saleCount;
  9.     private Boolean hasStock;
  10.     private Long hotScore;
  11.     private Long brandId;
  12.     private Long catalogId;
  13.     private String brandName;
  14.     private String brandImg;
  15.     private String catalogName;
  16.     private List<Attrs> attrs;
  18.     // 存储为es数据时应该作为nested类型存储
  19.     @Data
  20.     public static class Attrs {
  21.         private Long attrId;
  22.         private String attrName;
  23.         private String attrValue;
  24.     }
  25. }

商品上架的接口：

  1. @Override
  2. public void up(Long spuId) {
  3.     // 先查出spu对应的sku信息
  4.     List<SkuInfoEntity> skuInfoEntityList = skuInfoService.getSkuBySpuId(spuId);
  6.     // 获取所有的skuId
  7.     List<Long> skuIdList = skuInfoEntityList.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList());
  9.     // 设置属性
  10.     List<ProductAttrValueEntity> attrValueEntityList = productAttrValueService.baseAttrlistforspu(spuId);
  11.     List<Long> attrIds = attrValueEntityList.stream().map(attrValueEntity -> attrValueEntity.getAttrId()).collect(Collectors.toList());
  13.     List<Long> attrSearchIds = attrService.selectSearchAttrIds(attrIds);    // 查出满足检索条件的属性
  15.     HashSet<Long> set = new HashSet<>(attrSearchIds);
  17.     // 封装成搜索的属性
  18.     List<SkuEsModel.Attrs> searchAttrs = attrValueEntityList.stream().filter(attrValueEntity -> set.contains(attrValueEntity.getAttrId())).map(attrValueEntity -> {
  19.         SkuEsModel.Attrs attr = new SkuEsModel.Attrs();
  20.         BeanUtils.copyProperties(attrValueEntity, attr);
  21.         return attr;
  22.     }).collect(Collectors.toList());
  24.     // 远程调用查询库存信息
  25.     Map<Long, Boolean> stockMap = new HashMap<>();
  26.     try {
  27.         R r = wareFeignService.getSkuHasStock(skuIdList);
  28.         // TypeReference构造器失手保护，需要以内部类构造
  29.         TypeReference<List<SkuHasStockTo>> typeReference = new TypeReference<List<SkuHasStockTo>>() {
  30.         };
  31.         stockMap = r.getData(typeReference).stream().collect(Collectors.toMap(SkuHasStockTo::getSkuId, skuHasStockTo -> skuHasStockTo.getHasStock()));
  32.     } catch (Exception e) {
  33.         log.error("远程调用出现异常:" + e);
  34.     }
  36.     Map<Long, Boolean> finalStockMap = stockMap;
  37.     List<SkuEsModel> skuEsModelList = skuInfoEntityList.stream().map(skuInfo -> {
  38.         SkuEsModel skuEsModel = new SkuEsModel();
  39.         // 将一些属性进行对拷
  40.         BeanUtils.copyProperties(skuInfo, skuEsModel);
  41.         // 设置不对应的属性值
  42.         skuEsModel.setSkuPrice(skuInfo.getPrice());
  43.         skuEsModel.setSkuImg(skuInfo.getSkuDefaultImg());
  45.         // 查询品牌信息进行封装
  46.         BrandEntity brandById = brandService.getById(skuEsModel.getBrandId());
  47.         skuEsModel.setBrandId(brandById.getBrandId());
  48.         skuEsModel.setBrandName(brandById.getName());
  49.         skuEsModel.setBrandImg(brandById.getLogo());
  51.         // TODO 热度评分，先默认设置为0
  52.         skuEsModel.setHotScore(0L);
  54.         // 设置库存信息
  55.         if (finalStockMap == null) {
  56.             skuEsModel.setHasStock(true);
  57.         } else {
  58.             skuEsModel.setHasStock(finalStockMap.get(skuEsModel.getSkuId()));
  59.         }
  61.         // 查出分类信息进行封装
  62.         CategoryEntity categoryEntityById = categoryService.getById(skuEsModel.getCatalogId());
  63.         skuEsModel.setCatalogName(categoryEntityById.getName());
  65.         // 设置检索属性值
  66.         skuEsModel.setAttrs(searchAttrs);
  69.         return skuEsModel;
  70.     }).collect(Collectors.toList());
  72.     // 将数据保存到ES
  73.     R r = searchFeignService.productStatusUp(skuEsModelList);
  74.     if (r.getCode() == 0) {
  75.         // 远程调用成功，修改当前spu状态
  76.         baseMapper.updateSpuUpStatus(spuId, SpuConstant.PublishStatusEnum.SPU_UP.getCode());
  77.     } else {
  78.         // 远程调用失败
  79.         // TODO 重复调用问题（接口幂等性）
  80.     }
  82. }

其中调用了ES模块的保存接口:

controller:

  1. @RequestMapping("/search/save")
  2. @RestController
  3. public class ElasticSaveController {
  5.     @Autowired
  6.     private ElasticSaveService elasticSaveService;
  8.     /**
  9.      * 保存商品到ES中
  10.      *
  11.      * @return
  12.      */
  13.     @PostMapping("/product")
  14.     public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModelList) {
  15.         boolean flag = false;
  16.         try {
  17.             flag = elasticSaveService.productStatusUp(skuEsModelList);
  18.         } catch (IOException e) {
  19.             // 抛出异常
  20.             return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
  21.         }
  22.         // false表示没有错误
  23.         return flag ? R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg()) : R.ok();
  24.     }
  26. }

service接口保存信息再ES中：

  1. @Slf4j
  2. @Service
  3. public class ElasticSaveServiceImpl implements ElasticSaveService {
  5.     @Autowired
  6.     RestHighLevelClient restHighLevelClient;
  9.     @Override
  10.     public boolean productStatusUp(List<SkuEsModel> skuEsModelList) throws IOException {
  12.         // 给ES中保存数据
  13.         BulkRequest bulkRequest = new BulkRequest();
  14.         for (SkuEsModel model : skuEsModelList) {
  15.             // 创建索引对应的保存请求
  16.             IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
  17.             indexRequest.id(model.getSkuId().toString());
  18.             indexRequest.source(JSONObject.toJSONString(model), XContentType.JSON);
  19.             bulkRequest.add(indexRequest);
  20.         }
  22.         BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, GulimallSearchConfig.COMMON_OPTIONS);
  24.         // TODO 如果批量出现错误
  25.         boolean flag = bulkResponse.hasFailures(); // 响应体中检查是否出现错误
  27.         List<String> idList = Arrays.stream(bulkResponse.getItems()).map(BulkItemResponse::getId).collect(Collectors.toList());
  28.         log.info("商品上架完成:{}" + idList);
  30.         return flag;
  31.     }
  32. }

注意这里再调用远程接口在ware中查询库存时，需要返回数据在R中，并解析出来，此时方法如下：

商品上架 - 图2

最终采用了fastJson提供的转换，自己封装的方式（TypeReference封装返回类型）

在R中添加getData（）和setData（）方法

  1. // 转换数据，利用fastjson进行逆转
  2. public <T> T getData(TypeReference<T> typeReference) {
  3.     Object data = get("data");  // 默认是map
  4.     String jsonString = JSON.toJSONString(data);
  5.     T t = JSON.parseObject(jsonString, typeReference);
  6.     return t;
  7. }
  9. // feign返回对象时有用
  10. public R setData(Object data) {
  11.     put("data", data);
  12.     return this;
  13. }

在远程调用后进行转换

  1. // 远程调用查询库存信息
  2.     Map<Long, Boolean> stockMap = new HashMap<>();
  3.     try {
  4.         R r = wareFeignService.getSkuHasStock(skuIdList);
  5.         // TypeReference构造器失手保护，需要以内部类构造
  6.         TypeReference<List<SkuHasStockTo>> typeReference = new TypeReference<List<SkuHasStockTo>>() {
  7.         };
  8.         stockMap = r.getData(typeReference).stream().collect(Collectors.toMap(SkuHasStockTo::getSkuId, skuHasStockTo -> skuHasStockTo.getHasStock()));
  9.     } catch (Exception e) {
  10.         log.error("远程调用出现异常:" + e);
  11.     }

其他细节可以通过SpuInfoController的这个接口查看

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