ElasticSearch 8.X

最新推荐文章于 2024-04-01 10:13:01 发布
最新推荐文章于 2024-04-01 10:13:01 发布
阅读量521 收藏 1
点赞数 1
分类专栏： ElasticSearch 文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyujust/article/details/128723923
版权 
好久没有更新文章了，工作之后活成了社畜。想起最近流行的那句话，我想离开浪浪山。。。
累？糊口啊！大哥！
生活仍然要继续。。。
（坚持，努力，奋斗）
ps:以后坚持把一些会的东西写成文档。

之前研究ElasticSearch 8.X的客户端，原本想用SpringBoot的整个方案的，网上搜了一圈没有。GitHub上也说明不支持8.X的版本。所以这边就研究了一下官网给出的Java Client。

ps：先熟悉kibana 的语法，再看接口实现，比较好理解些。

下面给出了一些样例，主要批量的操作。单个的这边就不给出了，大家可以去看官网的文档，或者Github下载Java Client的源码，在Test中会给出demo样例。

（如果写的不好的或者有问题的地方，欢迎大评论）

pom.xml

<dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.4.3</version>
<dependency>

application.yml

elasticsearch:
  cluster-nodes: 192.168.105.29:9200

Configuration配置

    @Bean
    public ElasticsearchClient elasticsearchClient() {
        List<String> clusterNodes = elasticsearchProperties.getClusterNodes();
        clusterNodes.forEach(node -> {
            try {
                String[] parts = StringUtils.split(node, ":");
                Assert.notNull(parts, "Must defined");
                Assert.state(parts.length == 2, "Must be defined as 'host:port'");
                httpHosts.add(new HttpHost(parts[0], Integer.parseInt(parts[1])));
            } catch (Exception e) {
                throw new IllegalStateException("Invalid ES nodes " + "property '" + node + "'", e);
            }
        });
        RestClient restClient = RestClient.builder(httpHosts.toArray(new HttpHost[0])).build();
        // Create the transport with a Jackson mapper
        ElasticsearchTransport transport = new RestClientTransport(
                restClient, new JacksonJsonpMapper());

        return new ElasticsearchClient(transport);
    }

@Autowired
    private ElasticsearchClient elasticsearchClient;

精确查询 + 模糊匹配

public static List<Query> getComposeProceQuery(BillComposePrice composePrice, Bill bill, BillRequest request) {
        List<Query> res = new ArrayList<>();
        // TermQurey全匹配
        res.add(TermQuery.of(m -> m.field(EsField.AREA)
                .value(composePrice.getArea()))._toQuery());
        res.add(TermQuery.of(m -> m.field(EsField.BILL_NORM)
                .value(composePrice.getBillNorm()))._toQuery());
        res.add(TermQuery.of(m -> m.field(EsField.BILL_UNIT)
                .value(bill.getBillUnit()))._toQuery());
        // 过滤已删除的
        res.add(TermQuery.of(m -> m.field(EsField.DELETED_FLAG)
                .value(0))._toQuery());

        // 分词匹配
        res.add(MatchQuery.of(m -> m.field(EsField.BILL_PROFEATURE)
                .query(bill.getBillProFeature()))._toQuery());
        return res;
    }
