四、Elasticsearch之Java API-Java High Level REST Client

最新推荐文章于 2023-07-18 19:10:04 发布
最新推荐文章于 2023-07-18 19:10:04 发布
阅读量4.5k 收藏
点赞数 1
分类专栏： 项目发布 Java开发 开发工具 文章标签： elasticsearch java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36326332/article/details/107113321
版权

目录

https://github.com/shuchang-wang/Eleasticsearch

一、Java api 实现文档管理

1、导包【Maven】

2、代码

二、结合spring-boot-test测试文档查询

0、为什么使用spring boot test

1、导包

2、配置 application.yml

3、代码

1. 主类【配置springboot启动类】

2. 配置类

3.测试对索引文档的CRUD

4、测试对索引的管理

github托管源代码路径:

https://github.com/shuchang-wang/Eleasticsearch

 

一、Java api 实现文档管理

1、导包【Maven】

<dependency>

       <groupId>org.elasticsearch.client</groupId>

       <artifactId>elasticsearch-rest-high-level-client</artifactId>

       <version>7.4.2</version>

       <exclusions>

           <exclusion>

               <groupId>org.elasticsearch</groupId>

               <artifactId>elasticsearch</artifactId>

           </exclusion>

       </exclusions>

   </dependency>

   <dependency>

       <groupId>org.elasticsearch</groupId>

       <artifactId>elasticsearch</artifactId>

       <version>7.4.2</version>

   </dependency>

2、代码

步骤

  1. 获取连接客户端
  2. 构建请求
  3. 执行
  4. 获取结果

eg：

package com.alibaba.es;



import org.apache.http.HttpHost;

import org.elasticsearch.action.get.GetRequest;

import org.elasticsearch.action.get.GetResponse;

import org.elasticsearch.client.RequestOptions;

import org.elasticsearch.client.RestClient;

import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;



public class TestDemo {

   public static void main(String[] args) throws IOException {

       // 1 获取连接客户端

       RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(

          new HttpHost("192.168.21.131",9200,"http")

       ));

       // 2构建请求    PUT /book/_doc/1

       GetRequest request = new GetRequest("book","1");

       // 3执行

       GetResponse response = client.get(request, RequestOptions.DEFAULT);

       // 4获取结果

       System.out.println(response.getIndex());

       System.out.println(response.getType());

       System.out.println(response.getId());

       System.out.println(response.getVersion());

       System.out.println(response.getSeqNo());

       System.out.println(response.getPrimaryTerm());

       System.out.println(response.isExists());

       System.out.println(response.getSourceAsString());

   }

}

二、结合spring-boot-test测试文档查询

0、为什么使用spring boot test

  • 当今趋势
  • 方便开发
  • 创建连接交由spring容器，避免每次请求的网络开销。

1、导包

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter</artifactId>

    <version>2.0.6.RELEASE</version>

</dependency>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-test</artifactId>

    <scope>test</scope>

    <version>2.0.6.RELEASE</version>

</dependency>

<dependency>

    <groupId>org.elasticsearch.client</groupId>

    <artifactId>elasticsearch-rest-high-level-client</artifactId>

    <version>7.4.2</version>

    <exclusions>

         <exclusion>

               <groupId>org.elasticsearch</groupId>

               <artifactId>elasticsearch</artifactId>

         </exclusion>

    </exclusions>

</dependency>

<dependency>

    <groupId>org.elasticsearch</groupId>

    <artifactId>elasticsearch</artifactId>

    <version>7.4.2</version>

</dependency>

2、配置 application.yml

spring:

 application:

   name: search-service

alibaba:

 elasticsearch:

   hostlist: 192.168.21.131:9200 #多个节点中间用逗号分隔

3、代码

1. 主类【配置springboot启动类】

package com.alibaba.es;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;



@SpringBootApplication

public class SearchApplication {

   public static void main(String[] args) {

       SpringApplication.run(SearchApplication.class, args);

   }

}

2. 配置类

package com.alibaba.es.config;



import org.apache.http.HttpHost;

import org.elasticsearch.client.RestClient;

import org.elasticsearch.client.RestHighLevelClient;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



@Configuration

public class ElasticsearchConfig {



   @Value("${alibaba.elasticsearch.hostlist}")

   private String hostlist;



   @Bean(destroyMethod = "close")

   public RestHighLevelClient getRestHighLevelClient() {

       String[] hosts = hostlist.split(",");

       HttpHost[] hostArray = new HttpHost[hosts.length];

       for (int i = 0; i < hostArray.length; i++) {

           String item = hosts[i];

           hostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");

       }

       return new RestHighLevelClient(RestClient.builder(hostArray));

   }

}

3.测试对索引文档的CRUD

1、测试获取文档【Retrieve】

