检索服务

封装查询条件

注意请求标识

  1. /**
  2.  * 封装页面所有可能传递过来的查询条件
  3.  * 三种点击搜索的方式
  4.  * 1、点击搜索：keyword   【skuTitle】
  5.  * 2、点击分类：传catalog3Id【catalogld】
  6.  * 3、选择筛选条件
  7.  *      1、全文检索: keyword【skuTitle】
  8.  *      2、排序: saleCount_asc【销量】、hotScore_asc【综合排序：热度评分】、skuPrice_asc【价格】
  9.  *      3、过滤: hasStock、skuPrice区间、brandld、catalog3ld、attrs
  10.  *      4、聚合: attrs
  11.  *          attrs=2_5寸 传参格式，所以直接for循环split("_")就可以得到attrId与attrValue
  12.  *          attrs=1_白色:蓝色       然后值split(":")得到各项值attrValue
  13.  */
  14. @Data
  15. public class SearchParam {
  17.     private String keyword;// 页面传递过来的全文匹配关键字
  18.     private Long catalog3Id;// 三级分类的id
  19.     /**
  20.      * 排序：sort=saleCount_asc  sort=hotScore_asc  sort=skuPrice_asc
  21.      */
  22.     private String sort;
  23.     /**
  24.      * 过滤条件：
  25.      * hasStock=0/1【有货】
  26.      * skuPrice=0_500/500_/_500【价格区间】
  27.      * brandld=1
  28.      * attrs=1_白色:蓝色&attrs=2_2寸:5寸【属性可多选，值也可多选】
  29.      */
  30.     private Integer hasStock = 1;// 是否只显示有货，默认显示有货，null == 1会NullPoint异常  0/1
  31.     private String skuPrice;// 按照价格区间查询
  32.     private List<Long> brandId;// 品牌id，可多选
  33.     private List<String> attrs;// 三级分类id+属性值
  34.     private Integer pageNum = 1;// 页码
  36.     private String _queryString;// 原生的所有查询条件（来自url的请求参数），用于构建面包屑
  37. }

返回结果类

显示结果VO类

检索服务 - 图1

包括下面商品信息

面包屑导航

检索服务 - 图2

  1. @Data
  2. public class SearchResult {
  4.     private List<SkuEsModel> products;// es检索到的所有商品信息
  6.     /**
  7.      * 分页信息
  8.      */
  9.     private Integer pageNum;// 当前页码
  10.     private Long total;// 总记录数
  11.     private Integer totalPages;// 总页码
  12.     private List<Integer> pageNavs;// 导航页码[1、2、3、4、5]
  14.     private List<BrandVo> brands;// 当前查询到的结果所有涉及到的品牌
  15.     private List<CatalogVo> catalogs;// 当前查询到的结果所有涉及到的分类
  16.     /**
  17.      * attrs=1_anzhuo&attrs=5_其他:1080P
  18.      */
  19.     private List<AttrVo> attrs = new ArrayList<>();// 当前查询到的结果所有涉及到的属性【符合检索条件的，可检索的属性】
  22.     // ============================以上是要返回的数据====================================
  24.     // 面包屑导航数据
  25.     private List<NavVo> navs = new ArrayList<>();
  27.     // 封装筛选条件中的属性id集合【用于面包屑，选择属性后出现在面包屑中，下面的属性栏则隐藏】
  28.     // 该字段是提供前端用的
  29.     private List<Long> attrIds = new ArrayList<>();
  32.     /**
  33.      * 面包屑导航VO
  34.      */
  35.     @Data
  36.     public static class NavVo {
  37.         private String navName;// 属性名
  38.         private String navValue;// 属性值
  39.         private String link;// 回退地址（删除该面包屑筛选条件回退地址）
  40.     }
  42.     @Data
  43.     public static class BrandVo {
  44.         private Long brandId;//
  45.         private String brandName;//
  46.         private String brandImg;//
  47.     }
  49.     @Data
  50.     public static class CatalogVo {
  51.         private Long catalogId;// 显示分类id
  52.         private String catalogName;// 显示分类name
  53.     }
  55.     @Data
  56.     public static class AttrVo {
  57.         private Long attrId;// 允许检索的 属性Id
  58.         private String attrName;// 允许检索的 属性名
  59.         private List<String> attrValue;// 属性值【多个】
  60.     }
  61. }

