Java High Level REST Client 简单案例

最新推荐文章于 2024-08-23 16:38:09 发布
最新推荐文章于 2024-08-23 16:38:09 发布
阅读量783 收藏 1
点赞数
文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21299835/article/details/111821204
版权

接着https://mp.csdn.net/editor/html/111758076,继续分享一下High Level REST Client 的测试小demo.注(ES 版本还是7.3.2)

1.创建Client

    private String index = "project2index";
    private String type="project2type";
    private RestHighLevelClient client;

    @Before
    public void before(){
        HttpHost httpHost = new HttpHost("localhost", 9200, "http");
        RestClientBuilder builder = RestClient.builder(httpHost);
        client = new RestHighLevelClient(builder);
    }

 2.关闭client

    @After
    public void after() throws IOException {
        client.close();
    }

3.创建index

    @Test
    public void createIndex() throws IOException, InterruptedException {

        CreateIndexRequest request = new CreateIndexRequest(index);
        /** 设置属性 */
        request.settings(Settings.builder()
                /** 默认 5分片1副本 */
                .put("index.number_of_shards", 5)
                .put("index.number_of_replicas", 1)
        );
        /** 设置mapping 方式1 */
//        request.mapping(
//                "{\n" +
//                        "  \"properties\": {\n" +
//                        "    \"message\": {\n" +
//                        "      \"type\": \"text\"\n" +
//                        "    }\n" +
//                        "  }\n" +
//                        "}",
//                XContentType.JSON);
        /** 设置mapping 方式2 */
//        Map<String, Object> message = new HashMap<>();
//        message.put("type", "text");
//        Map<String, Object> properties = new HashMap<>();
//        properties.put("message", message);
//        Map<String, Object> mapping = new HashMap<>();
//        mapping.put("properties", properties);
//        ObjectMapper objectMapper = new ObjectMapper();
//        String s = objectMapper.writeValueAsString(mapping);
//        request.mapping(mapping);
        /** 设置mapping 方式3 */
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.startObject("properties");
            {
                builder.startObject("name");
                {
                    builder.field("type", "text");
                }
                builder.endObject();
                builder.startObject("desc");
                {
                    builder.field("type", "text");
                }
                builder.endObject();
            }
            builder.endObject();
        }
        builder.endObject();
        request.mapping(String.valueOf(builder));
        /** 设置mapping 方式4 整体设置 */
//        request.source("{\n" +
//                "    \"settings\" : {\n" +
//                "        \"number_of_shards\" : 1,\n" +
//                "        \"number_of_replicas\" : 0\n" +
//                "    },\n" +
//                "    \"mappings\" : {\n" +
//                "        \"properties\" : {\n" +
//                "            \"message\" : { \"type\" : \"text\" }\n" +
//                "        }\n" +
//                "    },\n" +
//                "    \"aliases\" : {\n" +
//                "        \"twitter_alias\" : {}\n" +
//                "    }\n" +
//                "}", XContentType.JSON);
        /** 同步处理 */
        IndicesClient indices = client.indices();
//        CreateIndexResponse createIndexResponse = indices.create(request, RequestOptions.DEFAULT);
//        System.out.println(createIndexResponse);

        ActionListener<CreateIndexResponse> listener =
                new ActionListener<CreateIndexResponse>() {

                    @Override
                    public void onResponse(CreateIndexResponse createIndexResponse) {
                        System.out.println("节点确认请求 "+createIndexResponse.isAcknowledged());
                    }

                    @Override
                    public void onFailure(Exception e) {
                        System.err.println("异常返回信息 "+e.getMessage());

                    }
                };
        /**异步创建index*/
        client.indices().createAsync(request, RequestOptions.DEFAULT, listener);
        Thread.sleep(2000);
        
    }