1.REST API

GET /book/_doc/1

2.代码实现：

package com.alibaba.es;



import org.elasticsearch.action.ActionListener;

import org.elasticsearch.action.get.GetRequest;

import org.elasticsearch.action.get.GetResponse;

import org.elasticsearch.client.RequestOptions;

import org.elasticsearch.client.RestHighLevelClient;

import org.elasticsearch.common.Strings;

import org.elasticsearch.search.fetch.subphase.FetchSourceContext;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;



import javax.annotation.Resource;

import java.io.IOException;



@SpringBootTest(classes = SearchApplication.class)

@RunWith(SpringRunner.class)

public class TestDocument {



   @Resource

   private RestHighLevelClient client;



    @Test

   public void testGet() throws IOException {

//        1.构建请求

       GetRequest getRequest = new GetRequest("test_post", "1");

//        -------------------------可选参数start-------------------------

//为特定字段配置_source_include

//        String[] includes = {"user","message"};

//        String[] excludes = Strings.EMPTY_ARRAY;

//        FetchSourceContext context = new FetchSourceContext(true,includes,excludes);

//        getRequest.fetchSourceContext(context);

//为特定字段配置_source_excludes

//        String[] includes = Strings.EMPTY_ARRAY;

//        String[] excludes = {"user","message"};

//        FetchSourceContext context = new FetchSourceContext(true,includes,excludes);

//        getRequest.fetchSourceContext(context);

//        设置路由

//        getRequest.routing("routing");

//        -------------------------可选参数end-------------------------



//        2.执行

//---------------------同步查询---------------------

       GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

//            3.处理执行结果

//            System.out.println(getResponse.getIndex());

//            System.out.println(getResponse.getType());

//            System.out.println(getResponse.getId());

//            System.out.println(getResponse.getVersion());

//            System.out.println(getResponse.getSeqNo());

//            System.out.println(getResponse.getPrimaryTerm());

//            System.out.println(getResponse.isExists());

//            System.out.println(getResponse.getSourceAsString());



//---------------------异步查询---------------------

//        ActionListener listener = new ActionListener() {

//            //成功时

//            public void onResponse(GetResponse getResponse) {

//                System.out.println(getResponse.getIndex());

//                System.out.println(getResponse.getType());

//                System.out.println(getResponse.getId());

//                System.out.println(getResponse.getVersion());

//                System.out.println(getResponse.getSeqNo());

//                System.out.println(getResponse.getPrimaryTerm());

//                System.out.println(getResponse.isExists());

//                System.out.println(getResponse.getSourceAsString());

//            }

//            //失败时

//            public void onFailure(Exception e) {

//                e.printStackTrace();

//            }

//        };

//        client.getAsync(getRequest, RequestOptions.DEFAULT, listener);

//        try {

//            Thread.sleep(5000);

//        } catch (InterruptedException e) {

//            e.printStackTrace();

//        }

       if (getResponse.isExists()) {

           System.out.println(getResponse.getIndex());

           System.out.println(getResponse.getType());

           System.out.println(getResponse.getId());

           System.out.println(getResponse.getVersion());

           System.out.println(getResponse.getSeqNo());

           System.out.println(getResponse.getPrimaryTerm());

           System.out.println(getResponse.isExists());

           System.out.println(getResponse.getSourceAsString());//以String获取数据

           System.out.println(getResponse.getSourceAsBytes());//以bytes获取数据

           System.out.println(getResponse.getSourceAsMap());//以Map获取数据

           System.out.println(getResponse.getSourceAsMap().get("user"));//获取Map中的数据

       } else {

           System.out.println("获取失败");

       }

   }

}

2、测试文档新增【Create】

1.REST API

PUT test_post/_doc/2

{

 "user":"tomas",

 "postDate":"2019-07-18",

 "message":"trying out es1"

}

2.代码实现：

@Test

   public void testAdd() throws IOException {

       //1.构建请求

       IndexRequest indexRequest = new IndexRequest("test_post");

       indexRequest.id("4");



// =======================构建文档数据=========================

       //方法一   String

       String jsonString = "{\n" +

               "  \"user\":\"tomas\",\n" +

               "  \"postDate\":\"2019-07-18\",\n" +

               "  \"message\":\"trying out es1\"\n" +

               "}";

       indexRequest.source(jsonString, XContentType.JSON);



       //方法二 Map

//        Map jsonMap = new HashMap();

//        jsonMap.put("user","tomas");

//        jsonMap.put("postDate","2019-07-18");

//        jsonMap.put("message","trying out es1");

//        indexRequest.source(jsonMap);



       //方法三 XContentBuilder

//        XContentBuilder builder = XContentFactory.jsonBuilder();

//        builder.startObject();

//        {

//            builder.field("user","tomas");

//            builder.timeField("postDate",new Date());

//            builder.field("message","trying out es1");

//        }

//        builder.endObject();

//        indexRequest.source(builder);



       //方法四 Object...

//        indexRequest.source("user","tomas","postDate",new Date(),"message","trying out es1");



       //============================可选参数============================

       //设置超时时间

//        indexRequest.timeout("1s");

//        indexRequest.timeout(TimeValue.timeValueSeconds(1));



       //手动维护版本号

//        indexRequest.version(4);

//        indexRequest.versionType(VersionType.EXTERNAL);



       //2.执行

       //同步执行

       IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);

