关于java-ee:Java操作Elasticsearch-之-Java-High-Level-REST-Clientedit

52次阅读

共计 19825 个字符，预计需要花费 50 分钟才能阅读完成。

1. 简述

  • Elasticsearch 是基于 Lucene 开发的一个分布式全文检索框架，向 Elasticsearch 中存储和从 Elasticsearch 中查问，格局是 json。
  • 向 Elasticsearch 中存储数据，其实就是向 es 中的 index 上面的 type 中存储 json 类型的数据。
  • elasticsearch 提供了很多语言的客户端用于操作 elasticsearch 服务，例如：java、python、.net、JavaScript、PHP 等。本文次要介绍如何应用 java 语言来操作 elasticsearch 服务。在 elasticsearch 的官网上提供了两种 java 语言的 API，一种是 Java Transport Client，一种是 Java REST Client。

Java Transport Client 是基于 TCP 协定交互的，在 elasticsearch 7.0+ 版本后官网不再赞成应用，在 Elasticsearch 8.0 的版本中齐全移除 TransportClient

Java REST Client 是基于 HTTP 协定交互，而 Java REST Client 又分为 Java Low Level REST Client 和 Java High Level REST Client

  • Java High Level REST Client 是在 Java Low Level REST Client 的根底上做了封装，使其以更加面向对象和操作更加便当的形式调用 elasticsearch 服务。

官网举荐应用 Java High Level REST Client，因为在理论应用中，Java Transport Client 在大并发的状况下会呈现连贯不稳固的状况。
那接下来咱们就来看看 elasticsearch 提供的 Java High Level REST Client（以下简称高级 REST 客户端）的一些根底的操作，跟多的操作大家自行浏览 elasticsearch 的官网文档：[https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html](https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html)

2. 筹备

  • 环境：

    • Windows 10
    • elasticsearch 7.91
    • IDEA
    • Maven
    • Java 8

高级客户端须要 Java 1.8 并依赖于 Elasticsearch core 我的项目

  • 依赖：
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.9.1</version>
        </dependency>

3. 初始化

  • 实例须要构建 REST 低级客户端生成器，如下所示：RestHighLevelClient
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));
  • 高级客户端将在外部创立用于基于提供的生成器执行申请的低级客户端。该低级客户端保护一个连接池并启动一些线程，因而，当您很好地实现高级客户端时，您应该敞开该高级客户端，而后敞开外部低级客户端以开释这些资源。这能够通过 以下工夫实现：close
client.close();

在无关 Java 高级客户端的本文档的其余部分中，实例将援用为。RestHighLevelClient client

案例： 

  • 查问 index 代码：
public static void main(String[] args)  {
        RestClientBuilder builder = RestClient.builder(
                new HttpHost(
                "127.0.0.1",  //es 主机 IP
                9200   // es 端口 http
                )
        );
        RestHighLevelClient client = new RestHighLevelClient(builder);
        GetRequest request = new GetRequest(
                "blog1", // 索引
                "1" // 文档 ID
        );

        // 当针对不存在的索引执行获取申请时，响应 404 状态码，将引发 IOException，须要按如下形式解决：GetResponse documentFields = null;
        try {documentFields = client.get(request, RequestOptions.DEFAULT);
        } catch (IOException e) {e.printStackTrace();
            //// 解决因为索引不存在而抛出的异常情况 
        }
        System.out.println(documentFields);
        try {client.close();
        } catch (IOException e) {e.printStackTrace();
        }

    }
  • 查问后果：
{
    "_index": "blog1",
    "_type": "_doc",
    "_id": "1",
    "_version": 1,
    "_seq_no": 0,
    "_primary_term": 1,
    "found": true,
    "_source": {
        "age": 1,
        "country": "fuzhou",
        "date": "2020-09-10",
        "name": "ngitvusercancel"
    }
}

上述是一个案例的展现，让咱们初步理解通过 Java 的高级 restful 客户端来拜访, 上面咱们将进行相干 Api 的介绍

4. 索引 API (Index Api)

4.1 创立索引（Create Index API）

**

