使用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"
}
}
}
}
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;
}
}
添加上聚合，高亮，过滤搜索的完整代码
/**
* @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;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