//        System.out.println(indexResponse.getIndex());

//        System.out.println(indexResponse.getType());

//        System.out.println(indexResponse.getId());

//        System.out.println(indexResponse.getVersion());

//        System.out.println(indexResponse.getResult());

//        System.out.println(indexResponse.getShardInfo());

//        System.out.println(indexResponse.getSeqNo());

//        System.out.println(indexResponse.getPrimaryTerm());

//        System.out.println(indexResponse.status());

//        System.out.println(indexResponse.toString());

       if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {

           DocWriteResponse.Result result = indexResponse.getResult();

           System.out.println("CREATE：" + result);

       } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {

           DocWriteResponse.Result result = indexResponse.getResult();

           System.out.println("UPDATE：" + result);

       }else{

           System.out.println(indexResponse.getResult() );

       }



//        "_shards" : {

//            "total" : 2,

//            "successful" : 2,

//            "failed" : 0

//        }

       ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();

       if(shardInfo.getTotal()!=shardInfo.getSuccessful()){

           System.out.println("处理成功的分片数少于总分片！");

       }



       if(shardInfo.getFailed()>0){

           ReplicationResponse.ShardInfo.Failure[] failures = shardInfo.getFailures();

           for (ReplicationResponse.ShardInfo.Failure failure : failures) {

               String reason = failure.reason();//每一个错误的原因

               System.out.println(reason);

           }

       }

       //异步执行

//        ActionListener listener = new ActionListener() {

//            public void onResponse(IndexResponse indexResponse) {

//                System.out.println(indexResponse.getIndex());

//                System.out.println(indexResponse.getType());

//                System.out.println(indexResponse.getId());

//                System.out.println(indexResponse.getVersion());

//                System.out.println(indexResponse.getResult());

//                System.out.println(indexResponse.getShardInfo());

//                System.out.println(indexResponse.getSeqNo());

//                System.out.println(indexResponse.getPrimaryTerm());

//                System.out.println(indexResponse.status());

//                System.out.println(indexResponse.toString());

//            }

//

//            public void onFailure(Exception e) {

//                e.printStackTrace();

//            }

//        };

//        client.indexAsync(indexRequest, RequestOptions.DEFAULT, listener);

//        try {

//            Thread.sleep(5000);

//        } catch (InterruptedException e) {

//            e.printStackTrace();

//        }

   }

3、测试文档修改【UPDATE】

1.REST API

POST /test_post/_doc/3/_update

{

  "doc": {

     "user":"tomas Lee"

  }

}

2.代码实现：

@Test

   public void testUpdate() throws IOException {

//        POST /test_post/_doc/3/_update

//        {

//            "doc": {

//                  "user":"tomas Lee"

//              }

//        }

       //1.构建请求

       UpdateRequest updateRequest = new UpdateRequest("test_post", "3");

       Map jsonMap = new HashMap();

       jsonMap.put("user", "tomas Lee");

       updateRequest.doc(jsonMap);



       //可选参数

       updateRequest.timeout("1s");

       updateRequest.retryOnConflict(3);//重试次数



       //2.执行

       //同步执行

       UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);

       //3.获取结果

       System.out.println(updateResponse.getIndex());

       System.out.println(updateResponse.getType());

       System.out.println(updateResponse.getId());

       System.out.println(updateResponse.getVersion());

       System.out.println(updateResponse.getSeqNo());

       System.out.println(updateResponse.getPrimaryTerm());

       System.out.println(updateResponse.getResult());

       if(updateResponse.getResult()== DocWriteResponse.Result.CREATED){//创建

           System.out.println("CREATE："+updateResponse.getResult());

       }else if(updateResponse.getResult()== DocWriteResponse.Result.UPDATED){//更新

           System.out.println("UPDATE："+updateResponse.getResult());

       }else if(updateResponse.getResult()== DocWriteResponse.Result.DELETED){//删除

           System.out.println("DELETE："+updateResponse.getResult());

       }else if(updateResponse.getResult()== DocWriteResponse.Result.NOOP){//没有操作

           System.out.println("NOOP："+updateResponse.getResult());

       }else {

           System.out.println(updateResponse.getResult());

       }



       //异步执行