4.1.1 案例：

    /*
     * 创立索引.
     * url:https://i-code.online/
     */
    public static void main(String[] args) {
        // 创立链接信息
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200)));

        // 创立索引申请 索引名称 student
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("student-1");

        // 创立索引时能够设置与之相干的 特定配置
        createIndexRequest.settings(Settings.builder()
                .put("index.number_of_shards",3) // 分片数
                .put("index.number_of_replicas",2) // 备份数
        );
        // 创立文档类型映射
        createIndexRequest.mapping("{\n" +
                "\"properties\": {\n" +
                "\"id\": {\n" +
                "\"type\": \"long\",\n" +
                "\"store\": true\n" +
                "},\n" +
                "\"name\": {\n" +
                "\"type\": \"text\",\n" +
                "\"index\": true,\n" +
                "\"analyzer\": \"ik_max_word\"\n" +
                "},\n" +
                "\"content\": {\n" +
                "\"type\": \"text\",\n" +
                "\"index\": true,\n" +
                "\"analyzer\": \"ik_max_word\"\n" +
                "}\n" +
                "}\n" +
                "}",
                XContentType.JSON  // 类型映射，须要的是一个 JSON 字符串
        );
        // 可选参数
        // 超时, 期待所有节点被确认(应用 TimeValue 形式)
        createIndexRequest.setTimeout(TimeValue.timeValueMinutes(1));

        try {
            // 同步执行
            CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
            // 返回的 CreateIndexResponse 容许检索无关执行的操作的信息，如下所示：boolean acknowledged = createIndexResponse.isAcknowledged();// 批示是否所有节点都已确认申请
            boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();// 批示是否在超时之前为索引中的每个分片启动了必须的分片正本数
            System.out.println("acknowledged:"+acknowledged);
            System.out.println("shardsAcknowledged:"+shardsAcknowledged);
            System.out.println(createIndexResponse.index());
        } catch (IOException e) {e.printStackTrace();
        }
        try {
            // 敞开客户端链接
            client.close();} catch (IOException e) {e.printStackTrace();
        }
    }

上述是一个 index 创立的过程，具体的细节操作 api 上面详解

4.1.2 创立索引申请

  • 须要参数：CreateIndexRequestindex
CreateIndexRequest request = new CreateIndexRequest("twitter");//<1>

<1> 要创立索引

4.1.3 索引设置

  • 创立的每个索引都能够具备与其关联的特定设置。
// 此索引的设置
request.settings(Settings.builder()
.put("index.number_of_shards", 3) // 分片数
.put("index.number_of_replicas", 2)// 备份数
);

4.1.4 索引映射

  • 能够创立索引，并创立其文档类型的映射
request.mapping(
"{\n" +
""properties": {\n"+"    "message": {\n"+"      "type": "text"\n"+"}\n"+"  }\n"+"}", //<1> 要定义的类型
XContentType.JSON); //<2> 此类型的映射，作为 JSON 字符串提供

<1> 要定义的类型
<2> 此类型的映射，作为 JSON 字符串提供

  • 除了下面显示的示例之外，还能够以不同的形式提供映射源：String
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);

request.mapping(mapping); // 承受 map 的映射汇合，主动转为 json

提供主动转换为 JSON 格局的映射源 Map
这种形式多层嵌套，在应用过程中留神嵌套，下面标签嵌套：properties -> message -> type

XContentBuilder builder = XContentFactory.jsonBuilder(); // 应用 XContentBuilder 内容生成器
builder.startObject();
{builder.startObject("properties");
    {builder.startObject("message");
        {builder.field("type", "text");
        }
        builder.endObject();}
    builder.endObject();}
builder.endObject();

映射作为对象提供的源，弹性搜寻内置帮忙器，用于生成 JSON 内容 XContentBuilder

4.1.5 索引别名

  • 能够在索引创立时设置别名
request.alias(new Alias("twitter_alias").filter(QueryBuilders.termQuery("user", "kimchy"))); // 要定义的别名

4.1.6 提供整个源

  • 后面咱们都是一步一步的设置的，其实也能够提供整个源，包含其所有局部（映射、设置和别名）：
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);

作为 JSON 字符串提供的源。它也能够作为 或 提供。MapXContentBuilder

4.1.7 可选参数

  • 能够抉择提供以下参数：
request.setTimeout(TimeValue.timeValueMinutes(2));

超时以期待所有节点将索引创立确认为 TimeValue

request.setMasterTimeout(TimeValue.timeValueMinutes(1));

以作为 TimeValue

request.waitForActiveShards(ActiveShardCount.from(2));
request.waitForActiveShards(ActiveShardCount.DEFAULT);