4.删除index

    @Test
    public void delete() throws IOException, InterruptedException {
        index = "projectindex";
        DeleteIndexRequest request = new DeleteIndexRequest(index);
        /** 可选项 */
        /** 等待所有节点超时时间 */
//        request.timeout(TimeValue.timeValueMinutes(2));
//        request.timeout("2m");
        /** 等待主节点超时时间 */
//        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
//        request.masterNodeTimeout("1m");
        /** LENIENT_EXPAND_OPEN */
        request.indicesOptions(IndicesOptions.lenientExpandOpen());
        /** 同步删除index */
        try{
            AcknowledgedResponse deleteIndexResponse = client.indices().delete(request, RequestOptions.DEFAULT);
        }catch (ElasticsearchException e){
            if (e.status() == RestStatus.NOT_FOUND) {
                System.out.println("NOT_FOUND！！");
            }else if(e.status() == RestStatus.NO_CONTENT){
                System.out.println("NO_CONTENT！！");
            }
        }
//
//        System.out.println("确认删除： "+deleteIndexResponse.isAcknowledged());
        /** 异步进行删除 */
        ActionListener<AcknowledgedResponse> listener =
                new ActionListener<AcknowledgedResponse>() {
                    @Override
                    public void onResponse(AcknowledgedResponse deleteIndexResponse) {
                        System.out.println("删除正常 "+deleteIndexResponse.isAcknowledged());
                    }

                    @Override
                    public void onFailure(Exception e) {
                        System.err.println("异常信息 "+e.getMessage());
                    }
                };
        client.indices().deleteAsync(request, RequestOptions.DEFAULT, listener);
        Thread.sleep(2000);
    }

5.判断index是否存在

    /**
     * 判断 index 是否存在
     */
    @Test
    public void getIndex() throws IOException, InterruptedException {
        index = "userindex";
        GetIndexRequest request = new GetIndexRequest(index);
        /** 可选配置 */
        /** 本地/节点 */
//        request.local(false);
        /** 可读 */
//        request.humanReadable(true);
        /** 是否包括默认配置 */
//        request.includeDefaults(false);
        /** 设置通配符表达式 */
//        request.indicesOptions(indicesOptions);
        /** 同步 */
//        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
//        System.err.println("index "+index+" 是否存在: "+(exists == true?"存在":"不存在"));
        /** 异步 */
        ActionListener<Boolean> listener = new ActionListener<Boolean>() {
            @Override
            public void onResponse(Boolean exists) {
                System.out.println("index "+index+" 是否存在: "+(exists == true?"存在":"不存在"));
            }

            @Override
            public void onFailure(Exception e) {
                System.err.println("异常信息 "+e.getMessage());
            }
        };
        client.indices().existsAsync(request, RequestOptions.DEFAULT, listener);
        Thread.sleep(2000);
    }

6.打开index

    /**
     * 在 kibana 的 索引管理 中 有个状态项 （open）
     * @throws IOException
     */
    @Test
    public void openIndex() throws IOException, InterruptedException {
        index = "userindex";
        OpenIndexRequest request = new OpenIndexRequest(index);
        /** 同步打开 */
        OpenIndexResponse openIndexResponse = client.indices().open(request, RequestOptions.DEFAULT);
        /** 异步打开 */
//        ActionListener<OpenIndexResponse> listener =
//                new ActionListener<OpenIndexResponse>() {
//                    @Override
//                    public void onResponse(OpenIndexResponse openIndexResponse) {
//                        System.out.println(openIndexResponse.isAcknowledged());
//                    }
//
//                    @Override
//                    public void onFailure(Exception e) {
//                        System.out.println(e.getMessage());
//                    }
//                };
//        client.indices().openAsync(request, RequestOptions.DEFAULT, listener);
//        Thread.sleep(2000);
    }

7.关闭index

    /**
     * 在 kibana 的 索引管理 中 有个状态项 (关闭)
     * @throws IOException
     */
    @Test
    public void closeIndex() throws IOException, InterruptedException {
        index = "userindex";
        CloseIndexRequest request = new CloseIndexRequest(index);
        /** 设置请求超时时间 */
//        request.timeout(TimeValue.timeValueMinutes(2));
//        request.timeout("2m");

        /** 同步 */
        AcknowledgedResponse closeIndexResponse = client.indices().close(request, RequestOptions.DEFAULT);
        System.err.println(closeIndexResponse.isAcknowledged());
        /** 异步 */
//        ActionListener<AcknowledgedResponse> listener =
//                new ActionListener<AcknowledgedResponse>() {
//                    @Override
//                    public void onResponse(AcknowledgedResponse closeIndexResponse) {
//                        System.out.println(closeIndexResponse.isAcknowledged());
//                    }
//
//                    @Override
//                    public void onFailure(Exception e) {
//                        System.out.println(e.getMessage());
//                    }
//                };
//        client.indices().closeAsync(request, RequestOptions.DEFAULT, listener);
//        Thread.sleep(2000);

    }

