东京热一精品无码av,无码激情亚洲一区,精品国产成人午夜福利

1、概述

　　Elasticsearch官方為Java提供了三種客戶端API

TransportClient：這種方式通過TCP與Elasticsearch服務(wù)進(jìn)行交互。
Java Low Level REST Client: 低級別的REST客戶端，通過http與集群交互，用戶需自己編組請求JSON串，及解析響應(yīng)JSON串。兼容所有ES版本。
Java High Level REST Client: 高級別的REST客戶端，基于低級別的REST客戶端，增加了編組請求JSON串、解析響應(yīng)JSON串等相關(guān)api。使用的版本需要保持和ES服務(wù)端的版本一致，否則會有版本問題。

　　官方文檔地址: https://artifacts.elastic.co/javadoc/org/elasticsearch/client/elasticsearch-rest-high-level-client/7.4.2/index.html

　　在 Elasticsearch 7.0 中不建議使用TransportClient，并且在8.0中會完全刪除TransportClient。因此，官方更建議我們用Java High Level REST Client。

The well known TransportClient is deprecated as of Elasticsearch 7 and will be removed in Elasticsearch 8. (see the Elasticsearch documentation). Spring Data Elasticsearch will support the TransportClient as long as it is available in the used Elasticsearch version but has deprecated the classes using it since version 4.0.

　　Spring Data Elasticsearch

　　Spring Data Elasticsearch作為Spring Data的一個子項目，封裝了對EalsticSearch的客戶端，現(xiàn)在最新版本是4.1.1，其內(nèi)核也是由TransportClient變?yōu)樵诤罄m(xù)版本中采用Java High Level REST Client，其支持版本情況如下：

　　詳情如github所示：https://github.com/spring-projects/spring-data-elasticsearch/blob/master/src/main/asciidoc/preface.adoc

　　因此我們就直接采用Java High Level REST Client的Elasticsearch客戶端進(jìn)行學(xué)習(xí)。

2、開發(fā)準(zhǔn)備

　　高級客戶端托管在Maven Central上。所需的最低Java版本是1.8。高級客戶端與Elasticsearch的發(fā)布周期相同。

　　1、Maven 依賴

　　下面是使用maven作為依賴管理器配置依賴項。將以下內(nèi)容添加到您的pom.xml文件中：

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.9.2</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.9.2</version>
</dependency>

　　2、Dependencies

　　高級客戶端依賴于以下部件及其傳遞依賴關(guān)系：

org.elasticsearch.client: elasticsearch-rest-client
org.elasticsearch: elasticsearch

　　3、初始化

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));

　　高級客戶端內(nèi)部會創(chuàng)建低級客戶端用于基于提供的builder執(zhí)行請求。低級客戶端維護(hù)一個連接池，并啟動一些線程，因此當(dāng)你用完以后應(yīng)該關(guān)閉高級客戶端，并且在內(nèi)部它將會關(guān)閉低級客戶端，以釋放這些資源。關(guān)閉客戶端可以使用close()方法：

client.close();

3、API文檔

　　3.1、索引管理

　　3.1.1、添加索引