//        ActionListener listener = new ActionListener() {

//            public void onResponse(UpdateResponse updateResponse) {

//                System.out.println(updateResponse.getIndex());

//                System.out.println(updateResponse.getType());

//                System.out.println(updateResponse.getId());

//                System.out.println(updateResponse.getVersion());

//                System.out.println(updateResponse.getResult());

//                System.out.println(updateResponse.getShardInfo());

//                System.out.println(updateResponse.getSeqNo());

//                System.out.println(updateResponse.getPrimaryTerm());

//                System.out.println(updateResponse.status());

//                System.out.println(updateResponse.toString());

//            }

//

//            public void onFailure(Exception e) {

//                e.printStackTrace();

//            }

//        };

//        client.updateAsync(updateRequest, RequestOptions.DEFAULT, listener);

//        try {

//            Thread.sleep(5000);

//        } catch (InterruptedException e) {

//            e.printStackTrace();

//        }

   }

4、测试文档删除【DELETE】

1.REST API

DELETE /test_post/_doc/3

2.代码实现：

@Test

   public void testDelete() throws IOException {

       //1.创建请求

       DeleteRequest deleteRequest = new DeleteRequest("test_post", "3");

       //2.执行

       DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);

       //3.处理结果

       System.out.println(deleteResponse.getIndex());

       System.out.println(deleteResponse.getType());

       System.out.println(deleteResponse.getId());

       System.out.println(deleteResponse.getVersion());

       System.out.println(deleteResponse.getSeqNo());

       System.out.println(deleteResponse.getPrimaryTerm());

       System.out.println(deleteResponse.getResult());



       //异步执行

//        ActionListener listener = new ActionListener() {

//            public void onResponse(DeleteResponse deleteResponse) {

//                System.out.println(deleteResponse.getIndex());

//                System.out.println(deleteResponse.getType());

//                System.out.println(deleteResponse.getId());

//                System.out.println(deleteResponse.getVersion());

//                System.out.println(deleteResponse.getSeqNo());

//                System.out.println(deleteResponse.getPrimaryTerm());

//                System.out.println(deleteResponse.getResult());

//            }

//

//            public void onFailure(Exception e) {

//                e.printStackTrace();

//            }

//        };

//        client.deleteAsync(deleteRequest, RequestOptions.DEFAULT, listener);

//        try {

//            Thread.sleep(5000);

//        } catch (InterruptedException e) {

//            e.printStackTrace();

//        }

   }

5、测试文档bulk【Bulk批量管理】

1.REST API

POST /_bulk

{"action": {"metadata"}}

{"data"}

2.代码实现：

@Test

   public void testBulk() throws IOException {

       //1.创建请求

       BulkRequest bulkRequest = new BulkRequest();

//        bulkRequest.add(new IndexRequest("post").id("1").source(XContentType.JSON, "filed", "1"));

//        bulkRequest.add(new IndexRequest("post").id("2").source(XContentType.JSON, "filed", "2"));

       bulkRequest.add(new UpdateRequest("post","1").doc(XContentType.JSON, "filed", "3"));

       bulkRequest.add(new DeleteRequest("post").id("2"));



       //2.执行

       //同步请求

       BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);



       //3.获取结果

       for (BulkItemResponse bulkItemResponse : bulkResponse) {

           DocWriteResponse response = bulkItemResponse.getResponse();

           switch (bulkItemResponse.getOpType()) {

               case INDEX:

                   IndexResponse indexResponse = (IndexResponse) response;

                   System.out.println("INDEX：" + indexResponse.getResult());

                   break;

               case CREATE:

                   IndexResponse createResponse = (IndexResponse) response;

                   System.out.println("CREATE：" + createResponse.getResult());

                   break;

               case UPDATE:

                   UpdateResponse updateResponse = (UpdateResponse) response;

                   System.out.println("UPDATE：" + updateResponse.getResult());

                   break;

               case DELETE:

                   DeleteResponse deleteResponse = (DeleteResponse) response;

                   System.out.println("DELETE：" + deleteResponse.getResult());

                   break;

               default:

                   System.out.println("其他！");

           }

       }



       //异步请求

//        ActionListener listener = new ActionListener() {

//            public void onResponse(BulkResponse bulkItemResponses) {

//                //3.获取结果

//                for (BulkItemResponse bulkItemResponse : bulkItemResponses) {

//                    DocWriteResponse response = bulkItemResponse.getResponse();

//                    switch (bulkItemResponse.getOpType()) {

//                        case INDEX:

//                            IndexResponse indexResponse = (IndexResponse) response;

//                            System.out.println("INDEX：" + indexResponse.getResult());