8.添加/修改mapping

 /**
     * 添加/修改 mapping
     *
     * @throws IOException
     */
    @Test
    public void putMapping() throws IOException, InterruptedException {
        index = "personindex";
        PutMappingRequest request = new PutMappingRequest(index);
        /** 方式1 */
        request.source(
                "{\n" +
                        "  \"properties\": {\n" +
                        "    \"message\": {\n" +
                        "      \"type\": \"text\"\n" +
                        "    }\n" +
                        "  }\n" +
                        "}",
                XContentType.JSON);
        /** 方式2 */
//        Map<String, Object> jsonMap = new HashMap<>();
//        Map<String, Object> message = new HashMap<>();
//        message.put("type", "text");
//        Map<String, Object> properties = new HashMap<>();
//        properties.put("message", message);
//        jsonMap.put("properties", properties);
//        request.source(jsonMap);
        /** 方式3 */
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.startObject("properties");
            {
                builder.startObject("id");
                {
                    builder.field("type", "integer");
                }
                builder.endObject();
                builder.startObject("name");
                {
                    builder.field("type", "text");
                }
                builder.endObject();
                builder.startObject("age");
                {
                    builder.field("type", "integer");
                }
                builder.endObject();
                builder.startObject("desc");
                {
                    builder.field("type", "text");
                }
                builder.endObject();
            }
            builder.endObject();
        }
        builder.endObject();
        request.source(builder);
        /** 同步 */
        AcknowledgedResponse putMappingResponse = client.indices().putMapping(request, RequestOptions.DEFAULT);
        System.err.println(putMappingResponse.isAcknowledged());
        /** 异步 */
//        ActionListener<AcknowledgedResponse> listener =
//                new ActionListener<AcknowledgedResponse>() {
//                    @Override
//                    public void onResponse(AcknowledgedResponse putMappingResponse) {
//                        System.out.println(putMappingResponse.isAcknowledged());
//                    }
//
//                    @Override
//                    public void onFailure(Exception e) {
//                        System.err.println(e.getMessage());
//                    }
//                };
//        client.indices().putMappingAsync(request, RequestOptions.DEFAULT, listener);
//        Thread.sleep(2000);
    }

9.查询mapping信息

    @Test
    public void getMapping() throws IOException {
        index = "personindex";
        GetMappingsRequest request = new GetMappingsRequest();
        /** 方法1 提前指定 index */
//        request.indices(index);
        /** 同步 */
        GetMappingsResponse getMappingResponse = client.indices().getMapping(request, RequestOptions.DEFAULT);
        Map<String, MappingMetaData> mappings = getMappingResponse.mappings();
        ObjectMapper mappers = new ObjectMapper();
        /** 方法1 显示结果 */
//        Set<Map.Entry<String, MappingMetaData>> entries = mappings.entrySet();
//        Iterator<Map.Entry<String, MappingMetaData>> iterator = entries.iterator();
//        Map.Entry<String, MappingMetaData> next = iterator.next();
//        System.out.println(next.getKey() +"\n"+mappers.writeValueAsString(next.getValue().getSourceAsMap()));
        /** 方式2 全部查出来 再过滤 */
        MappingMetaData indexMapping = mappings.get("personindex");
        Map<String, Object> mapping = indexMapping.sourceAsMap();
        System.out.println(mappers.writeValueAsString(mapping));
        System.out.println();
        System.out.println();
        /** 异步 */
//        ActionListener<GetMappingsResponse> listener =
//                new ActionListener<GetMappingsResponse>() {
//                    @Override
//                    public void onResponse(GetMappingsResponse putMappingResponse) {
//                        Map<String, MappingMetaData> mappings = getMappingResponse.mappings();
//                        Set<Map.Entry<String, MappingMetaData>> entries = mappings.entrySet();
//                        Iterator<Map.Entry<String, MappingMetaData>> iterator = entries.iterator();
//                        while(iterator.hasNext()){
//                            Map.Entry<String, MappingMetaData> next = iterator.next();
//                            ObjectMapper mappers = new ObjectMapper();
//
//                            try {
//                                System.out.println(next.getKey() +"\n"+mappers.writeValueAsString(next.getValue().getSourceAsMap()));
//                            } catch (JsonProcessingException e) {
//                                e.printStackTrace();
//                            }
//                        }
//                        System.out.println();
//                        System.out.println();
//                    }
//
//                    @Override
//                    public void onFailure(Exception e) {
//                        System.out.println(e.getMessage());
//                    }
//                };
//        client.indices().getMappingAsync(request, RequestOptions.DEFAULT, listener);

    }

