es搜索，统计

最新推荐文章于 2025-06-22 20:12:07 发布
原创 最新推荐文章于 2025-06-22 20:12:07 发布 · 253 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#elasticsearch #大数据 #java

记得好几年前用es做过标签画像统计，如今再看es时已是很生疏了，再用时已更新到了7.12版本了。以前用TransportClient客户端，现在出了而且是官方推荐用RestHighLevelClient客户端。

这几天用RestHighLevelClient时还是觉得比较方便的。现将一些基本常用功能记录一下。


1.初始化和关闭

public static RestHighLevelClient getClient(String host, int port) {
        LOGGER.info("Init ES!");
        client \= new RestHighLevelClient(
                RestClient.builder(new HttpHost(host, port, "http")));
        return client;
    }

    public static void closeES() {
        LOGGER.info("ES closed!");
        if(null != client) {
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.创建index以及mapping

public boolean createIndexMapping(RestHighLevelClient client, String indexName){
        LOGGER.info("create index and mapping ...");
        CreateIndexRequest createIndexRequest \= new CreateIndexRequest(indexName);

        createIndexRequest.settings(Settings.builder()
                .put("index.number\_of\_shards",1)
                .put("index.number\_of\_replicas",0));

        try {
            XContentBuilder xContentBuilder \= XContentFactory.jsonBuilder().startObject().startObject("properties")
                    .startObject("content")
                    .field("type", "text") // 数据类型
                    .field("index", "true") //默认
                    .field("analyzer", "ik\_max\_word")
                    .field("search\_analyzer", "ik\_smart")
                    .endObject()  
  
                    .startObject("date")
                    .field("type", "date") // 数据类型
                    .field("index", "true") //默认
                    .endObject()
                    .startObject("title")
                    .field("type", "text") // 数据类型
                    .field("index", "true") //默认
                    .field("analyzer", "ik\_max\_word")
                    .field("search\_analyzer", "ik\_smart")
                    .endObject()

                    .endObject()
                    .endObject();

            createIndexRequest.mapping(xContentBuilder);
            CreateIndexResponse createIndexResponse \= client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
            return createIndexResponse.isAcknowledged();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return false;
    }

3.获取一篇doc

public Map<String, Object> getOneMap(RestHighLevelClient client, String index, String id) {
        GetRequest getRequest \= new GetRequest(index, id);
        GetResponse getResponse \= null;
        try {
            getResponse \= client.get(getRequest, RequestOptions.DEFAULT);
            if(getResponse.isExists()) {
                return getResponse.getSource();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

4.删除多篇

/\*\*
     \* 批量删除
     \* @param client
     \* @param index
     \* @param ids
     \* @return
     \*/
    public Object deleteList(RestHighLevelClient client, String index, List<String> ids) {
        //构建批量删除请求
        DeleteByQueryRequest request = new DeleteByQueryRequest(index);
        IdsQueryBuilder queryBuilder \= new IdsQueryBuilder();
        for(String id: ids) {
            queryBuilder.addIds(id);
        }
        // 匹配所有
        request.setQuery(queryBuilder);
        BulkByScrollResponse response \= null;
        try {
            response \= client.deleteByQuery(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return JSONObject.toJSON(response);
    }

5.批量导入

/\*\*
     \* 批量导入
     \* @param client
     \* @param index
     \* @param list
     \* @return
     \*/
    public boolean insertDocByBulk(RestHighLevelClient client, String index, List<Doc> list) {
        //批量插入请求
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        for(int i = 0; i < list.size(); i++) {
            Doc doc \= list.get(i);
            //这里必须每次都使用new IndexRequest(index,type),不然只会插入最后一条记录(这样插入不会覆盖已经存在的Id，也就是不能更新)
            Map<String, Object> kv = new HashMap<>();
            kv.put("id", doc.getId());
            kv.put("title", doc.getTitle());
            kv.put("content", doc.getContent());

            bulkRequest.add(new IndexRequest(index).id(String.valueOf(doc.getId())).source(kv));
            //或者
            //bulkRequest.add(new IndexRequest(index).id(item.getID()).source(JSON.toJSONString(doc), XContentType.JSON));
        }

        try {
            // 客户端返回
            BulkResponse responses = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            // responses.hasFailures(); // 是否失败，false表示成功！
            if(RestStatus.CREATED == responses.status()) {
                return true;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

6.批量更新

/\*\*
     \* 批量update
     \* @param client
     \* @param index
     \* @param list
     \* @return
     \*/
    public boolean updateDocByBulk(RestHighLevelClient client, String index, List<Doc> list) {
        //批量插入请求
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        for(int i = 0; i < list.size(); i++) {
            Doc doc \= list.get(i);
            //这里必须每次都使用new IndexRequest(index,type),不然只会插入最后一条记录(这样插入不会覆盖已经存在的Id，也就是不能更新)
            Map<String, Object> kv = new HashMap<>();
            kv.put("id", doc.getId());
            kv.put("title", doc.getTitle());
            kv.put("content", doc.getContent());

            bulkRequest.add(new UpdateRequest().index(index).id(String.valueOf(doc.getId())).doc(kv));
        }

        try {
            // 客户端返回
            BulkResponse responses = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            // responses.hasFailures(); // 是否失败，false表示成功！
            if(RestStatus.OK == responses.status()) {
                return true;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

7.全量搜索

7.1 利用scroll

/\*\*
     \* 全量搜索
     \* @param client
     \* @param index
     \* @param field1
     \* @param field2
     \* @param query
     \* @param size
     \* @param include
     \* @param exclude
     \* @return
     \*/
    public List<org.elasticsearch.search.SearchHit> searchByQueryScrollAll(RestHighLevelClient client, String index, String field1, String field2, String query, int size, String\[\] include, String\[\] exclude) {
        List<org.elasticsearch.search.SearchHit> result = CollectionUtil.newArrayList();
        final Scroll scroll = new Scroll(TimeValue.timeValueMinutes(1L));
        SearchRequest searchRequest \= new SearchRequest(index);
        searchRequest.scroll(scroll);
        SearchSourceBuilder searchSourceBuilder \= new SearchSourceBuilder();
        // 高亮显示
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        // 高亮标签
        highlightBuilder.preTags("<a style='color: #e4393c'>");
        highlightBuilder.postTags("</a>");
        // 高亮字段
        highlightBuilder.field(field2);
        //设置最多一次能够取出（size）笔数据，从第（size + 1）笔数据开始，将开启滚动查询。  （滚动查询也属于这一次查询，只不过因为一次查不完，分多次查）
        searchSourceBuilder.size(size);
        //searchSourceBuilder.sort("\_score", SortOrder.DESC);
        //socre相同，则按时间降序排序
        //searchSourceBuilder.sort("publish\_date", SortOrder.DESC);
        //高亮显示添加到构造器(不需要高亮显示则不添加)
        searchSourceBuilder.highlighter(highlightBuilder);
        // 多字段联合查询
        //searchSourceBuilder.query(QueryBuilders.multiMatchQuery(query, field1, field2));
        searchSourceBuilder.query(QueryBuilders.boolQuery()
                .should(QueryBuilders.matchQuery(field1, query))
                .must(QueryBuilders.matchQuery(field2, query)));
        searchSourceBuilder.fetchSource(include, exclude);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse \= null;
        try {
            searchResponse \= client.search(searchRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        String scrollId \= searchResponse.getScrollId();
        org.elasticsearch.search.SearchHit\[\] searchHits \= searchResponse.getHits().getHits();
        while (searchHits != null && searchHits.length > 0) {
            for(org.elasticsearch.search.SearchHit hit: searchHits) {
                //String highlightText = hit.getHighlightFields().get(field2).getFragments()\[0\].toString();
                result.add(hit);
            }
            SearchScrollRequest searchScrollRequest \= new SearchScrollRequest(scrollId);
            searchScrollRequest.scroll(scroll);
            try {
                searchResponse \= client.scroll(searchScrollRequest, RequestOptions.DEFAULT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            scrollId \= searchResponse.getScrollId();
            searchHits \= searchResponse.getHits().getHits();
        }

        if(null != scrollId) {
            ClearScrollRequest clearScrollRequest \= new ClearScrollRequest();
            clearScrollRequest.addScrollId(scrollId);
            // 滚动完成后清除滚动上下文
            ClearScrollResponse clearScrollResponse = null;
            try {
                clearScrollResponse \= client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            //清除滚动是否成功
            boolean succeeded = clearScrollResponse.isSucceeded();
        }
        return result;
    }

7.2利用after

/\*\*
     \* 全量搜索
     \* @param client
     \* @param index
     \* @param field1
     \* @param field2
     \* @param query
     \* @param size
     \* @param include
     \* @param exclude
     \* @return
     \*/
    public List<org.elasticsearch.search.SearchHit> searchByQuerySearchAfter(RestHighLevelClient client, String index, String field1, String field2, String query, int size, String\[\] include, String\[\] exclude) {
        List<org.elasticsearch.search.SearchHit> result = CollectionUtil.newArrayList();
        SearchRequest request \= new SearchRequest(index);
        SearchSourceBuilder searchSourceBuilder \= new SearchSourceBuilder();
        // 高亮显示
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        // 高亮标签
        highlightBuilder.preTags("<a style='color: #e4393c'>");
        highlightBuilder.postTags("</a>");
        // 高亮字段
        highlightBuilder.field(field2);
        QueryBuilder queryBuilder \= QueryBuilders.boolQuery()
                .should(QueryBuilders.matchQuery(field1, query))
                .must(QueryBuilders.matchQuery(field2, query));

        // searchSourceBuilder.query(QueryBuilders.matchQuery(field, query));
        searchSourceBuilder.query(queryBuilder);
        searchSourceBuilder.fetchSource(include, exclude);
        //每页显示条数
        searchSourceBuilder.size(size);
        // 需要唯一不重复的字段作为排序
        searchSourceBuilder.sort("\_id", SortOrder.DESC);
        //searchSourceBuilder.sort("\_score", SortOrder.DESC);
        //score相同，则按时间降序排序
        //searchSourceBuilder.sort("publish\_date", SortOrder.DESC);
        //高亮显示添加到构造器(不需要高亮显示则不添加)
        searchSourceBuilder.highlighter(highlightBuilder);
        //构造器添加到搜索请求
        request.source(searchSourceBuilder);
        //客户端返回
        SearchResponse response = null;
        try {
            response \= client.search(request, RequestOptions.DEFAULT);
            //搜索结果
            org.elasticsearch.search.SearchHit\[\] hits = response.getHits().getHits();
            while(hits.length > 0) {
                for(org.elasticsearch.search.SearchHit hit : hits) {
                    result.add(hit);
                }
                org.elasticsearch.search.SearchHit last \= hits\[hits.length - 1\];
                searchSourceBuilder.searchAfter(last.getSortValues());
                response \= client.search(request, RequestOptions.DEFAULT);
                hits \= response.getHits().getHits();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

8.统计分析

/\*\*
     \* 多field统计
     \* @param client
     \* @param index
     \* @param query
     \* @param field1
     \* @param field2
     \* @param aggFields
     \*/
    public static Map<String, Map<String, Long>> countDocByTermsAgg(RestHighLevelClient client, String index, String query, String field1, String field2, String ... aggFields) {
        SearchSourceBuilder searchSourceBuilder \= new SearchSourceBuilder();
        searchSourceBuilder.fetchSource(false);
        SearchRequest request \= new SearchRequest(index);
        QueryBuilder queryBuilder \= QueryBuilders.boolQuery()
                .should(QueryBuilders.matchQuery(field1, query))
                .must(QueryBuilders.matchQuery(field2, query));
        searchSourceBuilder.query(queryBuilder);
        Map<String, Map<String, Long>>  fieldAggMap = CollectionUtil.newLinkedHashMap();
        TermsAggregationBuilder aggregationBuilder;
        SearchResponse response \= null;
        for(String fieldName : aggFields) {
            aggregationBuilder \= AggregationBuilders.terms("agg\_name").field(fieldName);
            searchSourceBuilder.aggregation(aggregationBuilder);
            request.source(searchSourceBuilder);
            searchSourceBuilder.size(0);
            try {
                response \= client.search(request, RequestOptions.DEFAULT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            Aggregations aggregations \= response.getAggregations();
            Terms byTopicAggregation \= aggregations.get("agg\_name");
            List<? extends Terms.Bucket> buckets = byTopicAggregation.getBuckets();
            Map<String, Long> bucketsFieldsAgg = CollectionUtil.newLinkedHashMap();
            buckets.forEach(b \->
                    bucketsFieldsAgg.put(b.getKeyAsString(), b.getDocCount())
            );
            fieldAggMap.put(fieldName, bucketsFieldsAgg);
        }
        return fieldAggMap;
    }
番石榴AI
关注
ElasticSearch 统计搜索热词
weixin_38225763的博客
10-30 1165
"categoryLabel" : "装配机器人工作站及装配线","categoryLabel" : "装配机器人工作站及装配线","categoryLabel" : "机器人控制软件","categoryLabel" : "特种机器人","categoryLabel" : "特种机器人","title" : "氧化锆 陶瓷涂料 耐火材料","companyName" : "艾克斯有限公司","companyName" : "艾克斯有限公司","categoryLabel" : "特种机器人",
ElasticSearch 统计分析全攻略
arnold66的专栏
12-28 1117
在大数据时代，数据的价值不仅在于存储，更在于能够从中挖掘出有意义的信息。ElasticSearch 作为一款强大的分布式搜索引擎，除了具备出色的搜索功能外，其内置的统计分析能力也不容小觑，能够助力我们快速洞察数据背后的规律。
ES聚合查询，折线图统计
whatzhang007的博客
09-07 1126
需求一 查询数据时间在a-b间，且serviceId=1的数量折线图 结果 java代码 需求二 从接口调用记录中统计每个应用分组的最大、最小、平均调用时长(group by + count、max、min) 结果 java代码 需求三 直方图加求平均值 结果 java代码...
【ES小结】还在用ElasticSearch做查询？换条思路实现高效数据统计
派大星的博客
08-16 4202
聚合是ES除搜索功能外提供的针对ES数据做统计分析的功能，聚合有助于根据搜索查询提供聚合数据，聚合查询是数据库中重要额功能特性，ES作为搜索引擎兼数据库，同样提供了强大的聚合分析功能力，它是基于查询条件来对数据进行分桶、计算的方法，这种很类似与SQL中的group by再加上一些函数方法的操作。在了解聚合查询之前需要注意的一点是：text类型是不支持聚合的，主要是因为text类型本身是分词的，通俗的说，如果一句话分成了多个词然后进行group by操作，那么问题就出现了，到底对哪一个词进行。...
探索数据的力量：Elasticsearch中指定链表字段的统计查询记录
最新发布
张彦峰的博客
06-22 10万+
本文探讨了在Elasticsearch中对sell_product_order索引中sellingProducts字段进行基本统计操作的方法。通过一系列具体查询示例，介绍了如何计算产品类型的频率、检索指定文档的产品数量，以及对产品类型进行细分统计。这些统计方法不仅增强了数据分析能力，还为业务决策提供了支持。文章强调了Elasticsearch的灵活性和高效性，并鼓励读者进一步探索其更多功能，以提升数据处理和决策支持的能力。
ES聚合统计group by,sum,max,min,avg,count等聚合统计
絮落锦乡的博客
02-01 8012
ES聚合统计group by,sum,max,min,avg,count等聚合统计
ES聚合统计
hdn_kb的博客
12-02 3208
1. 以多个字段唯一并去重后统计总数 2. 求近15添内日平均数据 3. 求近15天内平均数据
es聚合统计查询
talen_hx的博客
01-15 1490
#基数统计 GET kibana_sample_data_ecommerce/_search { "size": 0, "aggs": { "customer_id_card": { "cardinality": { "field": "customer_id", "precision_threshold": 80 } } } } #字段数量统计 GET kibana_sample_data_ecommerce/_sea...
基于Spring Data Jest的Elasticsearch数据统计示例
08-27
Elasticsearch是一个开源的搜索引擎，它提供了高效的搜索和数据分析功能。通过使用Elasticsearch，我们可以快速地检索和分析大量数据。 知识点5：Transport Client和REST Client Transport Client和REST Client是...
【ElasticSearch-聚合查询】ES聚合统计及springboot对比实现
qq_42890164的博客
01-26 3571
一文详解Elasticsearch中涉及的桶聚合、指标聚合、管道聚合及其所属各类函数使用及springboot对比实现
Elasticsearch——索引统计(_stats)详解
smart_an的专栏
07-30 948
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
ES SQL使用说明文档
weixin_30244889的博客
06-17 3437
ES SQL使用说明文档 一、Elasticsearch术语介绍 l 接近实时（NRT）： Elasticsearch 是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个很小的延迟，包括如果做了集群的话，集群中的各个节点数据同步也是接近实时的。 l 集群（cluster）： 一组拥有共同的 cluster name 的节点。 l 节点（node）： ...
es 统计查询
朝花夕拾
03-17 1万+
{ "size": 0, "aggs": { "xxxxxx": { "date_histogram": { "field": "createdAt", "interval": "day", "format": "yyyy-MM-dd"
es 聚合统计
he_yanghui的博客
01-05 2988
最新项目做ES 统计 就分享一下： 直接上代码 /** * 根据门类名称来分组统计 ，同时根据时间段获取数据 */ @Override public List<Map> esTjByMl(EsSearchDto esSearchDto) { List<Map> returnResult = new ArrayList<>(); String index = esSearchDto.getIndex(); try { SearchRequest
ES统计操作
诸葛子房的博客
07-26 1312
1、count
ES 中Metrics 聚合统计查询
u012663412的博客
08-09 1697
ES的Metrics 聚合统计功能
ES聚合统计语法
NOAH_123456的博客
03-16 430
ES聚合统计语法 1、按照日期纬度统计： https://blog.csdn.net/qq_36245532/article/details/117164399
es聚合统计
qingfeng2556的博客
08-08 656
es bucket聚合统计
ElasticSearch分组统计查询
weixin_42456784的博客
05-24 1811
ElasticSearch分组统计查询，使用ElasticsearchRestTemplate
Elasticsearch数据检索与统计的Java实现
Elasticsearch 作为一款分布式搜索和分析引擎，因其高性能、易于使用的 RESTful API 和广泛的应用场景，在数据检索和统计分析领域中占据着重要地位。Java 作为企业级应用中使用最广泛的编程语言之一，其对 Elastic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值