【业务功能篇90】微服务-springcloud-检索服务-ElasticSearch实战运用-DSL语句

川长思鸟来 2024-03-24 23:49 69阅读 0赞

## 商城检索服务 ##

![image.png][]

### 1.检索页面的搭建 ###

商品检索页面我们放在search服务中处理，首页我们需要在mall-search服务中支持Thymeleaf。添加对应的依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>

然后我们拷贝模板文件到template目录下，然后不要忘记添加Thymeleaf的名称空间

![image.png][image.png 1]

需要把相关的静态资源文件拷贝到Nginx服务中。目录结构是：/mydata/nginx/html/static/search/

![image.png][image.png 2]

我们需要修改index.html页面中的资源的路径

![image.png][image.png 3]

然后我们要通过 `msb.search.com` 来访问我们的检索服务，那么就需要设置对应的host文件

![image.png][image.png 4]

然后我们就需要修改Nginx的配置

![image.png][image.png 5]

这时我需要在修改网关的服务，根据我们的域名访问，那么需要网关路由到我们的检索服务中

![image.png][image.png 6]

然后我们就可以重启相关的服务 ，来测试了

![image.png][image.png 7]

### 2.检索服务 ###

#### 2.1 创建对应VO ####

我们需要检索数据库中的相关的商品信息，那么我们就需要提交相关的检索条件，为了统一的管理提交的数据，我们需要创建一个VO来封装信息。

/**
     * 封装页面所有可能提交的查询条件
     */
    @Data
    public class SearchParam {
        
    
        private String keyword; // 页面传递的查询全文匹配的关键字
        private Long catalog3Id;// 需要根据分类查询的编号
    
        /**
         * sort=salaCount_asc/desc
         * sort=skuPrice_asc/desc
         * sort=hotScore_asc/desc
         */
        private String sort; // 排序条件
        // 查询的筛选条件  hasStock=0/1;
        private Integer hasStock ; // 是否只显示有货
        // brandId=1&brandId=2
        private List<Long> brandId; // 按照品牌来查询，可以多选
        // skuPrice=200_300
        // skuPrice=_300
        // skuPrice=200_
        private String skuPrice; // 价格区间查询
        // 不同的属性  attrs:1_苹果:6.5寸
        private List<String> attrs; // 按照属性信息进行筛选
        private Integer pageNum; // 页码
    
    
    }

然后就是检索后的数据我们需要封装的VO对象，定义如下：

package com.msb.mall.mallsearch.vo;
    
    import com.msb.common.dto.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<AttrVo> attrs;
    
        // 当前查询的所有商品涉及到的所有的类别信息
        private List<CatalogVO> catalogs;
    
    
        @Data
        public static class CatalogVO{
        
            private Long catalogId;
            private String catalogName;
        }
    
        /**
         * 品牌的相关信息
         */
        @Data
        public static class BrandVO{
        
            private Long brandId; // 品牌的编号
            private String brandName; // 品牌的名称
            private String brandImg; // 品牌的图片
        }
    
        @Data
        public static class AttrVo{
        
            private Long attrId; // 属性的编号
            private String attrName; // 属性的名称
            private List<String> attrValue; // 属性的值
        }
    
    }

#### 2.2 构建查询DSL语句 ####

我们需要根据基本的检索条件来封装对应的DSL语句

*  查询关键字 模糊匹配
 *  过滤(分类，品牌，属性，价格区间，库存…)
 *  排序
 *  分页
 *  高亮

GET /product/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
        
              "match": {
        
                "subTitle": "华为"
              }
            }
          ],
          "filter": [
            {
        
              "term": {
        
                "catalogId": "225"
              }
            },
            {
        
              "terms": {
        
                "brandId": [
                  "13",
                  "16",
                  "14"
                ]
              }
            },
            {
        
              "range": {
        
                "skuPrice": {
        
                  "gte": 10,
                  "lte": 12000
                }
              }
            },
            {
        
              "nested": {
        
                "path": "attrs",
                "query": {
        
                  "bool": {
        
                    "must": [
                      {
        
                        "term": {
        
                          "attrs.attrId": {
        
                            "value": "9"
                          }
                        }
                      },
                      {
        
                        "terms": {
        
                          "attrs.attrValue": [
                            "12",
                            "08",
                            "11"
                          ]
                        }
                      }
                    ]
                  }
                }
              }
            }
          ]
        }
      },"sort": [
        {
        
          "skuPrice": {
        
            "order": "desc"
          }
        }
      ],"from": 0
      ,"size": 20
      ,"highlight": {
        
        "fields": {
        "subTitle": {
        }}
        ,"pre_tags": "<b style='color:red'>"
        ,"post_tags": "<b>"
      }
    }