//                            break;

//                        case CREATE:

//                            IndexResponse createResponse = (IndexResponse) response;

//                            System.out.println("CREATE：" + createResponse.getResult());

//                            break;

//                        case UPDATE:

//                            UpdateResponse updateResponse = (UpdateResponse) response;

//                            System.out.println("UPDATE：" + updateResponse.getResult());

//                            break;

//                        case DELETE:

//                            DeleteResponse deleteResponse = (DeleteResponse) response;

//                            System.out.println("DELETE：" + deleteResponse.getResult());

//                            break;

//                        default:

//                            System.out.println("其他！");

//                    }

//                }

//            }

//

//            public void onFailure(Exception e) {

//

//            }

//        };

//        client.bulkAsync(bulkRequest, RequestOptions.DEFAULT, listener);

//        try {

//            Thread.sleep(5000);

//        } catch (

//                InterruptedException e) {

//            e.printStackTrace();

//        }

   }

4、测试对索引的管理

1、测试构建索引

1.REST API

PUT /my_index
{
  "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 1
    },
    "mappings": {
        "properties": {
            "filed1": {
                "type": "text"
            },
            "filed2": {
                "type": "text"
            }
        }
    },
    "aliases": {
        "default_index": {}
    }
}

2.代码实现：

/**
     * 同步创建索引
     *
     * @throws IOException
     */
    @Test
    public void testCreateIndex() throws IOException {
        /*    PUT /my_index
    {
        "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 1
    },
        "mappings": {
        "properties": {
            "filed1": {
                "type": "text"
            },
            "filed2": {
                "type": "text"
            }
        }
    },
        "aliases": {
        "default_index": {}
    }
    }*/
        //1.获取请求
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("my_index");

        //设置请求参数
        createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "1").build());

        //设置映射1
        createIndexRequest.mapping("{\n" +
                "        \"properties\": {\n" +
                "            \"filed1\": {\n" +
                "                \"type\": \"text\"\n" +
                "            },\n" +
                "            \"filed2\": {\n" +
                "                \"type\": \"text\"\n" +
                "            }\n" +
                "        }\n" +
                "    }", XContentType.JSON);
        //设置映射2
//        Map<String, Object> filed1 = new HashMap<String, Object>();
//        filed1.put("type", "text");
//        filed1.put("analyzer", "standard");
//        Map<String, Object> filed2 = new HashMap<String, Object>();
//        filed2.put("type", "text");
//        Map<String, Object> properties = new HashMap<String, Object>();
//        properties.put("filed1", filed1);
//        properties.put("filed2", filed2);
//        Map<String, Object> mapping = new HashMap<String, Object>();
//        mapping.put("properties", properties);
//        createIndexRequest.mapping(mapping);
        //设置映射3
//        XContentBuilder xContentBuilder = XContentFactory.jsonBuilder();
//        xContentBuilder.startObject();
//        {
//            xContentBuilder.startObject("fild1");
//            {
//                xContentBuilder.field("type","text");
//            }
//            xContentBuilder.endObject();
//            xContentBuilder.startObject("fild2");
//            {
//                xContentBuilder.field("type","text");
//            }
//            xContentBuilder.endObject();
//        }
//        xContentBuilder.endObject();
//        createIndexRequest.mapping(xContentBuilder);
        //设置别名
        createIndexRequest.alias(new Alias("prod_index"));

        //==================可选参数==================
        //设置超时时间
        createIndexRequest.setTimeout(TimeValue.timeValueSeconds(5));
        //主节点超时时间
        createIndexRequest.setMasterTimeout(TimeValue.timeValueSeconds(5));
        //设置创建索引API返回响应之前等待活动分片的数量
        createIndexRequest.waitForActiveShards(ActiveShardCount.from(1));

        //2.执行
        CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        //3.处理结果
        //索引
        String index = createIndexResponse.index();
        System.out.println("index：" + index);
        //得到响应（全部）
        boolean acknowledged = createIndexResponse.isAcknowledged();
        System.out.println("acknowledged：" + acknowledged);
        //得到响应 指示是否在超时前为索引中的每个分片启动了所需数量的碎片副本
        boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
        System.out.println("shardsAcknowledged：" + shardsAcknowledged);

    }