public void createIndex() {
    CreateIndexRequest request = new CreateIndexRequest("testindex");
    request.settings(
            Settings.builder().put("index.analysis.analyzer.default.type", "ik_max_word")
                    .put("number_of_shards", 5)
                    .put("number_of_replicas", 1)
                    .put("refresh_interval", "30s"));
    request.mapping("{\"properties\":{\"testId\":{\"type\":\"text\",\"store\":false,\"index\":true" +
                    ",\"analyzer\":\"standard\"},\"testName\":{\"type\":\"text\",\"store\":false,\"index\":true}" +
                    ",\"testDesc\":{\"type\":\"text\",\"store\":false,\"index\":true}}}"
            , XContentType.JSON);
    // 為索引設(shè)置一個別名
    request.alias(new Alias("test_alias"));
    // 超時,等待所有節(jié)點被確認(rèn)(使用TimeValue方式)
    request.setTimeout(TimeValue.timeValueNanos(1000));

    // 連接master節(jié)點的超時時間(使用TimeValue方式)
    request.setMasterTimeout(TimeValue.timeValueSeconds(2));

    // 在創(chuàng)建索引API返回響應(yīng)之前等待的活動分片副本的數(shù)量，以int形式表示。
    request.waitForActiveShards(ActiveShardCount.from(1));
    // 在創(chuàng)建索引API返回響應(yīng)之前等待的活動分片副本的數(shù)量，以ActiveShardCount形式表示。
    // request.waitForActiveShards(ActiveShardCount.ONE);

    //同步執(zhí)行
    CreateIndexResponse createIndexResponse = client.indices().create(request,RequestOptions.DEFAULT);

    /***
     * 異步執(zhí)行:創(chuàng)建索引請求需要將CreateIndexRequest實例和ActionListener實例傳遞給異步方法：
     * CreateIndexResponse的典型監(jiān)聽器如下所示：
     * 異步方法不會阻塞并立即返回。
    ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
        @Override
        public void onResponse(CreateIndexResponse createIndexResponse) {
            //如果執(zhí)行成功，則調(diào)用onResponse方法;
        }
        @Override
        public void onFailure(Exception e) {
            //如果失敗，則調(diào)用onFailure方法。
        }
    };
    client.indices().createAsync(request, listener);//要執(zhí)行的CreateIndexRequest和執(zhí)行完成時要使用的ActionListener
    */
    //返回的CreateIndexResponse允許檢索有關(guān)執(zhí)行的操作的信息，如下所示：
    // 指示是否所有節(jié)點都已確認(rèn)請求
    boolean acknowledged = createIndexResponse.isAcknowledged();
    // 指示是否在超時之前為索引中的每個分片啟動了必需的分片副本數(shù)
    boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
    System.out.println("acknowledged:"+acknowledged+"; shardsAcknowledged:"+shardsAcknowledged);
}

　　3.1.2、刪除索引

public void deleteIndex() {
    DeleteIndexRequest request = new DeleteIndexRequest("testindex");//指定要刪除的索引名稱
    //可選參數(shù)：
    request.timeout(TimeValue.timeValueMinutes(2)); //設(shè)置超時，等待所有節(jié)點確認(rèn)索引刪除（使用TimeValue形式）
    // request.timeout("2m"); //設(shè)置超時，等待所有節(jié)點確認(rèn)索引刪除（使用字符串形式）

    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));////連接master節(jié)點的超時時間(使用TimeValue方式)
    // request.masterNodeTimeout("1m");//連接master節(jié)點的超時時間(使用字符串方式)

    //設(shè)置IndicesOptions控制如何解決不可用的索引以及如何擴(kuò)展通配符表達(dá)式
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步執(zhí)行
    AcknowledgedResponse deleteIndexResponse = client.indices().delete(request, RequestOptions.DEFAULT);

    /**
     * 異步執(zhí)行刪除索引請求需要將DeleteIndexRequest實例和ActionListener實例傳遞給異步方法：DeleteIndexResponse的典型監(jiān)聽器如下所示：
     * 異步方法不會阻塞并立即返回。
     ActionListener<DeleteIndexResponse> listener = new ActionListener<DeleteIndexResponse>() {
    @Override public void onResponse(DeleteIndexResponse deleteIndexResponse) {
    //如果執(zhí)行成功，則調(diào)用onResponse方法;
    }

    @Override public void onFailure(Exception e) {
    //如果失敗，則調(diào)用onFailure方法。
    }
    };
     * 異步執(zhí)行刪除索引請求需要將DeleteIndexRequest實例和ActionListener實例傳遞給異步方法：
     client.indices().deleteAsync(request, listener);
     */
    //Delete Index Response
    //返回的DeleteIndexResponse允許檢索有關(guān)執(zhí)行的操作的信息，如下所示：
    boolean acknowledged = deleteIndexResponse.isAcknowledged();//是否所有節(jié)點都已確認(rèn)請求

    //如果找不到索引，則會拋出ElasticsearchException：
    try {
        request = new DeleteIndexRequest("does_not_exist");
        client.indices().delete(request,RequestOptions.DEFAULT);
    } catch (ElasticsearchException exception) {
        if (exception.status() == RestStatus.NOT_FOUND) {
            //如果沒有找到要刪除的索引，要執(zhí)行某些操作
        }
    }
}

