【elasticsearch】四、SpringData ElasticSearch

迷南。 2023-02-14 13:09 1阅读 0赞

**目录**

一、SpringData ElasticSearch介绍

1.1 SpringData

1.2 SpringData ES

二、使用

2.1 配置文件

2.2 Bean对象构造

2.3 功能讲解

2.3.1 数据批量导入

2.3.2 多条件过滤

2.3.3 聚合搜索

2.3.4 分页查询

2.3.5 排序

2.3.6 高亮搜索

2.3.7 全部代码

--------------------

# 一、SpringData ElasticSearch介绍 #

## 1.1 SpringData  ##

Spring Data 是一个用于简化数据库访问，并支持云服务的开源框架。

其主要目标是使得对数据的访问变得方便快捷，极大的简化 JPA 的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。

## 1.2 SpringData ES ##

SpringData ElasticSearch 是基于 spring data API 简化 elasticsearch 操作。让我们无需使用 elasticsearch 自身提供的 API 就能访问和操作数据库。

# 二、使用 #

## 2.1 配置文件 ##

server:
      port: 18085
    spring:
      application:
        name: search
      main:
        allow-bean-definition-overriding: true #当遇到同样名字的时候，是否允许覆盖注册
      data:
        elasticsearch:
          cluster-name: my-application
          cluster-nodes: 192.168.47.142:9300
    eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:7001/eureka
      instance:
        prefer-ip-address: true
    feign:
      hystrix:
        enabled: true
    # 超时配置
    ribbon:
      ReadTimeout: 300000
    #hystrix 配置
    hystrix:
      command:
        default:
          execution:
            timeout:
              #如果enabled设置为false，则请求超时交给ribbon控制
              enabled: false
            isolation:
              thread:
                timeoutInMillisenconds: 10000

## 2.2 Bean对象构造 ##

import lombok.Data;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.annotations.Field;
 import org.springframework.data.elasticsearch.annotations.FieldType;
 
 import java.io.Serializable;
 import java.util.Date;
 import java.util.Map;
 
 @Document(indexName = "skuinfo", type = "docs")
 @Data
 public class SkuInfo implements Serializable {
 //商品id，同时也是商品编号
 @Id
 @Field(index = true, store = true, type = FieldType.Keyword)
 private Long id;
 
 //SKU名称
 /**
 * index: 添加数据的时候，是否分词
 * type ： text 支持分词
 * analyzer ： 创建索引的分词器
 * store：是否存储
 * searchAnalyzer: 搜索的时候使用的分词器
 */
 @Field(index = true, store = false, type = FieldType.Text, analyzer = "ik_smart")
 private String name;
 
 //商品价格，单位为：元
 @Field(type = FieldType.Double)
 private Long price;
 
 //库存数量
 private Integer num;
 
 //商品图片
 private String image;
 
 //商品状态，1-正常，2-下架，3-删除
 private String status;
 
 //创建时间
 private Date createTime;
 
 //更新时间
 private Date updateTime;
 
 //是否默认
 private String isDefault;
 
 //SPUID
 private Long spuId;
 
 //类目ID
 private Long categoryId;
 
 //类目名称
 /**
 * Type = FieldType.Keyword：不分词
 * 为了确保搜索更精准，不应对类目进行分词
 * 例如：手机、电脑
 */
 @Field(type = FieldType.Keyword)
 private String categoryName;
 
 //品牌名称
 /**
 * 为了确保品牌搜索更为精准，不应对品牌进行分词
 * 例如华为，就是华为
 */
 @Field(type = FieldType.Keyword)
 private String brandName;
 
 //规格
 private String spec;
 
 //规格参数
 private Map<String, Object> specMap;
 }

## 2.3 功能讲解 ##

### 2.3.1 数据批量导入 ###

在使用 elasticsearch 前，需要将数据提交到elasticsearch便于搜索。项目中使用 Feign 从商品服务中获取到数据，并导入这些数据到 elasticsearch

