1. day07 ES搜索

2. 根据关键字查询

changgou_service_search项目创建SearchService接口

  1. package com.changgou.search.service;
  3. import java.util.Map;
  5. public interface SearchService {
  7.     //按照查询添加进行数据查询
  8.     Map search(Map<String ,String> searchMap);
  9. }

创建SearchService接口实现类SearchServiceImpl

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.data.domain.Pageable;
  18. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  19. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  20. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  21. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  22. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  23. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  24. import org.springframework.stereotype.Service;
  26. import java.util.*;
  28. @Service
  29. public class SearchServiceImpl implements SearchService {
  31.     @Autowired
  32.     private ElasticsearchTemplate elasticsearchTemplate;
  34.     /**
  35.      * 根据前端传过来的字段进行查询
  36.      *
  37.      * @param searchMap
  38.      * @return
  39.      */
  40.     @Override
  41.     public Map search(Map<String, String> searchMap) {
  42.         Map<String, Object> resultMap = new HashMap<>();
  43.         //构建查询
  44.         if (searchMap != null) {
  45.             //构建查询条件封装对象
  46.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  47.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  49.             //按照关键字查询
  50.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  51.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  52.             }
  55.             nativeSearchQueryBuilder.withQuery(boolQuery);
  58.             //开启查询
  59.             /**
  60.              * 第一个参数: 条件的构建对象
  61.              * 第二个参数: 查询操作实体类
  62.              * 第三个参数: 查询结果操作对象
  63.              */
  64.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  65.                     new SearchResultMapper() {
  66.                         @Override
  67.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  68.                             //查询结果操作
  69.                             List<T> list = new ArrayList<>();
  70.                             //获取查询命中的数据
  71.                             SearchHits hits = searchResponse.getHits();
  72.                             if (hits != null) {
  73.                                 //非空
  74.                                 for (SearchHit hit : hits) {
  75.                                     //SearchHit转换为skuinfo
  76.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  77.                                     list.add((T) skuInfo);
  78.                                 }
  79.                             }
  80.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  81.                         }
  82.                     });
  84.             //封装最终返回结果
  85.             //总记录数
  86.             resultMap.put("total", resultInfo.getTotalElements());
  87.             //总页数
  88.             resultMap.put("totalPages", resultInfo.getTotalPages());
  89.             //数据集合
  90.             resultMap.put("rows", resultInfo.getContent());
  91.             return resultMap;
  92.         }
  94.         return null;
  95.     }
  96. }

changgou_service_search项目创建SearchController

  1. package com.changgou.search.controller;
  3. import com.changgou.search.service.SearchService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RequestParam;
  8. import org.springframework.web.bind.annotation.RestController;
  10. import java.util.Map;
  11. import java.util.Set;
  13. @RestController
  14. @RequestMapping("/search")
  15. public class SearchController {
  16.     @Autowired
  17.     private SearchService searchService;
  19.     @GetMapping
  20.     public Map search(@RequestParam Map<String, String> searchMap) {
  21.         //特殊符号处理
  22.         this.handleSearchMap(searchMap);
  23.         Map searchResult = searchService.search(searchMap);
  24.         return searchResult;
  25.     }
  27.     private void handleSearchMap(Map<String, String> searchMap) {
  28.         Set<Map.Entry<String, String>> entries = searchMap.entrySet();
  29.         for (Map.Entry<String, String> entry : entries) {
  30.             if (entry.getKey().startsWith("spec_")) {
  31.                 searchMap.put(entry.getKey(), entry.getValue().replace("+", "%2B"));
  32.             }
  33.         }
  34.     }
  37. }

删除索引库 重新导入索引 请求指定 localhost:9009/manager/importAll

测试关键字查询 localhost:9009/search?keywords=手机

3. 品牌条件筛选

用户有可能会根据分类搜索、品牌搜索，还有可能根据规格搜索，以及价格搜索和排序操作。根据分类和品牌搜索的时候，可以直接根据指定域搜索，而规格搜索的域数据是不确定的，价格是一个区间搜索，所以我们可以分为三段实现，先实现分类、品牌搜素，再实现规格搜索，然后实现价格区间搜索。

07. day07 ES搜索 - 图1