　　3.1.3、關(guān)閉索引

　　針對部分索引，我們暫時不需要對其進(jìn)行讀寫，可以臨時關(guān)閉索引，以減少es服務(wù)器的開銷。

public void closeIndex(){
    //關(guān)閉索引
    CloseIndexRequest request = new CloseIndexRequest("testindex");
    //可選參數(shù)：
    //設(shè)置超時，等待所有節(jié)點確認(rèn)索引已關(guān)閉（使用TimeValue形式）
    request.setTimeout(TimeValue.timeValueMinutes(2));

    //連接master節(jié)點的超時時間(使用TimeValue方式)
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));

    //設(shè)置IndicesOptions控制如何解決不可用的索引以及如何擴(kuò)展通配符表達(dá)式
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    //同步執(zhí)行
    CloseIndexResponse closeIndexResponse = client.indices().close(request,RequestOptions.DEFAULT);

    /** 異步執(zhí)行打開索引請求需要將CloseIndexRequest實例和ActionListener實例傳遞給異步方法：
     * CloseIndexResponse的典型監(jiān)聽器如下所示：
     * 異步方法不會阻塞并立即返回。
        ActionListener<CloseIndexResponse> listener = new ActionListener<CloseIndexResponse>() {
            @Override
            public void onResponse(CloseIndexResponse closeIndexResponse) {
                 //如果執(zhí)行成功，則調(diào)用onResponse方法;
            }

            @Override
            public void onFailure(Exception e) {
                 //如果失敗，則調(diào)用onFailure方法。
            }
        };
        client.indices().closeAsync(request, listener);
     */

    //返回的CloseIndexResponse 允許檢索有關(guān)執(zhí)行的操作的信息，指示是否所有節(jié)點都已確認(rèn)請求：
    boolean acknowledged = closeIndexResponse.isAcknowledged();
}

　　3.1.4、打開索引

public void openIndex(){
    //關(guān)閉索引
    OpenIndexRequest request = new OpenIndexRequest("testindex");
    //可選參數(shù)：
    //在打開索引API返回響應(yīng)之前等待的活動分片副本的數(shù)量，以int形式表示。
    request.waitForActiveShards(1);
    //在打開索引API返回響應(yīng)之前等待的活動分片副本的數(shù)量，以ActiveShardCount形式表示。
    //request.waitForActiveShards(ActiveShardCount.ONE);

    //設(shè)置IndicesOptions控制如何解決不可用的索引以及如何擴(kuò)展通配符表達(dá)式
    request.indicesOptions(IndicesOptions.strictExpandOpen());

    //同步執(zhí)行
    OpenIndexResponse openIndexResponse = client.indices().open(request,RequestOptions.DEFAULT);

    /** 異步執(zhí)行打開索引請求需要將CloseIndexRequest實例和ActionListener實例傳遞給異步方法：
     * CloseIndexResponse的典型監(jiān)聽器如下所示：
     * 異步方法不會阻塞并立即返回。
         ActionListener<CloseIndexResponse> listener = new ActionListener<CloseIndexResponse>() {
            @Override
            public void onResponse(CloseIndexResponse closeIndexResponse) {
                //如果執(zhí)行成功，則調(diào)用onResponse方法;
            }

            @Override
            public void onFailure(Exception e) {
                //如果失敗，則調(diào)用onFailure方法。
            }
            };
         client.indices().closeAsync(request, listener);
     */

    //返回的CloseIndexResponse 允許檢索有關(guān)執(zhí)行的操作的信息，指示是否所有節(jié)點都已確認(rèn)請求：
    boolean acknowledged = openIndexResponse.isAcknowledged();
}

　　3.2、文檔管理

　　3.2.1、添加文檔

