elasticsearch(es)高级查询api

蔚落 2024-03-25 13:35 97阅读 0赞

### 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，例如创建索引 ###

@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，与创建索引使用的请求对象不同 ###

@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();
      }

### 批量添加文档：批量做时，先创建一个BulkRequest的对象，可以将该对象理解为是一个保存request对象的容器，将所有的请求都初始化好后，添加到BulkRequest对象中，再使用BulkRequest对象的bulk方法，一次性执行完毕 ###

@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文档：根据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 {
        
            // 开始查询的记录数
            //页码
            Integer pageNum=1;
            //页数
            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 全部字段联合搜索 ###

@Test
        // MultiQuery 全部字段联合搜索 
        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 多字段联合搜索 ，使用多字段查询的时候，查询的字段要和查询的内容类型一直，不然就会报错，类似age字段是int类型，和name字段是string类型查询就会报错 ###

@Test
        // MultiQuery 多字段联合搜索
        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();
        }

### 多域联合查询的时候，可以通过 boost 来设置某个域在计算得分时候的比重，比重越高的域当他符合条件时计算的得分越高，相应的该记录也更靠前。通过在 fields 中给相应的字段用 ^权重倍数来实现 ###

@Test
        // MultiQuery 多字段联合搜索和设置权重
        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();
        }

### 如果我们既要对一些字段进行分词查询，同时要对另一些字段进行精确查询，就需要使用布尔查询来实现了。布尔查询对应于Lucene的BooleanQuery查询，实现将多个查询组合起来，有三个可选的参数：must：文档必须匹配must所包括的查询条件，相当于 “AND”should：文档应该匹配should所包括的查询条件其中的一个或多个，相当于 "OR"must\_not：文档不能匹配must\_not所包括的该查询条件，相当于“NOT” ###

```erlang
    GET user/_search
    {
        
        "query": {
        
            "bool": {
         // 布尔查询
                "must": [ // 查询条件 must 表示数组中的查询方式所规定的条件都必须满足
                    {
        
                        "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();
        }

### 定义过滤器查询，是在原本查询结果的基础上对数据进行筛选，因此省略了重新计算的分的步骤，效率更高。并且方便缓存。推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用，过滤器在布尔查询中使用，下边是在搜索结果的基础上进行过滤： ###

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();
        }

### 根据查询条件来删除 ###

@Test
        // 根据条件物理删除
        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数:"+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();
        }

### 创建索引并添加属性 ###

@Test
        // 创建索引并添加属性
        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();
    
                    // 添加整数类型字段
                    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>对象来存储异步操作的结果。然后，创建了一个ActionListener的匿名实现对象，并使用client.searchAsync()方法以异步方式执行搜索操作。在onResponse()方法中，将搜索结果存储到result Map中。如果异步响应失败，则使用onFailure()方法处理异常情况，并将错误消息存储到result Map中。  
> 最后，在异步操作完成之前，使用ResponseEntity.ok(result)返回一个HTTP 200 OK响应对象，并将result Map作为响应体返回给前端。

### 在Java中操作Elasticsearch进行异步搜索，如果需要等待搜索结果返回再继续执行，可以使用CompletableFuture来实现。具体步骤如下： ###

@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);
        }
    }