1
@Data
2
public class SearchAttr {
3
    @Field(type = FieldType.Long)
4
    private Long attrId;
5

6
    @Field(type = FieldType.Keyword)
7
    private String attrValue;
8

9
    @Field(type = FieldType.Keyword)
10
    private String attrName;
11
}

1
{
2
  "id": 101,
3
  "title": "某手机 256G 红色",
4
  "price": 2999.0,
5
  "tmId": 9,
6
  "hotScore": 20,
7
  "attrs": [
8
    {"attrId": 1, "attrName": "颜色", "attrValue": "红色"},
9
    {"attrId": 2, "attrName": "容量", "attrValue": "256G"}
10
  ]
11
}

1
private Long firstLevelCategoryId;
2
private Long secondLevelCategoryId;
3
private Long thirdLevelCategoryId;
4
private String trademark;
5
private String keyword;
6
private String order = "";
7
private String[] props;
8
private Integer pageNo = 1;
9
private Integer pageSize = 3;

1
@GetMapping("/list")
2
public Result list(SearchParam searchParam) throws IOException {
3
    SearchResponseDTO response = searchService.search(searchParam);
4
    return Result.ok(response);
5
}

1
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
2

3
buildDSL(builder, searchParam);
4
NativeSearchQuery query = builder.build();
5

6
SearchHits<Goods> hits =
7
        elasticsearchRestTemplate.search(query, Goods.class);
8

9
return parseResponseAsync(hits, searchParam);

1
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
2

3
String keyword = searchParam.getKeyword();
4
if (StringUtils.isNotBlank(keyword)) {
5
    boolQuery.must(QueryBuilders.matchQuery("title", keyword));
6
}
7

8
Long firstCategoryId = searchParam.getFirstLevelCategoryId();
9
if (firstCategoryId != null) {
10
    boolQuery.filter(QueryBuilders.termQuery(
11
            "firstLevelCategoryId", firstCategoryId));
12
}

1
String trademark = searchParam.getTrademark();
2
if (StringUtils.isNotBlank(trademark)) {
3
    String[] split = trademark.split(":");
4
    if (split.length == 2) {
5
        boolQuery.filter(
6
                QueryBuilders.termQuery("tmId", split[0]));
7
    }
8
}

1
for (String prop : searchParam.getProps()) {
2
    String[] split = prop.split(":");
3
    Long attrId = Long.valueOf(split[0]);
4
    String attrValue = split[1];
5

6
    BoolQueryBuilder subQuery = QueryBuilders.boolQuery()
7
            .filter(QueryBuilders.termQuery("attrs.attrId", attrId))
8
            .filter(QueryBuilders.termQuery("attrs.attrValue", attrValue));
9

10
    NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery(
11
            "attrs", subQuery, ScoreMode.None);
12
    boolQuery.filter(nestedQuery);
13
}

1
attrs[0] = { attrId: 1, attrValue: 红色 }
2
attrs[1] = { attrId: 2, attrValue: 256G }

1
PageRequest pageRequest = PageRequest.of(
2
        searchParam.getPageNo() - 1,
3
        searchParam.getPageSize());
4

5
nativeSearchQueryBuilder.withPageable(pageRequest);

1
if (StringUtils.isNotBlank(keyword)) {
2
    HighlightBuilder highlight = new HighlightBuilder();
3
    highlight.field("title");
4
    highlight.preTags("<span style='color:red'>");
5
    highlight.postTags("</span>");
6
    nativeSearchQueryBuilder.withHighlightBuilder(highlight);
7
}

1
TermsAggregationBuilder tmAgg = AggregationBuilders
2
        .terms("tmId_bucket")
3
        .field("tmId")
4
        .subAggregation(AggregationBuilders
5
                .terms("tmName_bucket").field("tmName"))
6
        .subAggregation(AggregationBuilders
7
                .terms("tmLogoUrl_bucket").field("tmLogoUrl"));
8

9
nativeSearchQueryBuilder.withAggregations(tmAgg);

1
NestedAggregationBuilder attrsAgg = AggregationBuilders
2
        .nested("attrsAgg", "attrs")
3
        .subAggregation(
4
                AggregationBuilders.terms("attrIdAgg")
5
                        .field("attrs.attrId")
6
                        .subAggregation(AggregationBuilders
7
                                .terms("attrNameAgg")
8
                                .field("attrs.attrName"))
9
                        .subAggregation(AggregationBuilders
10
                                .terms("attrValueAgg")
11
                                .field("attrs.attrValue"))
12
        );

1
attrsAgg
2
  -> attrIdAgg
3
      -> attrNameAgg
4
      -> attrValueAgg

1
FetchSourceFilter sourceFilter = new FetchSourceFilter(
2
        new String[]{"id", "defaultImg", "title", "price"},
3
        null);
4

5
nativeSearchQueryBuilder.withSourceFilter(sourceFilter);

1
List<Goods> goodsList = searchHits.getSearchHits().stream()
2
        .map(hit -> {
3
            Goods content = hit.getContent();
4
            List<String> titles = hit.getHighlightField("title");
5
            if (CollectionUtils.isNotEmpty(titles)) {
6
                content.setTitle(titles.get(0));
7
            }
8
            return content;
9
        })
10
        .collect(Collectors.toList());
11

12
searchResponseDTO.setGoodsList(
13
        goodsConverter.goodsPOs2DTOs(goodsList));

1
Nested attrsAgg = aggregations.get("attrsAgg");
2
Terms attrIdAgg = attrsAgg.getAggregations().get("attrIdAgg");
3

4
List<String> values = attrValueAgg.getBuckets()
5
        .stream()
6
        .map(bucket -> bucket.getKeyAsString())
7
        .collect(Collectors.toList());
8

9
responseAttrDTO.setAttrId(attrId);
10
responseAttrDTO.setAttrName(attrName);
11
responseAttrDTO.setAttrValueList(values);

1
long totalHits = searchHits.getTotalHits();
2
Integer pageSize = searchParam.getPageSize();
3
long totalPages = (long) Math.ceil((double) totalHits / pageSize);
4

5
if (totalPages == 0) {
6
    totalPages = 1;
7
}
8

9
searchResponseDTO.setTotal(totalHits);
10
searchResponseDTO.setPageNo(searchParam.getPageNo());
11
searchResponseDTO.setPageSize(pageSize);
12
searchResponseDTO.setTotalPages(totalPages);