public void createDocument(){
    IndexRequest indexRequest1 = new IndexRequest("testindex").id(generateId());

    //==============================提供文檔源========================================
    //方式1：以字符串形式提供
    String jsonString = "{\"testId\":\"json\",\"testName\":\"你猜不到的名字\",\"testDesc\":\"這是一條新聞描述\"}";
    indexRequest1.source(jsonString, XContentType.JSON);

    //方式2：以Map形式提供
    Map<String, Object> jsonMap = new HashMap<>();
    jsonMap.put("testId", "jsonMap");
    jsonMap.put("testName", "你猜不到的名字");
    jsonMap.put("testDesc", "這是一條新聞描述");
    //Map會自動轉(zhuǎn)換為JSON格式的文檔源
    IndexRequest indexRequest2 = new IndexRequest("testindex").source(jsonMap);

    // 方式3：文檔源以XContentBuilder對象的形式提供，Elasticsearch內(nèi)部會幫我們生成JSON內(nèi)容
    XContentBuilder builder = XContentFactory.jsonBuilder();
    builder.startObject();
    builder.field("testId", "builder");
    builder.field("testName", "你猜不到的名字");
    builder.field("testDesc", "這是一條新聞描述");
    builder.endObject();
    IndexRequest indexRequest3 = new IndexRequest("testindex").id(generateId()).source(builder);

    //方式4：以O(shè)bject key-pairs提供的文檔源，它會被轉(zhuǎn)換為JSON格式
    IndexRequest indexRequest4 = new IndexRequest("testindex")
            .id(UUID.randomUUID().toString().replaceAll("-", ""))
            .source("testId", "Object key-pairs",
                    "testName", "你猜不到的名字",
                    "testDesc", "這是一條新聞描述");

    //===============================可選參數(shù)start====================================
    //設(shè)置路由值
    // indexRequest1.routing("routing");

    //設(shè)置超時：等待主分片變得可用的時間:TimeValue方式
    indexRequest1.timeout(TimeValue.timeValueSeconds(1));
    // indexRequest1.timeout("1s"); //字符串方式

    //刷新策略:WriteRequest.RefreshPolicy實例方式
    indexRequest1.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);
    // indexRequest1.setRefreshPolicy("wait_for");//字符串方式

    // indexRequest1.version(2);//設(shè)置版本

    // indexRequest1.versionType(VersionType.INTERNAL);//設(shè)置版本類型

    //操作類型:DocWriteRequest.OpType方式
    indexRequest1.opType(DocWriteRequest.OpType.CREATE);
    // indexRequest1.opType("create");//字符串方式, 可以是 create 或 update (默認(rèn))

    // The name of the ingest pipeline to be executed before indexing the document
    // indexRequest1.setPipeline("pipeline");

    //===============================執(zhí)行====================================
    //同步執(zhí)行
    IndexResponse indexResponse = client.index(indexRequest1, RequestOptions.DEFAULT);

    //異步執(zhí)行:異步方法不會阻塞并立即返回,IndexResponse 的典型監(jiān)聽器如下所示：
    ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() {
        @Override
        public void onResponse(IndexResponse indexResponse) {
            //執(zhí)行成功時調(diào)用。 Response以參數(shù)方式提供
        }

        @Override
        public void onFailure(Exception e) {
            //在失敗的情況下調(diào)用。 引發(fā)的異常以參數(shù)方式提供
        }
    };
    //異步執(zhí)行索引請求需要將IndexRequest實例和ActionListener實例傳遞給異步方法：
    client.indexAsync(indexRequest2, RequestOptions.DEFAULT, listener);

    //Index Response:返回的IndexResponse允許檢索有關(guān)執(zhí)行操作的信息，如下所示：
    String index = indexResponse.getIndex();
    String type = indexResponse.getType();
    String id = indexResponse.getId();
    long version = indexResponse.getVersion();
    if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
        //處理（如果需要）第一次創(chuàng)建文檔的情況
    } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
        //處理（如果需要）文檔被重寫的情況
    }
    ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
    if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
        //處理成功分片數(shù)量少于總分片數(shù)量的情況
    }
    if (shardInfo.getFailed() > 0) {
        for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
            String reason = failure.reason();//處理潛在的失敗
        }
    }

    //如果存在版本沖突，則會拋出ElasticsearchException：
    IndexRequest request = new IndexRequest("posts", "doc", "1")
            .source("field", "value")
            .version(1);
    try {
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    } catch(ElasticsearchException e) {
        if (e.status() == RestStatus.CONFLICT) {
            //引發(fā)的異常表示返回了版本沖突錯誤
        }
    }

    //如果opType設(shè)置為創(chuàng)建但是具有相同索引，類型和ID的文檔已存在，則也會發(fā)生同樣的情況：
    request = new IndexRequest("posts", "doc", "1")
            .source("field", "value")
            .opType(DocWriteRequest.OpType.CREATE);
    try {
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    } catch(ElasticsearchException e) {
        if (e.status() == RestStatus.CONFLICT) {
            //引發(fā)的異常表示返回了版本沖突錯誤
        }
    }
}