10.添加数据

    /**
     * 添加数据
     */
    @Test
    public void putData() throws IOException {
        index = "personindex";
        /** 方式1 */
//        IndexRequest request = new IndexRequest(index);
//        request.id("1");
//        String jsonString = "{" +
//                "\"name\":\"小尘\"," +
//                "\"age\":\"6\"," +
//                "\"desc\":\"learn Elasticsearch\"" +
//                "}";
//        request.source(jsonString, XContentType.JSON);

        /** 方式2 */
        Map<String, Object> jsonMap = new HashMap<>();
        jsonMap.put("name", "刘备");
        jsonMap.put("age", 23);
        jsonMap.put("desc", "刘备 此人身长七尺五寸，两耳垂肩，双手过膝，目能自顾其耳，面如冠玉，唇若涂脂，性宽和，寡言语，喜怒不形于色，素有大志，专好结交天下豪杰。刘备的外貌描写如下： 此人身长七尺五寸，两耳垂肩，双手过膝，目能自顾其耳，面如冠玉，唇若涂脂，性宽和，寡言语，喜怒不形于色，素有大志，专好结交天下豪杰");
        IndexRequest request = new IndexRequest(index)
                .id("2").source(jsonMap);
        /** 方式3 */
//        XContentBuilder builder = XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.field("name", "小尘");
//            builder.field("age", 6);
//            builder.field("desc", "learn Elasticsearch");
//        }
//        builder.endObject();
//        IndexRequest indexRequest = new IndexRequest(index)
//                .id("1").source(builder);
//        IndexRequest indexRequest = new IndexRequest("posts")
//                .id("1")
//                .source("name", "小尘",
//                        "age", 6,
//                        "desc", "learn Elasticsearch");

        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        String index = indexResponse.getIndex();
        String id = indexResponse.getId();
        if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
            System.out.println("创建文档");
        } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
            System.out.println("修改文档");
        }
        ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
        if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
            System.out.println("成功分片数小于总的分片数");
        }
        if (shardInfo.getFailed() > 0) {
            for (ReplicationResponse.ShardInfo.Failure failure :
                    shardInfo.getFailures()) {
                String reason = failure.reason();
                System.err.println(reason);
            }
        }
    }

11.查询数据

    /**
     *
     * @throws IOException
     */
    @Test
    public void search() throws IOException {
        index = "personindex";
//        SearchRequest searchRequest = new SearchRequest();
        /** 指定 index */
        SearchRequest searchRequest = new SearchRequest(index);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        /** term 查询的字段不能再进行分词 */
//        searchSourceBuilder.query(QueryBuilders.termQuery("name", "刘"));
        /** 单个字段匹配 */
        searchSourceBuilder.query(QueryBuilders.matchQuery("name", "刘备"));
        /** 多个字段匹配 */
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("刘备", "name","desc"));
        /** 分页查询 */
//        searchSourceBuilder.from(0);
//        searchSourceBuilder.size(5);
        searchRequest.source(searchSourceBuilder);
        /** 模糊匹配 */
//        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("name", "尘");
//        /** 开启模糊查询 */
//        matchQueryBuilder.fuzziness(Fuzziness.FIELD);
//        /** 前缀匹配长度 */
//        matchQueryBuilder.prefixLength(2);
//        /** 最大模糊数 */
//        matchQueryBuilder.maxExpansions(10);
//        searchRequest.source(searchSourceBuilder);
        /** 对文档进行排序 */
//        searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
//        searchSourceBuilder.sort(new FieldSortBuilder("_id").order(SortOrder.ASC));
        /** 关闭解锁_source */