#### 2.3 构建SearchRequest对象 ####

根据客户端提交的检索的信息，我们需要封装为对应的SearchRequest对象，然后通过ES的API来检索数据。

/**
         * 构建检索的请求
         * 模糊匹配，关键字匹配
         * 过滤(类别，品牌，属性，价格区间，库存)
         * 排序
         * 分页
         * 高亮
         * 聚合分析
         * @param param
         * @return
         */
        private SearchRequest buildSearchRequest(SearchParam param) {
            SearchRequest searchRequest = new SearchRequest();
            searchRequest.indices(ESConstant.PRODUCT_INDEX);
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            // 构建具体的检索的条件
            // 1.构建bool查询
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            // 1.1 关键字的条件
            if(!StringUtils.isEmpty(param.getKeyword())){
                boolQuery.must(QueryBuilders.matchQuery("subTitle",param.getKeyword()));
            }
            // 1.2 类别的检索条件
            if(param.getCatalog3Id() != null){
                boolQuery.filter(QueryBuilders.termQuery("catalogId",param.getCatalog3Id()));
            }
            // 1.3 品牌的检索条件
            if(param.getBrandId() != null && param.getBrandId().size() > 0){
                boolQuery.filter(QueryBuilders.termsQuery("brandId",param.getBrandId()));
            }
            // 1.4 是否有库存
            if(param.getHasStock() != null){
                boolQuery.filter(QueryBuilders.termQuery("hasStock",param.getHasStock() == 1));
            }
            // 1.5 根据价格区间来检索
            if(!StringUtils.isEmpty(param.getSkuPrice())){
                String[] msg = param.getSkuPrice().split("_");
                RangeQueryBuilder skuPrice = QueryBuilders.rangeQuery("skuPrice");
                if(msg.length == 2){
                    // 说明是 200_300
                    skuPrice.gte(msg[0]);
                    skuPrice.lte(msg[1]);
                }else if(msg.length == 1){
                    // 说明是 _300  200_
                    if(param.getSkuPrice().endsWith("_")){
                        // 说明是 200_
                        skuPrice.gte(msg[0]);
                    }
                    if(param.getSkuPrice().startsWith("_")){
                        // 说明是 _300
                        skuPrice.lte(msg[0]);
                    }
                }
                boolQuery.filter(skuPrice);
            }
            // 1.6 属性的检索条件 attrs=20_8英寸:10英寸&attrs=19_64GB:32GB
            if(param.getAttrs() != null && param.getAttrs().size() > 0){
                for (String attrStr : param.getAttrs()) {
                    BoolQueryBuilder boolNestedQuery = QueryBuilders.boolQuery();
                    // attrs=19_64GB:32GB 我们首先需要根据 _ 做分割
                    String[] attrStrArray = attrStr.split("_");
                    // 属性的编号
                    String attrId = attrStrArray[0];
                    // 64GB:32GB  获取属性的值
                    String[] values = attrStrArray[1].split(":");
                    // 拼接组合条件
                    boolNestedQuery.must(QueryBuilders.termQuery("attrs.attrId",attrId));
                    boolNestedQuery.must(QueryBuilders.termsQuery("attrs.attrValue",values));
    
                    NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", boolNestedQuery, ScoreMode.None);
                    boolQuery.filter(nestedQuery);
                }
            }
            sourceBuilder.query(boolQuery);
    
            // 2.排序
            if(!StringUtils.isEmpty(param.getSort())){
                // sort=salaCount_asc/desc
                String[] s = param.getSort().split("_");
                SortOrder order = s[1].equalsIgnoreCase("asc")?SortOrder.ASC:SortOrder.DESC;
                sourceBuilder.sort(s[0], order);
            }
            // 3.处理分页
            // Integer pageNum; // 页码
            if(param.getPageNum() != null){
                // 需要做分页处理 pageSize = 5
                // pageNum:1 from:0  [0,1,2,3,4]
                // pageNum:2 from:5 [5,6,7,8,9]
                // from = ( pageNum - 1 ) * pageSize
                sourceBuilder.from( (param.getPageNum() - 1 ) * ESConstant.PRODUCT_PAGESIZE);
                sourceBuilder.size(ESConstant.PRODUCT_PAGESIZE);
            }
    
            // 4. 设置高亮
            if(!StringUtils.isEmpty(param.getKeyword())){
                // 如果有根据关键字查询那么我们才需要高亮设置
                HighlightBuilder highlightBuilder = new HighlightBuilder();
                highlightBuilder.field("subTitle");
                highlightBuilder.preTags("<b style='color:red'>");
                highlightBuilder.postTags("</b>");
                sourceBuilder.highlighter(highlightBuilder);
            }
    
            // 5.聚合运算
            // 5.1 品牌的聚合
            TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg");
            brand_agg.field("brandId");
            brand_agg.size(50);
            // 品牌的子聚合
            brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(10));
            brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(10));
            sourceBuilder.aggregation(brand_agg);
    
            // 5.2 类别的聚合
            TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg");
            catalog_agg.field("catalogId");
            catalog_agg.size(10);
            // 类别的子聚合
            catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(10));
            sourceBuilder.aggregation(catalog_agg);
    
            // 5.3 属性的聚合
            NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
            // 属性id聚合
            TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg");
            attr_id_agg.field("attrs.attrId");
            attr_id_agg.size(10);
            // 属性id下的子聚合 属性名称和属性值
            attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(10));
            attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(10));
            attr_agg.subAggregation(attr_id_agg);
            sourceBuilder.aggregation(attr_agg);
    
            System.out.println(sourceBuilder.toString());
            searchRequest.source(sourceBuilder);
    
            return searchRequest;
        }

