yml配置

  #es配置
spring:
  elasticsearch:
    rest:
      uris: 192.168.16.188:9200

添加依賴

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

使用編程的形式設置連接的ES服務器，并獲取客戶端對象，配置ES服務器地址與端口9200，記得客戶端使用完畢需要手工關閉。由于當前客戶端是手工維護的，因此不能通過自動裝配的形式加載對象

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootTest.class)
public class JeecgTest {
    @Test
//    @SneakyThrows
    public void name() {

        HttpHost host = HttpHost.create("http://localhost:9200");
        RestClientBuilder builder = RestClient.builder(host);

        client = new RestHighLevelClient(builder);

        try {
            client.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
   }
}

使用客戶端對象操作ES，例如創(chuàng)建索引

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootTest.class)
public class JeecgTest {
    private RestHighLevelClient client;
      @Test
      void testCreateIndex() throws IOException {
          HttpHost host = HttpHost.create("http://localhost:9200");
          RestClientBuilder builder = RestClient.builder(host);
          client = new RestHighLevelClient(builder);
        
          CreateIndexRequest request = new CreateIndexRequest("books");
          client.indices().create(request, RequestOptions.DEFAULT); 
        
          client.close();
      }
}

添加文檔，添加文檔使用的請求對象是IndexRequest，與創(chuàng)建索引使用的請求對象不同

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootTest.class)
public class JeecgTest {
    @Test
    public void testCreateIndex() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "張三");
        map.put("age", 20);
        IndexRequest request = new IndexRequest("user");
        String json = JSON.toJSONString(map);
        request.source(json, XContentType.JSON);
        IndexResponse index = client.index(request, RequestOptions.DEFAULT);
        client.close();
    }
}

/增量更新文檔

  @Test
  public void testUpdateDoc() throws IOException {
      HttpHost host = HttpHost.create("http://192.168.16.188:9200");
      RestClientBuilder builder = RestClient.builder(host);
      client = new RestHighLevelClient(builder);
      UpdateRequest updateRequest = new UpdateRequest("user", "88");
      updateRequest.timeout("1s");
      User user = new User();
      user.setAge(222);
      updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
      UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
      client.close();
  }

批量添加文檔：批量做時，先創(chuàng)建一個BulkRequest的對象，可以將該對象理解為是一個保存request對象的容器，將所有的請求都初始化好后，添加到BulkRequest對象中，再使用BulkRequest對象的bulk方法，一次性執(zhí)行完畢

    @Test
    //批量添加文檔
    public void testCreateDocAll() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        List<Map> list = new ArrayList<>();
        HashMap<String, Object> map = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            map.put("aa" + i, i);
            list.add(map);
        }
        BulkRequest bulk = new BulkRequest();
        for (Map map1 : list) {
            IndexRequest request = new IndexRequest("user");
            String json = JSON.toJSONString(map1);
            request.source(json, XContentType.JSON);
            bulk.add(request);
        }
        client.bulk(bulk, RequestOptions.DEFAULT);
        client.close();
    }

按id查詢1文檔：根據(jù)id查詢文檔使用的請求對象是GetRequest

    @Test
    //按id查詢
    public void getById() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        GetRequest request = new GetRequest("user", "88");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        String json = response.getSourceAsString();
        System.out.println(json);
        client.close();
    }

通過id查詢2

    @Test
    //按id查詢
    public void getById2() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("_id",88));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

按條件查詢文檔：按條件查詢文檔使用的請求對象是SearchRequest，查詢時調用SearchRequest對象的termQuery方法，需要給出查詢屬性名，此處支持使用合并字段，也就是前面定義索引屬性時添加的all屬性

    @Test
    //按條件查詢
    public void getBySearch() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchPhraseQuery("name","張三"));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

按條件高亮查詢

    @Test
    //按條件高亮查詢
    public void getBySearch2() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchPhraseQuery("name","張三"));
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        searchSourceBuilder.highlighter(highlightBuilder.field("name"));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields);
        }
        client.close();
    }

全文高亮查詢

    @Test
    //全文高亮查詢
    public void getBySearch2() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("張三"));
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        searchSourceBuilder.highlighter(highlightBuilder.field("*"));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields);
        }
        client.close();
    }