在创立索引 API 返回响应之前期待的流动分片正本数，作为 in t
在创立索引 API 返回响应之前期待的流动分片正本数，作为 ActiveShardCount

4.1.8 同步执行

  • 以下列形式执行 时，客户端将期待 返回，而后再继续执行代码：CreateIndexRequest CreateIndexResponse
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

同步调用可能会引发 在高级 REST 客户端中无奈解析 REST 响应、申请会收回工夫或相似状况下没有从服务器返回的响应的状况下。IOException
在服务器返回 或 错误代码的状况下，高级客户端尝试剖析响应注释谬误详细信息，而后引发泛型，并将原始代码增加为克制异样。4xx 5xx ElasticsearchExceptionResponseException

4.1.9 异步执行

  • 也能够以异步形式执行，以便客户端能够间接返回。用户须要指定如何通过将申请和侦听器传递到异步创立索引办法来解决响应或潜在故障：CreateIndexRequest
client.indices().createAsync(request, RequestOptions.DEFAULT, listener);

执行实现时要执行和要应用的 CreateIndexRequest ActionListener

  • 异步办法不会阻止并立刻返回。实现后，如果执行胜利实现，则应用 onResponse 办法调用，如果执行失败，则应用 onFailure 该办法。失败计划和预期异样与同步执行案例雷同。ActionListener

典型的侦听器如下所示：

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

    @Override
    public void onResponse(CreateIndexResponse createIndexResponse) {// 胜利执行时调用。}

    @Override
    public void onFailure(Exception e) {// 当整个失败时调用}
};

4.1.10 创立索引响应

  • 返回的容许检索无关执行操作的信息，如下所示：CreateIndexResponse
boolean acknowledged = createIndexResponse.isAcknowledged(); // <1>
boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged(); // <2>

<1> 批示所有节点是否都已确认申请

<2> 批示在计时之前是否为索引中的每个分片启动所需的分片正本数

4.2 删除索引（Delete Index Api)

4.2.1 案例：

    /**
     * 删除索引.
     * url:https://i-code.online/
     * @param args
     */
    public static void main(String[] args) {
        //1. 创立客户端
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200)));
        //2. 创立 DeleteIndexRequest 承受 index(索引名) 参数
        DeleteIndexRequest request = new DeleteIndexRequest("student");
        // 超时以期待所有节点确认索引删除 参数为 TimeValue 类型
        request.timeout(TimeValue.timeValueMinutes(1));
        // 连贯 master 节点的超时工夫(应用 TimeValue 形式)
        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
        try {
            // 调用 delete
            AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
            System.out.printf("isAcknowledged:%s", response.isAcknowledged());
        } catch (IOException e) {e.printStackTrace();
        }
    }

4.2.2 删除索引申请

  • 须要参数：DeleteIndexRequestindex
DeleteIndexRequest request = new DeleteIndexRequest("posts");//<1> <1> 索引（index）名

<1> 索引（index）名

4.2.3 可选参数

  • 能够抉择提供以下参数：
request.timeout(TimeValue.timeValueMinutes(2));
request.timeout("2m");

超时以期待所有节点确认索引删除为 TimeValue 类型

超时以期待所有节点确认索引删除为 String 类型

request.masterNodeTimeout(TimeValue.timeValueMinutes(1));// 连贯 master 节点的超时工夫(应用 TimeValue 形式)
request.masterNodeTimeout("1m");// 连贯 master 节点的超时工夫(应用字符串形式)

连贯 master 节点的超时工夫 (应用 TimeValue 形式)
连贯 master 节点的超时工夫(应用字符串形式)

request.indicesOptions(IndicesOptions.lenientExpandOpen());

设置管制如何解析不可用的索引以及如何开展通配符表达式 IndicesOptions

4.2.4 同步执行

  • 以下列形式执行 DeleteIndexRequest 时，客户端将期待 DeleteIndexResponse 返回，而后再继续执行代码：DeleteIndexRequest DeleteIndexResponse
AcknowledgedResponse deleteIndexResponse = client.indices().delete(request, RequestOptions.DEFAULT);

同步调用可能会引发 在高级 REST 客户端中无奈解析 REST 响应、申请会收回工夫或相似状况下没有从服务器返回的响应的状况下。IOException
在服务器返回 或 错误代码的状况下，高级客户端尝试剖析响应注释谬误详细信息，而后引发泛型，并将原始代码增加为克制异样。4xx 5xx ElasticsearchExceptionResponseException

