微服务实战——ElasticSearch（搜索）

商品检索——ElasticSearch（搜索）

1. 检索条件&排序条件分析

• 全文检索：skuTitle -> keyword
• 排序：saleCount（销量）、hotScore（热度分）、skuPrice（价格）
• 过滤：hasStock、skuPrice区间、brandId、catalog3Id、attrs
• 聚合：attrs
• 完整查询参数
• keyword=小米&sort=saleCount_desc/asc&hasStock=0/1&skuPrice=400_1900&brandId=1&catalog3Id=1&attrs=1_3G:4G:5G&attrs=2_骁龙845&attrs=4_高清屏

2. DSL分析

检索时需要进行：模糊匹配、过滤（按照属性,分类，品牌，价格区间，库存）、排序、分页、高亮、聚合分析 。

GET gulimall_product/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "skuTitle": "华为"
          }
        }
      ],
      "filter": [
        {
          "term": {
            "catalogId": "225"
          }
        },
        {
          "terms": {
            "brandId": [
              "4"
            ]
          }
        },
        {
          "term": {
            "hasStock": "false"
          }
        },
        {
          "range": {
            "skuPrice": {
              "gte": 1000,
              "lte": 7000
            }
          }
        },
        {
          "nested": {
            "path": "attrs",
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "attrs.attrId": {
                        "value": "1"
                      }
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  },
  "sort": [
    {
      "skuPrice": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 5,
  "highlight": {
    "fields": {"skuTitle": {}},
    "pre_tags": "<b style='color:red'>", 
    "post_tags": "</b>"
  },
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brandId",
        "size": 10
      },
      "aggs": {
        "brandNameAgg": {
          "terms": {
            "field": "brandName",
            "size": 10
          }
        },

        "brandImgAgg": {
          "terms": {
            "field": "brandImg",
            "size": 10
          }
        }

      }
    },
    "catalogAgg":{
      "terms": {
        "field": "catalogId",
        "size": 10
      },
      "aggs": {
        "catalogNameAgg": {
          "terms": {
            "field": "catalogName",
            "size": 10
          }
        }
      }
    },
    "attrs":{
      "nested": {
        "path": "attrs"
      },
      "aggs": {
        "attrIdAgg": {
          "terms": {
            "field": "attrs.attrId",
            "size": 10
          },
          "aggs": {
            "attrNameAgg": {
              "terms": {
                "field": "attrs.attrName",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}

3. 检索代码

3.1. 请求参数和返回结果封装

package com.atguigu.gulimall.search.vo;

import lombok.Data;

import java.util.List;

/**
 * 封装页面所有可能传递过来的查询条件
 * catalog3Id=225&keyword=小米&sort=saleCount_asc
 */
@Data
public class SearchParam {
    private String keyword;//页面传递过来的全文匹配关键字

    private Long catalog3Id;//三级分类id

    /**
     * sort=saleCount_asc/desc
     * sort=skuPrice_asc/desc
     * sort=hotScore_asc/desc
     */
    private String sort;//排序条件

    /**
     * 好多的过滤条件
     * hasStock(是否有货)、skuPrice区间、brandId、catalog3Id、attrs
     * hasStock=0/1
     * skuPrice=1_500
     */
    private Integer hasStock;//是否只显示有货

    private String skuPrice;//价格区间查询

    private List<Long> brandId;//按照品牌进行查询，可以多选

    private List<String> attrs;//按照属性进行筛选

    private Integer pageNum = 1;//页码
}

package com.atguigu.gulimall.search.vo;
 
import com.atguigu.common.to.es.SkuEsModel;
import lombok.Data;
 
import java.util.List;
 
@Data
public class SearchResult {
 
    /**
     * 查询到的商品信息
     */
    private List<SkuEsModel> products;
 
    private Integer pageNum;//当前页码
 
    private Long total;//总记录数
 
    private Integer totalPages;//总页码
 
    private List<BrandVo> brands;//当前查询到的结果，所有涉及到的品牌
 
    private List<CatalogVo> catalogs;//当前查询到的结果，所有涉及到的分类
 
    private List<AttrVo> attrs;//当前查询到的结果，所有涉及到的属性
 
    //=====================以上是返给页面的信息==========================
 
    @Data
    public static class BrandVo{
        private Long brandId;
 
        private String brandName;
 
        private String brandImg;
    }
 
    @Data
    public static class CatalogVo{
        private Long catalogId;
 
        private String catalogName;
 
        private String brandImg;
    }
 
    @Data
    public static class AttrVo{
        private Long attrId;
 
        private String attrName;
 
        private List<String> attrValue;
    }
}

3.2. 业务逻辑

3.2.1. SearchController

    /**
     * 自动将页面提交过来的所有请求查询参数封装成指定的对象
     *
     * @return
     */
    @GetMapping("/list.html")
    public String listPage(SearchParam searchParam, Model model) {
        SearchResult result = mallSearchService.search(searchParam);
        System.out.println("====================" + result);
        model.addAttribute("result", result);
        return "list";
    }

3.2.2. MallSearchServiceImpl

@Override
    public SearchResult search(SearchParam param) {

        SearchResult result = null;

        // 1.准备检索请求
        SearchRequest searchRequest = buildSearchRequest(param);
        try {
            // 2.执行检索请求
            SearchResponse response = esClient.search(searchRequest, COMMON_OPTIONS);

            // 3.解析响应数据并封装需要返回的页面数据
            result = buildSearchResult(param, response);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 准备检索请求
     * @return
     */
    private SearchRequest buildSearchRequest(SearchParam param) {
        // 构建DSL语句
        SearchSourceBuilder builder = new SearchSourceBuilder();

        /**
         * 查询：模糊匹配，过滤(按照属性，分类，品牌，价格区间，库存)
         */
        // 1.构建bool-query
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

        // 1.1.bool-must 模糊匹配
        String keyword = param.getKeyword();
        if(StringUtils.isNotEmpty(keyword)){
            boolQuery.must(QueryBuilders.matchQuery("skuTitle", keyword));
        }

        // 1.2.bool-filter 过滤条件
        // 1.2.1.bool-filter-catalogId
        Long catalog3Id = param.getCatalog3Id();
        if(catalog3Id != null){
            boolQuery.filter(QueryBuilders.termQuery("catalogId", catalog3Id));
        }

        // 1.2.2.bool-filter-brandId
        List<Long> brandIds = param.getBrandId();
        if(brandIds != null && brandIds.size() > 0){
            boolQuery.filter(QueryBuilders.termsQuery("brandId", brandIds));
        }

        // 1.2.3.bool-filter-hasStock = 0/1
        Integer hasStock = param.getHasStock();
        if(hasStock != null){
            boolQuery.filter(QueryBuilders.termQuery("hasStock", hasStock));
        }

        // 1.2.4.bool-filter-skuPrice = 1_500/_500/500_
        String skuPrice = param.getSkuPrice();
        if(StringUtils.isNotEmpty(skuPrice)){
            // 将skuPrice以_分隔
            String[] split = skuPrice.split("_");
            String lt = null, gt = null;
            if(split.length == 2){
                // case1: 1_500
                lt = split[1];
                // case2: _500
                if(StringUtils.isNotBlank(split[0])){
                    gt = split[0];
                }
            }else {
                // case3: 500_
                gt = split[0];
            }
            // 构建rangeQueryBuilder
            RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("skuPrice");
            if(StringUtils.isNotEmpty(lt)){
                rangeQueryBuilder.lt(Long.parseLong(lt));
            }
            if(StringUtils.isNotEmpty(gt)){
                rangeQueryBuilder.gt(Long.parseLong(gt));
            }
            // 放入boolQuery
            boolQuery.filter(rangeQueryBuilder);
        }

        // 1.2.5.bool-filter-nested-attrs = 2_5寸:6寸&2_16G:8G
        List<String> attrs = param.getAttrs();
        if(attrs != null && attrs.size() > 0){
            for (String attrStr : attrs) {
                BoolQueryBuilder nestedBoolQuery = QueryBuilders.boolQuery();
                // attrStr = 2_5寸:6寸
                String[] s = attrStr.split("_");
                String attrId = s[0];

                // s[1] = 5寸:6寸
                String[] attrValues = s[1].split(":");
                nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
                nestedBoolQuery.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));

                // 每一个必须都得生成nested查询
                NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", nestedBoolQuery, ScoreMode.None);
                boolQuery.filter(nestedQuery);
            }
        }

        // 把以上所有查询条件封装
        builder.query(boolQuery);

        /**
         * 处理：排序，分页，高亮
         */
        // 2.1.排序：sort = hotScore_asc/desc
        String sort = param.getSort();
        if(StringUtils.isNotEmpty(sort)){
            String[] s = sort.split("_");
            builder.sort(s[0], s[1].equalsIgnoreCase("asc") ? SortOrder.ASC : SortOrder.DESC);
        }

        // 2.2.分页
        builder.from((param.getPageNum() - 1) * EsConstant.PRODUCT_PAGE_SIZE);
        builder.size(EsConstant.PRODUCT_PAGE_SIZE);

        // 2.3.高亮
        if(StringUtils.isNotEmpty(keyword)){
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("skuTitle");
            highlightBuilder.preTags("<b style='color:red'>");
            highlightBuilder.postTags("</b>");
            builder.highlighter(highlightBuilder);
        }

        /**
         * 响应：聚合分析
         */
        // 3.1.聚合brandAgg
        TermsAggregationBuilder brandAgg = AggregationBuilders.terms("brandAgg");
        brandAgg.field("brandId").size(50);
        // 3.1.1.子聚合brandNameAgg
        brandAgg.subAggregation(AggregationBuilders.terms("brandNameAgg").field("brandName").size(1));
        // 3.1.2.子聚合brandImgAgg
        brandAgg.subAggregation(AggregationBuilders.terms("brandImgAgg").field("brandImg").size(1));
        // 3.1.3.整合brandAgg
        builder.aggregation(brandAgg);

        // 3.2.聚合catalogAgg
        TermsAggregationBuilder catalogAgg = AggregationBuilders.terms("catalogAgg");
        // 3.2.1.聚合catalogId
        catalogAgg.field("catalogId").size(20);
        // 3.2.2.子聚合catalogNameAgg
        catalogAgg.subAggregation(AggregationBuilders.terms("catalogNameAgg").field("catalogName").size(1));
        // 3.2.3.整合catalogAgg
        builder.aggregation(catalogAgg);

        // 3.3.聚合attrsAgg
        TermsAggregationBuilder attrIdAgg = AggregationBuilders.terms("attrIdAgg").field("attrs.attrId");
        // attrIdAgg的子聚合attrNameAgg
        TermsAggregationBuilder attrNameAgg = AggregationBuilders.terms("attrNameAgg").field("attrs.attrName").size(1);
        attrIdAgg.subAggregation(attrNameAgg);

        // attrIdAgg的子聚合attrValueAgg
        TermsAggregationBuilder attrValueAgg = AggregationBuilders.terms("attrValueAgg").field("attrs.attrValue").size(50);
        attrIdAgg.subAggregation(attrValueAgg);

        // attrsAgg的子聚合attrIdAgg
        NestedAggregationBuilder attrsAgg = AggregationBuilders.nested("attrsAgg", "attrs");
        attrsAgg.subAggregation(attrIdAgg);

        // 整合attrsAgg
        builder.aggregation(attrsAgg);

        System.out.println("DSL：" + builder.toString());

        SearchRequest request = new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX}, builder);
        return request;
    }

    /**
     * 构建页面响应数据
     * @param response
     * @return
     */
    private SearchResult buildSearchResult(SearchParam param, SearchResponse response) {
        SearchResult result = new SearchResult();

        // 1.products
        SearchHits hits = response.getHits();
        SearchHit[] searchHits = hits.getHits();
        List<SkuEsModel> esModels = Collections.emptyList();
        if (searchHits != null && searchHits.length > 0) {
            esModels = Arrays.stream(searchHits).map(searchHit -> {
                String source = searchHit.getSourceAsString();
                SkuEsModel esModel = JSON.parseObject(source, SkuEsModel.class);
                if (StringUtils.isNotEmpty(param.getKeyword())) {
                    HighlightField skuTitle = searchHit.getHighlightFields().get("skuTitle");
                    String string = skuTitle.getFragments()[0].string();
                    esModel.setSkuTitle(string);
                }
                return esModel;
            }).collect(Collectors.toList());
        }
        result.setProducts(esModels);

        Aggregations aggregations = response.getAggregations();
        // 2.brands
        ParsedLongTerms brandAgg = aggregations.get("brandAgg");
        List<BrandVo> brandVos = brandAgg.getBuckets().stream().map(bucket -> {
            BrandVo brandVo = new BrandVo();
            // brandId
            brandVo.setBrandId(bucket.getKeyAsNumber().longValue());

            Aggregations bucketAggs = bucket.getAggregations();
            // brandName
            ParsedStringTerms brandName = bucketAggs.get("brandNameAgg");
            brandVo.setBrandName(brandName.getBuckets().get(0).getKeyAsString());

            // brandImg
            ParsedStringTerms brandImg = bucketAggs.get("brandImgAgg");
            brandVo.setBrandImg(brandImg.getBuckets().get(0).getKeyAsString());

            return brandVo;
        }).collect(Collectors.toList());
        result.setBrands(brandVos);

        // 3.catalogs
        ParsedLongTerms catalogAgg = aggregations.get("catalogAgg");
        List<CatalogVo> catalogVos = catalogAgg.getBuckets().stream().map(bucket -> {
            CatalogVo catalogVo = new CatalogVo();
            catalogVo.setCatalogId(Long.parseLong(bucket.getKeyAsString()));
            ParsedStringTerms catalogNameAgg = bucket.getAggregations().get("catalogNameAgg");
            catalogVo.setCatalogName(catalogNameAgg.getBuckets().get(0).getKeyAsString());
            return catalogVo;
        }).collect(Collectors.toList());
        result.setCatalogs(catalogVos);

        // 4.attrs
        ParsedNested attrsAgg = aggregations.get("attrsAgg");
        ParsedLongTerms attrIdAgg = attrsAgg.getAggregations().get("attrIdAgg");
        List<AttrVo> attrVos = attrIdAgg.getBuckets().stream().map(bucket -> {
            AttrVo attrVo = new AttrVo();
            // attrId
            attrVo.setAttrId(Long.parseLong(bucket.getKeyAsString()));

            Aggregations bucketAggregations = bucket.getAggregations();
            // attrName
            ParsedStringTerms attrNameAgg = bucketAggregations.get("attrNameAgg");
            attrVo.setAttrName(attrNameAgg.getBuckets().get(0).getKeyAsString());
            // attrValues
            ParsedStringTerms attrValueAgg = bucketAggregations.get("attrValueAgg");
            List<String> attrValue = attrValueAgg.getBuckets().stream()
                    .map(MultiBucketsAggregation.Bucket::getKeyAsString).collect(Collectors.toList());
            attrVo.setAttrValues(attrValue);

            return attrVo;
        }).collect(Collectors.toList());
        result.setAttrs(attrVos);

        // 5.分页信息：pageNum, total, totalPages
        long total = hits.getTotalHits().value;
        result.setTotal(total);
        // 计算totalPages
        int totalPages = (int) (total / EsConstant.PRODUCT_PAGE_SIZE + (total % EsConstant.PRODUCT_PAGE_SIZE == 0 ? 0 : 1));
        result.setTotalPages(totalPages);
        result.setPageNum(param.getPageNum());

        // 6.面包屑导航功能
        List<String> _attrs = param.getAttrs();
        if(_attrs != null && _attrs.size() > 0){
            List<NavVo> navVos = _attrs.stream().map(attr -> {
                // attrs = 2_5寸:6存
                String[] split = attr.split("_");
                // 设置属性值
                NavVo navVo = new NavVo();
                navVo.setNavValue(split[1]);
                // 远程调用通过attrId获取attrName
                try {
                    R r = productFeignService.getAttrsInfo(Long.parseLong(split[0]));
                    result.getAttrIds().add(Long.valueOf(split[0]));
                    if(r.getCode() == 0){
                        AttrResponseVo attrResponseVo = r.getData("attr", new TypeReference<AttrResponseVo>() {
                        });
                        navVo.setNavName(attrResponseVo.getAttrName());
                    }else {
                        navVo.setNavName(split[0]);
                    }
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
                // 取消面包屑后，跳转到取消后的地方，将原url改为目标url
                String replace = replaceQueryString(param, attr, "attrs");
                navVo.setLink("http://search.gulimall.com/list.html" + (replace.isEmpty() ? "" : "?" + replace));
                return navVo;
            }).collect(Collectors.toList());
            result.setNavs(navVos);
        }

        // 品牌 条件筛选
        List<Long> brandIds = param.getBrandId();
        if(brandIds != null && brandIds.size() > 0){
            List<NavVo> navs = result.getNavs();
            NavVo navVo = new NavVo();
            navVo.setNavName("品牌");
            // 远程查询所有品牌
            R r = productFeignService.brandsInfo(brandIds);
            if(r.getCode() == 0){
                List<com.cwh.search.vo.BrandVo> brand = r.getData("brand", new TypeReference<List<com.cwh.search.vo.BrandVo>>() {
                });
                StringBuffer buffer = new StringBuffer();
                String replace = "";
                for (com.cwh.search.vo.BrandVo brandVo : brand) {
                    buffer.append(brandVo.getName() + ";");
                    replace = replaceQueryString(param, brandVo.getBrandId().toString(), "brandId");
                }
                navVo.setNavValue(buffer.toString());
                navVo.setLink("http://search.gulimall.com/list.html?" + (replace.isEmpty() ? "" : "?" + replace));
            }
            navs.add(navVo);
        }

        // TODO 分类 条件筛选

        return result;
    }

    private String replaceQueryString(SearchParam param, String value, String key) {
        String queryString = param.get_queryString();
        String encode = null;
        try {
            encode = URLEncoder.encode(value, "UTF-8");
            encode = encode.replace("+", "%20");//浏览器对空格编码和java不一样
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return queryString.replace("&" + key + "=" + encode, "");
    }