页面每次向后台传入对应的分类和品牌，后台据分类和品牌进行条件过滤即可。

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加品牌过滤

  1. //按照品牌进行过滤查询
  2. if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  3.     boolQuery.filter(QueryBuilders.termQuery("brandName",searchMap.get("brand")));
  4. }

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.data.domain.Pageable;
  18. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  19. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  20. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  21. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  22. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  23. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  24. import org.springframework.stereotype.Service;
  26. import java.util.*;
  28. @Service
  29. public class SearchServiceImpl implements SearchService {
  31.     @Autowired
  32.     private ElasticsearchTemplate elasticsearchTemplate;
  34.     /**
  35.      * 根据前端传过来的字段进行查询
  36.      *
  37.      * @param searchMap
  38.      * @return
  39.      */
  40.     @Override
  41.     public Map search(Map<String, String> searchMap) {
  42.         Map<String, Object> resultMap = new HashMap<>();
  43.         //构建查询
  44.         if (searchMap != null) {
  45.             //构建查询条件封装对象
  46.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  47.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  49.             //按照关键字查询
  50.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  51.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  52.             }
  54.             //按照品牌进行过滤查询
  55.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  56.                 boolQuery.filter(QueryBuilders.termQuery("brandName",searchMap.get("brand")));
  57.             }
  59.             nativeSearchQueryBuilder.withQuery(boolQuery);
  62.             //开启查询
  63.             /**
  64.              * 第一个参数: 条件的构建对象
  65.              * 第二个参数: 查询操作实体类
  66.              * 第三个参数: 查询结果操作对象
  67.              */
  68.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  69.                     new SearchResultMapper() {
  70.                         @Override
  71.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  72.                             //查询结果操作
  73.                             List<T> list = new ArrayList<>();
  74.                             //获取查询命中的数据
  75.                             SearchHits hits = searchResponse.getHits();
  76.                             if (hits != null) {
  77.                                 //非空
  78.                                 for (SearchHit hit : hits) {
  79.                                     //SearchHit转换为skuinfo
  80.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  81.                                     list.add((T) skuInfo);
  82.                                 }
  83.                             }
  84.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  85.                         }
  86.                     });
  88.             //封装最终返回结果
  89.             //总记录数
  90.             resultMap.put("total", resultInfo.getTotalElements());
  91.             //总页数
  92.             resultMap.put("totalPages", resultInfo.getTotalPages());
  93.             //数据集合
  94.             resultMap.put("rows", resultInfo.getContent());
  95.             return resultMap;
  96.         }
  98.         return null;
  99.     }
  100. }

测试请求 localhost:9009/search?keywords=手机&brand=华为

3.1. 按照品牌进行聚合查询

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.Pageable;
  20. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  21. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  22. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  23. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  24. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  25. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  26. import org.springframework.stereotype.Service;
  28. import java.util.*;
  29. import java.util.stream.Collectors;
  31. @Service
  32. public class SearchServiceImpl implements SearchService {
  34.     @Autowired
  35.     private ElasticsearchTemplate elasticsearchTemplate;
  37.     /**
  38.      * 根据前端传过来的字段进行查询
  39.      *
  40.      * @param searchMap
  41.      * @return
  42.      */
  43.     @Override
  44.     public Map search(Map<String, String> searchMap) {
  45.         Map<String, Object> resultMap = new HashMap<>();
  46.         //构建查询
  47.         if (searchMap != null) {
  48.             //构建查询条件封装对象
  49.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  50.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  52.             //按照关键字查询
  53.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  54.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  55.             }
  57.             //按照品牌进行过滤查询
  58.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  59.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  60.             }
  62.             nativeSearchQueryBuilder.withQuery(boolQuery);
  64.             //按照品牌进行分组(聚合)查询
  65.             String skuBrand = "skuBrand";
  66.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  69.             //开启查询
  70.             /**
  71.              * 第一个参数: 条件的构建对象
  72.              * 第二个参数: 查询操作实体类
  73.              * 第三个参数: 查询结果操作对象
  74.              */
  75.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  76.                     new SearchResultMapper() {
  77.                         @Override
  78.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  79.                             //查询结果操作
  80.                             List<T> list = new ArrayList<>();
  81.                             //获取查询命中的数据
  82.                             SearchHits hits = searchResponse.getHits();
  83.                             if (hits != null) {
  84.                                 //非空
  85.                                 for (SearchHit hit : hits) {
  86.                                     //SearchHit转换为skuinfo
  87.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  88.                                     list.add((T) skuInfo);
  89.                                 }
  90.                             }
  91.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  92.                         }
  93.                     });
  95.             //封装最终返回结果
  96.             //总记录数
  97.             resultMap.put("total", resultInfo.getTotalElements());
  98.             //总页数
  99.             resultMap.put("totalPages", resultInfo.getTotalPages());
  100.             //数据集合
  101.             resultMap.put("rows", resultInfo.getContent());
  103.             //封装品牌的分组结果
  104.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  105.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  106.             resultMap.put("brandList", brandList);
  107.             return resultMap;
  108.         }
  110.         return null;
  111.     }
  112. }

请求地址 localhost:9009/search?keywords=电视

添加品牌聚合后 通过关键字查询出结果中包含的品牌列表

4. 规格过滤

规格这一部分，需要向后台发送规格名字以及规格值，我们可以按照一定要求来发送数据，例如规格名字以特殊前缀提交到后台：spec_网络制式：电信4G、spec_显示屏尺寸：4.0-4.9英寸