/**
 * 导入索引库
 */
 @Override
 public void importData() {
 // Feign调用，查出SKU数据
 Result<List<Sku>> skuResult = skuFeign.findAll();
 
 // 将LIST<SKU>转换成LIST<SKUINFO>
 List<SkuInfo> skuInfoList = JSON.parseArray(JSON.toJSONString(skuResult.getData()), SkuInfo.class);
 
 
 // 循环当前 skuInfoList
 for (SkuInfo skuInfo : skuInfoList) {
 // 获取spec => Map(Strig) => Map类型
 Map<String, Object> specMap = JSON.parseObject(skuInfo.getSpec(), Map.class);
 // 如果需要生成动态的域，只需要将该域存入到一个Map<String,Object>对象中即可，该
 // Map<String,Object>的key会生成一个域，域的名字为该Map的key
 // 当前Map<String,Object>后面Object的值会作为当前Sku对象该域的值
 skuInfo.setSpecMap(specMap);
 }
 // 调用Dao实现批量导入数据
 skuEsMapper.saveAll(skuInfoList);
 }

### 2.3.2 多条件过滤 ###

通过  NativeSearchQueryBuilder 构建搜索对象，使用 BoolQueryBuilder 构建多条件对象，并且对多条件对象设值的方式，实现多条件过滤