4.2.5 异步执行

  • 也能够以异步形式执行，以便客户端能够间接返回。用户须要指定如何通过将申请和侦听器传递到异步删除索引办法来解决响应或潜在故障：DeleteIndexRequest
client.indices().deleteAsync(request, RequestOptions.DEFAULT, listener); //<1>

<1> 执行实现时要执行和要应用的 DeleteIndexRequest ActionListener

异步办法不会阻止并立刻返回。实现后，如果执行胜利实现，则应用 ActionListener#onResponse 办法调用，如果执行失败，则应用 ActionListener# onFailure 该办法。失败计划和预期异样与同步执行案例雷同。

典型的侦听器如下所示：delete-index

ActionListener<AcknowledgedResponse> listener =
        new ActionListener<AcknowledgedResponse>() {
    @Override
    public void onResponse(AcknowledgedResponse deleteIndexResponse) {// 胜利执行时调用。}

    @Override
    public void onFailure(Exception e) {// 当整个失败时调用。DeleteIndexRequest}
};

4.2.6 删除索引响应

  • 返回的容许检索无关执行操作的信息，如下所示：DeleteIndexResponse
boolean acknowledged = deleteIndexResponse.isAcknowledged(); //<1> 批示所有节点是否都已确认申请

<1> 批示所有节点是否都已确认申请

  • 如果未找到索引，将引发：ElasticsearchException
try {DeleteIndexRequest request = new DeleteIndexRequest("does_not_exist");
    client.indices().delete(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException exception) {if (exception.status() == RestStatus.NOT_FOUND) {// 如果未找到要删除的索引，则进行 ""}
}

如果未找到要删除的索引，则进行 ””

4.3 索引存在(Index Exists Api)

4.3.1 案例：

    /**
     * 索引是否存在 Api
     * url:www.i-code.online
     * @param args
     */
    public static void main(String[] args) {RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200)));
        // 创立申请
        GetIndexRequest request = new GetIndexRequest("student");

        //<1> 是返回本地信息还是从主节点检索状态
        request.local(false);
        //<2> 返回后果为适宜人类的格局
        request.humanReadable(true);
        try {boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
            System.out.println(exists);
        } catch (IOException e) {e.printStackTrace();
        }
    }

4.3.2 索引存在申请

  • 高级 REST 客户端应用 “Index Exists API”。索引名称是必须的。GetIndexRequest
GetIndexRequest request = new GetIndexRequest("twitter"); //<1> index 名称

<1> index 名称

4.3.3 可选参数

  • 索引存在 API 还承受以下可选参数，通过：GetIndexRequest
request.local(false);//<1> 是返回本地信息还是从主节点检索状态
request.humanReadable(true); //<2> 返回后果为适宜人类的格局
request.includeDefaults(false); //<3> 是否返回每个索引的所有默认设置
request.indicesOptions(indicesOptions); //<4> 管制如何解析不可用的索引以及如何开展通配符表达式

<1> 是返回本地信息还是从主节点检索状态
<2> 返回后果为适宜人类的格局
<3> 是否返回每个索引的所有默认设置
<4> 管制如何解析不可用的索引以及如何开展通配符表达式

4.3.4 同步执行

  • 以下列形式执行 时，客户端将期待 返回，而后再继续执行代码：GetIndexRequest boolean
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

与其余同步的雷同

4.3.5 异步执行

–

  • 也能够以异步形式执行，以便客户端能够间接返回。用户须要指定如何通过将申请和侦听器传递到异步索引存在的办法来解决响应或潜在故障：GetIndexRequest
client.indices().existsAsync(request, RequestOptions.DEFAULT, listener);//<1> 执行实现时要执行和要应用的 GetIndexRequest  ActionListener

<1> 执行实现时要执行和要应用的 GetIndexRequest ActionListener
异步的解决逻辑与其余异步的雷同，都是实现 ActionListener 的办法

4.3.6 响应

  • 响应是一个值，批示索引（或索引）是否存在。boolean

5. 文档 Api (Document APIs)

5.1 索引 API (Index Api)

5.1.1 案例：

  • 增加记录
    private static void test02() {RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200)));
        // 创立申请，参数 index 名称
        IndexRequest request = new IndexRequest("student");
        // 申请的模式，CREATE：创立模式，如果曾经存在则报错   Index: 存在则不再创立，也不报错
        request.opType(DocWriteRequest.OpType.INDEX);
        String json = "{\n" +
                "\"id\": 12,\n" +
                "\"name\": \"admin\",\n" +
                "\"content\": \" 步的解决逻辑与其余异步的雷同，都是实现 ActionListener 的办法 \"\n" +
                "}";
        request.id("1").source(
                json,
                XContentType.JSON
        );
        IndexResponse indexResponse = null;
        try {
            // 调用 index 办法
            indexResponse = client.index(request, RequestOptions.DEFAULT);
            System.out.println(indexResponse.getVersion());
            System.out.println(indexResponse.getIndex());
            System.out.println(indexResponse.getId());
            System.out.println(indexResponse.status());
        } catch (ElasticsearchStatusException | IOException e) {e.printStackTrace();
        }
    }