分頁查詢

    @Test
    //分頁查詢
    public void getBySearch3() throws IOException {
        // 開始查詢的記錄數(shù)
        //頁碼
        Integer pageNum=1;
        //頁數(shù)
        Integer pageSize=2;
        int start = (pageNum - 1) * pageSize;
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        searchSourceBuilder.from(start);
        searchSourceBuilder.size(pageSize);
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        client.close();
    }

MultiQuery 全部字段聯(lián)合搜索

    @Test
    // MultiQuery 全部字段聯(lián)合搜索 
    public void getBySearch4() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("三"));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

MultiQuery 多字段聯(lián)合搜索 ，使用多字段查詢的時候，查詢的字段要和查詢的內容類型一直，不然就會報錯，類似age字段是int類型，和name字段是string類型查詢就會報錯

    @Test
    // MultiQuery 多字段聯(lián)合搜索
    public void getBySearch5() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("王","name","file"));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

多域聯(lián)合查詢的時候，可以通過 boost 來設置某個域在計算得分時候的比重，比重越高的域當他符合條件時計算的得分越高，相應的該記錄也更靠前。通過在 fields 中給相應的字段用 ^權重倍數(shù)來實現(xiàn)

	@Test
    // MultiQuery 多字段聯(lián)合搜索和設置權重
    public void getBySearch6() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("廣","name","address").field("name",10));
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

如果我們既要對一些字段進行分詞查詢，同時要對另一些字段進行精確查詢，就需要使用布爾查詢來實現(xiàn)了。布爾查詢對應于Lucene的BooleanQuery查詢，實現(xiàn)將多個查詢組合起來，有三個可選的參數(shù)：must：文檔必須匹配must所包括的查詢條件，相當于 “AND”should：文檔應該匹配should所包括的查詢條件其中的一個或多個，相當于 "OR"must_not：文檔不能匹配must_not所包括的該查詢條件，相當于“NOT”