　　插入測試結(jié)果如下：

　　由于所有文檔的異步操作

　　3.2.2、文檔是否存在

public void exists(){
    GetRequest getRequest = new GetRequest("testindex").id("e749eada74ca4ded8232bf1fcf65585e");
    // 禁止獲取_source
    getRequest.fetchSourceContext(new FetchSourceContext(false));
    // 禁止獲取存儲字段
    getRequest.storedFields("_none_");
    boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
    System.out.println(getRequest.index() + "---" + getRequest.id() + "---文檔是否存在：" + exists);
}

//異步執(zhí)行獲取索引請求需要將GetRequest  實例和ActionListener實例傳遞給異步方法：
client.existsAsync(request, listener);

　　3.2.3、刪除文檔

public void deleteDocument() {
    DeleteRequest deleteRequest = new DeleteRequest("testindex").id("51dfb91a9d5c405f979");
    client.delete(deleteRequest, RequestOptions.DEFAULT);
    System.out.println(deleteRequest.index() + "---" + deleteRequest.id() + ": 文檔已刪除");
}

//異步執(zhí)行獲取索引請求需要將DeleteRequest  實例和ActionListener實例傳遞給異步方法：
client.deleteAsync(request, listener);

　　3.2.4、更新文檔

　　3.2.4.1、局部更新

public void updateDocumentPart(){
    // 方式1：使用Map形式，會被自動轉(zhuǎn)為json格式
    Map<String, Object> jsonMap = new HashMap<>();
    jsonMap.put("testId", "jsonMap2(新的類型)");
    jsonMap.put("testDesc", "這是一條新聞描述2(新的描述)");
    UpdateRequest request = new UpdateRequest("testindex", "Q0su_nUB4hs2I-RuESpC").doc(jsonMap);
    UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");

    // 方式2：使用字符串形式
    String jsonString = "{\"testId\":\"testIdNew\",\"testName\":\"testNameNew\"}";
    request = new UpdateRequest("testindex", "Q0su_nUB4hs2I-RuESpC").doc(jsonString, XContentType.JSON);
    response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");

    // 方式3：使用XContentBuilder形式
    XContentBuilder builder = XContentFactory.jsonBuilder();
    builder.startObject();
    {
        builder.field("testId", "使用XContentBuilder形式");
        builder.field("testName", "使用XContentBuilder形式 update");
    }
    builder.endObject();
    request = new UpdateRequest("testindex", "Q0su_nUB4hs2I-RuESpC").doc(builder);
    response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");

    //方式4：使用Object key-pairs形式
    request = new UpdateRequest("testindex","Q0su_nUB4hs2I-RuESpC")
            .doc("testId", "Object key-pairs",
                    "testDesc", "Object key-pairs update");
    response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");
}

　　3.2.4.1、全部更新

    //為內(nèi)聯(lián)腳本提供參數(shù)
    Map<String, Object> parameters = singletonMap("testDesc", "內(nèi)聯(lián)腳本");

    //方式1：使用painless語言和上面的參數(shù)創(chuàng)建一個內(nèi)聯(lián)腳本
    Script inline = new Script(ScriptType.INLINE, "painless", "ctx._source.field += params.count", parameters);
    UpdateRequest request = new UpdateRequest("testindex", "REsu_nUB4hs2I-RuESpD").script(inline);
    UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");


    //方式2：引用名稱為increment-field的腳本,改腳本定義的位置還沒搞清楚。
    Script stored =
            new Script(ScriptType.STORED, null, "increment-field", parameters);
    request = new UpdateRequest("testindex", "RUsu_nUB4hs2I-RuESpD").script(stored);
    response = client.update(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");
}

　　ES的全部更新和局部更新，底層有什么區(qū)別?