5.1.2 索引申请

  • 须要以下参数：IndexRequest
        // 创立申请，参数 index 名称
        IndexRequest request = new IndexRequest("student"); //<1> index 名称
        String json = "{\n" +
                "\"id\": 12,\n" +
                "\"name\": \"admin\",\n" +
                "\"content\": \" 步的解决逻辑与其余异步的雷同，都是实现 ActionListener 的办法 \"\n" +
                "}";
        request
            .id("1") // <2> 指定文档 ID 
            .source(
                json,
                XContentType.JSON // <3> 指定参数类型，json
        );

<1> index 名称指数

<2> 申请的文档 ID

<3> 指定参数类型，json

提供文档源

  • 除了下面显示的示例之外，还能够以不同的形式提供文档源：String
Map<String, Object> jsonMap = new HashMap<>();
jsonMap.put("id", 1);
jsonMap.put("name", "Admin);
jsonMap.put("content", "步的解决逻辑与其余异步的雷同");
IndexRequest indexRequest = new IndexRequest("student").id("1").source(jsonMap);

文档源作为 主动转换为 JSON 格局的 Map

XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{builder.field("id", 1);
builder.field("name", "admin);
builder.field("content", "trying out Elasticsearch");
}
builder.endObject();
IndexRequest indexRequest = new IndexRequest("student").id("1").source(builder);

文档源作为对象提供，弹性搜寻内置帮忙器生成 JSON 内容 XContentBuilder

IndexRequest indexRequest = new IndexRequest("student")
.id("1")
.source("id", 1,
"name", "admin",
"content", "trying out Elasticsearch");

作为密钥对提供的文档源，该源将转换为 JSON 格局 Object

5.1.3 可选参数

  • 能够抉择提供以下参数：
request.routing("routing"); //<1>

<1> 路由值

request.timeout(TimeValue.timeValueSeconds(1)); //<1>
request.timeout("1s");  // <2>

<1> 超时以期待主分片 作为 TimeValue
<2> 超时以期待主分片 作为 String

request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL); //<1>
request.setRefreshPolicy("wait_for"); //<2>

<1> 将策略刷新 为实例 WriteRequest.RefreshPolicy
<2> 将策略刷新 为 String

request.version(2);

版本

request.versionType(VersionType.EXTERNAL); // 版本类型

版本类型

request.opType(DocWriteRequest.OpType.CREATE);//<1>
request.opType("create");//<2>

<1> 作为值提供的操作类型 DocWriteRequest.OpType
<2> 提供的操作类型能够是 或（默认）String create index

request.setPipeline("pipeline");

在索引文档之前要执行的蕴含管道的名称

5.1.4 同步执行

  • 以下列形式执行 时，客户端将期待 返回，而后再继续执行代码：IndexRequest IndexResponse
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
  • 同步调用可能会引发 在高级 REST 客户端中无奈解析 REST 响应、申请会收回工夫或相似状况下没有从服务器返回的响应的状况下。IOException
  • 在服务器返回 或 错误代码的状况下，高级客户端尝试剖析响应注释谬误详细信息，而后引发泛型，并将原始代码增加为克制异样。4xx 5xx ElasticsearchExceptionResponseException

5.1.5 异步执行

  • 也能够以异步形式执行，以便客户端能够间接返回。用户须要指定如何通过将申请和侦听器传递到异步索引办法来解决响应或潜在故障：IndexRequest
client.indexAsync(request, RequestOptions.DEFAULT, listener); //<1>

<1> 执行实现时要执行和要应用的 IndexRequest ActionListener

  • 异步办法不会阻止并立刻返回。实现后，如果执行胜利实现，则应用 办法调用，如果执行失败，则应用 该办法。失败计划和预期异样与同步执行案例雷同。ActionListener onResponse onFailure
  • 典型的侦听器如下所示：index
listener = new ActionListener<IndexResponse>() {
    @Override
    public void onResponse(IndexResponse indexResponse) {//<1> 胜利执行时调用。}

    @Override
    public void onFailure(Exception e) {//<2> 当整个失败时调用。IndexRequest}
};

<1> 胜利执行时调用。

<2> 当整个失败时调用。> IndexRequest

5.1.6 索引响应

  • 返回的容许检索无关执行操作的信息，如下所示：IndexResponse
String index = indexResponse.getIndex();
String id = indexResponse.getId();
if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {//<1>} else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {//<2>}
ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
if (shardInfo.getTotal() != shardInfo.getSuccessful()) {// <3>}
if (shardInfo.getFailed() > 0) {
    for (ReplicationResponse.ShardInfo.Failure failure :
            shardInfo.getFailures()) {String reason = failure.reason(); //<4>
    }
}

<1> 解决（如果须要）首次创立文档的状况

<2> 解决（如果须要）文档被重写的状况，因为它曾经存在

<3> 解决胜利分片数少于总分片的状况

<4> 解决潜在的故障

  • 如果存在版本抵触，将引发：ElasticsearchException
IndexRequest request = new IndexRequest("posts")
    .id("1")
    .source("field", "value")
    .setIfSeqNo(10L)
    .setIfPrimaryTerm(20);
try {IndexResponse response = client.index(request, RequestOptions.DEFAULT);
} catch(ElasticsearchException e) {if (e.status() == RestStatus.CONFLICT) {//<1>}
}

<1> 引发异样批示返回版本抵触谬误

  • 在设置为且已存在具备雷同索引和 ID 的文档的状况下，将产生雷同的状况：opTypecreate
IndexRequest request = new IndexRequest("posts")
    .id("1")
    .source("field", "value")
    .opType(DocWriteRequest.OpType.CREATE);
try {IndexResponse response = client.index(request, RequestOptions.DEFAULT);
} catch(ElasticsearchException e) {if (e.status() == RestStatus.CONFLICT) {//<1>}
}

<1> 引发异样批示返回版本抵触谬误

5.2 获取 Api (Get API)

5.2.1 案例：

    private static void test01(){RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("127.0.0.1",9200)));
        GetRequest request = new GetRequest("student");
        // 为特定字段 配置  源蕴含
        String[] includs = {"name","id","content"};
        String[] excluds = {"id"};
        FetchSourceContext context = new FetchSourceContext(true,includs,excluds);

        request.id("1").version(2).fetchSourceContext(context);
        try {GetResponse documentFields = client.get(request, RequestOptions.DEFAULT);
            if (documentFields.isExists()) {
                // 检索名称
                System.out.println(documentFields.getIndex());
                // 获取文档源的 Map 后果
                System.out.println(documentFields.getSource());
                // 获取源作为 Map
                System.out.println(documentFields.getSourceAsMap());
                // 获取源作为 bytes
                System.out.println(documentFields.getSourceAsBytes());
            }else {System.out.println("不错在该数据");
            }

        } catch (IOException e) {e.printStackTrace();
        }
    }

5.2.2 获取申请

  • 须要以下参数：GetRequest
GetRequest getRequest = new GetRequest(
"posts", //<1>
"1");   //<1>

<1> 索引名称

<2> 文档 ID

5.2.3 可选参数

  • 能够抉择提供以下参数：
request.fetchSourceContext(FetchSourceContext.DO_NOT_FETCH_SOURCE);

禁用源检索，默认状况下启用

String[] includes = new String[]{"message", "*Date"};
String[] excludes = Strings.EMPTY_ARRAY;
FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
request.fetchSourceContext(fetchSourceContext);

为特定字段 配置 源蕴含

includes : 检索后果所蕴含的字段
excludes : 检索后果排除的字段

String[] includes = Strings.EMPTY_ARRAY;
String[] excludes = new String[]{"message"};
FetchSourceContext fetchSourceContext =
new FetchSourceContext(true, includes, excludes);
request.fetchSourceContext(fetchSourceContext);

为特定字段配置源排除

request.storedFields("message");
GetResponse getResponse = client.get(request, RequestOptions.DEFAULT);
String message = getResponse.getField("message").getValue();

为特定存储字段配置检索（要求字段独自存储在映射中）

检索存储的字段（要求该字段独自存储在映射中）message

request.routing("routing");

路由值

request.preference("preference");

首选项值

request.realtime(false);

将实时标记设置为（默认状况下）falsetrue

request.refresh(true);

在检索文档之前执行刷新（默认状况下）false

request.version(2);

版本

request.versionType(VersionType.EXTERNAL);

版本类型

5.2.4 同步执行

  • 以下列形式执行 时，客户端将期待 返回，而后再继续执行代码：GetRequest GetResponse
GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
  • 同步调用可能会引发 在高级 REST 客户端中无奈解析 REST 响应、申请会收回工夫或相似状况下没有从服务器返回的响应的状况下。IOException
  • 在服务器返回 或 错误代码的状况下，高级客户端尝试剖析响应注释谬误详细信息，而后引发泛型，并将原始代码增加为克制异样。4xx5xxElasticsearchExceptionResponseException

5.2.5 异步执行

  • 也能够以异步形式执行，以便客户端能够间接返回。用户须要指定如何通过将申请和侦听器传递到异步获取办法来解决响应或潜在故障：GetRequest
client.getAsync(request, RequestOptions.DEFAULT, listener);

执行实现时要执行和要应用的 GetRequest ActionListener

  • 异步办法不会阻止并立刻返回。实现后，如果执行胜利实现，则应用 办法调用，如果执行失败，则应用 该办法。失败计划和预期异样与同步执行案例雷同。ActionListeneronResponseonFailure
  • 典型的侦听器如下所示：get
ActionListener<GetResponse> listener = new ActionListener<GetResponse>() {
    @Override
    public void onResponse(GetResponse getResponse) {// 胜利执行时调用}

    @Override
    public void onFailure(Exception e) {// 当整个失败时调用。GetRequest}
};

5.2.6 获取响应

  • 返回的容许检索申请的文档及其元数据和最终存储的字段。GetResponse
String index = getResponse.getIndex();
String id = getResponse.getId();
if (getResponse.isExists()) {long version = getResponse.getVersion();
    String sourceAsString = getResponse.getSourceAsString();      // <1>  
    Map<String, Object> sourceAsMap = getResponse.getSourceAsMap(); // <2>
    byte[] sourceAsBytes = getResponse.getSourceAsBytes();          // <3>
} else {// <4>}

<1> 将文档检索为 String
<2> 将文档检索为 Map<String, Object>
<3> 将文档检索为 byte[]
<4> 解决找不到文档的计划。请留神，只管返回的响应具备状态代码，但返回的是无效的，而不是引发异样。此类响应不保留任何源文档，其办法将返回。404 GetResponseisExistsfalse

  • 当对不存在的索引执行 get 申请时，响应具备状态代码，即须要按如下形式解决的已引发申请：404 ElasticsearchException
GetRequest request = new GetRequest("does_not_exist", "1");
try {GetResponse getResponse = client.get(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException e) {if (e.status() == RestStatus.NOT_FOUND) {//<1> 解决引发异样，因为索引不存在}
}

<1> 解决引发异样，因为索引不存在

  • 如果申请了特定的文档版本，并且现有文档具备不同的版本号，则引发版本抵触：
try {GetRequest request = new GetRequest("posts", "1").version(2);
    GetResponse getResponse = client.get(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException exception) {if (exception.status() == RestStatus.CONFLICT) {// <1>}
}

<1> 引发异样批示返回版本抵触谬误

6. 结语

其实很多 Api 的应用都是相似雷同的，这里咱们不再对其余 Api 进行解析，须要理解的齐全能够去光网文档查看，文档地址在问上涨下面有。

本文由 AnonyStar 公布, 可转载但需申明原文出处。
企慕「优雅编码的艺术」深信游刃有余，致力扭转人生
欢送关注微信公账号：云栖简码 获取更多优质文章
更多文章关注笔者博客：云栖简码

正文完
java-ee
发表至： java-ee
2020-09-23
 0
关于java-ee:spring源码解读-IoC-之解析-import-标签
关于java-ee:spring源码解读-ioc之验证模型获取
关于java-ee:Jakarta-EE-Java-EE的终结者
关于java-ee:优雅关闭线程池的方案