后台接到数据后，可以根据前缀spec_来区分是否是规格，如果以spec_xxx开始的数据则为规格数据，需要根据指定规格找信息。

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //按照规格进行过滤查询
  2. for (String key : searchMap.keySet()) {
  3.     if (key.startsWith("spec_")){
  4.         String value = searchMap.get(key).replace("%2B","+");
  5.         boolQuery.filter(QueryBuilders.termQuery("specMap."+key.substring(5)+".keyword",value));
  6.     }
  7. }

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.Pageable;
  20. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  21. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  22. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  23. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  24. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  25. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  26. import org.springframework.stereotype.Service;
  28. import java.util.*;
  29. import java.util.stream.Collectors;
  31. @Service
  32. public class SearchServiceImpl implements SearchService {
  34.     @Autowired
  35.     private ElasticsearchTemplate elasticsearchTemplate;
  37.     /**
  38.      * 根据前端传过来的字段进行查询
  39.      *
  40.      * @param searchMap
  41.      * @return
  42.      */
  43.     @Override
  44.     public Map search(Map<String, String> searchMap) {
  45.         Map<String, Object> resultMap = new HashMap<>();
  46.         //构建查询
  47.         if (searchMap != null) {
  48.             //构建查询条件封装对象
  49.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  50.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  52.             //按照关键字查询
  53.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  54.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  55.             }
  57.             //按照品牌进行过滤查询
  58.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  59.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  60.             }
  62.             //按照规格进行过滤查询
  63.             for (String key : searchMap.keySet()) {
  64.                 if (key.startsWith("spec_")){
  65.                     String value = searchMap.get(key).replace("%2B","+");
  66.                     boolQuery.filter(QueryBuilders.termQuery("specMap."+key.substring(5)+".keyword",value));
  67.                 }
  68.             }
  70.             nativeSearchQueryBuilder.withQuery(boolQuery);
  72.             //按照品牌进行分组(聚合)查询
  73.             String skuBrand = "skuBrand";
  74.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  77.             //开启查询
  78.             /**
  79.              * 第一个参数: 条件的构建对象
  80.              * 第二个参数: 查询操作实体类
  81.              * 第三个参数: 查询结果操作对象
  82.              */
  83.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  84.                     new SearchResultMapper() {
  85.                         @Override
  86.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  87.                             //查询结果操作
  88.                             List<T> list = new ArrayList<>();
  89.                             //获取查询命中的数据
  90.                             SearchHits hits = searchResponse.getHits();
  91.                             if (hits != null) {
  92.                                 //非空
  93.                                 for (SearchHit hit : hits) {
  94.                                     //SearchHit转换为skuinfo
  95.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  96.                                     list.add((T) skuInfo);
  97.                                 }
  98.                             }
  99.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  100.                         }
  101.                     });
  103.             //封装最终返回结果
  104.             //总记录数
  105.             resultMap.put("total", resultInfo.getTotalElements());
  106.             //总页数
  107.             resultMap.put("totalPages", resultInfo.getTotalPages());
  108.             //数据集合
  109.             resultMap.put("rows", resultInfo.getContent());
  111.             //封装品牌的分组结果
  112.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  113.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  114.             resultMap.put("brandList", brandList);
  115.             return resultMap;
  116.         }
  118.         return null;
  119.     }
  120. }

请求地址 localhost:9009/search?keywords=电视&spec_尺寸=金色

4.1. 按照规格进行聚合查询

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //按照规格进行聚合查询
  2. String skuSpec = "skuSpec";
  3. nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  1. //封装规格分组结果
  2. StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  3. List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  4. resultMap.put("specList", specList);

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.Pageable;
  20. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  21. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  22. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  23. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  24. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  25. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  26. import org.springframework.stereotype.Service;
  28. import java.util.*;
  29. import java.util.stream.Collectors;
  31. @Service
  32. public class SearchServiceImpl implements SearchService {
  34.     @Autowired
  35.     private ElasticsearchTemplate elasticsearchTemplate;
  37.     /**
  38.      * 根据前端传过来的字段进行查询
  39.      *
  40.      * @param searchMap
  41.      * @return
  42.      */
  43.     @Override
  44.     public Map search(Map<String, String> searchMap) {
  45.         Map<String, Object> resultMap = new HashMap<>();
  46.         //构建查询
  47.         if (searchMap != null) {
  48.             //构建查询条件封装对象
  49.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  50.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  52.             //按照关键字查询
  53.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  54.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  55.             }
  57.             //按照品牌进行过滤查询
  58.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  59.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  60.             }
  62.             //按照规格进行过滤查询
  63.             for (String key : searchMap.keySet()) {
  64.                 if (key.startsWith("spec_")) {
  65.                     String value = searchMap.get(key).replace("%2B", "+");
  66.                     boolQuery.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
  67.                 }
  68.             }
  70.             nativeSearchQueryBuilder.withQuery(boolQuery);
  72.             //按照品牌进行分组(聚合)查询
  73.             String skuBrand = "skuBrand";
  74.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  76.             //按照规格进行聚合查询
  77.             String skuSpec = "skuSpec";
  78.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  80.             //开启查询
  81.             /**
  82.              * 第一个参数: 条件的构建对象
  83.              * 第二个参数: 查询操作实体类
  84.              * 第三个参数: 查询结果操作对象
  85.              */
  86.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  87.                     new SearchResultMapper() {
  88.                         @Override
  89.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  90.                             //查询结果操作
  91.                             List<T> list = new ArrayList<>();
  92.                             //获取查询命中的数据
  93.                             SearchHits hits = searchResponse.getHits();
  94.                             if (hits != null) {
  95.                                 //非空
  96.                                 for (SearchHit hit : hits) {
  97.                                     //SearchHit转换为skuinfo
  98.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  99.                                     list.add((T) skuInfo);
  100.                                 }
  101.                             }
  102.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  103.                         }
  104.                     });
  106.             //封装最终返回结果
  107.             //总记录数
  108.             resultMap.put("total", resultInfo.getTotalElements());
  109.             //总页数
  110.             resultMap.put("totalPages", resultInfo.getTotalPages());
  111.             //数据集合
  112.             resultMap.put("rows", resultInfo.getContent());
  114.             //封装品牌的分组结果
  115.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  116.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  117.             resultMap.put("brandList", brandList);
  119.             //封装规格分组结果
  120.             StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  121.             List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  122.             resultMap.put("specList", specList);
  124.             return resultMap;
  125.         }
  127.         return null;
  128.     }
  129. }