/**
     * 异步创建索引
     *
     * @throws IOException
     */
    @Test
    public void testCreateIndexAsync() throws IOException {
        //1.获取请求
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("my_index");

        //设置请求参数
        createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "1").build());

        //设置映射1
        createIndexRequest.mapping("{\n" +
                "        \"properties\": {\n" +
                "            \"filed1\": {\n" +
                "                \"type\": \"text\"\n" +
                "            },\n" +
                "            \"filed2\": {\n" +
                "                \"type\": \"text\"\n" +
                "            }\n" +
                "        }\n" +
                "    }", XContentType.JSON);
        //设置别名
        createIndexRequest.alias(new Alias("prod_index"));

        //==================可选参数==================
        //设置超时时间
        createIndexRequest.setTimeout(TimeValue.timeValueSeconds(5));
        //主节点超时时间
        createIndexRequest.setMasterTimeout(TimeValue.timeValueSeconds(5));
        //设置创建索引API返回响应之前等待活动分片的数量
        createIndexRequest.waitForActiveShards(ActiveShardCount.from(1));

        //2.执行
        ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
            @Override
            public void onResponse(CreateIndexResponse createIndexResponse) {
                //3.处理结果
                //索引
                String index = createIndexResponse.index();
                System.out.println("index：" + index);
                //得到响应（全部）
                boolean acknowledged = createIndexResponse.isAcknowledged();
                System.out.println("acknowledged：" + acknowledged);
                //得到响应 指示是否在超时前为索引中的每个分片启动了所需数量的碎片副本
                boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
                System.out.println("shardsAcknowledged：" + shardsAcknowledged);
            }

            @Override
            public void onFailure(Exception e) {
                e.printStackTrace();
            }
        };
        client.indices().createAsync(createIndexRequest, RequestOptions.DEFAULT, listener);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

2、测试删除索引

1.REST API

DELETE /my_index

2.代码实现：