//        searchSourceBuilder.fetchSource(false);
        /** 过滤 field */
        String[] includeFields = new String[] {"name","desc"};
        String[] excludeFields = new String[] {"age"};
        searchSourceBuilder.fetchSource(includeFields, excludeFields);
        /** 高亮 */
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        HighlightBuilder.Field highlightTitle =new HighlightBuilder.Field("name");
        highlightTitle.highlighterType("unified");
        highlightBuilder.field(highlightTitle);
        HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("desc");
        highlightBuilder.field(highlightUser);
        searchSourceBuilder.highlighter(highlightBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchResponse.getHits();
        TotalHits totalHits = hits.getTotalHits();
        /** 总的命中数 */
        long numHits = totalHits.value;
        System.err.println("总的命中数:  "+numHits);
        TotalHits.Relation relation = totalHits.relation;
        /** 匹配度 */
        float maxScore = hits.getMaxScore();
        System.err.println("匹配度  "+maxScore);
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String index = hit.getIndex();
            String id = hit.getId();
            float score = hit.getScore();
            System.out.println("index "+index +" id "+id+ " score "+ score);
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String desc = (String) sourceAsMap.get("desc");
            System.out.println(name+"  "+desc);
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField highlight = highlightFields.get("name");
            ObjectMapper objectMapper = new ObjectMapper();
            if(highlight != null){
                Text[] fragments = highlight.fragments();
                String fragmentString = fragments[0].string();
                System.err.println(fragmentString);
                sourceAsMap.put("name",fragmentString);
            }
            HighlightField highlight2 = highlightFields.get("desc");
            if(highlight2 != null){
                Text[] fragments2 = highlight2.fragments();
                String fragmentString2 = fragments2[0].string();
                System.err.println(fragmentString2);
                sourceAsMap.put("desc",fragmentString2);
            }
            System.err.println(objectMapper.writeValueAsString(sourceAsMap));
        }
    }

我这里只是写了一小部分基础的,具体可以查看官网.

官网:https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.3/index.html

