ElasticSearch在SpringBoot中的操作

import lombok.Data;

/**
 * @author Sun Jiandong
 * @description 分页信息参数
 */
@Data
public class PageInfo {
    /**
     * 当前页码
     */
    private Integer pageNo;
    /**
     * 分页页码
     */
    private Integer pageSize;

    /**
     * 分页起始指针
     */
    private Integer start;
    /**
     * 分页结束指针
     */
    private Integer end;

    public Integer getStart() {
        return (pageNo - 1) * pageSize;
    }

    public Integer getEnd() {
        return pageSize;
    }

    /**
     * 获取当前页码
     *
     * @return 当前页码
     */
    public Integer getPageNo() {
        if (pageNo == null || pageNo < 1) {
            pageNo = 1;
        }
        return pageNo;
    }

    /**
     * 获取每页显示记录数
     *
     * @return 每页记录数
     */
    public Integer getPageSize() {
        if (pageSize == null || pageSize < 1 || pageSize > 500) {
            pageSize = 50;
        }
        return pageSize;
    }
}

ES聚合请求实体

import lombok.Data;

import java.util.List;

/**
 * @author Sun Jiandong
 * @description Es聚合请求实体
 */ 
@Data
public class EsAggregationParam {
    /**
     * 聚合名称
     */
    private String name;
    /**
     * 子聚合
     */
    private List<EsAggregationParam> childAggregation;
}

ES通用响应实体

import lombok.Data;

import java.util.LinkedList;
import java.util.List;

/**
 * @author Sun Jiandong
 * @description Es响应结果通用实体类
 */
@Data
public class EsResult<T> {

    /**
     * 当前页码
     */
    private Integer pageNo;
    /**
     * 每页记录数
     */
    private Integer pageSize;
    /**
     * 总记录数
     */
    private Long total;
    /**
     * 总页码
     */
    private Long totalPage;
    /**
     * 最高得分
     */
    private Double maxScore;
    /**
     * 数据集合
     */
    private LinkedList<T> data;
    /**
     * 聚合结果
     */
    private List<AggregationResult> aggregationResultList;

    /**
     * 聚合响应实体
     */
    @Data
    public static class AggregationResult {

        /**
         * 聚合桶数据
         */
        private List<AggregationBucket> buckets;
        /**
         * 聚合桶值
         */
        private Double value;

        /**
         * 聚合结果
         */
        @Data
        public static class AggregationBucket {
            /**
             * 聚合字段
             */
            private String key;
            /**
             * 聚合记录数
             */
            private Long count;
            /**
             * 子聚合结果
             */
            private List<AggregationResult> childAggregationResult;
        }
    }

}

ES结构解析工具类

import com.hr.sjd.common.es.EsAggregationParam;
import com.hr.sjd.common.es.EsResult;
import com.hr.sjd.common.request.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.Avg;
import org.elasticsearch.search.aggregations.metrics.Max;
import org.elasticsearch.search.aggregations.metrics.Min;
import org.elasticsearch.search.aggregations.metrics.Sum;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Function;

/**
 * @author Sun Jiandong
 * @description Es结果解析的工具类
 */
@Slf4j
public class EsParseUtil {