/**
 * 查询条件构建
 * @param searchMap
 * @return
 */
 private NativeSearchQueryBuilder buildBasicQuery(Map<String, String> searchMap) {
 // 构建搜索对象，用于封装各种搜索条件的
 NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
 
 // 构建多条件对象
 BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
 
 /**
 * 根据关键词搜索
 * 构造对应的关键词搜索对象
 */
 if (searchMap != null && searchMap.size() > 0) {
 // 根据关键词搜索
 String keywords = searchMap.get("keywords");
 if (!StringUtils.isEmpty(keywords)) {
 boolQueryBuilder.must(QueryBuilders.queryStringQuery(keywords).field("name"));
 }
 
 // 根据关键词搜索
 String category = searchMap.get("category");
 if (!StringUtils.isEmpty(category)) {
 boolQueryBuilder.must(QueryBuilders.termQuery("categoryName", category));
 }
 
 // 根据关键词搜索
 String brand = searchMap.get("brand");
 if (!StringUtils.isEmpty(brand)) {
 boolQueryBuilder.must(QueryBuilders.termQuery("brandName", brand));
 }
 
 // 规格过滤实现
 // 由于可能存在多个规格，故需要循环取出以spec_开头的内容
 for (Map.Entry<String, String> entry : searchMap.entrySet()) {
 String key = entry.getKey();
 if (key.startsWith("spec_")) {
 String value = entry.getValue();
 boolQueryBuilder.must(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
 }
 }
 
 // 加个区间筛选 0-500元 500-1000元 ... 3000元以上
 // 去掉元和以上，根据-分割 [0,500] ... [3000]
 // 根据关键词搜索
 String price = searchMap.get("price");
 if (!StringUtils.isEmpty(price)) {
 price = price.replace("元", "").replace("以上", "");
 String[] prices = price.split("-");
 if (prices != null && prices.length > 0) {
 if (prices[0] != null) {
 boolQueryBuilder.must(QueryBuilders.rangeQuery("price").gt(Integer.parseInt(prices[0])));
 }
 if (prices.length > 1 && Double.valueOf(prices[1]) > Double.valueOf(prices[0])) {
 boolQueryBuilder.must(QueryBuilders.rangeQuery("price").lte(Integer.parseInt(prices[1])));
 }
 }
 }
 }
 builder.withQuery(boolQueryBuilder);
 return builder;
 }

### 2.3.3 聚合搜索 ###

聚合搜索等同于数据库中的 group by，即对结果集进行分组

**调用函数：**

/**
 * 多条件搜索
 * @param searchMap
 * @return
 */
 @Override
 public Map<String, Object> search(Map<String, String> searchMap){
 // 基本条件构建
 NativeSearchQueryBuilder builder = buildBasicQuery(searchMap);
 
 // 集合搜索
 // 当用户没有输入集合选择的时候，则需要去搜索，若选择了，则无需再去搜索
 Map<String, Object> resultMap = searchList(builder);
 // 获取分组数据
 Map<String, Object> groupMap = searchGroupList(builder, searchMap);
 // 合并分组数据和搜索数据
 resultMap.putAll(groupMap);
 
 return resultMap;
 }

**实现方法：**

/**
 * 结果集搜索
 * @param builder
 * @return
 */
 private Map<String, Object> searchList(NativeSearchQueryBuilder builder) {
 
 /// 开启高亮和配置 ///
 // 将商品名称作为高亮对象
 HighlightBuilder.Field field = new HighlightBuilder.Field("name");
 // 前缀 
 field.preTags("");
 // 后缀 
 field.postTags("");
 // 后缀长度 关键词数据的长度
 field.fragmentSize(100);
 // 添加高亮
 builder.withHighlightFields(field);
 
 /**
 * 执行搜索
 * 1. 搜索条件封装
 * 2. 搜索结果集（集合数据），需要转换的类型
 * 3. AggregatedPage<SkuInfo> 搜索结果集的封装
 */
 AggregatedPage<SkuInfo> page = elasticsearchTemplate
 .queryForPage(
 builder.build(), // 搜索条件封装
 SkuInfo.class, // 数据集合要转换的类型的字节码
 new SearchResultMapper() { // 执行搜索后，将数据结果集封装到该对象中
 @Override
 public <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> aClass, Pageable pageable) {
 // 存储所有转换后的高亮数据对象
 List<T> list = new ArrayList<>();
 
 // 执行查询，获取所有数据=>结果集[非高亮数据，高亮数据]
 for (SearchHit hit : response.getHits()) {
 // 分析结果集数据，获取非高亮数据
 SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
 // 分析结果集数据，获取高亮数据 => 只有某个域的高亮数据
 HighlightField highlightField = hit.getHighlightFields().get("name");
 if (highlightField != null && highlightField.getFragments() != null) {
 // 将高亮数据读取出来
 Text[] fragments = highlightField.getFragments();
 StringBuffer buffer = new StringBuffer();
 for (Text fragment : fragments) {
 buffer.append(fragment.toString());
 }
 // 将非高亮数据中指定的域替换成高亮数据
 skuInfo.setName(buffer.toString());
 }
 // 将高亮数据添加到集合中
 list.add((T)skuInfo);
 }
 // 将数据返回
 /**
 * 1. 搜索的集合数据（携带高亮）
 * 2. 分页对象信息
 * 3. 搜索记录的总条数
 */
 return new AggregatedPageImpl<T>(list, pageable, response.getHits().getTotalHits());
 }
 });
 
 // 获取数据结果集
 long totalElements = page.getTotalElements();
 int totalPages = page.getTotalPages();
 List<SkuInfo> contents = page.getContent();
 
 // 封装一个Map存储所有数据，并返回
 Map<String, Object> resultMap = new HashMap<String, Object>();
 resultMap.put("rows", contents);
 resultMap.put("total", totalElements);
 resultMap.put("totalPages", totalPages);
 return resultMap;
 }
 
 /**
 * 分组查询 => 根据分类分组、品牌分组、规格分组
 * @param builder
 * @return
 */
 private Map<String, Object> searchGroupList(NativeSearchQueryBuilder builder, Map<String, String> searchMap) {
 /**
 * 根据分类名称进行分组
 * addAggregation 添加一个聚合操作
 * 1）skuCategory 取别名
 * 2）categoryName 表示根据哪个域进行分组查询
 */
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("category"))) {
 builder.addAggregation(AggregationBuilders.terms("skuCategory").field("categoryName"));
 }
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("brand"))) {
 builder.addAggregation(AggregationBuilders.terms("skuBrand").field("brandName"));
 }
 builder.addAggregation(AggregationBuilders.terms("skuSpec").field("spec.keyword"));
 // 根据条件分组获取
 AggregatedPage<SkuInfo> aggregatedPage = elasticsearchTemplate.queryForPage(builder.build(), SkuInfo.class);
 
 // 定义一个Map，存储所有分组结果
 Map<String, Object> groupMapResult = new HashMap<String, Object>();
 
 /**
 * 获取分组数据
 * getAggregations 获取的是集合，可以根据多个域进行分组
 * .get("skuCategory") 获取指定域的集合数据
 */
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("caategory"))) {
 StringTerms categoryTerms = aggregatedPage.getAggregations().get("skuCategory");
 // 获取分类分组集合数据
 List<String> categoryList = getGroupList(categoryTerms);
 groupMapResult.put("categoryList", categoryList);
 }
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("brand"))) {
 StringTerms brandTerms = aggregatedPage.getAggregations().get("skuBrand");
 // 获取品牌分组集合数据
 List<String> brandList = getGroupList(brandTerms);
 groupMapResult.put("brandList", brandList);
 }
 
 // 获取规格分组集合数据
 StringTerms specTerms = aggregatedPage.getAggregations().get("skuSpec");
 List<String> specList = getGroupList(specTerms);
 groupMapResult.put("specList", specList);
 
 return groupMapResult;
 }