protected List<BillInfo> composePrice(BillRequest request,
                                          String indexName,
                                          BillComposePrice composePrice) throws IOException, ElasticsearchException {
        List<BillInfo> res = new ArrayList<>();
        List<List<Query>> searchQuerys = new ArrayList<>();
        List<Bill> bills = composePrice.getBills();
        for (Bill bill : bills) {
            // 生成查询条件
            searchQuerys.add(getComposeProceQuery(composePrice, bill, request));
        }
        // 查询条件
        List<RequestItem> requestItems = new ArrayList<>();
        for (List<Query> searchQuery : searchQuerys) {
            RequestItem.Builder requestBuilder = new RequestItem.Builder();
            // 设置索引表
            requestBuilder.header(h -> h.index(indexName));
            requestBuilder.body(b -> b.query(q -> q.bool(co -> {
                co.must(searchQuery);
                // 业务逻辑，根据不同条件执行不同的查询
                if (composePrice.getFindInSelfFlag() == 1 && composePrice.getFindInTradeFlag() == 1) {
                    co.must(userq -> userq.bool(userB -> userB.should(
                            TermQuery.of(m -> m.field(EsField.USER)
                                    .value(request.getUser()))._toQuery(),
                            TermQuery.of(m -> m.field(EsField.USER)
                                    .value(GlobalConstant.TRADE_USER))._toQuery()
                    )));
                }
                return co;
            })));
            requestItems.add(requestBuilder.build());
        }
        MsearchRequest.Builder builder = new MsearchRequest.Builder();
        // 批量查询
        List<MultiSearchResponseItem<BillInfo>> responses =
                elasticsearchClient.msearch(builder.searches(requestItems).build(), BillInfo.class).responses();
        // 解析结果
        for (MultiSearchResponseItem<BillInfo> mhit : responses) {
            if (!mhit.isFailure() && mhit.result().hits().hits().size() > 0) {
                List<Hit<BillInfo>> hits = mhit.result().hits().hits();
                // 返回第一个（第一个就是评分最高的那个）
                res.add(hits.get(0).source());
            } else {
                res.add(null);
            }
        }
        return res;
}

批量插入

先检查库中有没有对应数据，有就更新，没有就创建。外加条目数限制。

        // 校验库中是否已存在
        List<List<Query>> sameQuerys = new ArrayList<>();
        for (BillInfo bulkInfo : bulkInfos) {
            sameQuerys.add(EsConditionCreate.findSameQuery(bulkInfo));
        }
        List<MultiSearchResponseItem<BillInfo>> searchResponseItems =
                searchBulk(indexName, sameQuerys).responses();
        int updateCount = 0;
        // 获取相似的ID
        for (int i = 0; i < searchResponseItems.size(); i++) {
            MultiSearchResponseItem<BillInfo> hit = searchResponseItems.get(i);
            if (!hit.isFailure() && hit.result().hits().hits().size() != 0) {
                bulkInfos.get(i).setBillUID(hit.result().hits().hits().get(0).id());
                updateCount++;
            }
        }
        List<BillInfo> loadBulk;
        // 插入条目的限制
        if (createLimit != -1 && bulkInfos.size() - updateCount > createLimit) {
            loadBulk = new ArrayList<>();
            for (BillInfo billInfo : bulkInfos) {
                String billUID = billInfo.getBillUID();
                if (billUID.isEmpty() && createLimit <= 0) {
                    // 创建限制不加入
                    continue;
                } else if (billUID.isEmpty()) {
                    --createLimit;
                }
                loadBulk.add(billInfo);
            }
        } else {
            loadBulk = bulkInfos;
        }
        
        if (loadBulk.size() == 0) {
            throw new BillServerException(ResultCode.UPLOAD_OVER_MAX);
        }
        BulkRequest.Builder br = new BulkRequest.Builder();
        for (BillInfo billInfo : loadBulk) {
            br.operations(op -> op
                    .index(idx -> {
                        idx.index(indexName).document(billInfo);
                        // 相似的，直接覆盖。设置对应id
                        if (!billInfo.getBillUID().isEmpty()) {
                            idx.id(billInfo.getBillUID());
                        }
                        return idx;
                    }));
        }
        // 批量插入
        return elasticsearchClient.bulk(br.build());

批量查询