请求地址 localhost:9009/search?keywords=电视

5. 价格区间查询

价格区间查询，每次需要将价格传入到后台，前端传入后台的价格大概是price=0-500或者price=500-1000依次类推，最后一个是price=3000,后台可以根据-分割，如果分割得到的结果最多有2个，第1个表示x<price，第2个表示price<=y。

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //按照价格进行区间过滤查询
  2. if (StringUtils.isNotEmpty(searchMap.get("price"))) {
  3.     String[] prices = searchMap.get("price").split("-");
  4.     if (prices.length == 2) {
  5.         //是xx - xx 价格区间的条件
  6.         boolQuery.filter(QueryBuilders.rangeQuery("price").lte(prices[1]));
  7.     }
  8.     boolQuery.filter(QueryBuilders.rangeQuery("price").gte(prices[0]));
  9. }

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.Pageable;
  20. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  21. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  22. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  23. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  24. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  25. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  26. import org.springframework.stereotype.Service;
  28. import java.util.*;
  29. import java.util.stream.Collectors;
  31. @Service
  32. public class SearchServiceImpl implements SearchService {
  34.     @Autowired
  35.     private ElasticsearchTemplate elasticsearchTemplate;
  37.     /**
  38.      * 根据前端传过来的字段进行查询
  39.      *
  40.      * @param searchMap
  41.      * @return
  42.      */
  43.     @Override
  44.     public Map search(Map<String, String> searchMap) {
  45.         Map<String, Object> resultMap = new HashMap<>();
  46.         //构建查询
  47.         if (searchMap != null) {
  48.             //构建查询条件封装对象
  49.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  50.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  52.             //按照关键字查询
  53.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  54.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  55.             }
  57.             //按照品牌进行过滤查询
  58.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  59.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  60.             }
  62.             //按照规格进行过滤查询
  63.             for (String key : searchMap.keySet()) {
  64.                 if (key.startsWith("spec_")) {
  65.                     String value = searchMap.get(key).replace("%2B", "+");
  66.                     boolQuery.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
  67.                 }
  68.             }
  70.             nativeSearchQueryBuilder.withQuery(boolQuery);
  72.             //按照价格进行区间过滤查询
  73.             if (StringUtils.isNotEmpty(searchMap.get("price"))) {
  74.                 String[] prices = searchMap.get("price").split("-");
  75.                 if (prices.length == 2) {
  76.                     //是xx - xx 价格区间的条件
  77.                     boolQuery.filter(QueryBuilders.rangeQuery("price").lte(prices[1]));
  78.                 }
  79.                 boolQuery.filter(QueryBuilders.rangeQuery("price").gte(prices[0]));
  80.             }
  82.             //按照品牌进行分组(聚合)查询
  83.             String skuBrand = "skuBrand";
  84.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  86.             //按照规格进行聚合查询
  87.             String skuSpec = "skuSpec";
  88.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  92.             //开启查询
  93.             /**
  94.              * 第一个参数: 条件的构建对象
  95.              * 第二个参数: 查询操作实体类
  96.              * 第三个参数: 查询结果操作对象
  97.              */
  98.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  99.                     new SearchResultMapper() {
  100.                         @Override
  101.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  102.                             //查询结果操作
  103.                             List<T> list = new ArrayList<>();
  104.                             //获取查询命中的数据
  105.                             SearchHits hits = searchResponse.getHits();
  106.                             if (hits != null) {
  107.                                 //非空
  108.                                 for (SearchHit hit : hits) {
  109.                                     //SearchHit转换为skuinfo
  110.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  111.                                     list.add((T) skuInfo);
  112.                                 }
  113.                             }
  114.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  115.                         }
  116.                     });
  118.             //封装最终返回结果
  119.             //总记录数
  120.             resultMap.put("total", resultInfo.getTotalElements());
  121.             //总页数
  122.             resultMap.put("totalPages", resultInfo.getTotalPages());
  123.             //数据集合
  124.             resultMap.put("rows", resultInfo.getContent());
  126.             //封装品牌的分组结果
  127.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  128.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  129.             resultMap.put("brandList", brandList);
  131.             //封装规格分组结果
  132.             StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  133.             List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  134.             resultMap.put("specList", specList);
  136.             return resultMap;
  137.         }
  139.         return null;
  140.     }
  141. }