    /**
     * 解析聚合
     *
     * @param aggregations         所有聚合
     * @param aggregationParamList 聚合参数
     * @return
     */
    private static List<EsResult.AggregationResult> parseAggregation(Aggregations aggregations, List<EsAggregationParam> aggregationParamList) {
        //无聚合则返回空
        if (aggregationParamList == null || aggregationParamList.size() == 0) {
            return Collections.emptyList();
        }

        //所有聚合列表结果
        ArrayList<EsResult.AggregationResult> aggregationResultList = new ArrayList<>();

        //遍历聚合
        for (EsAggregationParam aggregationParam : aggregationParamList) {
            Aggregation aggregation = aggregations.get(aggregationParam.getName());
            //当前聚合的结果
            EsResult.AggregationResult aggregationResult = new EsResult.AggregationResult();
            //解析当前聚合
            if (aggregation instanceof Terms) {
                Terms terms = (Terms) aggregation;
                ArrayList<EsResult.AggregationResult.AggregationBucket> aggregationBuckets = new ArrayList<>();
                for (Terms.Bucket bucket : terms.getBuckets()) {
                    EsResult.AggregationResult.AggregationBucket aggregationBucket = new EsResult.AggregationResult.AggregationBucket();
                    //设置子聚合结果
                    List<EsResult.AggregationResult> childAggregationResult = parseAggregation(bucket.getAggregations(), aggregationParam.getChildAggregation());
                    aggregationBucket.setChildAggregationResult(childAggregationResult);

                    //设置当前聚合结果
                    aggregationBucket.setKey(bucket.getKeyAsString());
                    aggregationBucket.setCount(bucket.getDocCount());

                    aggregationBuckets.add(aggregationBucket);
                }
                aggregationResult.setBuckets(aggregationBuckets);
            } else if (aggregation instanceof Avg) {
                Avg avg = (Avg) aggregation;
                aggregationResult.setValue(avg.getValue());
            } else if (aggregation instanceof Sum) {
                Sum sum = (Sum) aggregation;
                aggregationResult.setValue(sum.getValue());
            } else if (aggregation instanceof Min) {
                Min min = (Min) aggregation;
                aggregationResult.setValue(min.getValue());
            } else if (aggregation instanceof Max) {
                Max max = (Max) aggregation;
                aggregationResult.setValue(max.getValue());
            } else {
                log.warn("聚合解析未匹配:{}", aggregation);
            }

            //添加当前聚合结果
            aggregationResultList.add(aggregationResult);
        }

        return aggregationResultList;
    }

    /**
     * 结果解析
     *
     * @param searchResponse 响应结果
     */
    public static <T> EsResult<T> parseResult(SearchResponse searchResponse,
                                              PageInfo pageInfo,
                                              Function<String, T> function,
                                              List<EsAggregationParam> aggregationParamList) {
        EsResult<T> esResult = new EsResult<>();

        Integer pageNo = pageInfo.getPageNo();
        Integer pageSize = pageInfo.getPageSize();
        /**
         * 设置起始指针
         */
        esResult.setPageNo(pageNo);

        /**
         * 设置每页记录数
         */
        esResult.setPageSize(pageSize);

        /**
         * 设置总记录数
         */
        SearchHits hits = searchResponse.getHits();
        long total = hits.getTotalHits().value;
        esResult.setTotal(total);

        /**
         * 设置总页码
         */
        long totalPage = total / pageSize == 0 ? total / pageSize : total / pageSize + 1;
        esResult.setTotalPage(totalPage);

        /**
         * 设置最大得分
         */
        esResult.setMaxScore((double) hits.getMaxScore());

        /**
         * 设置数据
         */
        LinkedList<T> list = new LinkedList<>();
        for (SearchHit hit : hits.getHits()) {
            String json = hit.getSourceAsString();
            T data = function.apply(json);

            Class<?> tClass = data.getClass();
            //将高亮字段重新赋值回实体类
            hit.getHighlightFields().forEach((field, highLightField) -> {
                try {
                    Field classField = tClass.getDeclaredField(field);
                    classField.setAccessible(true);
                    classField.set(data, highLightField.getFragments()[0].toString());
                } catch (Exception e) {
                    log.error("es高亮反射赋值失败", e);
                }
            });

            list.addLast(data);
        }
        esResult.setData(list);

        /**
         * 解析聚合
         */
        List<EsResult.AggregationResult> aggregationResults = parseAggregation(searchResponse.getAggregations(), aggregationParamList);
        esResult.setAggregationResultList(aggregationResults);

        return esResult;
    }
}

API操作

文档操作

批量删除

/**
     * 批量删除文档
     *
     * @throws IOException
     */
    @Test
    void bulkRemove() throws IOException {
        BulkRequest request = new BulkRequest("user");

        DeleteRequest deleteRequest1 = new DeleteRequest()
                .id("1");
        request.add(deleteRequest1);

        DeleteRequest deleteRequest2 = new DeleteRequest()
                .id("2");
        request.add(deleteRequest2);

        client.bulk(request, RequestOptions.DEFAULT);
    }