ES查询的实例语句

  1. {
  2.   "query": {
  3.     "bool": {
  4.       "must": [
  5.         {
  6.           "match": {
  7.             "skuTitle": "华为"
  8.           }
  9.         }
  10.       ],
  11.       "filter": [
  12.         {
  13.           "term": {
  14.             "catalogId": "225"
  15.           }
  16.         },
  17.         {
  18.           "terms": {
  19.             "brandId": [
  20.               "9",
  21.               "5"
  22.             ]
  23.           }
  24.         },
  25.         {
  26.           "nested": {
  27.             "path": "attrs",
  28.             "query": {
  29.               "bool": {
  30.                 "must": [
  31.                   {
  32.                     "term": {
  33.                       "attrs.attrId": {
  34.                         "value": "15"
  35.                       }
  36.                     }
  37.                   },
  38.                   {
  39.                     "terms": {
  40.                       "attrs.attrValue": [
  41.                         "高通(Qualcomm)"
  42.                       ]
  43.                     }
  44.                   }
  45.                 ]
  46.               }
  47.             }
  48.           }
  49.         },
  50.         {
  51.           "term": {
  52.             "hasStock": {
  53.               "value": "true"
  54.             }
  55.           }
  56.         },
  57.         {
  58.           "range": {
  59.             "skuPrice": {
  60.               "gte": 0,
  61.               "lte": 7000
  62.             }
  63.           }
  64.         }
  65.       ]
  66.     }
  67.   },
  68.   "sort": [
  69.     {
  70.       "saleCount": {
  71.         "order": "desc"
  72.       }
  73.     }
  74.   ],
  75.   "from": 0,
  76.   "size": 2,
  77.   "highlight": {
  78.     "fields": {
  79.       "skuTitle": {}
  80.     },
  81.     "pre_tags": "<b style='color:red'>",
  82.     "post_tags": "</b>"
  83.   },
  84.   "aggs": {
  85.     "brand_agg": {
  86.       "terms": {
  87.         "field": "brandId",
  88.         "size": 10
  89.       },
  90.       "aggs": {
  91.         "brand_name_agg": {
  92.           "terms": {
  93.             "field": "brandName",
  94.             "size": 10
  95.           }
  96.         },
  97.         "brand_img_agg": {
  98.           "terms": {
  99.             "field": "brandImg",
  100.             "size": 10
  101.           }
  102.         }
  103.       }
  104.     },
  105.     "catalog_agg": {
  106.       "terms": {
  107.         "field": "catalogId",
  108.         "size": 10
  109.       },
  110.       "aggs": {
  111.         "catalog_name_agg": {
  112.           "terms": {
  113.             "field": "catalogName",
  114.             "size": 10
  115.           }
  116.         }
  117.       }
  118.     },
  119.     "attr_agg": {
  120.       "nested": {
  121.         "path": "attrs"
  122.       },
  123.       "aggs": {
  124.         "attr_id_agg": {
  125.           "terms": {
  126.             "field": "attrs.attrId",
  127.             "size": 10
  128.           },
  129.           "aggs": {
  130.             "attr_name_agg": {
  131.               "terms": {
  132.                 "field": "attrs.attrName",
  133.                 "size": 10
  134.               }
  135.             },
  136.             "attr_value_agg": {
  137.               "terms": {
  138.                 "field": "attrs.attrValue",
  139.                 "size": 10
  140.               }
  141.             }
  142.           }
  143.         }
  144.       }
  145.     }
  146.   }
  147. }

