Elasticsearch RestHighLevelClient API 使用总结

最新推荐文章于 2024-08-16 17:29:46 发布
最新推荐文章于 2024-08-16 17:29:46 发布
阅读量2.2k 收藏 4
点赞数 2
分类专栏： Tools 软件设计 文章标签： elasticsearch 大数据 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shang_xs/article/details/127909240
版权

Elasticsearch RestHighLevelClient API 使用总结

题记

深秋初冬的一个晚上，突然间收到业务一个需求，要在老系统上使用新系统Elasticsearch库的数据。

目前项目情况，新、老系统并行运行，根据产品、渠道路由，但是老系统未使用Elasticsearch 新系统基础框架Spring Cloud Alibaba version -> 2.2.1RELEASE，老系统基础框架 Spring Framework version -> 4.3.24RELEASE。

技术响应

为了满足业务需求，经过技术分析讨论有两种实现方案：

方案一：

在新系统中暴露 HTTP 服务接口，让老系统直接调用新系统，完成数据获取；

方案二：

在老系统以最小侵入单元的形式集成 Elasticsearch，完成数据获取；

经过系统交互分析，从系统架构设计角度考虑，为减少系统耦合，采用方案二完成数据接入。

Elasticsearch 接入

maven 依赖
		<dependency>
			<groupId>org.elasticsearch</groupId>
			<artifactId>elasticsearch</artifactId>
			<version>6.8.6</version>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-client</artifactId>
			<version>6.8.6</version>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-high-level-client</artifactId>
			<version>6.8.6</version>
		</dependency>

注释：本文采用version -> 6.8.6 客户端完成接入，原因：与生产Elasticsearch版本保持一致。

实现自动装配

import lombok.extern.slf4j.Slf4j;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * elasticsearch 配置类
 */
@Slf4j
@Configuration
public class ElasticsearchConfig {

    @Value("${elasticsearch.cluster.address}")
    private String clusterAddress;

    @Value("${elasticsearch.username}")
    private String username;

    @Value("${elasticsearch.password}")
    private String password;

    @Value("${elasticsearch.shards}")
    private Integer numberOfShards;

    @Value("${elasticsearch.replicas}")
    private Integer numberOfReplicas;

    @Value("${elasticsearch.connect_timeout}")
    private Long connectTimeout;

    @Value("${elasticsearch.socket_timeout}")
    private Long socketTimeout;

    public static RestHighLevelClient client = null;

    public Integer getNumberOfShards() {
        return numberOfShards;
    }

    public Integer getNumberOfReplicas() {
        return numberOfReplicas;
    }

    /**
     * RestHighLevelClient bean创建
     */
    @Bean
    public RestHighLevelClient restClient() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(username, password));
        Header[] defaultHeaders = {new BasicHeader("content-type", "application/json")};
        RestClientBuilder restClientBuilder = RestClient.builder(HttpHost.create(clusterAddress));
        restClientBuilder
                .setHttpClientConfigCallback(httpAsyncClientBuilder -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider))
                .setDefaultHeaders(defaultHeaders)
                .setRequestConfigCallback(requestConfigBuilder -> {
                    // 连接5秒超时，套接字连接60s超时
                    return requestConfigBuilder.setConnectTimeout(connectTimeout.intValue()).setSocketTimeout(socketTimeout.intValue());
                })
                .setHttpClientConfigCallback(httpClientBuilder -> {
                    httpClientBuilder.disableAuthCaching();
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                });

        client = new RestHighLevelClient(restClientBuilder);
        return client;
    }


}
Elasticsearch 持久层接入

import cn.hutool.core.map.MapUtil;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.*;

/**
 * elasticsearch 持久层
 */
@Slf4j
@Service
public class ElasticsearchRepository {

    @Autowired
    private RestHighLevelClient client ;

    private final RequestOptions options = RequestOptions.DEFAULT;