// 根据条件批量查询
protected MsearchResponse<BillInfo> searchBulk(String indexName, List<List<Query>> searchQuerys)
            throws IOException, ElasticsearchException {
        List<RequestItem> requestItems = new ArrayList<>();
        for (List<Query> searchQuery : searchQuerys) {
            RequestItem.Builder requestBuilder = new RequestItem.Builder();
            requestBuilder.header(h -> h.index(indexName));
            requestBuilder.body(b -> b.query(q -> q.bool(co -> co.must(searchQuery))));
            requestItems.add(requestBuilder.build());
        }
        MsearchRequest.Builder builder = new MsearchRequest.Builder();

        return elasticsearchClient.msearch(builder.searches(requestItems).build(), BillInfo.class);
    }

    /**
     * 批量查询
     *
     * @param searchItems Tuple(id, indexName）
     * @return Tuple(id, indexName, value)
     */
    protected List<Tuple> searchByIdBulk(List<Tuple> searchItems)
            throws IOException, ElasticsearchException {
        List<MultiGetOperation> multiGetOperations = new ArrayList<>();

        for (Tuple searchItem : searchItems) {
            MultiGetOperation multiGetOperation = MultiGetOperation.of(mget -> mget
                    .index(searchItem.get(0)) // indexName
                    .id(searchItem.get(1))); // _id
            multiGetOperations.add(multiGetOperation);

        }

        MgetRequest.Builder builder = new MgetRequest.Builder();
        builder.docs(multiGetOperations);
        List<MultiGetResponseItem<BillInfo>> docs =
                elasticsearchClient.mget(builder.build(), BillInfo.class).docs();
        return getBillInfos(docs);
    }

批量更新

/**
     * 批量更新
     *
     * @param updateList, Tuple(indexName, id, doc)
     */
    protected BulkResponse updateBulk(List<Tuple> updateList)
            throws IOException, ElasticsearchException {
        BulkRequest.Builder br = new BulkRequest.Builder();
        for (Tuple updateItem : updateList) {
            br.operations(op -> op
                    .update(up -> up
                            .index(updateItem.get(0))
                            .id(updateItem.get(1))
                            .action(act -> act.doc(updateItem.get(2)))
                    ));
        }

        return elasticsearchClient.bulk(br.build());
    }

多条件查询

代码实在是太长了

Query finalFindByUser = findByUser;
        List<Map<Query, List<Query>>> finalFindByProfessions = findByProfessions;
        List<Query> finalFindByLockShellNum = findByLockShellNum;
        Query finalFindByTime = findByTime;
        List<Query> finalFindByWildcard = findByWildcard;
        Query finalFindByArea = findByArea;
        Query finalFindByBillNorm = findByBillNorm;
        Query finalFindBydeleteFlag = findBydeleteFlag;
        return elasticsearchClient.search(s -> s
                .index(indexName)
                .query(q -> q
                        .bool(b -> {
                            if (finalFindByUser != null) {
                                b.must(finalFindByUser);
                            }
                            if (finalFindBydeleteFlag != null) {
                                b.must(finalFindBydeleteFlag);
                            }
                            if (isAllSelect) {
                                return b;
                            }
                            if (finalFindByArea != null) {
                                b.must(finalFindByArea);
                            }
                            if (finalFindByBillNorm != null) {
                                b.must(finalFindByBillNorm);
                            }
                            if (finalFindByProfessions != null) {
                                b.must(pro -> pro.bool(
                                        professionQ -> {
                                            for (Map<Query, List<Query>> findByProfession : finalFindByProfessions) {
                                                for (Map.Entry<Query, List<Query>> entry : findByProfession.entrySet()) {
                                                    professionQ.should(professionS -> professionS
                                                            .bool(professionB ->
                                                                    professionB.must(entry.getKey()).should(entry.getValue()))
                                                    );
                                                }
                                            }
                                            professionQ.minimumShouldMatch("1");
                                            return professionQ;
                                        }
                                ));

                            }
                            if (finalFindByTime != null) {
                                b.must(finalFindByTime);
                            }
                            if (finalFindByLockShellNum != null) {
                                b.must(loc -> loc.bool(
                                        professionQ -> professionQ.should(finalFindByLockShellNum)
                                                .minimumShouldMatch("1")));
                            }
                            if (finalFindByWildcard != null) {
                                b.must(loc -> loc.bool(
                                        professionQ -> professionQ.should(finalFindByWildcard)
                                                .minimumShouldMatch("1")));
                            }

                            return b;
                        }))
                // sort by updatetime by aesc
                .sort(sinfo -> sinfo.field(f -> f.field(EsField.UPLOAD_TIME).order(SortOrder.Desc)))
                // 分页查询
                .from((searchRequest.getSectionNum() - 1) * searchRequest.getPerSectionNum())
                .size(searchRequest.getPerSectionNum()), BillInfo.class);