请求地址 localhost:9009/search?price=0-500

localhost:9009/search?price=4000

6. 分页查询

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //开启分页查询
  2. String pageNum = searchMap.get("pageNum"); //当前页
  3. String pageSize = searchMap.get("pageSize"); //每页显示多少条
  4. if (StringUtils.isEmpty(pageNum)) {
  5.     pageNum = "1";
  6. }
  7. if (StringUtils.isEmpty(pageSize)) {
  8.     pageSize = "30";
  9. }
  10. //设置分页
  11. nativeSearchQueryBuilder.withPageable(PageRequest.of(Integer.parseInt(pageNum) - 1, Integer.parseInt(pageSize)));

封装当前页码到返回结果中

  1. //当前页
  2. resultMap.put("pageNum", pageNum);

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.PageRequest;
  20. import org.springframework.data.domain.Pageable;
  21. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  22. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  23. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  24. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  25. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  26. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  27. import org.springframework.stereotype.Service;
  29. import java.util.*;
  30. import java.util.stream.Collectors;
  32. @Service
  33. public class SearchServiceImpl implements SearchService {
  35.     @Autowired
  36.     private ElasticsearchTemplate elasticsearchTemplate;
  38.     /**
  39.      * 根据前端传过来的字段进行查询
  40.      *
  41.      * @param searchMap
  42.      * @return
  43.      */
  44.     @Override
  45.     public Map search(Map<String, String> searchMap) {
  46.         Map<String, Object> resultMap = new HashMap<>();
  47.         //构建查询
  48.         if (searchMap != null) {
  49.             //构建查询条件封装对象
  50.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  51.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  53.             //按照关键字查询
  54.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  55.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  56.             }
  58.             //按照品牌进行过滤查询
  59.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  60.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  61.             }
  63.             //按照规格进行过滤查询
  64.             for (String key : searchMap.keySet()) {
  65.                 if (key.startsWith("spec_")) {
  66.                     String value = searchMap.get(key).replace("%2B", "+");
  67.                     boolQuery.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
  68.                 }
  69.             }
  71.             nativeSearchQueryBuilder.withQuery(boolQuery);
  73.             //按照价格进行区间过滤查询
  74.             if (StringUtils.isNotEmpty(searchMap.get("price"))) {
  75.                 String[] prices = searchMap.get("price").split("-");
  76.                 if (prices.length == 2) {
  77.                     //是xx - xx 价格区间的条件
  78.                     boolQuery.filter(QueryBuilders.rangeQuery("price").lte(prices[1]));
  79.                 }
  80.                 boolQuery.filter(QueryBuilders.rangeQuery("price").gte(prices[0]));
  81.             }
  83.             //按照品牌进行分组(聚合)查询
  84.             String skuBrand = "skuBrand";
  85.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  87.             //按照规格进行聚合查询
  88.             String skuSpec = "skuSpec";
  89.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  91.             //开启分页查询
  92.             String pageNum = searchMap.get("pageNum"); //当前页
  93.             String pageSize = searchMap.get("pageSize"); //每页显示多少条
  94.             if (StringUtils.isEmpty(pageNum)) {
  95.                 pageNum = "1";
  96.             }
  97.             if (StringUtils.isEmpty(pageSize)) {
  98.                 pageSize = "30";
  99.             }
  100.             //设置分页
  101.             nativeSearchQueryBuilder.withPageable(PageRequest.of(Integer.parseInt(pageNum) - 1, Integer.parseInt(pageSize)));
  104.             //开启查询
  105.             /**
  106.              * 第一个参数: 条件的构建对象
  107.              * 第二个参数: 查询操作实体类
  108.              * 第三个参数: 查询结果操作对象
  109.              */
  110.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  111.                     new SearchResultMapper() {
  112.                         @Override
  113.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  114.                             //查询结果操作
  115.                             List<T> list = new ArrayList<>();
  116.                             //获取查询命中的数据
  117.                             SearchHits hits = searchResponse.getHits();
  118.                             if (hits != null) {
  119.                                 //非空
  120.                                 for (SearchHit hit : hits) {
  121.                                     //SearchHit转换为skuinfo
  122.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  123.                                     list.add((T) skuInfo);
  124.                                 }
  125.                             }
  126.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  127.                         }
  128.                     });
  130.             //封装最终返回结果
  131.             //总记录数
  132.             resultMap.put("total", resultInfo.getTotalElements());
  133.             //总页数
  134.             resultMap.put("totalPages", resultInfo.getTotalPages());
  135.             //数据集合
  136.             resultMap.put("rows", resultInfo.getContent());
  138.             //封装品牌的分组结果
  139.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  140.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  141.             resultMap.put("brandList", brandList);
  143.             //封装规格分组结果
  144.             StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  145.             List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  146.             resultMap.put("specList", specList);
  148.             //当前页
  149.             resultMap.put("pageNum", pageNum);
  151.             return resultMap;
  152.         }
  154.         return null;
  155.     }
  156. }

