新版本踩坑记录：SpringBoot2.3.x整合ElasticSearch7.6.x（ElasticsearchRestTemplate）包含类型转换踩坑_search(querybuilder)' is deprecated

使用ElasticSearch7.6.x 的时候，和7之前的版本有很大的不同，下面列举了一些踩坑记录：eg ：StringTerms 类型转换失败问题，聚合查询自动拆分搜索关键字问题…等等（之后出现问题还会回头补坑）

聚合查询语句

# 聚合查询：match_phrase ---> 华为   二字不可以分开
GET /skuinfo/_search
{
  "query": {
    "match_phrase": {
      "name": "华为"
    }
  },
  "aggs": {
    "categoryName": {
      "terms": {
        "field": "categoryName.keyword"
      }
    }
  }
}

# 聚合查询：match ---> 华   为   二字可以分开
GET /skuinfo/_search
{
  "query": {
    "match": {
      "name": "华为"
    }
  },
  "aggs": {
    "categoryName": {
      "terms": {
        "field": "categoryName.keyword"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

SpringBoot整合使用

/**
 * @Auther: csp1999
 * @Date: 2021/01/18/16:04
 * @Description: 搜索微服务SkuService接口实现类
 */
@Service
public class SkuEsServiceImpl implements SkuEsService {

    @Autowired
    private SkuEsMapper skuEsMapper;

    @Autowired
    private SkuFeign skuFeign;

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    @Autowired
    private RestHighLevelClient restHighLevelClient;

//    @Autowired
//    @Qualifier("restHighLevelClient")
//    private RestHighLevelClient client;

    /**
     * 根据条件搜索：多条件搜索
     *
     * @param searchParamMap
     * @return
     */
    @Override
    public Map<String, Object> search(Map<String, String> searchParamMap) {

        // 构建搜索条件：搜索条件构造器
        NativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder();
        if (searchParamMap != null && searchParamMap.size() > 0) {
            // 根据关键词搜索
            String keywords = searchParamMap.get("keywords");

            if (StringUtils.isEmpty(keywords)) {
                keywords = "华为";// 赋值一个keywords默认的值
            }

            // 添加聚合查询操作：相当于sql的分组查询（去重复）--->SELECT category_name FROM `tb_sku` WHERE `name` LIKE '%华为%' GROUP BY category_name
            // 得到分类名称数据集合：
            //              category_name
            //              交换机
            //              手机
            searchQueryBuilder.addAggregation(
                    // AggregationBuilders聚合条件构造器
                    // terms("categoryName")：给列取别名
                    // field("categoryName.keyword")：
                    //      categoryName字段名称
                    //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                    // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                    // size 指定查询结果的数量 默认是10个
                    AggregationBuilders
                            .terms("categoryName")
                            .field("categoryName.keyword")
                            .size(50)
            );

            // 如果关键词不为空，则搜索关键词数据
            if (!StringUtils.isEmpty(keywords)) {
                searchQueryBuilder.withQuery(
                        QueryBuilders.matchPhraseQuery("name", keywords)
                        // 不能使用：QueryBuilders.matchQuery("name", keywords) ，这样会导致：
                        // 搜索华为 ---> 华    为 二字可以拆分查询，而matchPhraseQuery 是不可以拆分的
                );
            }

            // 分页：默认第1页的50条数据
            searchQueryBuilder.withPageable(PageRequest.of(0, 50));
        }

        // 搜索条件构造器构建：NativeSearchQuery
        NativeSearchQuery searchQuery = searchQueryBuilder.build();

        // 执行搜索，获取封装响应数据结果的SearchHits集合
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(searchQuery, SkuInfo.class);

        /*
         * 获取聚合后的以categoryName分组的分类名称集合
         * searchHits.getAggregations() 获取的是Aggregations集合
         * get("skuCategoryGroup") 获取指定categoryName域的分类名称集合数据 eg:[手机,家用电器,手机配件]
         * Aggregation ---> StringTerms 转换成子类
         */
        // Terms ：注意这里是巨型踩坑，在ES7之前可以使用StringTerms，但是7之后，如果出现类型转换错误，建议使用Terms替代StringTerms
        Terms terms = searchHits.getAggregations().get("categoryName");
        // 获取分类名称集合
        List<String> categoryList = this.getStringsCategoryList(terms);


        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> searchPageFor = SearchHitSupport.searchPageFor(searchHits, searchQuery.getPageable());

        // 总记录数
        long totalElements = searchPageFor.getTotalElements();
        // 总页数
        int totalPages = searchPageFor.getTotalPages();
        // 当前页数
        int currentPage = searchPageFor.getPageable().getPageNumber();
        // 当前页总记录数
        int currentPageRows = searchPageFor.getPageable().getPageSize();

        // 获取所需SkuInfo集合数据内容
        List<SearchHit<SkuInfo>> content = searchPageFor.getContent();

        // 解析并再封装数据
        // 封装一个Map 存储所有数据，并返回
        HashMap<String, Object> resultMap = new HashMap<>();
        resultMap.put("totalPage", totalPages);// 总页数
        resultMap.put("total", totalElements);// 总记录数
        resultMap.put("currentPage", currentPage);// 当前页
        resultMap.put("currentPageRows", currentPageRows);// 当前页总记录数
        resultMap.put("categoryList", categoryList);// 商品分类名称数据集合
        resultMap.put("rows", content);// 商品SkuInfo数据集合

        return resultMap;
    }

    /**
     * 从StringTerms中获取分类名称集合categoryList
     **/
    private List<String> getStringsCategoryList(Terms terms) {
        List<String> categoryList = new ArrayList<>();

        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                String keyAsString = bucket.getKeyAsString();// 分组的值（分类名称）
                categoryList.add(keyAsString);
            }
        }
        return categoryList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

添加上聚合，高亮，过滤搜索的完整代码

/**
 * @Auther: csp1999
 * @Date: 2021/01/18/16:04
 * @Description: 搜索微服务SkuService接口实现类
 */
@Service
public class SkuEsServiceImpl implements SkuEsService {

    @Autowired
    private SkuEsMapper skuEsMapper;

    @Autowired
    private SkuFeign skuFeign;

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 将数据库中的全部Sku数据导入ES中
     */
    @Override
    public void importDataToElasticSearch(int start, int end) {
        // 调用Feign,查询List<Sku>
        Result<List<Sku>> skuListResult = skuFeign.findAll(start, end);

        // 将List<Sku>转成List<SkuInfo>
        // JSON.toJSONString(skuListResult.getData()): 将skuListResult中的List<Sku>转成json格式
        // JSON.parseArray(): 将json格式的List<Sku>转成List<SkuInfo>集合
        List<SkuInfo> skuInfoList = JSON.parseArray(JSON.toJSONString(skuListResult.getData()), SkuInfo.class);

        // 遍历当前skuInfoList
        for (SkuInfo skuInfo : skuInfoList) {

            // 获取spec(String类型的Map数据) -> 将其转成 Map类型 ->{'颜色': '梵高星空典藏版', '版本': '8GB+128GB'}
            Map<String, Object> specMap = JSON.parseObject(skuInfo.getSpec(), Map.class);
            // 给skuInfo中的specMap属性赋值
            // 当前Map<String,Object> 的值Object会被作为Sku对象该域（key）对应的值
            skuInfo.setSpecMap(specMap);
        }

        // 调用Mapper 实现数据批量导入
        skuEsMapper.saveAll(skuInfoList);
    }

    /**
     * 根据条件搜索：多条件搜索
     *
//     * @param searchParamMap
     * @return
     */
    @Deprecated // 已被优化,不再使用该方法，其功能被search(Map<String, String> searchParamMap)方法替代
    public Map<String, Object> search2(Map<String, String> searchParamMap) {

        // 1.构建搜索条件：搜索条件构造器(后期有多个检索条件，专门封装一个方法)
        NativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder();
//        if (searchParamMap != null && searchParamMap.size() > 0) {
        // 根据关键词搜索
        String keywords = searchParamMap.get("keywords");

        if (StringUtils.isEmpty(keywords)) {
            keywords = "手机";// 赋值一个keywords默认的值
        }

        // 如果关键词不为空，则搜索关键词数据
        if (!StringUtils.isEmpty(keywords)) {
            searchQueryBuilder.withQuery(
                    QueryBuilders.matchPhraseQuery("name", keywords)
                    // 多个字段匹配搜索关键词
//                    QueryBuilders.multiMatchQuery(keywords, "name.keyword", "categoryName.keyword", "brandNam.keyword")
                    // 不能使用：QueryBuilders.matchQuery("name", keywords) ，这样会导致：
                    // 搜索华为 ---> 华    为 二字可以拆分查询，而matchPhraseQuery 是不可以拆分的
            );
        }

        // 根据分类名称对结果集进行分组：[手机，交换机]
        // 添加聚合查询操作：相当于sql的分组查询（去重复）--->SELECT category_name FROM `tb_sku` WHERE `name` LIKE '%华为%' GROUP BY category_name
        // 得到分类名称数据集合：
        //              category_name
        //              交换机
        //              手机
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("categoryName")：给列取别名
                // field("categoryName.keyword")：
                //      categoryName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("categoryName")
                        .field("categoryName.keyword")
                        .size(100)
        );

        // 根据品牌名称对结果集分组： [华为，小米，中心，苹果]
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("brandName")：给列取别名
                // field("brandName.keyword")：
                //      brandName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("brandName")
                        .field("brandName.keyword")
                        .size(100)
        );

        // 根据品牌名称对结果集分组： [华为，小米，中心，苹果]
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("brandName")：给列取别名
                // field("brandName.keyword")：
                //      brandName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("spec")
                        .field("spec.keyword")
                        .size(100)
        );

        // 分页：默认第1页的100条数据
        searchQueryBuilder.withPageable(PageRequest.of(0, 100));
//    }

        //========================过滤查询 开始=====================================
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        if (searchParamMap != null) {
            for (String key : searchParamMap.keySet()) {//{ brand:"",category:"",spec_网络:"电信4G"}
                if (key.startsWith("spec_")) {
                    //截取规格的名称
                    boolQueryBuilder.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", searchParamMap.get(key)));
                }
            }
        }

        String category = searchParamMap.get("category");
        if (!StringUtils.isEmpty(category)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("categoryName", category));
        }

        String brand = searchParamMap.get("brand");
        if (!StringUtils.isEmpty(brand)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("brandName", brand));
        }

        // 过滤查询
        searchQueryBuilder.withFilter(boolQueryBuilder);
        //========================过滤查询 结束=====================================

        // 搜索条件构造器构建：NativeSearchQuery
        NativeSearchQuery searchQuery = searchQueryBuilder.build();

        // 执行搜索，获取封装响应数据结果的SearchHits集合
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(searchQuery, SkuInfo.class);
        /*
         * 获取聚合后的以categoryName分组的分类名称集合
         * searchHits.getAggregations() 获取的是Aggregations集合
         * get("skuCategoryGroup") 获取指定categoryName域的分类名称集合数据 eg:[手机,家用电器,手机配件]
         * Aggregation ---> StringTerms 转换成子类
         */
        // 从Terms中获取分类名称集合
        // 注意:当用户选择(点击)了某个分类,将该分类作为搜索条件,这种情况下则不需要再对分类进行分组搜索,因为分组搜索的数据是用于显示分类搜索条件的,不需要重复展示
        // Terms ：注意这里是巨型踩坑，在ES7之前可以使用StringTerms，但是7之后，如果出现类型转换错误，建议使用Terms替代StringTerms
        // searchParamMap -> brand
        Terms categoryTerms = searchHits.getAggregations().get("categoryName");
        List<String> categoryList = this.getResultListByTerms(categoryTerms);

        // 从Terms中获取品牌名称集合
        // 注意:当用户选择(点击)了某个品牌,将该品牌作为搜索条件,这种情况下则不需要再对品牌进行分组搜索,因为分组搜索的数据是用于显示品牌搜索条件的,不需要重复展示
        // searchParamMap -> brand
        Terms BrandTerms = searchHits.getAggregations().get("brandName");
        List<String> brandList = this.getResultListByTerms(BrandTerms);

        Terms SpecTerms = searchHits.getAggregations().get("spec");
        // 获取spec规格域集合
        Map<String, Set<String>> specMap = this.getResultMapByTerms(SpecTerms);

        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> searchPageFor = SearchHitSupport.searchPageFor(searchHits, searchQuery.getPageable());

        // 总记录数
        long totalElements = searchPageFor.getTotalElements();
        // 总页数
        int totalPages = searchPageFor.getTotalPages();
        // 当前页数
        int currentPage = searchPageFor.getPageable().getPageNumber();
        // 当前页总记录数
        int currentPageRows = searchPageFor.getPageable().getPageSize();

        // 获取所需SkuInfo集合数据内容
        List<SearchHit<SkuInfo>> content = searchPageFor.getContent();

        // 解析并再封装数据
        // 封装一个Map 存储所有数据，并返回
        HashMap<String, Object> resultMap = new HashMap<>();
        resultMap.put("totalPage", totalPages);// 总页数
        resultMap.put("total", totalElements);// 总记录数
        resultMap.put("currentPage", currentPage + 1);// 当前页
        resultMap.put("currentPageRows", currentPageRows);// 当前页总记录数
        resultMap.put("categoryList", categoryList);// 商品分类名称数据集合
        resultMap.put("brandList", brandList);// 商品分类名称数据集合
        resultMap.put("specMap", specMap);// 商品分类名称数据集合
        resultMap.put("rows", content);// 商品SkuInfo数据集合

        return resultMap;
    }

    /**
     * @param terms
     * @return
     */
    @Deprecated // 该方法不再使用，仅供与优化后的方法进行对比
    private Map<String, Set<String>> getResultMapByTerms(Terms terms) {

        // key :规格的名称
        // value :规格名称对应的选项的多个值集合set
        Map<String, Set<String>> specMap = new HashMap<String, Set<String>>();
        Set<String> specValues = new HashSet<String>();

        // 1.获取封装在terms中的商品spec规格集合
        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                // 2.遍历terms.getBuckets(),逐行获取商品规格spec数据(json字符串类型)
                // spec :{"手机屏幕尺寸":"5.5寸","网络":"电信4G","颜色":"白","测试":"s11","机身内存":"128G","存储":"16G","像素":"300万像素"}
                String keyAsString = bucket.getKeyAsString();

                // 3.每循环一次就将json串类型的spec数据转换成Map<String, String>类型  key :规格的名称  value:规格名对应的选项的单个值
                Map<String, String> map = JSON.parseObject(keyAsString, Map.class);
                // 4.遍历上面一步转换为Map<String, String>类型的商品规格spec
                for (Map.Entry<String, String> stringStringEntry : map.entrySet()) {
                    //
                    String key = stringStringEntry.getKey();// 规格名称  eg:手机屏幕尺寸
                    String value = stringStringEntry.getValue();// 规格的名称对应的单个选项值 eg:5.5寸

                    // 先从最上面声明的specMap中 根据spec规格名称(key),获取该规格名称对应的商品参数集合(HashSet<String>类型的value)
                    specValues = specMap.get(key);
                    // 如果specValues不存在则新new一个
                    if (specValues == null) {
                        specValues = new HashSet<>();
                    }
                    // 将本次循环,根据商品规格名称(key)而获取到的单个规格参数存入HashSet(HashSet可以去重复!)
                    specValues.add(value);
                    // 5.将specValues放回specMap中去
                    specMap.put(key, specValues);
                }
            }
        }
        return specMap;
    }

    /**
     * 从Terms中获取封装数据的结果集
     */
    @Deprecated // 该方法不再使用，仅供与优化后的方法进行对比
    private List<String> getResultListByTerms(Terms terms) {
        List<String> resultList = new ArrayList<>();

        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                String keyAsString = bucket.getKeyAsString();// 分组的值（分类名称/品牌名称）
                resultList.add(keyAsString);
            }
        }
        return resultList;
    }

    /**
     * 关键字检索(优化后的搜索方法)
     *
     * @param searchMap
     * @return
     */
    @Override
    public Map<String, Object> search(Map<String, String> searchMap) {
        // 1.封装检索条件(后期有多个检索条件，专门封装一个方法)
        NativeSearchQueryBuilder builder = builderBasicQuery(searchMap);
        // 2.根据关键字检索,获取改关键字下的商品信息
        Map<String, Object> resultMap = searchForPage(builder);
        // 3.商品分类列表
//        List<String> categoryList = searchCategoryList(builder);
//        resultMap.put("categoryList", categoryList);
        // 4.品牌分类列表查询
//        List<String> brandList = searchBrandList(builder);
//        resultMap.put("brandList", brandList);
        // 获取数据的总条数
        String totalElements = resultMap.get("TotalElements").toString();
        int totalSize = Integer.parseInt(totalElements);
        if (totalSize <= 0) {
            //判断totalSize是否小于等于0，如果小于等于0会报角标越界异常，需要给totalSize设置默认值防止报错
            totalSize = 10000;
        }
        // 5.统计规格分类列表
//        Map<String, Set<String>> specList = searchSpecList(builder,totalSize);
//        resultMap.put("specList", specList);
        // 6.将检索的结果封装到map中
        Map<String, Object> map = searchGroupList(builder, totalSize);
        resultMap.putAll(map);
        return resultMap;
    }
    
    /**
     * 统计规格分类列表查询, 品牌分类列表查询 ,商品分类分组统计实现(封装一个方法返回所有检索条件结果返回)
     *
     * @param builder
     * @return
     */
    private Map<String, Object> searchGroupList(NativeSearchQueryBuilder builder, int totalSize) {
        // 聚合查询   (分类)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuCategpryName").field("categoryName.keyword").size(totalSize));
        // 聚合查询   (品牌)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuBrandName").field("brandName.keyword").size(totalSize));
        // 聚合查询   (品牌)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuSpec").field("spec.keyword").size(totalSize));
        // 分组结果集
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(builder.build(), SkuInfo.class);
        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> page = SearchHitSupport.searchPageFor(searchHits, builder.build().getPageable());

        //处理结果集
        Aggregations aggregations = page.getSearchHits().getAggregations();
        // 统计分类
        List<String> categoryList = getGroupList(aggregations, "skuCategpryName");
        // 统计品牌
        List<String> brandList = getGroupList(aggregations, "skuBrandName");
        // 统计规格
        List<String> spceList = getGroupList(aggregations, "skuSpec");
        // 将统计规格的List结果集转成Map返回
        Map<String, Set<String>> specmap = pullMap(spceList);
        // 将所有的数据封装Map
        Map<String, Object> map = new HashMap<>();
        map.put("categoryList", categoryList);
        map.put("brandList", brandList);
        map.put("specMap", specmap);
        // 返回最终结果集
        return map;
    }

    /**
     * 处理聚合查询(分类，品牌，品牌)结果集
     *
     * @param
     * @return
     */
    private List<String> getGroupList(Aggregations aggregations, String groupName) {
        Terms terms = aggregations.get(groupName);
        List<String> resultList = new ArrayList<>();

        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                String keyAsString = bucket.getKeyAsString();// 分组的值（分类名称/品牌名称）
                resultList.add(keyAsString);
            }
        }
        return resultList;
    }

    /**
     * 处理规格数据封装Map
     *
     * @param list
     * @return
     */
    private Map<String, Set<String>> pullMap(List<String> list) {
        Map<String, Set<String>> map = new HashMap<>();
        for (String spec : list) {
            // 将字符JSON数据转Map
            Map<String, String> specMap = JSON.parseObject(spec, Map.class);
            // 遍历map
            Set<Map.Entry<String, String>> entrySet = specMap.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                // 电视音响效果":
                String key = entry.getKey();
                // 小影院...
                String value = entry.getValue();
                // value是多个且不能重复使用Set集合存储
                // 首先判断map中是否有set
                Set<String> set = map.get(key);
                if (set == null) {
                    // 判断set是否为空，如果是空就new HashSet
                    set = new HashSet<>();
                }
                // set不为空就直接往里面添加数据
                set.add(value);
                map.put(key, set);
            }
        }
        return map;
    }

    /**
     * 根据关键字进行检索
     *
     * @param builder
     * @return
     */
    private Map<String, Object> searchForPage(NativeSearchQueryBuilder builder) {
        // 关键字的高亮显示
        // 继续封装检索条件
        HighlightBuilder.Field field = new HighlightBuilder.Field("name");  //sku的name如果有关键字就进行高亮
        field.preTags("<font color='red'>");    // 开始标签
        field.postTags("</font>");              // 结束标签
        field.fragmentSize(100);                // 显示的字符个数
        builder.withHighlightFields(field);

        NativeSearchQuery build = builder.build();
        //AggregatedPage<SkuInfo> page = elasticsearchTemplate.queryForPage(build, SkuInfo.class);
        // 分组结果集
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(builder.build(), SkuInfo.class);
        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> page = SearchHitSupport.searchPageFor(searchHits, builder.build().getPageable());

        // 取出高亮的结果数据，在该对象中
        // 遍历: 对返回的内容进行处理(高亮字段替换原来的字段)
        for(SearchHit<SkuInfo> searchHit:searchHits){
            // 获取searchHit中的高亮内容
            Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
            // 将高亮的内容填充到content中
            searchHit.getContent().setName(highlightFields.get("name")==null ? searchHit.getContent().getName():highlightFields.get("name").get(0));
        }

        Map<String, Object> map = new HashMap<>();
        // 商品结果集
        map.put("rows", page.getContent());
        //总条数
        map.put("TotalElements", page.getTotalElements());
        //总页数
        map.put("TotalPages", page.getTotalPages());
        // 分页当前页码
        map.put("pageNum", build.getPageable().getPageNumber() + 1);
        // 每页显示条数
        map.put("pageSize", build.getPageable().getPageSize());

        return map;
    }

    /**
     * 此方法用于封装检索条件NativeSearchQueryBuilder
     *
     * @param searchMap
     * @return
     */
    private NativeSearchQueryBuilder builderBasicQuery(Map<String, String> searchMap) {
        // 封装检索条件
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        // 添加过滤条件
        BoolQueryBuilder boolBuilder = new BoolQueryBuilder();
        if (searchMap != null) {

            // 1.根据关键字检索
            String keywords = searchMap.get("keywords");
            if (!StringUtils.isEmpty(keywords)) {
                builder.withQuery(QueryBuilders.matchPhraseQuery("name", keywords));
            }

            // 继续拼接条件
            // 2.根据商品分类过滤
            String category = searchMap.get("category");
            if (!StringUtils.isEmpty(category)) {
                boolBuilder.must(QueryBuilders.matchPhraseQuery("categoryName", category));
            }

            // 3.根据商品品牌过滤
            String brand = searchMap.get("brand");
            if (!StringUtils.isEmpty(brand)) {
                boolBuilder.must(QueryBuilders.matchPhraseQuery("brandName", brand));
            }

            // 4.根据商品规格过滤(选择的规格有多个)
            // ::spec_屏幕尺寸 ：5.7, spec_内存 ：40G
            Set<String> keys = searchMap.keySet();
            for (String key : keys) {
                // 判断规格条件是否是spec_开头的
                if (key.startsWith("spec_")) {
                    String value = searchMap.get(key).replace("\\", "");
                    boolBuilder.must(QueryBuilders.matchQuery("specMap." + key.substring(5) + ".keyword", value));
                }
            }

            // 5.根据商品价格过滤(区间段)
            String price = searchMap.get("price");
            if (!StringUtils.isEmpty(price)) {
                // 页面传的价格式(min ~ max / >price /  <price)
                String[] priceArray = price.split("-");
                // 如果传的价格参数是一个就大于(>=)查询
                boolBuilder.must(QueryBuilders.rangeQuery("price").gte(priceArray[0]));
                if (priceArray.length > 1) {
                    // 如果传的价格参数是两个就小于(<=)查询
                    boolBuilder.must(QueryBuilders.rangeQuery("price").lte(priceArray[1]));
                }
            }

            // 6.进行排序查询(排序字段,ASC DESC)
            // 排序的字段
            String sortField = searchMap.get("sortField");
            // 排序的规则(ASC DESC)
            String sortRule = searchMap.get("sortRule");
            if (!StringUtils.isEmpty(sortField)) {
                builder.withSort(SortBuilders.fieldSort(sortField).order(SortOrder.valueOf(sortRule)));
            }
        }
        // 7. 将过滤的条件都加到builder中NativeSearchQueryBuilder
        builder.withFilter(boolBuilder);

        // 8. 添加分页条件 age1:当前页（page）   age2：每页显示数据（size）
        String page = searchMap.get("pageNum");
        if (StringUtils.isEmpty(page)) {
            // 默认起始页为第一页
            page = "1";
        }
        int pageNum = Integer.parseInt(page);
        // 动态获得前端传
        String size = searchMap.get("size");
        // 默认一页显示20条数据
        if (StringUtils.isEmpty(size)) {
            size = "20";
        }
        int pageSize = Integer.parseInt(size);
        Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
        builder.withPageable(pageable);
        return builder;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531