批量保存

/**
     * 批量操作文档
     *
     * @throws IOException
     */
    @Test
    void bulkSave() throws IOException {
        BulkRequest bulkRequest = new BulkRequest("user");
        List<User> userList = userService.list();

        for (User user : userList) {
            User.EsUser esUser = BeanUtil.copyProperties(user, User.EsUser.class);
            esUser.setFirstName(user.getName().substring(0, 1));
            esUser.setLastName(user.getName().substring(1));

            IndexRequest request = new IndexRequest()
                    .id(user.getId().toString())
                    .source(JSONUtil.toJsonStr(esUser), XContentType.JSON);

            bulkRequest.add(request);
        }

        client.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

批量更新

/**
     * 批量修改数据,增量修改
     *
     * @throws Exception
     */
    @Test
    void bulkUpdate() throws Exception {
        BulkRequest request = new BulkRequest();

        User.EsUser esUser = new User.EsUser();
        esUser.setFirstName("吴");

        UpdateRequest updateRequest = new UpdateRequest("user", "1")
                .doc(JSONUtil.toJsonStr(esUser), XContentType.JSON);

        request.add(updateRequest);
        client.bulk(request, RequestOptions.DEFAULT);
    }

修改

/**
     * 单独修改文档,增量修改
     *
     * @throws IOException
     */
    @Test
    void update() throws IOException {
        UpdateRequest request = new UpdateRequest("user", "1");
        User.EsUser esUser = new User.EsUser();
        esUser.setFirstName("孙");
        request.doc(JSONUtil.toJsonStr(esUser), XContentType.JSON);
        client.update(request, RequestOptions.DEFAULT);
    }

常用查询操作

bool多条件组合

/**
     * bool多条件组合
     *
     * @throws IOException
     */
    @Test
    void bool() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();

        //构造bool条件
        //must
        boolQueryBuilder.must(new RangeQueryBuilder("score").gte(90));

        BoolQueryBuilder queryBuilder = new BoolQueryBuilder();
        List<QueryBuilder> should = queryBuilder.should();
        should.add(new TermQueryBuilder("gender", "0"));
        should.add(new MatchQueryBuilder("addr", "北京市"));
        boolQueryBuilder.must(queryBuilder);

        //must_not
        boolQueryBuilder.mustNot(new RangeQueryBuilder("score").gte("91"));

        //filter
        List<QueryBuilder> filter = boolQueryBuilder.filter();
        filter.add(new TermQueryBuilder("gender", "1"));

        sourceBuilder.query(boolQueryBuilder);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

match内容匹配

/**
     * 单字段双向分词匹配
     *
     * @throws IOException
     */
    @Test
    void match() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("introduce", "happens");
        sourceBuilder.query(matchQueryBuilder);

        request.source(sourceBuilder);
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);

        EsResult<User> esResult = parseResult(search, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

match_all匹配全部

/**
     * 匹配全部
     *
     * @throws IOException
     */
    @Test
    void matchAll() throws IOException {
        SearchRequest request = new SearchRequest("user");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(new MatchAllQueryBuilder());

        request.source(sourceBuilder);

        SearchResponse search = client.search(request, RequestOptions.DEFAULT);

        EsResult<User> esResult = parseResult(search, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

multi_match多字段匹配

/**
     * 多字段分词匹配
     *
     * @throws IOException
     */
    @Test
    void multiMatch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.query(new MultiMatchQueryBuilder("if", "introduce"));

        searchRequest.source(sourceBuilder);
        SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);

        EsResult<User> esResult = parseResult(search, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

range范围匹配

/**
     * 范围查询
     *
     * @throws IOException
     */
    @Test
    void range() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(new RangeQueryBuilder("score").gte(90).lte(100));
        request.source(sourceBuilder);

        SearchResponse search = client.search(request, RequestOptions.DEFAULT);

        EsResult<User> esResult = parseResult(search, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

function_score得分控制

/**
     * 得分控制
     *
     * @throws IOException
     */
    @Test
    void scoreControl() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //构造查询
        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("introduce", "happens");

        //构造加分查询
        FunctionScoreQueryBuilder.FilterFunctionBuilder[] filterFunctionBuilders = new FunctionScoreQueryBuilder.FilterFunctionBuilder[1];
        RangeQueryBuilder rangeQueryBuilder = new RangeQueryBuilder("score").gte(90);
        filterFunctionBuilders[0] = new FunctionScoreQueryBuilder.FilterFunctionBuilder(rangeQueryBuilder, new WeightBuilder().setWeight(2));

        FunctionScoreQueryBuilder functionScoreQueryBuilder = new FunctionScoreQueryBuilder(matchQueryBuilder, filterFunctionBuilders)
                .boostMode(CombineFunction.SUM);
        sourceBuilder.query(functionScoreQueryBuilder);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

term精确匹配

/**
     * 不分词精准匹配
     *
     * @throws IOException
     */
    @Test
    void term() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(new TermQueryBuilder("addr", "北京市"));
        request.source(sourceBuilder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

常用设置操作

high_light高亮设置

/**
     * 高亮显示
     *
     * @throws IOException
     */
    @Test
    void highLight() throws IOException {
        SearchRequest request = new SearchRequest("user");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //设置查询
        sourceBuilder.query(new MatchQueryBuilder("introduce", "if"));

        //设置高连
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.requireFieldMatch(false);
        HighlightBuilder addrHighLight = highlightBuilder.field("addr");
        addrHighLight.preTags("<em>");
        addrHighLight.postTags("</em>");
        HighlightBuilder introduceHighLight = highlightBuilder.field("introduce");
        introduceHighLight.preTags("<em>");
        introduceHighLight.postTags("</em>");
        sourceBuilder.highlighter(highlightBuilder);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

page分页设置

/**
     * 数据分页
     *
     * @throws IOException
     */
    @Test
    void page() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.query(new MatchAllQueryBuilder());
        sourceBuilder.from((pageNo - 1) * PageSize);
        sourceBuilder.size(PageSize);

        request.source(sourceBuilder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

sort排序

/**
     * 排序,排序后得分失效
     *
     * @throws IOException
     */
    @Test
    void sort() throws IOException {

        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.query(new MatchAllQueryBuilder());

        List<SortBuilder<?>> sorts = new ArrayList<>();
        sorts.add(SortBuilders.fieldSort("score").order(SortOrder.DESC));
        sourceBuilder.sort(sorts);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        });

        print(esResult);
    }

常见聚合操作

avg平均值聚合

/**
     * 平均值聚合
     *
     * @throws IOException
     */
    @Test
    void avg() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询
        sourceBuilder.query(new MatchAllQueryBuilder());

        //聚合
        List<EsAggregationParam> esAggregationParamList = new ArrayList<>();
        EsAggregationParam esAggregationParam = new EsAggregationParam();
        esAggregationParam.setName("gender_agg");
        ArrayList<EsAggregationParam> childAggregation = new ArrayList<>();
        EsAggregationParam aggregationParam = new EsAggregationParam();
        aggregationParam.setName("score_avg");
        childAggregation.add(aggregationParam);
        esAggregationParam.setChildAggregation(childAggregation);
        esAggregationParamList.add(esAggregationParam);
        TermsAggregationBuilder genderAggregation = new TermsAggregationBuilder("gender_agg")
                .field("gender")
                .size(2)
                .subAggregation(new AvgAggregationBuilder("score_avg")
                        .field("score"));
        sourceBuilder.aggregation(genderAggregation);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        }, esAggregationParamList);

        print(esResult);
    }

max最大值聚合

/**
     * 最大值聚合
     *
     * @throws IOException
     */
    @Test
    void min() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询条件
        sourceBuilder.query(new MatchAllQueryBuilder());

        //聚合条件
        ArrayList<EsAggregationParam> esAggregationParamList = new ArrayList<>();
        EsAggregationParam esAggregationParam = new EsAggregationParam();
        esAggregationParam.setName("gender_agg");
        EsAggregationParam childesAggregationParam = new EsAggregationParam();
        childesAggregationParam.setName("score_agg");
        esAggregationParam.setChildAggregation(Collections.singletonList(childesAggregationParam));
        esAggregationParamList.add(esAggregationParam);

        TermsAggregationBuilder aggregation = new TermsAggregationBuilder("gender_agg")
                .field("gender")
                .size(2)
                .subAggregation(new MaxAggregationBuilder("score_agg")
                        .field("score"));
        sourceBuilder.aggregation(aggregation);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        }, esAggregationParamList);

        print(esResult);
    }