请求封装接口

  1. @Override
  2. public SearchResult search(SearchParam searchParam) {
  3.     // 动态构建查询需要的DSL语句
  4.     SearchResult searchResult = null;
  6.     // 准备检索请求
  7.     SearchRequest searchRequest = buildSearchRequest(searchParam);
  9.     // 执行检索请求
  10.     try {
  11.         SearchResponse response = restHighLevelClient.search(searchRequest, GulimallSearchConfig.COMMON_OPTIONS);
  13.         // 封装返回结果
  14.         searchResult = buildSearchResponse(response, searchParam);
  15.     } catch (IOException e) {
  16.         e.printStackTrace();
  17.     }
  19.     return searchResult;
  20. }
  22. /**
  23.  * 准备检索请求（参照dsl.json文件）
  24.  *
  25.  * @param searchParam
  26.  * @return
  27.  */
  28. private SearchRequest buildSearchRequest(SearchParam searchParam) {
  29.     SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();    // 构建DSL语句
  31.     // 构建 bool-query,根据商品的标题进行检索
  32.     BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  34.     if (!StringUtils.isEmpty(searchParam.getKeyword())) {
  35.         boolQueryBuilder.must(QueryBuilders.matchQuery("skuTitle", searchParam.getKeyword()));
  36.     }
  38.     // 构建 bool-filter-term,根据三级分类进行检索
  39.     if (!StringUtils.isEmpty(searchParam.getCatalog3Id())) {
  40.         boolQueryBuilder.filter(QueryBuilders.termQuery("catalogId", searchParam.getCatalog3Id()));
  41.     }
  43.     // 构建 bool-filter-term,根据品牌id进行检索
  44.     if (!StringUtils.isEmpty(searchParam.getBrandId())) {
  45.         boolQueryBuilder.filter(QueryBuilders.termQuery("brandId", searchParam.getBrandId()));
  46.     }
  48.     // bool-filter,根据属性值进行检索
  49.     if (!StringUtils.isEmpty(searchParam.getAttrs())) {
  50.         for (String attr : searchParam.getAttrs()) {
  51.             BoolQueryBuilder nestedBoolQuery = QueryBuilders.boolQuery();
  52.             // attr格式  attrs=1_白色:蓝色
  53.             String[] attrs = attr.split("_");
  54.             String attrId = attrs[0];
  55.             String[] attrValues = attrs[1].split(":");// 再将多个属性值分开
  56.             // TODO 此时如果属性只有一个，那么在ES中会封装为[高通]，此时会查不到数据
  57.             nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
  58.             if (attrValues.length == 1) {
  59.                 nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrValue", attrValues[0]));
  60.             } else {
  61.                 // 多个就放入数组
  62.                 nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrValue", attrValues));
  63.             }
  64.             // 创建nested查询（注意每一个属性值，都需要一个nested进行查询）
  65.             NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", nestedBoolQuery, ScoreMode.None);   // 最后参数表示不参与评分
  66.             boolQueryBuilder.filter(nestedQuery);
  67.         }
  68.     }
  70.     // 构建 bool-filter-term,根据是否有库存进行检索
  71.     boolQueryBuilder.filter(QueryBuilders.termQuery("hasStock", searchParam.getHasStock() == 1));
  73.     // bool-filter,根据价格区间进行查询
  74.     // skuPrice=0_500/500_/_500【价格区间】
  75.     if (!StringUtils.isEmpty(searchParam.getSkuPrice())) {
  76.         RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
  77.         String skuPrice = searchParam.getSkuPrice();
  78.         String[] s = skuPrice.split("_");
  79.         if (s.length == 2) {    // 指定了两边区间 0_500
  80.             rangeQuery.gte(s[0]).lte(s[1]);
  81.         } else { // 指定了一边区间 500_/_500
  82.             if (skuPrice.endsWith("_")) {
  83.                 rangeQuery.gte(s[0]);
  84.             }
  86.             if (skuPrice.startsWith("_")) {
  87.                 rangeQuery.lte(s[0]);
  88.             }
  89.         }
  91.         boolQueryBuilder.filter(rangeQuery);
  92.     }
  94.     // 把以前所有的条件封装起来
  95.     searchSourceBuilder.query(boolQueryBuilder);
  97.     // 排序：sort=saleCount_asc
  98.     if (!StringUtils.isEmpty(searchParam.getSort())) {
  99.         String[] s = searchParam.getSort().split("_");
  100.         SortOrder sortOrder = s[1].equalsIgnoreCase("asc") ? SortOrder.ASC : SortOrder.DESC;
  101.         searchSourceBuilder.sort(s[0], sortOrder);
  102.     }
  104.     // 分页
  105.     // "from": 0,
  106.     // "size": 2,
  107.     searchSourceBuilder.from((searchParam.getPageNum() - 1) * EsConstant.PRODUCT_PAGESIZE);
  108.     searchSourceBuilder.size(EsConstant.PRODUCT_PAGESIZE);
  110.     // 高亮
  111.     // "highlight": {
  112.     //    "fields": {
  113.     //        "skuTitle": {}
  114.     //    },
  115.     //    "pre_tags": "<b style='color:red'>",
  116.     //            "post_tags": "</b>"
  117.     // }
  118.     if (!StringUtils.isEmpty(searchParam.getKeyword())) {
  119.         HighlightBuilder highlightBuilder = new HighlightBuilder();
  120.         highlightBuilder.field("skuTitle");
  121.         highlightBuilder.preTags("<b style='color:red'>");
  122.         highlightBuilder.postTags("</b>");
  123.         searchSourceBuilder.highlighter(highlightBuilder);
  124.     }
  126.     // 聚合分析
  127.     // 品牌聚合
  128.     TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg").field("brandId").size(50);
  129.     brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(1));
  130.     brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(1));
  131.     searchSourceBuilder.aggregation(brand_agg);
  133.     // 分类聚合
  134.     TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg").field("catalogId").size(20);
  135.     catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1));
  136.     searchSourceBuilder.aggregation(catalog_agg);
  138.     // 属性聚合(nested属性)
  139.     NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
  140.     TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId");
  141.     attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1));
  142.     attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50));
  143.     attr_agg.subAggregation(attr_id_agg);
  144.     searchSourceBuilder.aggregation(attr_agg);
  146.     System.out.println(searchSourceBuilder.toString());
  148.     SearchRequest searchRequest = new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX}, searchSourceBuilder);
  150.     return searchRequest;
  151. }