　　答：全部更新，是直接把之前的老數(shù)據(jù)，標(biāo)記為刪除狀態(tài)，然后，再添加一條更新的；局域更新，只是修改某個字段。

　　3.2.4.3、更新不存在則插入upsert

public void updateDocumentInsert(){
    //如果文檔尚不存在，則可以使用upsert方法定義一些將作為新文檔插入的內(nèi)容：
    //與部分文檔更新類似，可以使用接受String，Map，XContentBuilder或Object key-pairs的方式來定義upsert文檔的內(nèi)容。
    Map<String, Object> jsonMap = new HashMap<>();
    jsonMap.put("testId", "jsonMap2(新的類型)");
    jsonMap.put("testDesc", "這是一條新聞描述2(新的描述)");
    UpdateRequest request = new UpdateRequest("testindex", "updateDocumentInsert").docAsUpsert(true).doc(jsonMap);
    UpdateResponse response = client.update(request,RequestOptions.DEFAULT);
    System.out.println(response.getIndex() + "---" + response.getId() + "完成更新");
}

//異步執(zhí)行獲取索引請求需要將UpdateRequest  實例和ActionListener實例傳遞給異步方法：
client.updateAsync(request, listener);

　　3.2.5、批量更新文檔

public void bulk() {
    BulkRequest request = new BulkRequest();
    request.add(new IndexRequest("testindex")
            .source(XContentType.JSON, "testId", "foo", "testName", "lucky", "testDesc", "qwer"));
    request.add(new IndexRequest("testindex")
            .source(XContentType.JSON, "testId", "bar", "testName", "Jon", "testDesc", "sadasd"));
    request.add(new IndexRequest("testindex")
            .source(XContentType.JSON, "testId", "baz", "testName", "Lucy", "testDesc", "zxczx"));
    // id為10的不存在
    request.add(new DeleteRequest("testindex", "4eb9eaeb9522495e954"));
    request.add(new UpdateRequest("testindex", "e749eada74ca4ded8232bf1fcf65585e")
            .doc(XContentType.JSON, "testId", "12312313", "testName", "1221312", "testDesc", "435345353"));
    BulkResponse bulkResponse = null;
    bulkResponse = client.bulk(request, RequestOptions.DEFAULT);
    // 獲取執(zhí)行狀態(tài)
    System.out.println("批量更新結(jié)果狀態(tài)：" + bulkResponse.status());
}

public final Cancellable bulkAsync(BulkRequest bulkRequest, RequestOptions options, ActionListener<BulkResponse> listener) {
    return this.performRequestAsyncAndParseEntity((ActionRequest)bulkRequest, RequestConverters::bulk, options, 
　　　　　　　　　　BulkResponse::fromXContent, listener, Collections.emptySet());
}

　　3.3、文檔搜索

　　3.3.1、獲取一個文檔

public void getDocument(){
    GetRequest getRequest = new GetRequest("testindex", "e749eada74ca4ded8232bf1fcf65585e");
    GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
    String index = getResponse.getIndex();
    String id = getResponse.getId();
    if (getResponse.isExists()) {
        long version = getResponse.getVersion();
        String sourceAsString = getResponse.getSourceAsString();
        Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
        byte[] sourceAsBytes = getResponse.getSourceAsBytes();

        System.out.println("索引：" + index + "，ID：" + id + "版本：" + version);
        System.out.println(sourceAsString);
        System.out.println(sourceAsMap);
        System.out.println(sourceAsBytes.toString());
    } else {
        System.out.println("未查到結(jié)果");
    }
}

//異步執(zhí)行獲取索引請求需要將GetRequest 實例和ActionListener實例傳遞給異步方法：
client.getAsync(getRequest, listener);

　　3.3.2、批量查詢