    /**
     * 写入数据
     * @param indexName
     * @param dataMap 数据实体
     * @return
     */
    public boolean insert (String indexName, Map<String,Object> dataMap){

        try {
            BulkRequest request = new BulkRequest();
            request.add(new IndexRequest(indexName,"record").id(dataMap.remove("id").toString())
                    .opType("create").source(dataMap, XContentType.JSON));
            client.bulk(request, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#insert, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }

    /**
     * 批量写入数据
     * @param indexName
     * @param userIndexList
     * @return
     */
    public boolean batchInsert (String indexName, List<Map<String,Object>> userIndexList){

        try {
            BulkRequest request = new BulkRequest();
            for (Map<String,Object> dataMap:userIndexList){
                request.add(new IndexRequest(indexName,"record").id(dataMap.remove("id").toString())
                        .opType("create").source(dataMap,XContentType.JSON));
            }
            client.bulk(request, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#batchInsert, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 更新数据
     * 可以直接修改索引结构
     * @param indexName
     * @param dataMap
     * @return
     */
    public boolean update (String indexName, Map<String,Object> dataMap){

        try {
            UpdateRequest updateRequest = new UpdateRequest(indexName,"record", dataMap.remove("id").toString());
            updateRequest.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
            updateRequest.doc(dataMap) ;
            client.update(updateRequest, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#update, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 根据 id 及索引删除数据
     * @param indexName
     * @param id
     * @return
     */
    public boolean delete (String indexName, String id){

        try {
            DeleteRequest deleteRequest = new DeleteRequest(indexName,"record", id);
            client.delete(deleteRequest, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#delete, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 判断索引是否存在
     * @param indexName
     * @return
     */
    public boolean checkIndex (String indexName) {

        try {
            return client.indices().exists(new GetIndexRequest(indexName), options);
        } catch (IOException e) {
            log.error("ElasticsearchRepository#checkIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE ;
    }


    /**
     * 创建索引
     * @param indexName
     * @param columnMap
     * @return
     */
    public boolean createIndex (String indexName ,Map<String, Object> columnMap){

        try {
            if(!checkIndex(indexName)){
                CreateIndexRequest request = new CreateIndexRequest(indexName);
                if (columnMap != null && columnMap.size()>0) {
                    Map<String, Object> source = new HashMap<>();
                    source.put("properties", columnMap);
                    request.mapping(source);
                }
                client.indices().create(request, options);
                return Boolean.TRUE ;
            }
        } catch (IOException e) {
            log.error("ElasticsearchRepository#createIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 删除索引
     * @param indexName
     * @return
     */
    public boolean deleteIndex(String indexName) {

        try {
            if(checkIndex(indexName)){
                DeleteIndexRequest request = new DeleteIndexRequest(indexName);
                AcknowledgedResponse response = client.indices().delete(request, options);
                return response.isAcknowledged();
            }
        } catch (Exception e) {
            log.error("ElasticsearchRepository#deleteIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 查询满足条件的数据条数
     * @param indexName
     * @param matchMap
     * @return
     */
    public Long count (String indexName, LinkedHashMap<String, Object> matchMap){

        // 查询器构造
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        CountRequest countRequest = new CountRequest(indexName);
        countRequest.source(sourceBuilder);
        try {
            CountResponse countResponse = client.count(countRequest, options);
            return countResponse.getCount();
        } catch (Exception e) {
            log.error("ElasticsearchRepository#count, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return 0L;
    }


    /**
     * 查询满足条件的数据集合
     * 适用于满足条件的数据条数可控的全量查询 PS：单次查询条数不超过 10000条
     * @param indexName
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> list (String indexName, LinkedHashMap<String, Object> matchMap) {

        // 查询条件,指定时间并过滤指定字段值
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询参数拼接
        if (MapUtil.isNotEmpty(matchMap)){
            matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
        }
        sourceBuilder.query(queryBuilder);
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#list, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


    /**
     * 根据查询条件，分页查询
     * 适用于满足条件的数据总量较大的循环查询场景
     * @param indexName
     * @param offset 偏移量
     * @param size 条数
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> page (String indexName, Integer offset, Integer size, LinkedHashMap<String, Object> matchMap) {

        // 添加分页参数
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.from(offset);
        sourceBuilder.size(size);
        sourceBuilder.sort("createTime", SortOrder.DESC);
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        // 查询请求
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);

        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#page, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


    /**
     * 根据条件查询，按照创建时间进行降序排列
     * 可扩展，根据更新时间、 id、证件号等
     * @param indexName
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> sort (String indexName, LinkedHashMap<String, Object> matchMap) {

        // 先升序时间，在倒序年龄
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.sort("createTime", SortOrder.ASC);

        // 查询器构造
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#sort, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


}
单元测试

采用 Junit实现

总结

1.在承接业务需求时，首先要结合功能实现的复杂度，考虑架构的合理性，在相对更合理的系统设计背景下进行功能设计、开发；
2.进行技术开发时，首先要考虑功能对模块的侵入性，在最小侵入性的前提下，采用与基础框架融合的方式，完成开发任务。

shang_xs
关注
专栏目录
用Elastic官方的API，elasticsearch-rest-high-level-client来简单操作Elasticsearch的增删改查等功能，包教包会~
bb1272196672的博客
08-23 1443
用Elastic官方的API，elasticsearch-rest-high-level-client来简单操作Elasticsearch的增删改查等功能。java操作elasticsearch。spring。Elastic官方的api
ElasticSearch (四)Java之Elasticsearch RestHighLevelClient API 使用增删改查
AudiFashion的博客
07-21 1384
ES的安装及java集成ES与新增索引在前面几篇 此篇如有疑问可观看下面链接的内容，谢谢！ https://blog.csdn.net/weixin_40685388/article/details/95905359 1.创建获取id的接口 /** * es跟id获取参数 */ public interface EsEntity { /** * 根据id获取数据 ...
elasticsearch-rest-high-level-client api
qq_42920045的博客
12-31 3573
elasticsearch-rest-high-level-client api 官方给的5.5.3的API并不支持高级API, 发现只有5.6以上的版本支持 官方文档位置 导入依赖 <properties> <!-- 建议和es版本保持一致 --> <elasticsearch.version>6.2.2</elasticse...
ElasticSearch7.2学习—springboot集成elasticsearch
最新发布
nianfen的博客
08-16 763
Java Low Level REST Client: 低级别的REST客户端，通过http与集群交互，用户需自己编组请求JSON串，及解析响应JSON串。兼容所有ES版本。Java High Level REST Client: 高级别的REST客户端，基于低级别的REST客户端，增加了编组请求JSON串、解析响应JSON串等相关api。使用的版本需要保持和ES服务端的版本一致，否则会有版本问题。官方推荐使用高级版，低级版需要自己准确记住api。
elasticsearch使用与高级api的使用（RestHighLevelClient）
yang_zzu的博客
11-16 3264
-- 添加索引（数据库） curl -XPUT http://192.168.232.30:9200/yang_zzu/ -- 在表 employee 中添加一个 id 为 1 的数据 curl -H "Content-Type: application/json" -XPUT http://192.168.232.30:9200/yang_zzu/employee/1 -d ' { "first_name" : "daming", "last_name" : "erming",...
es-05-获取 resthighlevelclient及api
weixin_33738555的博客
08-02 478
在6.x以前, 使用最多的是transportclient, 但在7.x会被废弃,  先说以前的创建方式:  具体可见: https://www.cnblogs.com/wenbronk/p/6383194.html /** * 获取连接, 第一种方式 * @throws Exception */ // @Before public void ...
ElasticSearch篇——测试类测试restHighLevelClient常见API，一篇文章带你彻底吃透ES集成到Spring中如何使用，史上最全面、最详细使用方法分享！！！！！！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
12-10 1051
话不多说，直接开冲，大家准备好~创建索引测试用例控制台：查看ES的head可视化工具刚刚创建的索引，创建成功！
中间件：ElasticSearch组件RestHighLevelClient用法详解
【积累】，是一个长期持续的过程。
01-25 8616
RestHighLevelClient的API作为ElasticSearch备受推荐的客户端组件，其封装系统操作ES的方法，包括索引结构管理，数据增删改查管理，常用查询方法，并且可以结合原生ES查询原生语法，功能十分强大。在使用RestHighLevelClient的语法时，通常涉及上面几个方面，在掌握基础用法之上可以根据业务特点进行一些自定义封装，这样可以更优雅的解决业务需求。...
ElasticSearch (五)Java之Elasticsearch RestHighLevelClient 基础API与函数,分组查询使用
AudiFashion的博客
08-16 5644
本章通过ElasticSearch进行查询 must 多个查询条件的完全匹配,相当于 and。 mustNot 多个查询条件的相反匹配，相当于 not。 should 至少有一个查询条件匹配, 相当于 or。 1.创建查询类 1.1 根据系统id进行查询 @Slf4j @Repository public class ESDao { @Autowired ...
55、ElasticSearch RestHighLevelClient 简单查询
weixin_40968009的博客
11-22 443
本章学习了ElasticSearch RestHighLevelClient简单查询的相关API，都是基于QueryBuilders工具类实现的。
基于Elasticsearch Java API的参考手册
04-29
1. **创建客户端**: 使用`TransportClient`或`RestHighLevelClient`，前者通过TCP传输层与Elasticsearch通信，后者使用HTTP RESTful接口，更符合现代开发习惯。 2. **连接集群**: 设置集群名称和节点地址，建立...
ElasticSearch RestHighLevelClient 关于索引库、文档的基础操作
11-20
它的RestHighLevelClient是官方推荐的Java客户端，提供了一种与Elasticsearch服务器进行交互的高级接口，支持RESTful API，使得开发者能更方便地执行各种操作，如创建、更新、查询索引库以及管理文档。 首先，我们...
Java High Level REST Client 中文API（仅供参考）
热门推荐
含江君
10-18 1万+
1、初始化 兼容性 Java High Level REST Client需要Java 1.8，并依赖于Elasticsearch核心项目，客户端版本与客户端开发的Elasticsearch版本相同，它接受与TransportClient相同的请求参数，并返回相同的响应对象，如果需要将应用程序从TransportClient迁移到新的REST客户端，请参阅迁移指南。 High Level Clie...
Elasticsearch入门(RestHighLevelClient)-客户端封装-API查询
Kevin__Durant的博客
03-07 894
背景 - 大数据架构业务场景中需要实时数据落入ES，基本上是业务数据，目的是为了封装后作为规则引擎的变量提供，是变量系统的一部分； - 架构数据流来源于Maxwell，Spark Streaming做数据流处理，落库使用RestHighLevelClient的同步提交Bulk写入；增删改此文档不涉及，主要就是客户端以及查询的封装，为后续变量系统的应用部分； 客户端 streaming直接使用 def createESClientNew(): RestHighLevelClient = { new Re
ElasticSearch java high level api文档笔记
Amau_xushiwei的博客
06-24 494
//初始化并返回client public RestHighLevelClient init(String host,Integer port,String username,String password) { final CredentialsProvider credentialsProvider = new BasicCredentialsProvider(); credentialsProvider.setCredentials(AuthScope....
ElasticSearch高级API
长沙老码农
01-29 1805
目录 1、ElasticSearch编程操作 1.1 依赖坐标 1.2 创建客户端 1.3 创建索引 1.4 查询索引 1.5 创建文档 1.6 修改文档 1.7 Bulk批量操作 1.8 根据ID查询文档 1.9 高级查询 2、Spring Data ElasticSearch 2.1 什么是Spring Data 2.2 什么是Spring Data ElasticSearch 2.3 Spring集成Spring Data ElasticSearch 3、聚合分析 .
elasticsearch Java High Level REST Client API 使用（一）
choulu6980的博客
10-27 467
官方API地址 前言： 近期在做mysql到ES的增量实时同步项目（处理链路如上图），前期采用了单条进行增删改操作，但由于实时同步的数据量非常大，性能非但不能满足，并且会触发乐观锁导致数据最终一致性不能完全保证。 经过查询一些资料和实际验证发现bulkprocess...
RestHighLevelClient的简单使用
m0_67402341的博客
06-12 3867
二、代码 1、添加索引结构到es 2、获取索引信息 3、删除索引 4、添加数据到索引中 5、局部更新索引中的数据 6、根据文档id查询索引中的数据 7、根据文档id删除索引中的数据 8、根据查询条件删除索引中的数据 9、批量插入数据到索引中 10、批量删除索引中的数据 11、高级查询之查询全部数据 12、高级查询之term精准匹配 13、高级查询之分页查询 14、高级查询之排序查询 15、高级查询之source获取部分字段内容 16、高级查询之should匹配 17、高级查询
elasticsearch Java High Level REST Client API 使用(二)
choulu6980的博客
03-15 234
前言： 目前对es版本进行了升级，从5.5.3升级到了6.3.2 ，故对之前的集成方式做了微调。 elasticsearch Java High Level REST Client API 使用（一） 其他API使用请参考官方6.3.2文档 ->6.3官方API 1.mav...
Java Elasticsearch RestHighLevelClient
05-29
Java Elasticsearch RestHighLevelClient是Elasticsearch Java客户端中的一种高级REST客户端，它提供了简单易用的API，可以用于连接到Elasticsearch集群，并执行各种操作，如索引、搜索、删除、更新等。使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值