ES返回JSON数据

  1. {
  2.   "took" : 14,
  3.   "timed_out" : false,
  4.   "_shards" : {
  5.     "total" : 1,
  6.     "successful" : 1,
  7.     "skipped" : 0,
  8.     "failed" : 0
  9.   },
  10.   "hits" : {
  11.     "total" : {
  12.       "value" : 4,
  13.       "relation" : "eq"
  14.     },
  15.     "max_score" : null,
  16.     "hits" : [
  17.       {
  18.         "_index" : "gulimall_product",
  19.         "_type" : "_doc",
  20.         "_id" : "51",
  21.         "_score" : null,
  22.         "_source" : {
  23.           "attrs" : [
  24.             {
  25.               "attrId" : 15,
  26.               "attrName" : "CPU品牌",
  27.               "attrValue" : "高通(Qualcomm)"
  28.             },
  29.             {
  30.               "attrId" : 16,
  31.               "attrName" : "CPU型号",
  32.               "attrValue" : "鸿蒙"
  33.             }
  34.           ],
  35.           "brandId" : 9,
  36.           "brandImg" : "https://gulimall-hello.oss-cn-beijing.aliyuncs.com/2019-11-18/de2426bd-a689-41d0-865a-d45d1afa7cde_huawei.png",
  37.           "brandName" : "华为",
  38.           "catalogId" : 225,
  39.           "catalogName" : "手机",
  40.           "hasStock" : true,
  41.           "hotScore" : 0,
  42.           "saleCount" : 0,
  43.           "skuId" : 51,
  44.           "skuImg" : "https://project-guli-education.oss-cn-chengdu.aliyuncs.com/2022-05-03/842c391d-6a37-441e-8aa4-ce5041b23ecb_23d9fbb256ea5d4a.jpg",
  45.           "skuPrice" : 6099.0,
  46.           "skuTitle" : "华为mate40pro 5G手机 夏日胡杨 8+128G全网通（4G版）  黑色 8+256GB 4G",
  47.           "spuId" : 29
  48.         },
  49.         "highlight" : {
  50.           "skuTitle" : [
  51.             "<b style='color:red'>华为</b>mate40pro 5G手机 夏日胡杨 8+128G全网通（4G版）  黑色 8+256GB 4G"
  52.           ]
  53.         },
  54.         "sort" : [
  55.           0
  56.         ]
  57.       },
  58.       {
  59.         "_index" : "gulimall_product",
  60.         "_type" : "_doc",
  61.         "_id" : "52",
  62.         "_score" : null,
  63.         "_source" : {
  64.           "attrs" : [
  65.             {
  66.               "attrId" : 15,
  67.               "attrName" : "CPU品牌",
  68.               "attrValue" : "高通(Qualcomm)"
  69.             },
  70.             {
  71.               "attrId" : 16,
  72.               "attrName" : "CPU型号",
  73.               "attrValue" : "鸿蒙"
  74.             }
  75.           ],
  76.           "brandId" : 9,
  77.           "brandImg" : "https://gulimall-hello.oss-cn-beijing.aliyuncs.com/2019-11-18/de2426bd-a689-41d0-865a-d45d1afa7cde_huawei.png",
  78.           "brandName" : "华为",
  79.           "catalogId" : 225,
  80.           "catalogName" : "手机",
  81.           "hasStock" : true,
  82.           "hotScore" : 0,
  83.           "saleCount" : 0,
  84.           "skuId" : 52,
  85.           "skuImg" : "https://project-guli-education.oss-cn-chengdu.aliyuncs.com/2022-05-03/842c391d-6a37-441e-8aa4-ce5041b23ecb_23d9fbb256ea5d4a.jpg",
  86.           "skuPrice" : 6099.0,
  87.           "skuTitle" : "华为mate40pro 5G手机 夏日胡杨 8+128G全网通（4G版）  黑色 8+256GB 5G",
  88.           "spuId" : 29
  89.         },
  90.         "highlight" : {
  91.           "skuTitle" : [
  92.             "<b style='color:red'>华为</b>mate40pro 5G手机 夏日胡杨 8+128G全网通（4G版）  黑色 8+256GB 5G"
  93.           ]
  94.         },
  95.         "sort" : [
  96.           0
  97.         ]
  98.       }
  99.     ]
  100.   },
  101.   "aggregations" : {
  102.     "catalog_agg" : {
  103.       "doc_count_error_upper_bound" : 0,
  104.       "sum_other_doc_count" : 0,
  105.       "buckets" : [
  106.         {
  107.           "key" : 225,
  108.           "doc_count" : 4,
  109.           "catalog_name_agg" : {
  110.             "doc_count_error_upper_bound" : 0,
  111.             "sum_other_doc_count" : 0,
  112.             "buckets" : [
  113.               {
  114.                 "key" : "手机",
  115.                 "doc_count" : 4
  116.               }
  117.             ]
  118.           }
  119.         }
  120.       ]
  121.     },
  122.     "attr_agg" : {
  123.       "doc_count" : 8,
  124.       "attr_id_agg" : {
  125.         "doc_count_error_upper_bound" : 0,
  126.         "sum_other_doc_count" : 0,
  127.         "buckets" : [
  128.           {
  129.             "key" : 15,
  130.             "doc_count" : 4,
  131.             "attr_name_agg" : {
  132.               "doc_count_error_upper_bound" : 0,
  133.               "sum_other_doc_count" : 0,
  134.               "buckets" : [
  135.                 {
  136.                   "key" : "CPU品牌",
  137.                   "doc_count" : 4
  138.                 }
  139.               ]
  140.             },
  141.             "attr_value_agg" : {
  142.               "doc_count_error_upper_bound" : 0,
  143.               "sum_other_doc_count" : 0,
  144.               "buckets" : [
  145.                 {
  146.                   "key" : "高通(Qualcomm)",
  147.                   "doc_count" : 4
  148.                 }
  149.               ]
  150.             }
  151.           },
  152.           {
  153.             "key" : 16,
  154.             "doc_count" : 4,
  155.             "attr_name_agg" : {
  156.               "doc_count_error_upper_bound" : 0,
  157.               "sum_other_doc_count" : 0,
  158.               "buckets" : [
  159.                 {
  160.                   "key" : "CPU型号",
  161.                   "doc_count" : 4
  162.                 }
  163.               ]
  164.             },
  165.             "attr_value_agg" : {
  166.               "doc_count_error_upper_bound" : 0,
  167.               "sum_other_doc_count" : 0,
  168.               "buckets" : [
  169.                 {
  170.                   "key" : "鸿蒙",
  171.                   "doc_count" : 4
  172.                 }
  173.               ]
  174.             }
  175.           }
  176.         ]
  177.       }
  178.     },
  179.     "brand_agg" : {
  180.       "doc_count_error_upper_bound" : 0,
  181.       "sum_other_doc_count" : 0,
  182.       "buckets" : [
  183.         {
  184.           "key" : 9,
  185.           "doc_count" : 4,
  186.           "brand_img_agg" : {
  187.             "doc_count_error_upper_bound" : 0,
  188.             "sum_other_doc_count" : 0,
  189.             "buckets" : [
  190.               {
  191.                 "key" : "https://gulimall-hello.oss-cn-beijing.aliyuncs.com/2019-11-18/de2426bd-a689-41d0-865a-d45d1afa7cde_huawei.png",
  192.                 "doc_count" : 4
  193.               }
  194.             ]
  195.           },
  196.           "brand_name_agg" : {
  197.             "doc_count_error_upper_bound" : 0,
  198.             "sum_other_doc_count" : 0,
  199.             "buckets" : [
  200.               {
  201.                 "key" : "华为",
  202.                 "doc_count" : 4
  203.               }
  204.             ]
  205.           }
  206.         }
  207.       ]
  208.     }
  209.   }
  210. }

