ElasticSearch JAVA HighLevelClient

最新推荐文章于 2024-02-05 11:04:32 发布
最新推荐文章于 2024-02-05 11:04:32 发布
阅读量1k 收藏 1
点赞数
分类专栏： Elasticsearch 文章标签： elasticsearch java highlevelclient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43315211/article/details/99431210
版权

在 pom.xml 中加入 Elasticsearch 的依赖：

		<dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.2.0</version>
        </dependency>
        
		<!--程序启动时报一下错误需要添加httpclient的依赖-->
		<!--java.lang.ClassNotFoundException: org.apache.http.client.config.RequestConfig-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.8</version>
        </dependency>

client

分为免密直接连接和需要用户名和密码两种连接方式

package elasticSearch.highLevelClient;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

/**
 * @author [tu.tengfei]
 * @description
 * @date 2019/8/10
 */
public class ESHighClient {
    public static RestHighLevelClient client;
    public static void getESClient(){

//        client = new RestHighLevelClient(RestClient.builder(
//                new HttpHost("slave01", 9200, "http"),
//                new HttpHost("master01", 9200, "http")
//        ));


		//需要用户名和密码的认证
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "passwd"));
        RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost("192.168.108.126", 9200, "http"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                        return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                });
        client = new RestHighLevelClient(restClientBuilder);
    }

    public static void clientClose(){
        if (client!=null){
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

High Index API

package elasticSearch.highLevelClient;

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.*;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.tasks.TaskSubmissionResponse;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.index.reindex.ReindexRequest;
import org.elasticsearch.index.reindex.UpdateByQueryRequest;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;

import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;

/**
 * @author [tu.tengfei]
 * @description
 * @date 2019/8/10
 */
public class HighIndexAPI {


    public static void main(String[] args) {
        ESHighClient.getESClient();
        RestHighLevelClient client = ESHighClient.client;
//        updateIndex(client);
//        getRequest(client);
//        existsAPI(client);
//        updateAPI(client);
//        bulkAPI(client);
//        multiGetAPI(client);
//        reindexAPI(client);
//        updateByQuery(client);
        deleteByQuery(client);
        ESHighClient.clientClose();
    }

    public static void submitIndex(RestHighLevelClient client) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name", "汪峰");
        hashMap.put("address", "重庆市渝北区财富中心");
        hashMap.put("send_time", "2019-08-07");
        hashMap.put("num", "sf112011482");
        IndexRequest express_info_v1 = new IndexRequest("express_info_v1").id("3").source(hashMap);
        try {
            IndexResponse indexResponse = client.index(express_info_v1, RequestOptions.DEFAULT);
            System.out.println(indexResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void getRequest(RestHighLevelClient client) {
        GetRequest getRequest = new GetRequest("express_info_v1", "2");
        try {
            GetResponse documentFields = client.get(getRequest, RequestOptions.DEFAULT);
            System.out.println(documentFields);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void existsAPI(RestHighLevelClient client) {
        GetRequest getRequest = new GetRequest("express_info_v1", "3");
        //不查询_source
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        //不存储字段
        getRequest.storedFields("__none__");
        try {
            boolean documentFields = client.exists(getRequest, RequestOptions.DEFAULT);
            System.out.println(documentFields);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void updateAPI(RestHighLevelClient client) {

        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name", "汪大峰");
        hashMap.put("send_time", "2019-08-11");
        UpdateRequest updateRequest = new UpdateRequest("express_info_v1", "3").doc(hashMap);
        try {
            UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
            System.out.println(update);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void bulkAPI(RestHighLevelClient client) {
        String index = "express_info_v1";
        BulkRequest bulkRequest = new BulkRequest();
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name", "张三");
        hashMap.put("address", "重庆市渝北区金开大道");
        hashMap.put("send_time", "2019-08-09");
        hashMap.put("num", "sf112011485");
        HashMap<String, Object> hashMap2 = new HashMap<>();
        hashMap2.put("name", "李四");
        hashMap2.put("address", "重庆市渝北区鸳鸯街道");
        hashMap2.put("send_time", "2019-07-09");
        hashMap2.put("num", "sf1120111111");
        bulkRequest.add(new IndexRequest(index).id("4").source(hashMap));
        bulkRequest.add(new IndexRequest(index).id("5").source(hashMap2));
        try {
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            System.out.println(bulkResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void multiGetAPI(RestHighLevelClient client) {
        MultiGetRequest request = new MultiGetRequest();
        request.add(new MultiGetRequest.Item("express_info_v1", "1"));
        request.add(new MultiGetRequest.Item("express_info_v1", "2"));
        try {
            MultiGetResponse response = client.mget(request, RequestOptions.DEFAULT);
            MultiGetItemResponse[] responses = response.getResponses();
//            System.out.println(responses);
            for (int i = 0; i < responses.length; i++) {
                GetResponse response1 = responses[i].getResponse();
                System.out.println(response1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void reindexAPI(RestHighLevelClient client) {
        ReindexRequest reindexRequest = new ReindexRequest();
        reindexRequest.setSourceIndices("express_info_v1");
        reindexRequest.setDestIndex("express_info_v5");
        reindexRequest.setRefresh(true);

        try {
            TaskSubmissionResponse taskSubmissionResponse = client.submitReindexTask(reindexRequest, RequestOptions.DEFAULT);
            System.out.println(taskSubmissionResponse);
            System.out.println(taskSubmissionResponse.getTask());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void updateByQuery(RestHighLevelClient client) {
        UpdateByQueryRequest request = new UpdateByQueryRequest("express_info_v1");
        request.setQuery(new TermQueryBuilder("name", "李四"));
//        request.setQuery(new MatchQueryBuilder("fieldName","value"));
        request.setScript(new Script(ScriptType.INLINE, "painless", "ctx._source.send_time = '2019-08-12'", Collections.emptyMap()));
        try {
            BulkByScrollResponse bulkByScrollResponse = client.updateByQuery(request, RequestOptions.DEFAULT);
            System.out.println(bulkByScrollResponse);
            System.out.println(bulkByScrollResponse.getStatus());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void deleteByQuery(RestHighLevelClient client) {
        DeleteByQueryRequest request = new DeleteByQueryRequest("express_info_v1");
        request.setQuery(new TermQueryBuilder("name", "李四"));
        try {
            BulkByScrollResponse bulkByScrollResponse = client.deleteByQuery(request, RequestOptions.DEFAULT);
            System.out.println(bulkByScrollResponse);
            System.out.println(bulkByScrollResponse.getStatus());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

High Search API

package elasticSearch.highLevelClient;

import org.elasticsearch.action.search.*;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.script.ScriptType;
import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
import org.elasticsearch.script.mustache.MultiSearchTemplateResponse;
import org.elasticsearch.script.mustache.SearchTemplateRequest;
import org.elasticsearch.script.mustache.SearchTemplateResponse;
import org.elasticsearch.search.Scroll;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.elasticsearch.search.suggest.SuggestBuilders;
import org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder;

import java.io.IOException;
import java.util.HashMap;

/**
 * @author [tu.tengfei]
 * @description
 * @date 2019/8/12
 */
public class HighSearchAPI {
    public static void main(String[] args) {
        ESHighClient.getESClient();
        RestHighLevelClient client = ESHighClient.client;
//        basicSearchAPI(client);
//        suggestionSearchAPI(client);
//        scrollSearchAPI(client);
//        multiSearch(client);
//        searchTemplate(client);
        multiSearchTemplate(client);
        ESHighClient.clientClose();
    }
    public static void basicSearchAPI(RestHighLevelClient client){
        SearchRequest searchRequest = new SearchRequest("express_info_v1");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("name","张三"));
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(5);
        searchRequest.source(searchSourceBuilder);
        try {
            SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
            System.out.println(search);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static void suggestionSearchAPI(RestHighLevelClient client){
        SearchRequest searchRequest = new SearchRequest("pinyin_suggester");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        CompletionSuggestionBuilder termSuggestionBuilder = SuggestBuilders.completionSuggestion("keyword.keyword_first_py").text("cxk");
        SuggestBuilder suggestBuilder = new SuggestBuilder();
        suggestBuilder.addSuggestion("suggest_keyword",termSuggestionBuilder);
        searchSourceBuilder.suggest(suggestBuilder);
        searchRequest.source(searchSourceBuilder);
        try {
            SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
            System.out.println(search);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void scrollSearchAPI(RestHighLevelClient client){
        Scroll scroll = new Scroll(TimeValue.timeValueMinutes(1L));
        SearchRequest searchRequest = new SearchRequest("express_info_v5");
        searchRequest.scroll(scroll);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("address","江西省"));
        searchRequest.source(searchSourceBuilder);

        try {
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            String scrollId = searchResponse.getScrollId();
            SearchHit[] hits = searchResponse.getHits().getHits();

            while (hits!=null && hits.length>0){
                SearchScrollRequest searchScrollRequest = new SearchScrollRequest(scrollId);
                searchScrollRequest.scroll(scroll);
                searchResponse = client.scroll(searchScrollRequest, RequestOptions.DEFAULT);
                scrollId = searchResponse.getScrollId();
                hits = searchResponse.getHits().getHits();
            }

            ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
            clearScrollRequest.addScrollId(scrollId);
            ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
            boolean succeeded = clearScrollResponse.isSucceeded();
            System.out.println(succeeded);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void multiSearch(RestHighLevelClient client){
        MultiSearchRequest multiSearchRequest = new MultiSearchRequest();
        SearchRequest searchRequest = new SearchRequest("express_info_v5");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("address","江西省"));
        searchRequest.source(searchSourceBuilder);

        SearchRequest searchRequest1 = new SearchRequest("express_info_v2");
        searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("address","康庄美地"));
        searchRequest1.source(searchSourceBuilder);

        multiSearchRequest.add(searchRequest);
        multiSearchRequest.add(searchRequest1);

        try {
            MultiSearchResponse msearch = client.msearch(multiSearchRequest, RequestOptions.DEFAULT);
            System.out.println(msearch);
            MultiSearchResponse.Item[] responses = msearch.getResponses();
            for (int i =0;i<responses.length;i++){
                System.out.println(responses);
                System.out.println(responses[i].getResponse());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void searchTemplate(RestHighLevelClient client){
        SearchTemplateRequest searchTemplateRequest = new SearchTemplateRequest();
        searchTemplateRequest.setRequest(new SearchRequest("express_info_v5"));

        searchTemplateRequest.setScriptType(ScriptType.INLINE);
        searchTemplateRequest.setScript(
                "{" +
                "   \"query\":{" +
                        "   \"match\":{" +
                        "       \"{{field}}\":\"{{value}}\"" +
                        "           }" +
                        "       }," +
                        "   \"size\":\"{{size}}\"" +
                        "}");
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("field","address");
        hashMap.put("value","江西省");
        hashMap.put("size",5);

        searchTemplateRequest.setScriptParams(hashMap);

        try {
            SearchTemplateResponse searchTemplateResponse = client.searchTemplate(searchTemplateRequest, RequestOptions.DEFAULT);
            SearchResponse response = searchTemplateResponse.getResponse();
            System.out.println(response);
            System.out.println(response.getHits());
            System.out.println(searchTemplateResponse.getSource());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void multiSearchTemplate(RestHighLevelClient client){
        String[] searchTerms = {"康庄美地","江西省"};
        MultiSearchTemplateRequest multiSearchTemplateRequest = new MultiSearchTemplateRequest();

        for (String searchTerm:searchTerms){
            SearchTemplateRequest searchTemplateRequest = new SearchTemplateRequest();
            searchTemplateRequest.setRequest(new SearchRequest("express_info_v5"));

            searchTemplateRequest.setScriptType(ScriptType.INLINE);
            searchTemplateRequest.setScript(
                    "{" +
                            "\"query\":{" +
                            "   \"match\":{" +
                            "       \"{{field}}\":\"{{value}}\"" +
                            "       }" +
                            "   }," +
                            "\"size\":\"{{size}}\"" +
                    "}"
            );
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("field","address");
            hashMap.put("value",searchTerm);
            hashMap.put("size",5);
            searchTemplateRequest.setScriptParams(hashMap);
            multiSearchTemplateRequest.add(searchTemplateRequest);
        }

        try {
            MultiSearchTemplateResponse multiSearchTemplateResponse = client.msearchTemplate(multiSearchTemplateRequest, RequestOptions.DEFAULT);
            for (MultiSearchTemplateResponse.Item item:multiSearchTemplateResponse.getResponses()){
                if (item.isFailure()){
                    System.out.println(item.getFailureMessage());
                }else {
                    SearchTemplateResponse response = item.getResponse();
                    SearchResponse searchResponse = response.getResponse();
                    System.out.println(searchResponse);
                    System.out.println(searchResponse.getHits());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

High Indices API

package elasticSearch.highLevelClient;

import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeResponse;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;

/**
 * @author [tu.tengfei]
 * @description
 * @date 2019/8/12
 */
public class HighIndicesAPI {
    public static void main(String[] args) {
        ESHighClient.getESClient();
        RestHighLevelClient client = ESHighClient.client;
//        analyzeAPI(client);
        createIndex(client);
        ESHighClient.clientClose();
    }

    public static void analyzeAPI(RestHighLevelClient client){
        AnalyzeRequest analyzeRequest = new AnalyzeRequest();
        analyzeRequest.text("爱我中华人民共和国");
        analyzeRequest.analyzer("ik_smart");
//        analyzeRequest.index("");
        try {
            AnalyzeResponse analyze = client.indices().analyze(analyzeRequest, RequestOptions.DEFAULT);
            System.out.println(analyze);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void createIndex(RestHighLevelClient client){
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("express_info_v6");

        createIndexRequest.settings(Settings.builder()
            .put("index.number_of_shards",3)
            .put("index.number_of_replicas",2));

        createIndexRequest.mapping(
                "{\n" +
                        "  \"properties\":{\n" +
                        "    \"name\":{\n" +
                        "      \"type\":\"text\",\n" +
                        "      \"fields\": {\n" +
                        "        \"suggest_key\":{\n" +
                        "          \"type\":\"completion\",\n" +
                        "          \"analyzer\":\"key_pinyin\"\n" +
                        "        },\n" +
                        "        \"suggest_full\":{\n" +
                        "          \"type\":\"completion\",\n" +
                        "          \"analyzer\":\"full_pinyin\"\n" +
                        "        }\n" +
                        "      }\n" +
                        "    },\n" +
                        "    \"address\":{\n" +
                        "      \"type\":\"text\",\n" +
                        "      \"fields\": {\n" +
                        "        \"suggest_key\":{\n" +
                        "          \"type\":\"completion\",\n" +
                        "          \"analyzer\":\"key_pinyin\"\n" +
                        "        },\n" +
                        "        \"suggest_full\":{\n" +
                        "          \"type\":\"completion\",\n" +
                        "          \"analyzer\":\"full_pinyin\"\n" +
                        "        }\n" +
                        "      }\n" +
                        "    },\n" +
                        "    \"send_time\":{\n" +
                        "      \"type\":\"date\",\n" +
                        "      \"format\": \"yyyy-MM-dd\"\n" +
                        "    },\n" +
                        "    \"num\":{\n" +
                        "      \"type\":\"text\",\n" +
                        "      \"analyzer\": \"key_pinyin\"\n" +
                        "    }\n" +
                        "  }\n" +
                        "}", XContentType.JSON
        );
        try {
            CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
            System.out.println(createIndexResponse);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
weixin_43315211
关注
专栏目录
ElasticSearch7.0 Java High Level Client使用教程（三：聚合查询）
weixin_42473019的博客
06-05 1296
前两篇介绍了es的简单条件查询，本文将在条件查询的基础上添加聚合条件进行查询，聚合查询很大的不同是在查询结果的解析上。 首先看一下这条dsl查询语句： GET test*/_search { "size": 0, "timeout": "60s", "query": { "bool": { "must": [ { "terms": { "server_name.keyword": [ "w
ElasticSearch7.0 Java High Level Client使用教程（一：简单查询）
weixin_42473019的博客
05-21 1590
本文将演示如何使用ES提供的Java高级包来查询数据，首先API其实就是在底层构建一条DSL查询语句，所以我们首先看一下这条语句: GET test*/_search { "timeout": "60s", "query": { "bool": { "must": [ { "terms": { "status.keyword": [ "301", "302"
ElasticSearch Java High Level Client使用备忘
Layingo的博客
11-27 261
ElasticSearch Java High Level Client 封装类似SQL select * from xxx group by xxx.xxx order by xxx的实现 可以通过top_hits实现 /** * @return SearchSourceBuilder 是封装在SearchRequest里的，它里面就是ElasticSearch的查询条件 */ publi...
SpringBoot 整合ElasticSearch,high level client
weixin_44743332的博客
10-23 838
分三步： 1.导入依赖 2.编写配置，给容器注入一个RestHighLevelClient 3.使用 1.先创建一个模块，然后导入ES 的high level client 3.index: 可从ES 中保存和更新数据。 检索：也就是要构造出一下的格式 ...
ElasticSearch 使用 High Level REST Client 实现搜索等功能实战
Java知音
06-29 880
点击关注公众号，实用技术文章及时了解ES 全称 Elasticsearch 是一款分布式的全文搜索引擎，在互联网公司中，这款搜索引擎一直被程序员们所推崇。常见的使用场景如ELK日志分析，电商APP的商品推荐，社交APP的同城用户推荐等等。在ES的官网文档中，目前主要提供了两种方式访问，一种叫做Low Client，一种叫做High Level Rest Client。在今...
ElasticSearch RestHighLevelClient 通用操作
大树叶 技术专栏
07-27 6085
项目中使用到ElasticSearch作为搜索引擎。而ES的环境搭建自然是十分简单，且本身就适应于分布式环境，因此这块就不多赘述。而其本身特性和查询语句这篇博文不会介绍，如果有机会会深入介绍。 ​ 所以这篇博文主要还是介绍Java客户端中如何使用查询搜索引擎中的数据。而使用的Java客户端是官方新推出的RestHighLevelClient，使用Http连接查询结果。但是网上相关资料较少，只有官...
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar；...标签：elasticsearch、client、rest、high、level、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵
基于Java High Level Client的Elasticsearch客户端的常用操作代码
04-17
Elasticsearch客户端常用代码封装实例 基于MyBatis Plus的Java High Level Client ES客户端的常用操作 如：增删改查、聚合查询、客户端封装、节点嗅探等常用代码示例
ElasticSearch Java High level Rest Client 官方文档中文翻译(一)
weixin_41927235的博客
05-29 3483
ElasticSearch Java High level Rest Client 官方文档中文翻译 一 纯粹记录自己在看官网的es rest high level api 时的翻译笔记，可以对照着官网文档看。 Java High level Rest Client 为什么不用 spring data es ？ 1. rest high level api 支持异步操作，提交请求之后直接返回 2. 更接近原生的es http请求方式 ElasticSearch Java
elasticsearch 基础介绍及使用 （high-level-client）
JKjiang123的博客
05-29 1万+
一、ElasticSearch 简介 1、简介 ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多员工能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 是用 Java 语言开发的，并作为 Apache 许可条款下的开放源码发布，是一种流行的企业级搜索引擎。ElasticSearch 用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。 2、特性 分布式的文档存储引擎 分布式的搜索引擎和分析引擎 分...
ElasticSearch 8.x 使用 High Level Client 以 HTTPS 方式链接，SSL 证书、主机名验证器 各是什么，如何忽略
最新发布
qq_19283249的博客
02-05 2816
生产环境的 ElasticSearch 有时可能是通过域名来访问的，并且是 https 开头的，那就需要 SSL/TLS 认证了，但是我们并不需要，那只能忽略了。 那该如何忽略呢？
java.lang.NoClassDefFoundError: org/elasticsearch/client/RestHighLevelClient
qq_42889988的博客
01-31 1329
心都凉了，主要是引入依赖的时候，RestHighLevelClient版本和子包版本不一致，我这边的话是选中的三个包版本不一致，当然图里是我整里半天整一致的，原先好像是7.x，可能是因为我的电脑里6和7都有吧。。。 解决方案就是强制依赖包的版本确保一致，我这边是用了management，也可以用exclousions先排除依赖包，在引入正确的版本，当然这边因为版本不一致报了各种各样的错误，不一定就是这个异常，勿喷 <dependencyManagement> <de.
java.lang.NoClassDefFoundError: org/elasticsearch/client/RestHighLevelClient异常问题
热门推荐
tc979907461的博客
04-01 1万+
1、问题 今天在启动微服务项目的时候出现了一个错误，大概就是controller调用某个implservice的Bean找不到。 elasticsearch下的xcontent包下找不到ToXcontentObject这个类。 2、排查 先查看POM文件，确认导入无误。 检查一遍yml配置文件，没什么大问题，检查一下JDK版本，也是没问题。再看了下maven projects，没有冲突，而且...
elasticsearch-rest-high-level-client
WGYHAPPY的博客
03-07 2870
文章目录Gradle 依赖Client 初始化RequestOptions支持的API单文档APIIndex APIGet APIGetSourceApiExists APIDelete APIUpdate APITerms Vectors API多文档APIBulk APIMulti-Get APIReindex APIUpdate By Query APIDeleted By Query APIRethrollte APIMulti Terms API Gradle 依赖 dependencies {
第07讲：Java High Level Client，读写 ES 利器
Marion的博客
05-11 839
分片是 ElasticSearch 中最小的数据分配单位，即一个分片总是作为一个整体被分配到集群中的某个节点。继续深入分片的结构会发现，一个分片是由多个 Segment 构成的，如下图所示：Segment 是最小的数据存储单元，ElasticSearch 每隔一段时间会产生一个新的 Segment，用于写入最新的数据。旧的 Segment 是不可改变的，只能用于数据查询，是无法继续向其中写入数据的。旧 Segment 不支持修改，那么在读操作的时候就不需要加锁，省去了锁本身以及竞争锁相关的开销；
ElasticSearch java high level api文档笔记
Amau_xushiwei的博客
06-24 492
//初始化并返回client public RestHighLevelClient init(String host,Integer port,String username,String password) { final CredentialsProvider credentialsProvider = new BasicCredentialsProvider(); credentialsProvider.setCredentials(AuthScope....
Springboot整合Elasticsearch(High-level-Client)
bigsai
03-29 1万+
前言 通过学习Elasticsearch一小段时间来稍微认识了一点ES的体系架构。发现ES最大的坑就是版本兼容性问题了—在整合Springboot也不例外，但是，有一种方式能较好的解决—通过restclient。 项目github地址springboot_elasticsearch求star 内容 当前springboot整合ElasticSearch的方法主体分为2大种——restcl...
ElasticSearch 使用Java High Level REST Client API实现搜索功能-笔记
DraGon_HooRay的博客
09-22 773
我使用ElasticSearch-7.5.2基于springboot开发。 7.x算是比较新的版本，网上关于es的api更多是transport API的说明。所以在这里记录一下，仅供参考。 Java REST客户端有两种版本： Java Low Level REST Client：Elasticsearch的官方低级客户端。它允许通过http与Elasticsearch集群进行通信。将请求编组和对用户取消编组的响应离开。它与所有Elasticsearch版本兼容。 Java High Level REST
Java High Level REST Client 操作 elasticsearch
xiaoyaGrace的博客
02-25 187
Java 高级别 REST 客户端（The Java High Level REST Client）以后简称高级客户端，内部仍然是基于低级客户端。它提供了更多的 API，接受请求对象作为参数并返回响应对象，由客户端自己处理编码和解码。 每个 API 都可以同步或异步调用。 同步方法返回一个响应对象，而异步方法的名称以 async 后缀结尾，需要一个监听器参数，一旦...
springboot整合High Level Client elasticsearch详细步骤
06-01
好的，下面我来为你讲解如何在Spring Boot中整合Elasticsearch的High Level Client，具体步骤如下： 1. 添加Elasticsearch依赖 在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.elasticsearch.client ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值