请求地址 localhost:9009/search?price=4000&pageNum=10&pageSize=20

7. 搜索排序

07. day07 ES搜索 - 图2

排序这里总共有根据价格排序、根据评价排序、根据新品排序、根据销量排序，排序要想实现非常简单，只需要告知排序的域以及排序方式即可实现。

价格排序：只需要根据价格高低排序即可，降序价格高->低，升序价格低->高

评价排序：评价分为好评、中评、差评，可以在数据库中设计3个列，用来记录好评、中评、差评的量，每次排序的时候，好评的比例来排序，当然还要有条数限制，评价条数需要超过N条。

新品排序：直接根据商品的发布时间或者更新时间排序。

销量排序：销量排序除了销售数量外，还应该要有时间段限制。

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //按照相关字段进行排序查询
  2. //1.当前域 2.当前的排序操作(升序ASC,降序DESC)
  3. if (StringUtils.isNotEmpty(searchMap.get("sortField")) && StringUtils.isNotEmpty(searchMap.get("sortRule"))) {
  4.     if ("ASC".equals(searchMap.get("sortRule"))) {
  5.         //升序操作
  6.         nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.ASC));
  7.     }else {
  8.         //降序
  9.         nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.DESC));
  10.     }
  11. }

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.elasticsearch.search.sort.SortBuilders;
  19. import org.elasticsearch.search.sort.SortOrder;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.data.domain.PageRequest;
  22. import org.springframework.data.domain.Pageable;
  23. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  24. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  25. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  26. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  27. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  28. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  29. import org.springframework.stereotype.Service;
  31. import java.util.*;
  32. import java.util.stream.Collectors;
  34. @Service
  35. public class SearchServiceImpl implements SearchService {
  37.     @Autowired
  38.     private ElasticsearchTemplate elasticsearchTemplate;
  40.     /**
  41.      * 根据前端传过来的字段进行查询
  42.      *
  43.      * @param searchMap
  44.      * @return
  45.      */
  46.     @Override
  47.     public Map search(Map<String, String> searchMap) {
  48.         Map<String, Object> resultMap = new HashMap<>();
  49.         //构建查询
  50.         if (searchMap != null) {
  51.             //构建查询条件封装对象
  52.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  53.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  55.             //按照关键字查询
  56.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  57.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  58.             }
  60.             //按照品牌进行过滤查询
  61.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  62.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  63.             }
  65.             //按照规格进行过滤查询
  66.             for (String key : searchMap.keySet()) {
  67.                 if (key.startsWith("spec_")) {
  68.                     String value = searchMap.get(key).replace("%2B", "+");
  69.                     boolQuery.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
  70.                 }
  71.             }
  73.             nativeSearchQueryBuilder.withQuery(boolQuery);
  75.             //按照价格进行区间过滤查询
  76.             if (StringUtils.isNotEmpty(searchMap.get("price"))) {
  77.                 String[] prices = searchMap.get("price").split("-");
  78.                 if (prices.length == 2) {
  79.                     //是xx - xx 价格区间的条件
  80.                     boolQuery.filter(QueryBuilders.rangeQuery("price").lte(prices[1]));
  81.                 }
  82.                 boolQuery.filter(QueryBuilders.rangeQuery("price").gte(prices[0]));
  83.             }
  85.             //按照品牌进行分组(聚合)查询
  86.             String skuBrand = "skuBrand";
  87.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  89.             //按照规格进行聚合查询
  90.             String skuSpec = "skuSpec";
  91.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  93.             //开启分页查询
  94.             String pageNum = searchMap.get("pageNum"); //当前页
  95.             String pageSize = searchMap.get("pageSize"); //每页显示多少条
  96.             if (StringUtils.isEmpty(pageNum)) {
  97.                 pageNum = "1";
  98.             }
  99.             if (StringUtils.isEmpty(pageSize)) {
  100.                 pageSize = "30";
  101.             }
  102.             //设置分页
  103.             nativeSearchQueryBuilder.withPageable(PageRequest.of(Integer.parseInt(pageNum) - 1, Integer.parseInt(pageSize)));
  105.             //按照相关字段进行排序查询
  106.             //1.当前域 2.当前的排序操作(升序ASC,降序DESC)
  107.             if (StringUtils.isNotEmpty(searchMap.get("sortField")) && StringUtils.isNotEmpty(searchMap.get("sortRule"))) {
  108.                 if ("ASC".equals(searchMap.get("sortRule"))) {
  109.                     //升序操作
  110.                     nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.ASC));
  111.                 }else {
  112.                     //降序
  113.                     nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.DESC));
  114.                 }
  115.             }
  117.             //开启查询
  118.             /**
  119.              * 第一个参数: 条件的构建对象
  120.              * 第二个参数: 查询操作实体类
  121.              * 第三个参数: 查询结果操作对象
  122.              */
  123.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  124.                     new SearchResultMapper() {
  125.                         @Override
  126.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  127.                             //查询结果操作
  128.                             List<T> list = new ArrayList<>();
  129.                             //获取查询命中的数据
  130.                             SearchHits hits = searchResponse.getHits();
  131.                             if (hits != null) {
  132.                                 //非空
  133.                                 for (SearchHit hit : hits) {
  134.                                     //SearchHit转换为skuinfo
  135.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  136.                                     list.add((T) skuInfo);
  137.                                 }
  138.                             }
  139.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  140.                         }
  141.                     });
  143.             //封装最终返回结果
  144.             //总记录数
  145.             resultMap.put("total", resultInfo.getTotalElements());
  146.             //总页数
  147.             resultMap.put("totalPages", resultInfo.getTotalPages());
  148.             //数据集合
  149.             resultMap.put("rows", resultInfo.getContent());
  151.             //封装品牌的分组结果
  152.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  153.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  154.             resultMap.put("brandList", brandList);
  156.             //封装规格分组结果
  157.             StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  158.             List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  159.             resultMap.put("specList", specList);
  161.             //当前页
  162.             resultMap.put("pageNum", pageNum);
  164.             return resultMap;
  165.         }
  167.         return null;
  168.     }
  169. }