min最小值聚合

/**
     * 最小值
     *
     * @throws IOException
     */
    @Test
    void min() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询条件
        sourceBuilder.query(new MatchAllQueryBuilder());

        //聚合条件
        ArrayList<EsAggregationParam> esAggregationParamList = new ArrayList<>();
        EsAggregationParam esAggregationParam = new EsAggregationParam();
        esAggregationParam.setName("gender_agg");
        EsAggregationParam childesAggregationParam = new EsAggregationParam();
        childesAggregationParam.setName("birth_gender");
        esAggregationParam.setChildAggregation(Collections.singletonList(childesAggregationParam));
        esAggregationParamList.add(esAggregationParam);

        TermsAggregationBuilder aggregation = new TermsAggregationBuilder("gender_agg")
                .field("gender")
                .size(2)
                .subAggregation(new MinAggregationBuilder("birth_gender")
                        .field("birth"));
        sourceBuilder.aggregation(aggregation);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        }, esAggregationParamList);

        print(esResult);
    }

sum求和聚合

/**
     * 最小值
     *
     * @throws IOException
     */
    @Test
    void min() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询条件
        sourceBuilder.query(new MatchAllQueryBuilder());

        //聚合条件
        ArrayList<EsAggregationParam> esAggregationParamList = new ArrayList<>();
        EsAggregationParam esAggregationParam = new EsAggregationParam();
        esAggregationParam.setName("gender_agg");
        EsAggregationParam childesAggregationParam = new EsAggregationParam();
        childesAggregationParam.setName("birth_gender");
        esAggregationParam.setChildAggregation(Collections.singletonList(childesAggregationParam));
        esAggregationParamList.add(esAggregationParam);

        TermsAggregationBuilder aggregation = new TermsAggregationBuilder("gender_agg")
                .field("gender")
                .size(2)
                .subAggregation(new MinAggregationBuilder("birth_gender")
                        .field("birth"));
        sourceBuilder.aggregation(aggregation);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        }, esAggregationParamList);

        print(esResult);
    }

terms等值聚合

/**
     * 等值聚合
     * @throws IOException
     */
    @Test
    void term() throws IOException {
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询
        sourceBuilder.query(new MatchAllQueryBuilder());

        //聚合
        ArrayList<EsAggregationParam> esAggregationParamList = new ArrayList<>();

        EsAggregationParam esAggregationParam = new EsAggregationParam();
        esAggregationParam.setName("score_agg");
        EsAggregationParam childesAggregationParam = new EsAggregationParam();
        childesAggregationParam.setName("gender_agg");
        esAggregationParam.setChildAggregation(Collections.singletonList(childesAggregationParam));

        esAggregationParamList.add(esAggregationParam);

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders
                .terms("score_agg")
                .field("score")
                .size(102)
                .subAggregation(AggregationBuilders
                        .terms("gender_agg")
                        .field("gender")
                        .size(2));

        sourceBuilder.aggregation(termsAggregationBuilder);

        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsResult<User> esResult = parseResult(response, json -> {
            User.EsUser esUser = JSONUtil.toBean(json, User.EsUser.class);
            User user = BeanUtil.copyProperties(esUser, User.class);
            user.setName(esUser.getFirstName() + esUser.getLastName());
            return user;
        }, esAggregationParamList);

        print(esResult);
    }