小_北_辰
关注
Java HighLevel Rest Client
liushaojiax的博客
03-22 892
JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。索引库操作的基本步骤：初始化RestHighLevelClient创建XxxIndexRequest。XXX是Create、Get、Delete准备DSL（ Create时需要，其它是无参）发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete。
Java操作Elasticsearch 之 [Java High Level REST Clientedit]
AnonyStar | Blog
09-23 626
1. 简述 Elasticsearch 是基于 Lucene 开发的一个分布式全文检索框架，向 Elasticsearch 中存储和从 Elasticsearch 中查询，格式是json。 向 Elasticsearch 中存储数据，其实就是向 es 中的 index 下面的 type 中存储 json 类型的数据。 elasticsearch 提供了很多语言的客户端用于操作 elasticsearch 服务，例如： java 、 python 、 .net 、 JavaScript 、 PHP ..
RestHighLevelClient判断index是否存在
01-07
判断Index是否存在版本以6.4.2为准，6.2.1api不一样     public boolean indexExists(String indexName) {             GetIndexRequest request = new GetIndexRequest();             request.indices(indexName);             try {                 return rhlClient.indices().exists(request, RequestOptions.DEFAULT);            
Java Rest High Level Client简单集成示例
xpm_xq的博客
08-23 3543
1. ES官方文档地址 ES的连接查询可以使用多种方式，但有的连接方式在高版本的ES中会逐渐取消，所以使用官方推荐的Java High Level Rest Client方式，通过HTTP请求对ES进行连接查询 官方文档地址 （6.4版本） https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.4/java-rest-hi...
ES 一次成功后，后面失败
最新发布
qq_37860468的博客
08-23 164
记一次失败的经历，因为将连接的客户端关了。写流操作写成了习惯，用完即关了。client 为 RestHighLevelClient client;RestHighLevelClient 对象。
Elasticsearch Java High Level REST Client（Exists API）
weixin_34018202的博客
11-23 748
Exists API 如果文档存在，则existsAPI返回true，否则返回false。 Exists请求 它就像Get API一样使用GetRequest，支持所有可选参数，由于exists()只返回true或false，我们建议关闭获取_source和任何存储的字段，以便请求稍微轻一点： GetRequest getRequest ...
java rest client 例子,Elasticsearch5.5.1 JAVA客户端RestClient示例
weixin_34017901的博客
03-12 156
【实例简介】Elasticsearch5.5.1 JAVA客户端RestClient示例代码,详细介绍:http://blog.csdn.net/u011781521/article/details/77853571【实例截图】【核心代码】8cdeee8f-e5cd-4d85-b81d-ace35a9868b7└── RestClient├── pom.xml├── src│ ├── main...
elasticsearch JavaAPI获取RestHighLevelClient
滴水穿石的启示
07-19 686
public static RestHighLevelClient getRestHighLevelClient() { String clusterNodes = PropertyUtil.getProperty("spring.data.elasticsearch.cluster-nodes"); String username = PropertyU...
[Java]本地Java High-Level单应用调用ES-7.8.1简单方法
qq_28033719的博客
03-25 3339
目录 查看ES官网： 下载访问ES 编写Java访问： 参考的文章： 查看ES官网： 目前官网是这个：Elastic Stack and Product Documentation | Elastic 如果要其他版本，往下找找，然后注意是不是ES，然后可以点击这里： 然后这个地方有关于watch的java-api，同时里面有一个警告 同事要注意ES版本，如果是ES8开始就将High-Level移除了，所以要es的Java依赖和ES版本尽量一致，如果对应不上版本号程序可能
java操作elasticsearch的案例解析
08-25
文章中首先介绍了 Elasticsearch 官方提供的 Java 语言 API，包括 Java TransportClient 和 Java REST Client，后者又分为 Java Low Level REST Client 和 Java High Level REST Client。然后，文章详细介绍了使用 ...
Elasticsearch的使用RestHighLevelClient
zwc953685177的博客
09-14 1304
一、准备 1.1、依赖 <elasticsearch.version>7.12.1</elasticsearch.version> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version&g
ES7中restHighLevelClient判断一个索引是否存在
asdasdsfaadasqw的博客
07-27 2237
/** * 判断一个索引是否存在 * @param indexName * @return */ private boolean isExistsIndex(String indexName){ GetIndexRequest request = new GetIndexRequest(); try { boolean exists = restHighLevelClient.indices().exists(request.indices(indexName),
java 连接 Elasticsearch 使用 RestHighLevelClient 进行插入、删除、修改、查询数据
m0_50163856的博客
08-27 3076
依赖 <!-- elasticsearch-rest-client --> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-client</artifactId> <version>7.13.3</version> </dependency> <
ElasticSearch篇——测试类测试restHighLevelClient常见API，一篇文章带你彻底吃透ES集成到Spring中如何使用，史上最全面、最详细使用方法分享！！！！！！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
12-10 1111
话不多说，直接开冲，大家准备好~创建索引测试用例控制台：查看ES的head可视化工具刚刚创建的索引，创建成功！
ES客户端RestHighLevelClient的使用
J_bean的博客
12-14 5472
ES客户端RestHighLevelClient的使用介绍
自定义elasticsearchRestHighLevelClient工具类
u014259503的博客
11-07 2253
一、使用原因 1.由于客户要求，es要是用官方推荐elasticsearch-rest-high-level-client，原来用的是spring集成的感觉用着挺方便，换了jar后两个jar不兼容，所以全部换成了elasticsearch-rest-high-level-client-6.5.0.jar（我们目前用的ES版本），但是用起来不是很方便，所以写了一个工具类； 二、工具实例 ...
RestHighLevelClient操作elasticsearch
weixin_47345703的博客
09-24 299
将RestHighLevelClient添加到Spring容器 @Value("${elasticsearch.server.host:localhost}") private String[] elasticsearchHost; @Bean public RestHighLevelClient restHighLevelClient() { try { HttpHost[] httpHosts = new HttpHost[elasticsear
Elasticsearch Java REST高级客户端-DocumentApi
热门推荐
周天祥的博客
07-19 1万+
Elasticsearch Java REST高级客户端-DocumentApi 版本：Elasticsearch 7.2.0 当你把Elasticsearch升级到7后会发现TransportClient这个客户端已过时，而且PreBuiltTransportClient这个已被删除，那么现在有如何使用java 客户端？Elasticsearch官方建议使用REST高级客户端RestHigh...
java high level rest client
03-16
Java高级REST客户端是一种用于与RESTful Web服务进行交互的Java库。它提供了一组易于使用的API，使开发人员能够轻松地执行HTTP请求和处理响应。这个库可以用于访问各种RESTful Web服务，包括基于JSON和XML的服务。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值