### 2.3.4 分页查询 ###

当数据量过多时，可以使用分页查询配合前端展示。

通过 withPageable 设置分页参数

**测试：**

http://localhost:18085/search?keywords=%E5%8D%8E%E4%B8%BA&pageNum=2&pageSize=3

### 2.3.5 排序 ###

通过 withSort 实现排序

**测试：**

http://localhost:18085/search?pageNum=1&sortField=price&sortRule=desc

### 2.3.6 高亮搜索 ###

高亮搜索指根据商品关键字搜索商品时，显示的页面对关键字给定了特殊样式，让他显示得更加突出。

如京东，对高亮搜索的关键词显示为红色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx_size_16_color_FFFFFF_t_70][]

**测试：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx_size_16_color_FFFFFF_t_70 1][]

### 2.3.7 全部代码 ###

import com.alibaba.fastjson.JSON;
 import io.swagger.models.auth.In;
 import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.common.text.Text;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.search.SearchHit;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
 import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
 import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
 import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
 import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortOrder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
 import org.springframework.data.elasticsearch.core.SearchResultMapper;
 import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
 import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
 import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 
 import java.util.*;
 
 /**
 * @File: SkuServiceImpl
 * @Description:
 * @Author: tom
 * @Create: 2020-06-04 09:13
 **/
 @Service
 public class SkuServiceImpl implements SkuService {
 
 @Autowired
 private SkuFeign skuFeign;
 
 @Autowired
 private SkuEsMapper skuEsMapper;
 
 /**
 * ElasticsearchTemplate： 可以实现索引库的增删改查
 */
 @Autowired
 private ElasticsearchTemplate elasticsearchTemplate;
 
 /**
 * 多条件搜索
 * @param searchMap
 * @return
 */
 @Override
 public Map<String, Object> search(Map<String, String> searchMap){
 // 基本条件构建
 NativeSearchQueryBuilder builder = buildBasicQuery(searchMap);
 
 // 集合搜索
 // 当用户没有输入集合选择的时候，则需要去搜索，若选择了，则无需再去搜索
 Map<String, Object> resultMap = searchList(builder);
 // 获取分组数据
 Map<String, Object> groupMap = searchGroupList(builder, searchMap);
 resultMap.putAll(groupMap);
 
 return resultMap;
 }
 
 /**
 * 查询条件构建
 * @param searchMap
 * @return
 */
 private NativeSearchQueryBuilder buildBasicQuery(Map<String, String> searchMap) {
 // 构建搜索对象，用于封装各种搜索条件的
 NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
 
 // 构建多条件对象
 BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
 
 /**
 * 根据关键词搜索
 * 构造对应的关键词搜索对象
 */
 if (searchMap != null && searchMap.size() > 0) {
 // 根据关键词搜索
 String keywords = searchMap.get("keywords");
 if (!StringUtils.isEmpty(keywords)) {
 boolQueryBuilder.must(QueryBuilders.queryStringQuery(keywords).field("name"));
 }
 
 // 根据关键词搜索
 String category = searchMap.get("category");
 if (!StringUtils.isEmpty(category)) {
 boolQueryBuilder.must(QueryBuilders.termQuery("categoryName", category));
 }
 
 // 根据关键词搜索
 String brand = searchMap.get("brand");
 if (!StringUtils.isEmpty(brand)) {
 boolQueryBuilder.must(QueryBuilders.termQuery("brandName", brand));
 }
 
 // 规格过滤实现
 // 由于可能存在多个规格，故需要循环取出以spec_开头的内容
 for (Map.Entry<String, String> entry : searchMap.entrySet()) {
 String key = entry.getKey();
 if (key.startsWith("spec_")) {
 String value = entry.getValue();
 boolQueryBuilder.must(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", value));
 }
 }
 
 // 加个区间筛选 0-500元 500-1000元 ... 3000元以上
 // 去掉元和以上，根据-分割 [0,500] ... [3000]
 // 根据关键词搜索
 String price = searchMap.get("price");
 if (!StringUtils.isEmpty(price)) {
 price = price.replace("元", "").replace("以上", "");
 String[] prices = price.split("-");
 if (prices != null && prices.length > 0) {
 if (prices[0] != null) {
 boolQueryBuilder.must(QueryBuilders.rangeQuery("price").gt(Integer.parseInt(prices[0])));
 }
 if (prices.length > 1 && Double.valueOf(prices[1]) > Double.valueOf(prices[0])) {
 boolQueryBuilder.must(QueryBuilders.rangeQuery("price").lte(Integer.parseInt(prices[1])));
 }
 }
 }
 
 /**
 * 排序实现
 */
 String sortField = searchMap.get("sortField");
 String sortRole = searchMap.get("sortRule");
 if (!StringUtils.isEmpty(sortField) && !StringUtils.isEmpty(sortRole)) {
 builder.withSort(new FieldSortBuilder(sortField).order(SortOrder.valueOf(sortRole.toUpperCase())));
 }
 }
 
 // 分页处理，若不传则默认第一页
 Map<String, Integer> pageMap = coverterPage(searchMap);
 builder.withPageable(PageRequest.of(pageMap.get("pageNum") - 1, pageMap.get("pageSize")));
 
 builder.withQuery(boolQueryBuilder);
 return builder;
 }
 
 /**
 * 接收前端传入的分页参数
 * @param searchMap
 * @return
 */
 public Map<String,Integer> coverterPage(Map<String,String> searchMap) {
 Map<String, Integer> map = new HashMap<String, Integer>();
 Integer defPageNum = 1;
 Integer defPageSize = 10;
 
 if (searchMap != null){
 try {
 if (!StringUtils.isEmpty(searchMap.get("pageNum"))) {
 map.put("pageNum",Integer.parseInt(searchMap.get("pageNum")));
 } else {
 map.put("pageNum", defPageNum);
 }
 if (!StringUtils.isEmpty(searchMap.get("pageSize"))) {
 map.put("pageSize",Integer.parseInt(searchMap.get("pageSize")));
 } else {
 map.put("pageSize", defPageSize);
 }
 } catch (Exception e) {
 map.put("pageNum", defPageNum);
 map.put("pageSize", defPageSize);
 }
 }
 return map;
 }
 
 /**
 * 结果集搜索
 * @param builder
 * @return
 */
 private Map<String, Object> searchList(NativeSearchQueryBuilder builder) {
 
 /// 开启高亮和配置 ///
 // 将商品名称作为高亮对象
 HighlightBuilder.Field field = new HighlightBuilder.Field("name");
 // 前缀 
 field.preTags("");
 // 后缀 
 field.postTags("");
 // 后缀长度 关键词数据的长度
 field.fragmentSize(100);
 // 添加高亮
 builder.withHighlightFields(field);
 
 /**
 * 执行搜索
 * 1. 搜索条件封装
 * 2. 搜索结果集（集合数据），需要转换的类型
 * 3. AggregatedPage<SkuInfo> 搜索结果集的封装
 */
 AggregatedPage<SkuInfo> page = elasticsearchTemplate
 .queryForPage(
 builder.build(), // 搜索条件封装
 SkuInfo.class, // 数据集合要转换的类型的字节码
 new SearchResultMapper() { // 执行搜索后，将数据结果集封装到该对象中
 @Override
 public <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> aClass, Pageable pageable) {
 // 存储所有转换后的高亮数据对象
 List<T> list = new ArrayList<>();
 
 // 执行查询，获取所有数据=>结果集[非高亮数据，高亮数据]
 for (SearchHit hit : response.getHits()) {
 // 分析结果集数据，获取非高亮数据
 SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
 // 分析结果集数据，获取高亮数据 => 只有某个域的高亮数据
 HighlightField highlightField = hit.getHighlightFields().get("name");
 if (highlightField != null && highlightField.getFragments() != null) {
 // 将高亮数据读取出来
 Text[] fragments = highlightField.getFragments();
 StringBuffer buffer = new StringBuffer();
 for (Text fragment : fragments) {
 buffer.append(fragment.toString());
 }
 // 将非高亮数据中指定的域替换成高亮数据
 skuInfo.setName(buffer.toString());
 }
 // 将高亮数据添加到集合中
 list.add((T)skuInfo);
 }
 // 将数据返回
 /**
 * 1. 搜索的集合数据（携带高亮）
 * 2. 分页对象信息
 * 3. 搜索记录的总条数
 */
 return new AggregatedPageImpl<T>(list, pageable, response.getHits().getTotalHits());
 }
 });
 
 // 获取数据结果集
 long totalElements = page.getTotalElements();
 int totalPages = page.getTotalPages();
 List<SkuInfo> contents = page.getContent();
 
 // 封装一个Map存储所有数据，并返回
 Map<String, Object> resultMap = new HashMap<String, Object>();
 resultMap.put("rows", contents);
 resultMap.put("total", totalElements);
 resultMap.put("totalPages", totalPages);
 return resultMap;
 }
 
 /**
 * 分组查询 => 根据分类分组、品牌分组、规格分组
 * @param builder
 * @return
 */
 private Map<String, Object> searchGroupList(NativeSearchQueryBuilder builder, Map<String, String> searchMap) {
 /**
 * 根据分类名称进行分组
 * addAggregation 添加一个聚合操作
 * 1）skuCategory 取别名
 * 2）categoryName 表示根据哪个域进行分组查询
 */
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("category"))) {
 builder.addAggregation(AggregationBuilders.terms("skuCategory").field("categoryName"));
 }
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("brand"))) {
 builder.addAggregation(AggregationBuilders.terms("skuBrand").field("brandName"));
 }
 builder.addAggregation(AggregationBuilders.terms("skuSpec").field("spec.keyword"));
 AggregatedPage<SkuInfo> aggregatedPage = elasticsearchTemplate.queryForPage(builder.build(), SkuInfo.class);
 
 // 定义一个Map，存储所有分组结果
 Map<String, Object> groupMapResult = new HashMap<String, Object>();
 
 /**
 * 获取分组数据
 * getAggregations 获取的是集合，可以根据多个域进行分组
 * .get("skuCategory") 获取指定域的集合数据
 */
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("caategory"))) {
 StringTerms categoryTerms = aggregatedPage.getAggregations().get("skuCategory");
 // 获取分类分组集合数据
 List<String> categoryList = getGroupList(categoryTerms);
 groupMapResult.put("categoryList", categoryList);
 }
 if (searchMap == null || StringUtils.isEmpty(searchMap.get("brand"))) {
 StringTerms brandTerms = aggregatedPage.getAggregations().get("skuBrand");
 // 获取品牌分组集合数据
 List<String> brandList = getGroupList(brandTerms);
 groupMapResult.put("brandList", brandList);
 }
 
 // 获取规格分组集合数据
 StringTerms specTerms = aggregatedPage.getAggregations().get("skuSpec");
 List<String> specList = getGroupList(specTerms);
 groupMapResult.put("specList", specList);
 
 return groupMapResult;
 }
 
 /**
 * 获取分组集合数据
 * @param stringTerms
 * @return
 */
 public List<String> getGroupList(StringTerms stringTerms) {
 List<String> groupList = new ArrayList<String>();
 for (StringTerms.Bucket bucket : stringTerms.getBuckets()) {
 String keyName = bucket.getKeyAsString();
 groupList.add(keyName);
 }
 return groupList;
 }
 
 /**
 * 分类分组查询
 * @param builder
 * @return
 */
 private List<String> searchCategoryList(NativeSearchQueryBuilder builder) {
 /**
 * 根据分类名称进行分组
 * addAggregation 添加一个聚合操作
 * 1）skuCategory 取别名
 * 2）categoryName 表示根据哪个域进行分组查询
 */
 builder.addAggregation(AggregationBuilders.terms("skuCategory").field("categoryName"));
 AggregatedPage<SkuInfo> aggregatedPage = elasticsearchTemplate.queryForPage(builder.build(), SkuInfo.class);
 /**
 * 获取分组数据
 * getAggregations 获取的是集合，可以根据多个域进行分组
 * .get("skuCategory") 获取指定域的集合数据
 */
 StringTerms aggregation = aggregatedPage.getAggregations().get("skuCategory");
 List<String> categoryList = new ArrayList<String>();
 for (StringTerms.Bucket bucket : aggregation.getBuckets()) {
 String categoryName = bucket.getKeyAsString();// 其中的一个分类名称，如手机
 categoryList.add(categoryName);
 }
 return categoryList;
 }
 
 /**
 * 品牌分组查询
 * @param builder
 * @return
 */
 private List<String> searchBrandList(NativeSearchQueryBuilder builder) {
 /**
 * 根据品牌名称进行分组
 * addAggregation 添加一个聚合操作
 * 1）skuCategory 取别名
 * 2）categoryName 表示根据哪个域进行分组查询
 */
 builder.addAggregation(AggregationBuilders.terms("skuBrand").field("brandName"));
 AggregatedPage<SkuInfo> aggregatedPage = elasticsearchTemplate.queryForPage(builder.build(), SkuInfo.class);
 /**
 * 获取分组数据
 * getAggregations 获取的是集合，可以根据多个域进行分组
 * .get("skuCategory") 获取指定域的集合数据 {华为，小米，中型}
 */
 StringTerms aggregation = aggregatedPage.getAggregations().get("skuBrand");
 List<String> brandList = new ArrayList<String>();
 for (StringTerms.Bucket bucket : aggregation.getBuckets()) {
 String categoryName = bucket.getKeyAsString();// 其中的一个分类名称，如手机
 brandList.add(categoryName);
 }
 return brandList;
 }
 
 /**
 * 规格分组查询
 * @param builder
 * @return
 */
 private Map<String, Set<String>> searchSpecList(NativeSearchQueryBuilder builder) {
 /**
 * 根据规格名称进行分组
 * addAggregation 添加一个聚合操作
 * 1）skuCategory 取别名
 * 2）categoryName 表示根据哪个域进行分组查询
 */
 builder.addAggregation(AggregationBuilders.terms("skuSpec").field("spec.keyword"));
 AggregatedPage<SkuInfo> aggregatedPage = elasticsearchTemplate.queryForPage(builder.build(), SkuInfo.class);
 /**
 * 获取规格数据
 * getAggregations 获取的是集合，可以根据多个域进行分组
 * .get("skuCategory") 获取指定域的集合数据
 */
 StringTerms aggregation = aggregatedPage.getAggregations().get("skuSpec");
 List<String> specList = new ArrayList<String>();
 for (StringTerms.Bucket bucket : aggregation.getBuckets()) {
 String specName = bucket.getKeyAsString();// 其中的一个分类名称，如手机
 specList.add(specName);
 }
 
 // 循环 specList，将每个JSON字符串转成Map
 Map<String, Set<String>> allSpec = new HashMap<String, Set<String>>();
 for (String spec : specList) {
 Map<String, String> specMap = JSON.parseObject(spec, Map.class);
 for (Map.Entry<String, String> entry : specMap.entrySet()) {
 String key = entry.getKey(); // 规格名字
 String value = entry.getValue(); // 规格值
 
 // 将当前循环的数据整合
 Set<String> specSet = allSpec.get(key);
 if (specSet == null) {
 specSet = new HashSet<String>();
 }
 specSet.add(value);
 allSpec.put(key, specSet);
 }
 }
 return allSpec;
 }
 
 /**
 * 导入索引库
 */
 @Override
 public void importData() {
 // Feign调用，查出SKU数据
 Result<List<Sku>> skuResult = skuFeign.findAll();
 
 // 将LIST<SKU>转换成LIST<SKUINFO>
 List<SkuInfo> skuInfoList = JSON.parseArray(JSON.toJSONString(skuResult.getData()), SkuInfo.class);
 
 
 // 循环当前 skuInfoList
 for (SkuInfo skuInfo : skuInfoList) {
 // 获取spec => Map(Strig) => Map类型
 Map<String, Object> specMap = JSON.parseObject(skuInfo.getSpec(), Map.class);
 // 如果需要生成动态的域，只需要将该域存入到一个Map<String,Object>对象中即可，该
 // Map<String,Object>的key会生成一个域，域的名字为该Map的key
 // 当前Map<String,Object>后面Object的值会作为当前Sku对象该域的值
 skuInfo.setSpecMap(specMap);
 }
 // 调用Dao实现批量导入数据
 skuEsMapper.saveAll(skuInfoList);
 }
 }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202006051132400.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200605220338390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDE2MzMx,size_16,color_FFFFFF,t_70