返回结果封装方法

  1. /**
  2.  * 封装返回结果（参照result.json文件）
  3.  *
  4.  * @param response
  5.  * @return
  6.  */
  7. private SearchResult buildSearchResponse(SearchResponse response, SearchParam searchParam) {
  9.     SearchResult searchResult = new SearchResult();
  10.     SearchHits hits = response.getHits();
  12.     // 封装商品信息
  13.     // 保存进去就是以SkuEsModel保存的
  14.     List<SkuEsModel> skuEsModelList = new ArrayList<>();
  15.     // hits的hits中的source保存的是商品信息
  16.     for (SearchHit hit : response.getHits()) {
  17.         // 获取到json数据，转换为对象
  18.         String sourceAsString = hit.getSourceAsString();
  19.         SkuEsModel skuEsModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
  20.         // 设置高亮标题
  21.         if (!StringUtils.isEmpty(searchParam.getKeyword())) {
  22.             Map<String, HighlightField> highlightFieldMap = hit.getHighlightFields();
  23.             String skuTitle = highlightFieldMap.get("skuTitle").getFragments()[0].string();
  24.             skuEsModel.setSkuTitle(skuTitle);
  25.         }
  26.         skuEsModelList.add(skuEsModel);
  27.     }
  28.     searchResult.setProducts(skuEsModelList);
  30.     // 当前商品所涉及的品牌信息
  31.     ParsedLongTerms brand_agg = response.getAggregations().get("brand_agg");
  32.     List<SearchResult.BrandVo> brandVoList = new ArrayList<>();
  33.     List<? extends Terms.Bucket> brandList = brand_agg.getBuckets();
  34.     for (Terms.Bucket bucket : brandList) {
  35.         SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
  37.         // 获取品牌的id
  38.         long brandId = bucket.getKeyAsNumber().longValue();
  40.         // 获取品牌的名字
  41.         String brandName = ((ParsedStringTerms) bucket.getAggregations().get("brand_name_agg")).getBuckets().get(0).getKeyAsString();
  43.         // 获取品牌的图片
  44.         String brandImage = ((ParsedStringTerms) bucket.getAggregations().get("brand_img_agg")).getBuckets().get(0).getKeyAsString();
  46.         brandVo.setBrandId(brandId);
  47.         brandVo.setBrandName(brandName);
  48.         brandVo.setBrandImg(brandImage);
  50.         brandVoList.add(brandVo);
  51.     }
  52.     searchResult.setBrands(brandVoList);
  54.     // 当前商品所涉及的属性信息
  55.     ParsedNested attr_agg = response.getAggregations().get("attr_agg");
  56.     List<SearchResult.AttrVo> attrVoList = new ArrayList<>();
  57.     ParsedLongTerms attrIdAgg = attr_agg.getAggregations().get("attr_id_agg");
  58.     for (Terms.Bucket bucket : attrIdAgg.getBuckets()) {
  59.         SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
  61.         // 属性id
  62.         long attrId = bucket.getKeyAsNumber().longValue();
  64.         // 属性名
  65.         String attrName = ((ParsedStringTerms) bucket.getAggregations().get("attr_name_agg")).getBuckets().get(0).getKeyAsString();
  67.         // 属性值
  68.         List<String> attrValueList = ((ParsedStringTerms) bucket.getAggregations().get("attr_value_agg")).getBuckets().stream().map(item -> {
  69.             String attrValue = ((Terms.Bucket) item).getKeyAsString();
  70.             return attrValue;
  71.         }).collect(Collectors.toList());
  73.         attrVo.setAttrId(attrId);
  74.         attrVo.setAttrName(attrName);
  75.         attrVo.setAttrValue(attrValueList);
  77.         attrVoList.add(attrVo);
  78.     }
  79.     searchResult.setAttrs(attrVoList);
  81.     // 当前商品所涉及到的所有分类信息(从聚合中取出)
  82.     ParsedLongTerms catalog_agg = response.getAggregations().get("catalog_agg");
  83.     List<SearchResult.CatalogVo> catalogVoList = new ArrayList<>();
  84.     List<? extends Terms.Bucket> catalogList = catalog_agg.getBuckets();
  85.     for (Terms.Bucket bucket : catalogList) {
  86.         SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
  87.         // 得到分类id
  88.         String catalogId = bucket.getKeyAsString();
  89.         catalogVo.setCatalogId(Long.parseLong(catalogId));
  91.         // 得到分类名，子聚合
  92.         ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
  93.         List<? extends Terms.Bucket> catalogNameList = catalog_name_agg.getBuckets();
  94.         String catalogName = catalogNameList.get(0).getKeyAsString();
  95.         catalogVo.setCatalogName(catalogName);
  97.         catalogVoList.add(catalogVo);
  98.     }
  99.     searchResult.setCatalogs(catalogVoList);
  101.     // 封装分页信息
  102.     long total = hits.getTotalHits().value;
  103.     searchResult.setPageNum(searchParam.getPageNum());
  104.     searchResult.setTotal(total);
  105.     // 总页码（总页数 / 每页数）有余数加一
  106.     int totalPage = (int) total % EsConstant.PRODUCT_PAGESIZE == 1 ? (((int) total / EsConstant.PRODUCT_PAGESIZE) + 1) : (int) total / EsConstant.PRODUCT_PAGESIZE;
  107.     searchResult.setTotalPages(totalPage);
  109.     // 导航页码[1、2、3、4、5]
  110.     List<Integer> pageNavList = new ArrayList<>();
  111.     for (int i = 1; i <= totalPage; i++) {
  112.         pageNavList.add(i);
  113.     }
  114.     searchResult.setPageNavs(pageNavList);
  116.     // 构建面包屑导航功能
  117.     if (searchParam.getAttrs() != null && searchParam.getAttrs().size() > 0) {
  118.         List<SearchResult.NavVo> navVoList = searchParam.getAttrs().stream().map(attr -> {
  119.             SearchResult.NavVo navVo = new SearchResult.NavVo();
  120.             // attr=2_5寸:6寸(此时只有属性id和属性值)
  121.             String[] split = attr.split("_");
  122.             // 此时需要调用product服务查询属性名
  123.             navVo.setNavValue(split[1]);
  124.             R r = productFeignClient.attrInfo(Long.parseLong(split[0]));
  125.             searchResult.getAttrIds().add(Long.parseLong(split[0]));
  126.             if (r.getCode() == 0) {
  127.                 AttrResponseVo data = r.getData("attr", new TypeReference<AttrResponseVo>() {
  128.                 });
  129.                 // 设置属性名
  130.                 navVo.setNavName(data.getAttrName());
  131.             } else {
  132.                 navVo.setNavName(split[0]);
  133.             }
  135.             // 取消了这个面包屑以后，我们要跳转到那个地方.将请求地址的urL里面的当前置空拿到所有的查询条件，去掉当前等条件
  136.             // attrs=15_海思(Hisilicon)
  137.             String replace = replaceQueryString(searchParam, attr, "attrs");
  138.             navVo.setLink("http://search.gulimalls.com/list.html?" + replace);
  140.             return navVo;
  141.         }).collect(Collectors.toList());
  142.         searchResult.setNavs(navVoList);
  143.     }
  145.     if (!StringUtils.isEmpty(searchParam.getBrandId())) {
  146.         SearchResult.NavVo navVo = new SearchResult.NavVo();
  147.         navVo.setNavName("品牌");
  149.         // 远程查询所有品牌
  150.         R r = productFeignClient.getInfoByBrandIds(searchParam.getBrandId());
  151.         if (r.getCode() == 0) {
  152.             List<BrandVo> brandVo = r.getData("brand", new TypeReference<List<BrandVo>>() {
  153.             });
  154.             StringBuffer sb = new StringBuffer();
  155.             String replace = null;
  156.             for (BrandVo brand : brandVo) {
  157.                 sb.append(brand.getBrandName() + ";");
  158.                 replace = replaceQueryString(searchParam, brand.getBrandId().toString(), "brandId");
  159.             }
  160.             navVo.setNavValue(sb.toString());
  161.             navVo.setLink("http://search.gulimalls.com/list.html?" + replace);
  162.         }
  163.         searchResult.getNavs().add(navVo);
  164.     }
  166.     // TODO 分类的面包屑，不需要导航取消
  168.     return searchResult;
  169. }
  171. /**
  172.  * 替换地址字符串
  173.  *
  174.  * @param searchParam
  175.  * @param attr
  176.  * @return
  177.  */
  178. private String replaceQueryString(SearchParam searchParam, String attr, String key) {
  179.     // TODO 请求地址参数转义有问题
  180.     String encode = null;
  181.     try {
  182.         encode = URLEncoder.encode(attr, "UTF-8");
  183.         encode = encode.replace("+", "%20"); // 处理空格
  184.         encode = encode.replace("%28", "("); // 处理)
  185.         encode = encode.replace("%29", ")"); // 处理(
  186.     } catch (UnsupportedEncodingException e) {
  187.         e.printStackTrace();
  188.     }
  189.     String replace = searchParam.get_queryString().replace("&" + key + "=" + encode, " ");
  190.     return replace;
  191. }

Controller层

  1. @Controller
  2. public class SearchController {
  4.     @Autowired
  5.     private ElasticSearchService elasticSearchService;
  7.     @GetMapping("/list.html")
  8.     public String list(SearchParam searchParam, Model model, HttpServletRequest httpServletRequest) {
  9.         searchParam.set_queryString(httpServletRequest.getQueryString());   // 获取查询请求
  10.         SearchResult searchResult = elasticSearchService.search(searchParam);
  11.         model.addAttribute("result", searchResult);
  12.         return "list";
  13.     }
  15. }