请求地址 localhost:9009/search?pageSize=1000&sortField=price&sortRule=DESC

8. 高亮显示

07. day07 ES搜索 - 图3

高亮显示是指根据商品关键字搜索商品的时候，显示的页面对关键字给定了特殊样式，让它显示更加突出，如上图商品搜索中，关键字编程了红色，其实就是给定了红色样式。

07. day07 ES搜索 - 图4

第1点，例如在百度中搜索数据的时候，会有2个地方高亮显示，分别是标题和描述，商城搜索的时候，只是商品名称高亮显示了。而高亮显示其实就是添加了样式，例如<span style="color:red;">笔记本</span>,而其中span开始标签可以称为前缀，span结束标签可以称为后缀。

第2点，高亮搜索使用ElasticsearchTemplate实现。

第3点，高亮搜索后，会搜出非高亮数据和高亮数据，高亮数据会加上第1点中的高亮样式，此时我们需要将非高亮数据换成高亮数据即可。例如非高亮:华为笔记本性能超强悍 高亮数据：华为<span style="color:red;"笔记本</span>性能超强悍,将非高亮的换成高亮的，到页面就能显示样式了。

修改搜索微服务com.changgou.service.SearchServiceImpl的搜索方法 在关键字查询boolQuery构建下添加

  1. //设置高亮域以及高亮的样式
  2. HighlightBuilder.Field field =new HighlightBuilder.Field("name")//高亮域
  3.         //高亮前缀
  4.         .preTags("<span style='color:red'>")
  5.         //高亮后缀
  6.         .postTags("</span>");
  7. nativeSearchQueryBuilder.withHighlightFields(field);

在SearchHit转换为skuinfo后 降skuinfo中的name属性 替换为添加高亮样式后的name

  1. Map<String, HighlightField> highlightFields = hit.getHighlightFields(); //获取所有高亮域
  2. if (highlightFields !=null && highlightFields.size() > 0){
  3.     //替换数据
  4.     skuInfo.setName(highlightFields.get("name").getFragments()[0].toString());
  5. }