```erlang
GET user/_search
{
    "query": {
        "bool": { // 布爾查詢
            "must": [ // 查詢條件 must 表示數(shù)組中的查詢方式所規(guī)定的條件都必須滿足
                {
                    "multi_match": {
                        "query": "王小妹",
                        "minimum_should_match": "50%",
                        "fields": [
                            "name^10",
                            "title"
                        ]
                    }
                },
                {
                    "match": {
                        "address": "廣州"
                    }
                }
            ]
        }
    }
}

    @Test
    // 布爾查詢 BoolQuery
    public void getBySearch7() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 搜索方式
        // 首先構造多關鍵字查詢條件
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("王小妹", "name", "title").field("name", 10);
        // 然后構造匹配查詢條件
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "廣州");
        // 組合兩個條件，組合方式為 must 全滿足
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.must(matchQueryBuilder);
        // 將查詢條件封裝給查詢對象
        searchSourceBuilder.query(boolQueryBuilder);
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

定義過濾器查詢，是在原本查詢結果的基礎上對數(shù)據(jù)進行篩選，因此省略了重新計算的分的步驟，效率更高。并且方便緩存。推薦盡量使用過慮器去實現(xiàn)查詢或者過慮器和查詢共同使用，過濾器在布爾查詢中使用，下邊是在搜索結果的基礎上進行過濾：

GET user/_search
{
    "query": {
        "bool": {
            "must": [
                {
                    "multi_match": {
                        "query": "王小妹",
                        "minimum_should_match": "50%",
                        "fields": [
                            "name^10",
                            "title"
                        ]
                    }
                }
            ],
            "filter": [
                {
                    // 過濾條件：studymodel 必須是 201001
                    "match": {"address": "廣州"}
                },
                {
                    // 過濾條件：年齡 >=10 <=100
                    "range": {"age": {"gte": 10,"lte": 100}}
                }
            ]
        }
    }
}

    @Test
    // 過濾器
    public void getBySearch8() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 搜索方式
        // 首先構造多關鍵字查詢條件
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("王小妹", "name", "title").field("name", 10);
        // 構造匹配查詢條件
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "廣州");
        // 構造范圍查詢條件
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").gt(10).lt(100);
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.filter(matchQueryBuilder);
        boolQueryBuilder.filter(rangeQueryBuilder);
        // 將查詢條件封裝給查詢對象
        searchSourceBuilder.query(boolQueryBuilder);
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

注意：range和term一次只能對一個Field設置范圍過慮

排序，在查詢的結果上進行二次排序，支持對 keyword、date、float 等類型添加排序，text類型的字段不允許排序

GET user/_search
{
    "query": {
        "bool": {
            "filter": [
                {
                    "range": {
                        "age": {
                            "gte": 10,
                            "lte": 100
                        }
                    }
                }
            ]
        }
    },
    "sort": [
        {
            "age": "desc" 
        }
    ]
}

    @Test
    // 排序
    public void getBySearch9() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest request = new SearchRequest("user");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 構造范圍查詢條件
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").gt(10).lt(100);
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.filter(rangeQueryBuilder);
        searchSourceBuilder.sort("age", SortOrder.DESC);
        // 將查詢條件封裝給查詢對象
        searchSourceBuilder.query(boolQueryBuilder);
        request.source(searchSourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String source = hit.getSourceAsString();
            System.out.println(source);
        }
        client.close();
    }

根據(jù)查詢條件來刪除

@Test
    // 根據(jù)條件物理刪除
    public void deleteBySearch() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        DeleteByQueryRequest request = new DeleteByQueryRequest("efshdx"); // 替換成您的索引名稱
        MatchPhraseQueryBuilder matchPhraseQueryBuilder = QueryBuilders.matchPhraseQuery("catagoryId", "1640927455451201537");
        request.setQuery(matchPhraseQueryBuilder);
        BulkByScrollResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT); // 替換成您的Elasticsearch客戶端實例
        long deleted = response.getStatus().getDeleted();
        System.out.println("刪除掉的es數(shù):"+deleted);
        client.close();
    }

更新，或者新建屬性

    @Test
    // 使用es的Update Mapping API來更新日期映射,或者新建屬性
    public void updateDateMapping() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        PutMappingRequest request = new PutMappingRequest("person1"); // 替換成您的索引名稱
        XContentBuilder mappingBuilder = XContentFactory.jsonBuilder();
        mappingBuilder.startObject();
        {
            mappingBuilder.startObject("properties");
            {
                mappingBuilder.startObject("time1");
                {
                    mappingBuilder.field("type", "date");
                    mappingBuilder.field("format", "yyyy/MM/dd"); // 更新日期格式
                }
                mappingBuilder.endObject();
                mappingBuilder.startObject("time2");
                {
                    mappingBuilder.field("type", "date");
                    mappingBuilder.field("format", "yyyy/MM/dd"); // 更新日期格式
                }
                mappingBuilder.endObject();
            }
            mappingBuilder.endObject();
        }
        mappingBuilder.endObject();
        request.source(mappingBuilder);
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT); // 替換成您的Elasticsearch客戶端實例

        client.close();
    }

創(chuàng)建索引并添加屬性

@Test
    // 創(chuàng)建索引并添加屬性
    public void addIndexAndMapping() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        CreateIndexRequest request = new CreateIndexRequest("person1"); // 替換成您的索引名稱
        XContentBuilder mappingBuilder = XContentFactory.jsonBuilder();
        mappingBuilder.startObject();
        {
            mappingBuilder.startObject("properties");
            {
                // 添加字符串類型字段
                mappingBuilder.startObject("string-field");
                {
                    mappingBuilder.field("type", "text");
                }
                mappingBuilder.endObject();

                // 添加整數(shù)類型字段
                mappingBuilder.startObject("integer-field");
                {
                    mappingBuilder.field("type", "integer");
                }
                mappingBuilder.endObject();

                // 添加日期類型字段
                mappingBuilder.startObject("date-field");
                {
                    mappingBuilder.field("type", "date");
                    mappingBuilder.field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis");
                }
                mappingBuilder.endObject();

                // 添加嵌套類型字段
                mappingBuilder.startObject("nested-field");
                {
                    mappingBuilder.field("type", "nested");
                    mappingBuilder.startObject("properties");
                    {
                        mappingBuilder.startObject("nested-string-field");
                        {
                            mappingBuilder.field("type", "text");
                        }
                        mappingBuilder.endObject();
                    }
                    mappingBuilder.endObject();
                }
                mappingBuilder.endObject();
            }
            mappingBuilder.endObject();
        }
        mappingBuilder.endObject();
        request.mapping(mappingBuilder);
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT); // 替換成您的Elasticsearch客戶端實例

        client.close();
    }

單屬性多條件查詢，類似in查詢

@Test
    // 單屬性多條件查詢，類似in查詢
    public void queryByMultiFieldValue() throws IOException {
        HttpHost host = HttpHost.create("http://192.168.16.188:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
        SearchRequest searchRequest = new SearchRequest("person1"); // 替換成您的索引名稱
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<String> list = new ArrayList<>();
        list.add("我40");
        list.add("我50");
        TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("newName", list);
        searchSourceBuilder.query(termsQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT); // 替換成您的Elasticsearch客戶端實例
        client.close();
    }

在SpringMVC中，可以使用ResponseEntity對象將異步操作的結果返回給前端。以下是示例代碼：

@RestController
@RequestMapping("/es")
public class EsController {
    private final RestHighLevelClient client;

    @Autowired
    public EsController(RestHighLevelClient client) {
        this.client = client;
    }

    @PostMapping("/search")
    public ResponseEntity<Map<String, Object>> search(@RequestBody SearchRequest request) {
        Map<String, Object> result = new HashMap<>();

		CountDownLatch countDownLatch = new CountDownLatch(1);
        ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {
            @Override
            public void onResponse(SearchResponse searchResponse) {
                // 在這里處理異步響應結果
                SearchHits hits = searchResponse.getHits();
                Long total = hits.getTotalHits().value;
                List<Map<String, Object>> record = new ArrayList<>();
                for (SearchHit hit : hits) {
                    Map<String, Object> sourceAsString = hit.getSourceAsMap();
                    if (sourceAsString != null) {
                        sourceAsString.put("id", sourceAsString.get("metaId"));
                    }
                    record.add(sourceAsString);
                }
                result.put("record", record);
                result.put("total", total);
                countDownLatch.countDown();
            }

            @Override
            public void onFailure(Exception e) {
            countDownLatch.countDown();
                // 處理異步響應失敗情況
                result.put("error", e.getMessage());
            }
        };

        client.searchAsync(request, RequestOptions.DEFAULT, listener);
        countDownLatch.await();

        // 返回異步操作的結果
        return ResponseEntity.ok(result);
    }
}

在以上示例代碼中，定義了一個返回類型為ResponseEntity<Map<String, Object>>的/search POST映射方法，并使用Map<String, Object>對象來存儲異步操作的結果。然后，創(chuàng)建了一個ActionListener的匿名實現(xiàn)對象，并使用client.searchAsync()方法以異步方式執(zhí)行搜索操作。在onResponse()方法中，將搜索結果存儲到result Map中。如果異步響應失敗，則使用onFailure()方法處理異常情況，并將錯誤消息存儲到result Map中。
最后，在異步操作完成之前，使用ResponseEntity.ok(result)返回一個HTTP 200 OK響應對象，并將result Map作為響應體返回給前端。文章來源地址http://www.zghlxwxcb.cn/news/detail-406300.html

在Java中操作Elasticsearch進行異步搜索，如果需要等待搜索結果返回再繼續(xù)執(zhí)行，可以使用CompletableFuture來實現(xiàn)。具體步驟如下：

@RestController
@RequestMapping("/es")
public class EsController {
    private final RestHighLevelClient client;

    @Autowired
    public EsController(RestHighLevelClient client) {
        this.client = client;
    }

    @PostMapping("/search")
    public ResponseEntity<Map<String, Object>> search(@RequestBody SearchRequest request) {
        Map<String, Object> result = new HashMap<>();

		CompletableFuture<SearchResponse> future = new CompletableFuture<>();
        ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {
            @Override
            public void onResponse(SearchResponse searchResponse) {
                // 在這里處理異步響應結果
                SearchHits hits = searchResponse.getHits();
                Long total = hits.getTotalHits().value;
                List<Map<String, Object>> record = new ArrayList<>();
                for (SearchHit hit : hits) {
                    Map<String, Object> sourceAsString = hit.getSourceAsMap();
                    if (sourceAsString != null) {
                        sourceAsString.put("id", sourceAsString.get("metaId"));
                    }
                    record.add(sourceAsString);
                }
                result.put("record", record);
                result.put("total", total);
                future.complete(searchResponse);
            }

            @Override
            public void onFailure(Exception e) {
            future.completeExceptionally(e);
                // 處理異步響應失敗情況
                result.put("error", e.getMessage());
            }
        };

        client.searchAsync(request, RequestOptions.DEFAULT, listener);
        SearchResponse searchResponse = future.get();

        // 返回異步操作的結果
        return ResponseEntity.ok(result);
    }
}

到了這里，關于elasticsearch(es)高級查詢api的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！