#### 2.4 构建SearchResult对象 ####

当我们通过封装的SearchRequest对象从ES中检索出了相关的信息后，我们需要将返回的SearchResponse对象封装为前端接收的SearchResult对象。

*  所有的满足条件的商品
 *  分页相关的信息
 *  当前商品涉及的品牌信息
 *  当前商品涉及的类别信息
 *  当前商品涉及的属性信息

/**
         * 根据检索的结果解析封装为SearchResult对象
         * @param response
         * @return
         */
        private SearchResult buildSearchResult(SearchResponse response,SearchParam param){
            SearchResult result = new SearchResult();
            SearchHits hits = response.getHits();
            // 1.检索的所有商品信息
            SearchHit[] products = hits.getHits();
            List<SkuESModel> esModels = new ArrayList<>();
            if(products != null && products.length > 0){
                for (SearchHit product : products) {
                    String sourceAsString = product.getSourceAsString();
                    // 把json格式的字符串通过fastjson转换为SkuESModel对象
                    SkuESModel model = JSON.parseObject(sourceAsString, SkuESModel.class);
                    if(!StringUtils.isEmpty(param.getKeyword())){
                        // 我们需要设置高亮
                        HighlightField subTitle = product.getHighlightFields().get("subTitle");
                        String subTitleHighlight = subTitle.getFragments()[0].string();
                        model.setSubTitle(subTitleHighlight); // 设置高亮
                    }
                    esModels.add(model);
                }
            }
            result.setProducts(esModels);
            Aggregations aggregations = response.getAggregations();
            // 2.当前商品所涉及到的所有的品牌
            ParsedLongTerms brand_agg = aggregations.get("brand_agg");
            List<? extends Terms.Bucket> buckets = brand_agg.getBuckets();
            // 存储所有品牌的容器
            List<SearchResult.BrandVO> brandVOS = new ArrayList<>();
            if(buckets!=null && buckets.size() > 0){
                for (Terms.Bucket bucket : buckets) {
                    SearchResult.BrandVO brandVO = new SearchResult.BrandVO();
                    // 获取品牌的key
                    String keyAsString = bucket.getKeyAsString();
                    brandVO.setBrandId(Long.parseLong(keyAsString)); // 设置品牌的编号
                    // 然后我们需要获取品牌的名称和图片的地址
                    ParsedStringTerms brand_img_agg = bucket.getAggregations().get("brand_img_agg");
                    List<? extends Terms.Bucket> bucketsImg = brand_img_agg.getBuckets();
                    if(bucketsImg != null && bucketsImg.size() > 0){
                        String img = bucketsImg.get(0).getKeyAsString();
                        brandVO.setBrandImg(img);
                    }
                    // 获取品牌名称的信息
                    ParsedStringTerms brand_name_agg = bucket.getAggregations().get("brand_name_agg");
                    String breadName = brand_name_agg.getBuckets().get(0).getKeyAsString();
                    brandVO.setBrandName(breadName);
    
                    brandVOS.add(brandVO);
                }
            }
            result.setBrands(brandVOS);
            // 3.当前商品涉及到的所有的类别信息
            ParsedLongTerms catalog_agg = aggregations.get("catalog_agg");
            List<? extends Terms.Bucket> bucketsCatalogs = catalog_agg.getBuckets();
            // 创建一个保存所有类别的容器
            List<SearchResult.CatalogVO> catalogVOS = new ArrayList<>();
            if(bucketsCatalogs != null && bucketsCatalogs.size() > 0){
                for (Terms.Bucket bucket : bucketsCatalogs) {
                    SearchResult.CatalogVO catalogVO = new SearchResult.CatalogVO();
                    String keyAsString = bucket.getKeyAsString(); // 获取类别的编号
                    catalogVO.setCatalogId(Long.parseLong(keyAsString));
                    // 获取类别的名称
                    ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
                    String catalogName = catalog_name_agg.getBuckets().get(0).getKeyAsString();
                    catalogVO.setCatalogName(catalogName);
                    catalogVOS.add(catalogVO);
                }
            }
            result.setCatalogs(catalogVOS);
            // 4.当前商品涉及到的所有的属性信息
            ParsedNested attr_agg = aggregations.get("attr_agg");
            ParsedLongTerms attr_id_agg = attr_agg.getAggregations().get("attr_id_agg");
            List<? extends Terms.Bucket> bucketsAttr = attr_id_agg.getBuckets();
            List<SearchResult.AttrVo > attrVos = new ArrayList<>();
            if(bucketsAttr != null && bucketsAttr.size() > 0){
                for (Terms.Bucket bucket : bucketsAttr) {
                    SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
                    // 获取属性的编号
                    String keyAsString = bucket.getKeyAsString();
                    attrVo.setAttrId(Long.parseLong(keyAsString));
                    // 又得分别获取 属性的名称 和 属性的值
                    ParsedStringTerms attr_name_agg = bucket.getAggregations().get("attr_name_agg");
                    String attrName = attr_name_agg.getBuckets().get(0).getKeyAsString(); // 属性的名称
                    attrVo.setAttrName(attrName);
                    ParsedStringTerms attr_value_agg = bucket.getAggregations().get("attr_value_agg");
                    if(attr_value_agg.getBuckets() != null && attr_value_agg.getBuckets().size() > 0 ){
                        List<String> values = attr_value_agg.getBuckets().stream().map(item -> {
                            String keyAsString1 = item.getKeyAsString();
                            return keyAsString1;
                        }).collect(Collectors.toList());
                        attrVo.setAttrValue(values);
                    }
                    attrVos.add(attrVo);
                }
    
            }
            result.setAttrs(attrVos);
            // 5. 分页信息  当前页 总的记录数  总页数
            long total = hits.getTotalHits().value;
            result.setTotal(total);// 设置总记录数  6 /5  1+1
            result.setPageNum(param.getPageNum()); // 设置当前页
            long totalPage = total % ESConstant.PRODUCT_PAGESIZE == 0 ? total / ESConstant.PRODUCT_PAGESIZE : (total / ESConstant.PRODUCT_PAGESIZE + 1);
            result.setTotalPages((int)totalPage); // 设置总的页数
            return result;
        }

[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/7b3650913a9b49128ae60122221f1050.png
[image.png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/2d715eb29600428c84a6f037452404aa.png
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/962d360d14734cc4b21484488db2fa6e.png
[image.png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/db869fb316e641b0870d860bc04e315a.png
[image.png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c6ad167a636b45f1a7bed4c8a3deb382.png
[image.png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/15df7a494b9649a383e8f9145375d281.png
[image.png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/82e9332a0487474294177b58f603bc25.png
[image.png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/79d483c2bd9c45bfb72169ceef280ca1.png