完整代码

  1. package com.changgou.search.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.changgou.search.pojo.SkuInfo;
  5. import com.changgou.search.service.SearchService;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.elasticsearch.action.get.GetResponse;
  8. import org.elasticsearch.action.get.MultiGetResponse;
  9. import org.elasticsearch.action.search.SearchResponse;
  10. import org.elasticsearch.index.query.BoolQueryBuilder;
  11. import org.elasticsearch.index.query.Operator;
  12. import org.elasticsearch.index.query.QueryBuilder;
  13. import org.elasticsearch.index.query.QueryBuilders;
  14. import org.elasticsearch.search.SearchHit;
  15. import org.elasticsearch.search.SearchHits;
  16. import org.elasticsearch.search.aggregations.AggregationBuilders;
  17. import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
  18. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  19. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
  20. import org.elasticsearch.search.sort.SortBuilders;
  21. import org.elasticsearch.search.sort.SortOrder;
  22. import org.springframework.beans.factory.annotation.Autowired;
  23. import org.springframework.data.domain.PageRequest;
  24. import org.springframework.data.domain.Pageable;
  25. import org.springframework.data.elasticsearch.core.AbstractResultMapper;
  26. import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
  27. import org.springframework.data.elasticsearch.core.SearchResultMapper;
  28. import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
  29. import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
  30. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  31. import org.springframework.stereotype.Service;
  33. import java.util.*;
  34. import java.util.stream.Collectors;
  36. @Service
  37. public class SearchServiceImpl implements SearchService {
  39.     @Autowired
  40.     private ElasticsearchTemplate elasticsearchTemplate;
  42.     /**
  43.      * 根据前端传过来的字段进行查询
  44.      *
  45.      * @param searchMap
  46.      * @return
  47.      */
  48.     @Override
  49.     public Map search(Map<String, String> searchMap) {
  50.         Map<String, Object> resultMap = new HashMap<>();
  51.         //构建查询
  52.         if (searchMap != null) {
  53.             //构建查询条件封装对象
  54.             NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  55.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
  57.             //按照关键字查询
  58.             if (StringUtils.isNotEmpty(searchMap.get("keywords"))) {
  59.                 boolQuery.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
  60.             }
  62.             //按照品牌进行过滤查询
  63.             if (StringUtils.isNotEmpty(searchMap.get("brand"))) {
  64.                 boolQuery.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
  65.             }
  67.             //按照规格进行过滤查询
  68.             for (String key : searchMap.keySet()) {
  69.                 if (key.startsWith("spec_")) {
  70.                     String value = searchMap.get(key).replace("%2B", "+");
  71.                     boolQuery.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
  72.                 }
  73.             }
  75.             nativeSearchQueryBuilder.withQuery(boolQuery);
  77.             //按照价格进行区间过滤查询
  78.             if (StringUtils.isNotEmpty(searchMap.get("price"))) {
  79.                 String[] prices = searchMap.get("price").split("-");
  80.                 if (prices.length == 2) {
  81.                     //是xx - xx 价格区间的条件
  82.                     boolQuery.filter(QueryBuilders.rangeQuery("price").lte(prices[1]));
  83.                 }
  84.                 boolQuery.filter(QueryBuilders.rangeQuery("price").gte(prices[0]));
  85.             }
  87.             //按照品牌进行分组(聚合)查询
  88.             String skuBrand = "skuBrand";
  89.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
  91.             //按照规格进行聚合查询
  92.             String skuSpec = "skuSpec";
  93.             nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
  95.             //开启分页查询
  96.             String pageNum = searchMap.get("pageNum"); //当前页
  97.             String pageSize = searchMap.get("pageSize"); //每页显示多少条
  98.             if (StringUtils.isEmpty(pageNum)) {
  99.                 pageNum = "1";
  100.             }
  101.             if (StringUtils.isEmpty(pageSize)) {
  102.                 pageSize = "30";
  103.             }
  104.             //设置分页
  105.             nativeSearchQueryBuilder.withPageable(PageRequest.of(Integer.parseInt(pageNum) - 1, Integer.parseInt(pageSize)));
  107.             //按照相关字段进行排序查询
  108.             //1.当前域 2.当前的排序操作(升序ASC,降序DESC)
  109.             if (StringUtils.isNotEmpty(searchMap.get("sortField")) && StringUtils.isNotEmpty(searchMap.get("sortRule"))) {
  110.                 if ("ASC".equals(searchMap.get("sortRule"))) {
  111.                     //升序操作
  112.                     nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.ASC));
  113.                 }else {
  114.                     //降序
  115.                     nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.DESC));
  116.                 }
  117.             }
  119.             //设置高亮域以及高亮的样式
  120.             HighlightBuilder.Field field =new HighlightBuilder.Field("name")//高亮域
  121.                     //高亮前缀
  122.                     .preTags("<span style='color:red'>")
  123.                     //高亮后缀
  124.                     .postTags("</span>");
  125.             nativeSearchQueryBuilder.withHighlightFields(field);
  127.             //开启查询
  128.             /**
  129.              * 第一个参数: 条件的构建对象
  130.              * 第二个参数: 查询操作实体类
  131.              * 第三个参数: 查询结果操作对象
  132.              */
  133.             AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class,
  134.                     new SearchResultMapper() {
  135.                         @Override
  136.                         public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
  137.                             //查询结果操作
  138.                             List<T> list = new ArrayList<>();
  139.                             //获取查询命中的数据
  140.                             SearchHits hits = searchResponse.getHits();
  141.                             if (hits != null) {
  142.                                 //非空
  143.                                 for (SearchHit hit : hits) {
  144.                                     //SearchHit转换为skuinfo
  145.                                     SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
  146.                                     Map<String, HighlightField> highlightFields = hit.getHighlightFields(); //获取所有高亮域
  147.                                     if (highlightFields !=null && highlightFields.size() > 0){
  148.                                         //替换数据
  149.                                         skuInfo.setName(highlightFields.get("name").getFragments()[0].toString());
  150.                                     }
  152.                                     list.add((T) skuInfo);
  153.                                 }
  154.                             }
  155.                             return new AggregatedPageImpl<T>(list, pageable, hits.getTotalHits(), searchResponse.getAggregations());
  156.                         }
  157.                     });
  159.             //封装最终返回结果
  160.             //总记录数
  161.             resultMap.put("total", resultInfo.getTotalElements());
  162.             //总页数
  163.             resultMap.put("totalPages", resultInfo.getTotalPages());
  164.             //数据集合
  165.             resultMap.put("rows", resultInfo.getContent());
  167.             //封装品牌的分组结果
  168.             StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
  169.             List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  170.             resultMap.put("brandList", brandList);
  172.             //封装规格分组结果
  173.             StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
  174.             List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
  175.             resultMap.put("specList", specList);
  177.             //当前页
  178.             resultMap.put("pageNum", pageNum);
  180.             return resultMap;
  181.         }
  183.         return null;
  184.     }
  185. }

请求地址 localhost:9009/search?keywords=电脑 查看关键字是否被添加高亮样式