public void getBulk(){
    MultiGetRequest request = new MultiGetRequest();
    request.add(new MultiGetRequest.Item("testindex", "e749eada74ca4ded8232bf1fcf65585e"));
    request.add(new MultiGetRequest.Item("testindex", "RUsu_nUB4hs2I-RuESpD"));
    request.add(new MultiGetRequest.Item("testindex", "Q0su_nUB4hs2I"));

    MultiGetResponse responses = null;
    try {
        responses = client.mget(request, RequestOptions.DEFAULT);
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 打印查詢結(jié)果
    System.out.println("MultiGetResponse:");
    responses.forEach(item -> System.out.println(item.getResponse().getSourceAsString()));
}

//異步執(zhí)行獲取索引請求需要將GetRequest 實例和ActionListener實例傳遞給異步方法：
client.mgetAsync(getRequest, listener);

　　3.3.3、高亮查詢

public void highLightSearch(){
    //條件搜索
    SearchRequest searchRequest = new SearchRequest("testindex");
    SearchSourceBuilder builder = new SearchSourceBuilder();
    //分頁
    builder.from(1);
    builder.size(5);

    TermQueryBuilder title = QueryBuilders.termQuery("testDesc", "新聞");
    builder.query(title);
    builder.timeout(new TimeValue(60, TimeUnit.SECONDS));

    HighlightBuilder highlightBuilder = new HighlightBuilder();
    //高亮的字段
    highlightBuilder.field("testDesc");
    //是否多個字段都高亮
    highlightBuilder.requireFieldMatch(false);
    //前綴后綴
    highlightBuilder.preTags("<span style='color:red'>");
    highlightBuilder.postTags("</span>");
    builder.highlighter(highlightBuilder);

    //執(zhí)行搜索
    searchRequest.source(builder);
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
    //解析結(jié)果
    ArrayList<Map<String,Object>> list = new ArrayList<>();
    for (SearchHit hit : searchResponse.getHits().getHits()) {
        //解析高亮的字段
        //獲取高亮字段
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        System.out.println("highlightFields=========="+"\n"+highlightFields);
        HighlightField testDesc = highlightFields.get("testDesc");
        System.out.println("testDesc=========="+"\n"+testDesc);
        //原來的結(jié)果
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        //將原來的字段替換為高亮字段即可
        if (testDesc!=null){
            Text[] fragments = testDesc.fragments();
            String newTitle = "";
            for (Text text : fragments) {
                newTitle +=text;
            }
            //替換掉原來的內(nèi)容
            sourceAsMap.put("testDesc",newTitle);
        }
        list.add(sourceAsMap);
    }
    System.out.println("搜索結(jié)果:總共"+list.size()+"條，分別是："+list);
}

//異步執(zhí)行獲取索引請求需要將GetRequest 實例和ActionListener實例傳遞給異步方法：
client.searchAsync(getRequest, listener);

　　3.3.4、復(fù)合查詢

　　待補(bǔ)充

posted on 2020-11-27 03:22 kosamino 閱讀(548) 評論(0) 收藏舉報

1、概述

Spring Data Elasticsearch

2、開發(fā)準(zhǔn)備

1、Maven 依賴

2、Dependencies

3、初始化

3、API文檔

3.1、索引管理

3.1.1、添加索引

3.1.2、刪除索引

3.1.3、關(guān)閉索引

3.1.4、打開索引

3.2、文檔管理

3.2.1、添加文檔

3.2.2、文檔是否存在

3.2.3、刪除文檔

3.2.4、更新文檔

3.2.4.1、局部更新

3.2.4.1、全部更新

ES的全部更新和局部更新，底層有什么區(qū)別?

3.2.4.3、更新不存在則插入upsert

3.2.5、批量更新文檔

3.3、文檔搜索

3.3.1、獲取一個文檔

3.3.2、批量查詢

3.3.3、高亮查詢

　　Spring Data Elasticsearch

2、開發(fā)準(zhǔn)備

　　1、Maven 依賴

　　2、Dependencies

　　3、初始化

　　3.1、索引管理

　　3.1.1、添加索引

　　3.1.2、刪除索引

　　3.1.3、關(guān)閉索引

　　3.1.4、打開索引

　　3.2、文檔管理

　　3.2.1、添加文檔

　　3.2.2、文檔是否存在

　　3.2.3、刪除文檔

　　3.2.4、更新文檔

　　3.2.4.1、局部更新

　　3.2.4.1、全部更新

　　ES的全部更新和局部更新，底層有什么區(qū)別?

　　3.2.4.3、更新不存在則插入upsert

　　3.2.5、批量更新文檔

　　3.3、文檔搜索

　　3.3.1、獲取一個文檔

　　3.3.2、批量查詢

　　3.3.3、高亮查詢