/**
     * 同步删除索引
     *
     * @throws IOException
     */
    @Test
    public void testDeleteIndex() throws IOException {
        //构建请求
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("my_index");
        deleteIndexRequest.timeout(TimeValue.timeValueSeconds(5));
        deleteIndexRequest.masterNodeTimeout(TimeValue.timeValueSeconds(5));

        //同步执行
        AcknowledgedResponse acknowledgedResponse = client.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        //处理响应
        boolean acknowledged = acknowledgedResponse.isAcknowledged();
        System.out.println(acknowledged);
    }


    /**
     * 异步删除索引
     *
     * @throws IOException
     */
    @Test
    public void testDeleteIndexAsync() throws IOException {
        //构建请求
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("my_index");
        deleteIndexRequest.timeout(TimeValue.timeValueSeconds(5));
        deleteIndexRequest.masterNodeTimeout(TimeValue.timeValueSeconds(5));

        //异步执行
        ActionListener<AcknowledgedResponse> listener = new ActionListener<AcknowledgedResponse>() {
            @Override
            public void onResponse(AcknowledgedResponse acknowledgedResponse) {
                //处理响应
                boolean acknowledged = acknowledgedResponse.isAcknowledged();
                System.out.println(acknowledged);
                System.out.println(acknowledgedResponse.toString());
                System.out.println("删除索引成功！！！");
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("删除索引失败！！！");
                e.printStackTrace();
            }
        };
        client.indices().deleteAsync(deleteIndexRequest, RequestOptions.DEFAULT, listener);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

3、测试查看索引是否存在

代码实现：

/**
     * 同步获取索引 Index exists API
     *
     * @throws IOException
     */
    @Test
    public void testExistsIndex() throws IOException {
        //构建请求
        GetIndexRequest getIndexRequest = new GetIndexRequest("my_index");
        //=========================参数=========================
        //从主节点返回本地索引信息状态
        getIndexRequest.local(false);
        //以适合人类的格式返回
        getIndexRequest.humanReadable(true);
        //是否返回每个索引的所有默认配置
        getIndexRequest.includeDefaults(false);
        //执行
        boolean exists = client.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        //处理响应
        System.out.println(exists);
    }

    /**
     * 异步获取索引 Index exists API
     *
     * @throws IOException
     */
    @Test
    public void testExistsIndexAsync() throws IOException {
        //构建请求
        GetIndexRequest getIndexRequest = new GetIndexRequest("my_index");
        //=========================参数=========================
        //从主节点返回本地索引信息状态
        getIndexRequest.local(false);
        //以适合人类的格式返回
        getIndexRequest.humanReadable(true);
        //是否返回每个索引的所有默认配置
        getIndexRequest.includeDefaults(false);
        //执行
        ActionListener<Boolean> listener = new ActionListener<Boolean>() {

            @Override
            public void onResponse(Boolean exists) {
                //处理响应
                System.out.println(exists);
            }

            @Override
            public void onFailure(Exception e) {
                e.printStackTrace();
            }
        };
        client.indices().existsAsync(getIndexRequest, RequestOptions.DEFAULT, listener);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

4、测试关闭索引

代码实现：

    /**
     * 同步关闭索引
     */
    @Test
    public void testCloseIndex() throws IOException {
        //构建请求
        CloseIndexRequest closeIndexRequest = new CloseIndexRequest("my_index");
        //执行
        AcknowledgedResponse acknowledgedResponse = client.indices().close(closeIndexRequest, RequestOptions.DEFAULT);
        //处理响应
        boolean acknowledged = acknowledgedResponse.isAcknowledged();
        System.out.println(acknowledged);
    }

    /**
     * 异步关闭索引
     */
    @Test
    public void testCloseIndexAsync() {
        //构建请求
        CloseIndexRequest closeIndexRequest = new CloseIndexRequest("my_index");
        //执行
        ActionListener<AcknowledgedResponse> listener = new ActionListener<AcknowledgedResponse>() {
            @Override
            public void onResponse(AcknowledgedResponse acknowledgedResponse) {
                boolean acknowledged = acknowledgedResponse.isAcknowledged();
                System.out.println(acknowledged);
            }

            @Override
            public void onFailure(Exception e) {
                e.printStackTrace();
            }
        };
        client.indices().closeAsync(closeIndexRequest, RequestOptions.DEFAULT, listener);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

5、测试打开索引

代码实现：

 /**
     * 同步打开索引
     *
     * @throws IOException
     */
    @Test
    public void testOpenIndex() throws IOException {
        //构建请求
        OpenIndexRequest openIndexRequest = new OpenIndexRequest("my_index");
        //执行
        OpenIndexResponse openIndexResponse = client.indices().open(openIndexRequest, RequestOptions.DEFAULT);
        //处理响应结果
        boolean acknowledged = openIndexResponse.isAcknowledged();
        System.out.println(acknowledged);
    }

    /**
     * 异步打开索引
     *
     * @throws IOException
     */
    @Test
    public void testOpenIndexAsync() {
        //构建请求
        OpenIndexRequest openIndexRequest = new OpenIndexRequest("my_index");
        ActionListener<OpenIndexResponse> listener = new ActionListener<OpenIndexResponse>() {
            @Override
            public void onResponse(OpenIndexResponse openIndexResponse) {
                //处理响应结果
                boolean acknowledged = openIndexResponse.isAcknowledged();
                System.out.println(acknowledged);
            }

            @Override
            public void onFailure(Exception e) {
                e.printStackTrace();
            }
        };
        //执行
        client.indices().openAsync(openIndexRequest, RequestOptions.DEFAULT, listener);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

 

Doctor舒畅
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA实现ElasticSearch的简单实例
07-29
在eclipse上，操作elasticsearch的简单程序
Java Elasticsearch教程
guanshengg的博客
08-13 1万+
​ Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，本教程从Java语言角度讲解如何操作Elasticsearch，如果不熟悉Elasticsearch，可以先学习Elasticsearch教程，掌握基本概念和查询语法 ​
Elasticsearch 介绍及java集成
yuechuzhixing的博客
07-18 9177
Elasticsearch 介绍及java集成
ElasticSearch JavaAPI(java操作)
weixin_43949154的博客
04-01 6526
操作ElasticSearch分为脚本操作(运维人员常用)和java操作(开发人员常用)，今天小编主要介绍java操作方式，之前小编讲解了ES如何搭建，并介绍了IK分词器，今天基于ES环境来继续学习。 需求：使用sringboot整合ElasticSearch 实现步骤： 1、 搭建springboot工程 2、 引入ElasticSearch相关坐标 3、 测试编码 下面是ElasticSearch的相关坐标 开始部署springboot项目 由于不是web工程，下面页面不需要勾选 直接fin.
Java开发 - Elasticsearch初体验
CodingFire的博客
02-28 1万+
es全称Elasticsearch，开发界简称es，如果你是做开发的，和后台接触时多多少少应该听过他们说es，redis这些不知所谓的名词，今天，你学习这部分内容就是当初不明所以的东西es。首先声明，es不是SpringCloud的组件，也并不是Java专属的，其他的后端语言也可以使用es。由于es是一个由Java开发的软件，所以启动需要Java环境变量。es有一个中文名字，叫全文搜索引擎，它的优点是可以从大量数据中根据指定的关键字快速的匹配出相关的内容。
Elasticsearch Java HighLevel REST Client（Search API）
our_sky的博客
03-11 731
Elasticsearch7.4 使用RestHighLevelClient 简单教程 第一步：引入maven jar包 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-lev...
java bulk_Elasticsearch Java High Level REST Client（Bulk API）
weixin_42400074的博客
02-20 758
Bulk APIJava High Level REST Client提供了Bulk处理器来帮助处理批量请求。Bulk请求BulkRequest可以使用一个请求执行多个索引、更新和/或删除操作。它需要在批量请求中添加至少一个操作：BulkRequest request = new BulkRequest();request.add(new IndexRequest("posts").id("1")...
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
包含翻译后的API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.elasticsearch.client:elasticsearch-rest-high-level-client:6.8.3； 标签：elasticsearch...
elasticsearch-rest-high-level-client-6.8.3-API文档-中英对照版.zip
07-13
包含翻译后的API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.elasticsearch.client:elasticsearch-rest-high-level-client:6.8.3； 标签：...
elasticsearch-rest-client-6.8.3-API文档-中文版.zip
07-13
包含翻译后的API文档：elasticsearch-rest-client-6.8.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.elasticsearch.client:elasticsearch-rest-client:6.8.3； 标签：elasticsearch、client、rest、中文...
java-high-level-REST-client.pdf
12-02
高可用 REST 客户端的坐标在描述中未给出，通常会以类似于 `org.elasticsearch.client:elasticsearch-rest-high-level-client:<version>` 的形式存在，`<version>` 应替换为实际的 Elasticsearch 客户端版本号。...
elasticsearch-rest-high-level-client-7.5.1.jar
02-24
java运行依赖jar包
Java操作Elasticsearch的所有方法
weixin_39363116的博客
02-18 9315
使用Java操作Elasticsearch的所有方法 13.1 Elasticsearch简介 Elasticsearch是基于Lucene开发的一个分布式全文检索框架，向Elasticsearch中存储和从Elasticsearch中查询，格式是json。 a）、索引index，相当于数据库中的database。 b）、类型type相当于数据库中的table。 c）、主键id相当于数据库中记录的主键，是唯一的。 d）、文档 document （相当于一条数据） 文档是ElasticSearch的基本单
java 操作elasticsearch详细总结
老男孩的架构路
01-15 5073
基于spring-data的方式，在工程启动的时候，会自动读取实体类相关的注解，自动完成索引的创建，运行下创建索引的测试方法；接下来将对上面的两种操作模式做一个详细的总结，本篇所述的es基于7.6.2版本，配合的kibana也为7.6.2版本。我们知道es最强大的功能就是文档检索了，接下来演示下与es文档查询相关的常用API的操作；在实际开发过程中，对于文档的操作更为的频繁，接下来演示与es文档相关的操作api。导入核心依赖，主要是es的rest依赖，其他的可以根据自己的需要导入；
Java集成elasticsearch
weixin_45410882的博客
09-24 5162
Java集成elasticsearch
ElasticSearch在Java中的使用
qq2444036297的博客
06-29 7194
ElasticSearch在Java中的使用
ElasticSearch-7.17支持两种客户端连接方式（RestHighLevelClient 和Elasticsearch Java API）
u013250861的博客
12-07 1742
学习es时发现了一个大问题，学习的版本为7.8.0（尚硅谷yyds），自己使用的是7.17.8，但是最新的版本已经是8.5X了（心累，怎么升级这么快）。 因为目前用的还是jdk1.8，所以就按照7.17.8的版本 RestHighLevelClient 创建连接，但是从7.15.0版本开始ES官方已经不推荐Rest客户端了，所以查了一下官网，发现Elasticsearch Java API 客户端（全新的客户端库），可以和 RestHighLevelClient 兼容使用，官方原文：避免在过渡
maven-assembly-plugin插件
热门推荐
心情舒畅
08-27 1万+
0、背景 　　最近我们项目越来越多了，然后发现项目中都使用assembly插件进行打包的，于是就进行了深入的了解，本文分享该插件的配置以及微服务的统一打包方式。 一、介绍 maven提供的打包插件有如下三种： plugin function maven-jar-plugin maven 默认打包插件【springboot默认使用该方式打包】，用来创建 project jar maven-shade-plugin 用来打可执行包，executable(fat) jar
Java使用elasticsearch-rest-high-level-client6.8.5初始化RestHighLevelClient
最新发布
08-18
如果你想使用`elasticsearch-rest-high-level-client`版本6.8.5进行初始化，你需要在Maven项目中添加相应的依赖项。在你的pom.xml文件中，添加以下依赖项： ```xml <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>6.8.5</version> </dependency> ``` 然后，你可以使用以下代码初始化RestHighLevelClient： ```java import org.apache.http.HttpHost; import org.elasticsearch.client.RestClient; import org.elasticsearch.client.RestHighLevelClient; public class Main { public static void main(String[] args) { RestHighLevelClient client = new RestHighLevelClient( RestClient.builder( new HttpHost("localhost", 9200, "http"))); // 使用client进行操作 // 关闭client try { client.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 上述代码中，我们使用本地的Elasticsearch实例进行初始化。你可以根据实际情况修改主机名和端口号。一旦`client`对象初始化完成，你就可以使用它来执行各种Elasticsearch操作。最后，不要忘记在不再需要使用RestHighLevelClient时关闭它。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值