cyujust
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Elasticsearch - Elasticsearch 8.X；Elasticsearch 8.X集群（十）
MinggeQingchun的博客
09-17 2452
支持矩阵 | Elastic。
Elasticsearch使用msearch提高聚合效率(与search检索对比)
后端开发
02-23 1978
数据量共约3000万+，在使用es进行term聚合的时候，发现执行耗费时间巨大，因此采用了msearch的检索方式多搜索接口编辑 多搜索 API 从单个 API 请求执行多个搜索。请求的格式类似于批量 API 格式，并使用 换行符分隔的 JSON （NDJSON） 格式。结构类型于下。
ElasticSearch 实战：ElasticSearch文档多条件查询
最新发布
qq_33240556的博客
04-01 585
Elasticsearch 实战：Elasticsearch 文档多条件查询在实际应用中，常常需要根据多个条件对文档进行筛选。Elasticsearch 提供了多种查询类型和查询组合机制，支持构建复杂的多条件查询。
[elastic 8.x]java客户端连接elasticsearch与操作索引与文档
m0_67713667的博客
11-05 1821
/
Elasticsearch的单条插入批量插入及根据条件删除记录的操作转java代码示例
梨木乔
12-27 2283
Elasticsearch的部分操作（单条插入批量插入及根据条件删除记录），转java代码的示例如下： /** 批量插入多条记录到ES中(client即为RestHighLevelClient的一个实例，此处不在具体展示其创建过程) * @param dataList * @param indexName */ public void writeDataToES(List<Map<String, Object>> dataList, String indexName)
ES的java客户端中SearchRequest和SearchResponse的序列化和反序列化
热门推荐
Oliver的博客
11-17 1万+
Elastcsearch官方提供了一个elasticsearch-rest-high-level-client，作者在写bug的时候需要将其中的ActionRequest（子类包括SearchRequest、IndexRequest、UpdateRequest等）和SearchResponse类分别做序列化和反序列化。 首先，这两个类都没有实现Serializable接口也无法直接用Json工具...
《OpenGL ES 3.x游戏开发 上卷》源码
08-07
《OpenGL ES 3.x游戏开发 上卷》的源码， Eclipse工程
elasticsearch-image-1.0-SNAPSHOT.zip elasticsearch插件 以图搜图 LIRE
07-19
使用方法：将插件解压到elasticsearch 的plugins目录下即可。 存储数据时 ColorLayout surfFeature = new ColorLayout(); surfFeature.extract(ImageIO.read(imgfilepath)); JSONObject o = new JSONObject(); o....
ElasticSearch6.2.4最新实战教程.zip
08-28
elasticsearch 6.x 实战教程 ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTfulweb接口。ElasticSearch是用Java开发的，并作为Apache许可条款下的开放源码发布...
elasticsearch-sql安装使用文档.docx
03-11
如果我们安装不成功，我们可以直接下载 Elasticsearch-SQL 插件的压缩包，然后解压，完成之后重命名文件夹为 sql ，放到 ES 的安装路径的 plugins目录中，例如：..\elasticsearch-6.4.0\plugins\sql。
ElasticSearch集群统计Bigdesk.zip
07-17
Bigdesk 是 ElasticSearch 的一个集群监控工具，可生成 ElasticSearch 集群的即时图表和统计信息。可以通过它来查看es集群的各种状态，如：cpu、内存使用情况，索引数据、搜索情况，http连接数等。版本对应关系表：...
ElasticSearch8.x.x 【一篇文章精通系列】【ES的基本操作，ES安装，ES head + Kibana】
程序员猫爪
11-06 2347
一、ElasticSearch的安装，1、解压安装ES，2、熟悉目录，3、启动ES，4、安装可视化界面（elasticsearch head） 5、了解ELK，6、安装Kibana，（1）下载解压Kibana，（2）启动Kibana，（3）访问：[http://localhost:5601](http://localhost:5601)，（4）Kibana开发工具 （5）汉化`Kibana`，设置在`config`下的`kibana.yml` 二、ElasticSearch的核心概念，1、基本概念，2、物理
ElasticSearch 8.x 安装及集群搭建
zzhongcy的专栏
10-17 4980
Elasticsearch，简称为ES。ES是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据。Elasticsearch是面向文档的一种数据库，这意味着其不再需要行列式的表格字段约束。ES会存储整个构造好的数据或文档，然而不仅仅是储存数据，这使得文档中每个数据可以被标识，进而可以被检索。在ES中，执行index，search，sort或过滤文档等操作都不是传统意义上的行列式的数据。ES从根本上对数据的不同思考方式也正是他能应对复杂数据结构的全文检索的原因之一。
Elasticsearch8.x版本Java客户端Elasticsearch Java API 如何并发修改
lnn112233的博客
03-18 667
并发控制，一般有两种方案，悲观锁和乐观锁，其中悲观锁是默认每次更新操作肯定会冲突，所以每次操作都要先获取锁，操作完毕再释放锁，适用于写比较多的场景。而乐观锁是默认每次更新操作都不会冲突，所以在更新前和更新后都不需要获取锁和释放锁的操作，所以效率更高，适合于读多写少的场景中。
elasticsearch8.x知识梳理
知识库总结、分享
06-27 511
elasticsearch，简称为 ES， ES 是一个开源的支持分布式的全文搜索、聚合分析和存储引擎， 是整个 ElasticStack 技术栈的核心。它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理 PB 级别的数据。es是解决海量数据全文检索的不二之选。搜索 、 聚合分析 、 大数据存储分布式 、 高性能 、 高可用 、 可伸缩 、 易维护支持文本搜索 、 结构化数据 、 非结构化数据 、地理位置搜索等。
ElasticSearch多条件复杂查询实现
qq_42855167的博客
02-20 1176
ElasticSearch实现多条件复杂查询
必备 | Elasticsearch 8.X 最少必要知识视频（全）
铭毅天下Elasticsearch
02-21 586
1、你使用 Elasticsearch 8.X 了吗？Elastic Stack 数据平台由Logstash、Beats、ElasticSearch和Kibana四大核心产品组成，在数据摄取、存储计算分析及数据可视化方面有着无可比拟的优势。在存储、计算和分析方面，ElasticSearch允许执行和合并多种类型的搜索，解决不断涌现的各种用例，并具有极高的可用性及容错性，充分保障集群安全。Kiban...
【ElasticSearch教程】--- Elasticsearch文档多条件查询(十二)
maoye的博客
05-09 4818
多条件查询 同时满足must 查询的body体的查询不能在使用match关键字了，而需要使用，bool然后要多个条件同时成立，接下来要填入must，多个条件用数组。body样例如下： { "query":{ "bool": { "must":[ { "match":{ "category":"床上用品"
全文检索 Elasticearch 多条件检索 过滤检索 分词检索
weixin_45626288的博客
10-16 1080
Elasticearch 1.ElasticaSearch安装2. elasticsearch.yml3. 启动elasticsearch4. 使用Postman 创建索引库1. 使用postman或curl这样的工具创建：5. 创建 IDEA 项目1. 创建myes 项目2. 添加依赖3. 创建 application.yml 配置文件4. 在 config 包下创建MyElasticsearchConfig6. 创建测试类MyEsTest7. 创建启动类 MyEsApp8. 启动服务在控制台得到测试数
elasticsearch7.x跟8.x
07-28
Elasticsearch 7.x和8.x是Elasticsearch的不同版本。它们之间有一些重要的区别和改进。以下是一些主要的区别： 1. 性能改进：Elasticsearch 8.x引入了一些性能优化，包括更快的搜索和聚合操作，以及更高效的索引和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值