Elasticsearch7.x——High Level REST Client（二）Search/Sync Search APIs

最新推荐文章于 2023-11-15 11:25:29 发布
最新推荐文章于 2023-11-15 11:25:29 发布
阅读量315 收藏
点赞数 1
分类专栏： ElasticSearch 文章标签： Elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/133992853
版权

目录

7、Search APIs

7.1、SearchSourceBuilder

控制搜索行为的大多数选项都可以在SearchSourceBuilder上设置，它或多或少包含与Rest API的搜索请求体中的选项相当的选项。

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//查询语句
sourceBuilder.query(QueryBuilders.termQuery("user", "kimchy"));
//from
sourceBuilder.from(0);
//size
sourceBuilder.size(5);
//超时
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
7.1.1、排序（SortBuilder）

SearchSourceBuilder允许添加一个或多个SortBuilder实例。有四种特殊的实现：

  • FieldSortBuilder：字段排序
  • GeoDistanceSortBuilder：Geo距离排序
  • ScoreSortBuilder：评分排序
  • ScriptSortBuilder：脚本排序
//评分排序
sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
//字段排序
sourceBuilder.sort(new FieldSortBuilder("id").order(SortOrder.ASC));
7.1.2、字段过滤
//不获取_source字段
sourceBuilder.fetchSource(false);
//通过includes和exclude过滤
String[] includeFields = new String[] {"title", "innerObject.*"};
String[] excludeFields = new String[] {"user"};
sourceBuilder.fetchSource(includeFields, excludeFields);
7.1.3、高亮

突出显示搜索结果可以通过在SearchSourceBuilder上设置HighlightBuilder来实现。通过添加一个或多个HighlightBuilder，可以为每个字段定义不同的突出显示行为。

//创建一个HighlightBuilder
HighlightBuilder highlightBuilder = new HighlightBuilder();
//创建一个高亮字段
HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title");
//设置字段高亮显示类型
highlightTitle.highlighterType("unified");
//将字段高亮添加到高亮器中
highlightBuilder.field(highlightTitle);
//第二个高亮字段
HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");
//添加到高亮器
highlightBuilder.field(highlightUser);
//高亮器加入到builder
sourceBuilder.highlighter(highlightBuilder);
7.1.4、聚合

聚合可以通过首先创建适当的AggregationBuilder，然后在SearchSourceBuilder上设置它来添加到搜索中

//创建一个聚合Builder，指定集合类型、字段
TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_company")
        .field("company.keyword");
//子聚合
aggregation.subAggregation(AggregationBuilders.avg("average_age")
        .field("age"));
//加入到Builder
sourceBuilder.aggregation(aggregation);
7.1.5、Profile API

Profile API可用于分析特定搜索请求的查询和聚合的执行情况。为了使用它，profile标志必须在SearchSourceBuilder上设置为true:

SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.profile(true);

7.2、QueryBuilder

搜索查询是使用QueryBuilder对象创建的。QueryBuilder存在于Elasticsearch的查询DSL支持的每种搜索查询类型。

共有两种创建方式：

  • 使用构造函数new一个
MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("user", "kimchy");
matchQueryBuilder.fuzziness(Fuzziness.AUTO); 
matchQueryBuilder.prefixLength(3); 
matchQueryBuilder.maxExpansions(10);
  • 使用QueryBuilders工具类创建
QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")
                                                .fuzziness(Fuzziness.AUTO)
                                                .prefixLength(3)
                                                .maxExpansions(10);
7.2.1、简单查询
//查询所有
MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
//词项查询
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "hello");
//全文检索
QueryBuilders.matchQuery("content", "content")
        .analyzer("english");//设置分词器
//分词查询
QueryBuilders.matchPhraseQuery("content", "content")
        .slop(2);//指定slop
//前缀分词匹配
QueryBuilders.matchBoolPrefixQuery("conotnet", "con")
        .maxExpansions(1);//最大匹配数
//多字段 搜索title、content字段中的hello
QueryBuilders.multiMatchQuery("hello", "title", "content")
        .field("title", 1.2f);//指定字段权重
//query_string
QueryBuilders.queryStringQuery("(title:Reversus) OR (content:Nanette)")
        .field("content", 1.2f);//指定字段权重
//query_string升级版：使用 +、|、- 代替 AND、OR、NOT 等。
QueryBuilders.simpleQueryStringQuery("lake + street")
        .field("content");
//词项查询
QueryBuilders.termQuery("title.keyword", "hello");
//多词项查询
QueryBuilders.termsQuery("title.keyword", "value1", "value2");
//范围查询
QueryBuilders.rangeQuery("age")
        .gte("18")
        .lte("28");
//非空查询
QueryBuilders.existsQuery("content");
//前缀匹配
QueryBuilders.prefixQuery("content", "prefix_value");
//通配符查询
QueryBuilders.wildcardQuery("content", "h?ll*");
//正则查询
QueryBuilders.regexpQuery("content", "na.*");
//模糊查询
QueryBuilders.fuzzyQuery("title", "javo");
//多id查询
QueryBuilders.idsQuery()
        .addIds("1", "2", "3");
7.2.2、复合查询
7.2.2.1、constant_score query——无关词频的查询
@Test
public void constant_score_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("bank");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * constant_score query 无关词频的查询
     * GET /bank/_search
     * {
     *   "query": {
     *     "constant_score": {
     *       "filter": {
     *         "match": {
     *           "employer": "Chillium"
     *         }
     *       },
     *       "boost": 1.2
     *     }
     *   }
     * }
     */ 
    ConstantScoreQueryBuilder queryBuilder = QueryBuilders.constantScoreQuery(
            QueryBuilders.matchQuery("employer", "Chillium")
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println(response.toString());
}
7.2.2.2、bool query——逻辑组合查询
@Test
public void bool_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("bank");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * bool query——逻辑组合查询
     * GET /bank/_search
     * {
     *   "query": {
     *     "bool": {
     *       "must": [
     *         {
     *           "match": {
     *             "address": "street"
     *           }
     *         }
     *       ],
     *       "should": [
     *         {
     *           "term": {
     *             "balance": {
     *               "value": 1
     *             }
     *           }
     *         }
     *       ],
     *       "must_not": [
     *         {
     *           "range": {
     *             "age": {
     *               "gte": 20,
     *               "lte": 39
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   },
     *   "from": 0,
     *   "size": 2
     * }
     */
    BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .must(QueryBuilders.matchQuery("address", "street"))
            .should(QueryBuilders.termQuery("balance", 1))
            .mustNot(QueryBuilders.rangeQuery("age").gte(20).lte(39));
    sourceBuilder.query(queryBuilder).from(0).size(2);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println(response.toString());
}
7.2.2.3、dis_max query——分离最大化查询
@Test
public void dis_max_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("blog");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * dis_max query——分离最大化查询
     * GET /blog/_search
     * {
     *   "query": {
     *     "dis_max": {
     *       "tie_breaker": 0.7,
     *       "boost": 1.2,
     *       "queries": [
     *         {
     *           "match": {
     *             "title": "java解决方案"
     *           }
     *         },
     *         {
     *           "match": {
     *             "content": "java解决方案"
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.disMaxQuery()
            .tieBreaker(0.7f)
            .boost(1.2f)
            .add(QueryBuilders.matchQuery("title", "java解决方案"))
            .add(QueryBuilders.matchQuery("content", "java解决方案"));

    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println(response.toString());
}
7.2.2.4、function_score query——自定义评分
@Test
public void function_score_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("blog");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * function_score query——自定义评分
     * GET /blog/_search
     * {
     *   "query": {
     *     "function_score": {
     *       "query": {
     *         "match": {
     *           "title": "java"
     *         }
     *       },
     *       "functions": [
     *         {
     *           "weight": 10
     *         }
     *       ]
     *     }
     *   }
     * }
     */

    WeightBuilder weightBuilder = ScoreFunctionBuilders.weightFactorFunction(10);
    FunctionScoreQueryBuilder.FilterFunctionBuilder[] filterFunctionBuilders = new FunctionScoreQueryBuilder.FilterFunctionBuilder[1];
    filterFunctionBuilders[0] = new FunctionScoreQueryBuilder.FilterFunctionBuilder(weightBuilder);
    QueryBuilder queryBuilder = QueryBuilders.functionScoreQuery(
            QueryBuilders.matchQuery("title", "java"),
            filterFunctionBuilders
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println(response.toString());
}
7.2.2.5、boosting query——子句加权查询
@Test
public void boosting_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("blog");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * boosting query——子句加权查询
     * GET /blog/_search
     * {
     *   "query": {
     *     "boosting": {
     *       "positive": {
     *         "match": { "title": "java" }
     *       },
     *       "negative": {
     *         "term": { "votes": 10 }
     *       },
     *       "negative_boost": 0.5
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.boostingQuery(
            QueryBuilders.matchQuery("title", "java"),
            QueryBuilders.termQuery("votes", 10)
    ).negativeBoost(0.5f);

    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println(response.toString());
}
7.2.2.6、has_child query——子查父
@Test
public void has_child_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("stu_class");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * has_child query——子查父
     * GET /stu_class/_search
     * {
     *   "query": {
     *     "has_child": {
     *       "type": "student",
     *       "query": {
     *         "match": {
     *           "name": "wangwu"
     *         }
     *       }
     *     }
     *   }
     * }
     */
    HasChildQueryBuilder queryBuilder = new HasChildQueryBuilder(
            "student",
            QueryBuilders.matchQuery("name", "wangwu"),
            ScoreMode.Max
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.2.7、has_parent query——父查子
@Test
public void has_parent_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("stu_class");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * has_parent query——父查子
     * GET /stu_class/_search
     * {
     *   "query": {
     *     "has_parent": {
     *       "parent_type": "class",
     *       "query": {
     *         "match": {
     *           "name": "一班"
     *         }
     *       }
     *     }
     *   }
     * }
     */
    HasParentQueryBuilder queryBuilder = new HasParentQueryBuilder(
            "class",
            QueryBuilders.matchQuery("name", "一班"),
            false
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.2.8、parent_id——父id查子文档
@Test
public void parent_id() throws IOException {
    SearchRequest searchRequest = new SearchRequest("stu_class");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * parent_id——父id查子文档
     * GET /stu_class/_search
     * {
     *   "query": {
     *     "parent_id": {
     *       "type": "student",
     *       "id": 2
     *     }
     *   }
     * }
     */
    ParentIdQueryBuilder queryBuilder = new ParentIdQueryBuilder(
            "student",
            "2"
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.2.9、nested query——嵌套查询
@Test
public void nested_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("movies");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * nested query——嵌套查询
     * GET /movies/_search
     * {
     *   "query": {
     *     "nested": {
     *       "path": "actors",
     *       "query": {
     *         "bool": {
     *           "must": [
     *             {
     *               "match": {
     *                 "actors.name": "张国荣"
     *               }
     *             },
     *             {
     *               "match": {
     *                 "actors.gender": "男"
     *               }
     *             }
     *           ]
     *         }
     *       }
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.nestedQuery(
            "actors",
            QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("actors.name", "张国荣"))
                .must(QueryBuilders.matchQuery("actors.gender", "男")),
            ScoreMode.Max
    );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.3、地理位置查询
7.2.3.1、geo_distance query
@Test
public void geo_distance_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("geo");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * geo_distance query
     * GET /geo/_search
     * {
     *   "query": {
     *     "bool": {
     *       "must": [
     *         {
     *           "match_all": {}
     *         }
     *       ],
     *       "filter": [
     *         {
     *           "geo_distance": {
     *             "distance": "600km",
     *             "location": {
     *               "lat": 34.288991865037524,
     *               "lon": 108.9404296875
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .must(QueryBuilders.matchAllQuery())
            .filter(
              QueryBuilders.geoDistanceQuery("location")
                    .distance("600km")
                    .point(34.288991865037524d, 108.9404296875d)
            );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.3.2、geo_bounding_box query
@Test
public void geo_bounding_box_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("geo");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * geo_bounding_box_query
     * GET /geo/_search
     * {
     *   "query": {
     *     "bool": {
     *       "must": [
     *         {
     *           "match_all": {}
     *         }
     *       ],
     *       "filter": [
     *         {
     *           "geo_bounding_box": {
     *             "location": {
     *               "top_right": {
     *                 "lat": 32.0639555946604,
     *                 "lon": 118.78967285156249
     *               },
     *               "bottom_left": {
     *                 "lat": 29.98824461550903,
     *                 "lon": 122.20642089843749
     *               }
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .must(QueryBuilders.matchAllQuery())
            .filter(
                    QueryBuilders.geoBoundingBoxQuery("location")
                        .setCornersOGC(
                                new GeoPoint(29.98824461550903d, 122.20642089843749d),
                                new GeoPoint(32.0639555946604d, 118.78967285156249d)
                        )
            );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.3.3、geo_polygon query
@Test
public void geo_polygon_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("geo");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * geo_polygon query
     * GET /geo/_search
     * {
     *   "query": {
     *     "bool": {
     *       "must": [
     *         {
     *           "match_all": {}
     *         }
     *       ],
     *       "filter": [
     *         {
     *           "geo_polygon": {
     *             "location": {
     *               "points": [
     *                 {
     *                   "lat": 31.793755581217674,
     *                   "lon": 113.8238525390625
     *                 },
     *                 {
     *                   "lat": 30.007273923504556,
     *                   "lon": 114.224853515625
     *                 },
     *                 {
     *                   "lat": 30.007273923504556,
     *                   "lon": 114.8345947265625
     *                 }
     *               ]
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    List<GeoPoint> list = new ArrayList<>();
    list.add(new GeoPoint(31.793755581217674d, 113.8238525390625d));
    list.add(new GeoPoint(30.007273923504556d, 114.224853515625));
    list.add(new GeoPoint(30.007273923504556d, 114.8345947265625d));
    QueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .must(QueryBuilders.matchAllQuery())
            .filter(
                    QueryBuilders.geoPolygonQuery(
                            "location",
                            list
                    )
            );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.3.4、geo_shape query
@Test
public void geo_shape_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("geo_shape");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * geo_shape query
     * GET /geo_shape/_search
     * {
     *   "query": {
     *     "bool": {
     *       "must": [
     *         {
     *           "match_all": {}
     *         }
     *       ],
     *       "filter": [
     *         {
     *           "geo_shape": {
     *             "location": {
     *               "shape": {
     *                 "type": "envelope",
     *                 "coordinates": [
     *                   [
     *                     106.5234375,
     *                     36.80928470205937
     *                   ],
     *                   [
     *                     115.3344726625,
     *                     32.24997445586331
     *                   ]
     *                 ]
     *               },
     *               "relation": "within"
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .must(QueryBuilders.matchAllQuery())
            .filter(
                    QueryBuilders.geoShapeQuery(
                            "location",
                            new Rectangle(106.5234375, 115.3344726625, 36.80928470205937,32.24997445586331 )
                    ).relation(ShapeRelation.WITHIN)
            );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.4、特殊查询
7.2.4.1、more_like_this query——基于内容的推荐
@Test
public void more_like_this_query() throws IOException{
    SearchRequest searchRequest = new SearchRequest("bank");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * more_like_this query——基于内容的推荐
     * GET /bank/_search
     * {
     *   "query": {
     *     "more_like_this": {
     *       "fields": [
     *         "address"
     *       ],
     *       "like": "madison street",
     *       "min_term_freq": 1,
     *       "max_query_terms": 12
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery(
            new String[]{"address"},
            new String[]{"madison street"},
            null
    ).minTermFreq(1).maxQueryTerms(12);
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.2.4.2、script query——脚本查询
@Test
public void script_query() throws IOException {
    SearchRequest searchRequest = new SearchRequest("bank");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    /**
     * script query——脚本查询
     * GET /bank/_search
     * {
     *   "query": {
     *     "bool": {
     *       "filter": [
     *         {
     *           "script": {
     *             "script": {
     *               "lang": "painless",
     *               "source": "doc['age'].value > 39"
     *             }
     *           }
     *         }
     *       ]
     *     }
     *   }
     * }
     */
    QueryBuilder queryBuilder = QueryBuilders.boolQuery()
            .filter(
                    QueryBuilders.scriptQuery(
                            new Script(
                                    ScriptType.INLINE,
                                    "painless",
                                    "doc['age'].value > 39",
                                    new HashMap<>()
                            )
                    )
            );
    sourceBuilder.query(queryBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}

7.3、Search API

@Test
public void search_test() throws IOException {
    //最基本的形式:
    //创建SearchRequest。如果没有参数，这将对所有索引运行。
    SearchRequest searchRequest = new SearchRequest("bank");
    //构建搜索参数
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //添加一个match_all查询
    searchSourceBuilder.query(QueryBuilders.matchAllQuery());
    //添加到请求
    searchRequest.source(searchSourceBuilder);
    //同步请求
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
}
7.3.1、提交请求

同步提交：

SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

异步提交：

ActionListener<SearchResponse> listener = new ActionListener<SearchResponse>() {
    @Override
    public void onResponse(SearchResponse searchResponse) {
        //成功
    }

    @Override
    public void onFailure(Exception e) {
        //失败
    }
};

client.searchAsync(searchRequest, RequestOptions.DEFAULT, listener);
7.3.2、响应(SearchResponse)
7.3.2.1、普通响应信息

普通响应信息：

//响应
//Http状态码
RestStatus status = searchResponse.status();
//花费的时间
TimeValue took = searchResponse.getTook();
//是否提前中止
Boolean terminatedEarly = searchResponse.isTerminatedEarly();
//是否超时
boolean timedOut = searchResponse.isTimedOut();
//搜索影响的总分片数
int totalShards = searchResponse.getTotalShards();
//搜索成功的分片数
int successfulShards = searchResponse.getSuccessfulShards();
//搜索失败的分片数
int failedShards = searchResponse.getFailedShards();
//分片上的失败信息
for (ShardSearchFailure failure : searchResponse.getShardFailures()) {
    // failures should be handled here
    System.out.println(failure.getMessage());
}
7.3.2.2、命中的结果信息

响应中包含的SearchHits:

//搜索结果
SearchHits hits = searchResponse.getHits();
//SearchHits提供了关于所有命中的全局信息，如命中总数或最高分数:
TotalHits totalHits = hits.getTotalHits();
//总的命中数
long numHits = totalHits.value;
//命中数是准确的(equal_to)，还是总数的下限(greater_than_equal_to)
TotalHits.Relation relation = totalHits.relation;
//最高评分
float maxScore = hits.getMaxScore();
//遍历单个搜索结果
SearchHit[] searchHits = hits.getHits();
for (SearchHit hit : searchHits) {
    //SearchHit提供访问基本信息，如索引、文档ID和每个搜索命中的分数:
    String index = hit.getIndex();
    String id = hit.getId();
    float score = hit.getScore();
    //以简单的JSON-String返回文档源。
    String sourceAsString = hit.getSourceAsString();
    //以map键/值对映射的形式返回文档源。常规字段由字段名作为关键字，并包含字段值。
    //多值字段作为对象列表返回，嵌套对象作为另一个map键/值映射返回。
    Map<String, Object> sourceAsMap = hit.getSourceAsMap();
    String documentTitle = (String) sourceAsMap.get("title");
    List<Object> users = (List<Object>) sourceAsMap.get("user");
    Map<String, Object> innerObject = (Map<String, Object>) sourceAsMap.get("innerObject");
}
7.3.2.3、高亮信息
//如果请求包含高亮字段，hit对象提供了对HighlightField实例的字段名映射的访问，
//每个实例包含一个或多个高亮文本片段:
for (SearchHit hit : hits.getHits()) {
    Map<String, HighlightField> highlightFields = hit.getHighlightFields();
    //获取title字段的高亮显示
    HighlightField highlight = highlightFields.get("title");
    //获取一个或多个包含突出显示的字段内容的片段
    Text[] fragments = highlight.fragments();
    String fragmentString = fragments[0].string();
}
7.3.2.4、聚合信息
//通过首先获取聚合树的根，即aggregs对象，然后按名称获取聚合，可以从SearchResponse中检索聚合
Aggregations aggregations = searchResponse.getAggregations();
//根据名称，获取by_company terms聚合
Terms byCompanyAggregation = aggregations.get("by_company");
//获取Elastic相关的桶
Terms.Bucket elasticBucket = byCompanyAggregation.getBucketByKey("Elastic");
//从该桶获取average_age子聚合
Avg averageAge = elasticBucket.getAggregations().get("average_age");
//获取值
double avg = averageAge.getValue();

//注意，如果通过名称访问聚合，需要根据你请求的聚合类型指定聚合接口，否则将抛出ClassCastException:
Range range = aggregations.get("by_company");

//还可以将所有聚合作为由聚合名称键控的映射来访问。在这种情况下，需要显式地转换到适当的聚合接口:
Map<String, Aggregation> aggregationMap = aggregations.getAsMap();
Terms companyAggregation = (Terms) aggregationMap.get("by_company");

//也可以将所有顶级聚合作为列表返回:
List<Aggregation> aggregationList = aggregations.asList();

//可以遍历所有的聚合，然后决定如何根据它们的类型进一步处理它们:
for (Aggregation agg : aggregations) {
    String type = agg.getType();
    if (type.equals(TermsAggregationBuilder.NAME)) {
        Terms.Bucket bucket = ((Terms) agg).getBucketByKey("Elastic");
        long numberOfDocs = bucket.getDocCount();
    }
}

7.4、Search Scroll API

Scroll API可用于从搜索请求中检索大量结果。

@Test
public void search_scroll() throws IOException {
    //1.初始化搜索滚动上下文
    SearchRequest searchRequest = new SearchRequest("bank");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.matchQuery("address", "street"))
                        .size(2);//一次检索多少结果
    searchRequest.source(searchSourceBuilder);
    //设置滚动间隔
    searchRequest.scroll(TimeValue.timeValueMinutes(1L));
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
    //读取返回的滚动id，它指向正在保持活动状态的搜索上下文，并将在下一个搜索滚动调用中用到它
    String scrollId = searchResponse.getScrollId();
    //第一批结果
    SearchHits hits = searchResponse.getHits();
    SearchHit[] searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        System.out.println(hit.getSourceAsString());
    }

    //第二步：设置返回的scrollId和新的滚动间隔，延续滚动上下文
    SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
    scrollRequest.scroll(TimeValue.timeValueSeconds(30));
    SearchResponse searchScrollResponse = client.scroll(scrollRequest, RequestOptions.DEFAULT);
    //读取新的滚动id，它指向正在保持活动的搜索上下文，并将在下一个搜索滚动调用中使用
    scrollId = searchScrollResponse.getScrollId();
    //第二批结果
    hits = searchScrollResponse.getHits();
    searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        System.out.println(hit.getSourceAsString());
    }

    //第三步：重复第二步
    scrollRequest.scrollId(scrollId);
    scrollRequest.scroll(TimeValue.timeValueSeconds(30));
    searchScrollResponse = client.scroll(scrollRequest, RequestOptions.DEFAULT);
    //读取滚动id
    scrollId = searchScrollResponse.getScrollId();
    searchHits = hits.getHits();
    for (SearchHit hit : searchHits) {
        System.out.println(hit.getSourceAsString());
    }


    //最后：清除滚动上下文
    ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
    clearScrollRequest.addScrollId(scrollId);
    ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
    System.out.println(clearScrollResponse.isSucceeded());
}
7.4.1、异步请求
ActionListener<SearchResponse> scrollListener =
        new ActionListener<SearchResponse>() {
    @Override
    public void onResponse(SearchResponse searchResponse) {
        
    }

    @Override
    public void onFailure(Exception e) {
        
    }
};

client.scrollAsync(scrollRequest, RequestOptions.DEFAULT, scrollListener);
7.4.2、完整示例
@Test
public void scroll_example() throws IOException {
    final Scroll scroll = new Scroll(TimeValue.timeValueMinutes(1L));
    SearchRequest searchRequest = new SearchRequest("posts");
    searchRequest.scroll(scroll);
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(matchQuery("title", "Elasticsearch"));
    searchRequest.source(searchSourceBuilder);

    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
    String scrollId = searchResponse.getScrollId();
    SearchHit[] searchHits = searchResponse.getHits().getHits();

    while (searchHits != null && searchHits.length > 0) {

        SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
        scrollRequest.scroll(scroll);
        searchResponse = client.scroll(scrollRequest, RequestOptions.DEFAULT);
        scrollId = searchResponse.getScrollId();
        searchHits = searchResponse.getHits().getHits();
    }

    ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
    clearScrollRequest.addScrollId(scrollId);
    ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
    boolean succeeded = clearScrollResponse.isSucceeded();
}

7.5、Multi-Search API

multiSearch API在单个http请求中并行执行多个搜索请求。

@Test
public void multi_search() throws IOException {
    //MultiSearchRequest是空的，可以添加所有想要执行的搜索
    MultiSearchRequest request = new MultiSearchRequest();
    //第一个请求
    SearchRequest firstSearchRequest = new SearchRequest("bank");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.matchQuery("address", "street"));
    firstSearchRequest.source(searchSourceBuilder);
    request.add(firstSearchRequest);
    //第二个请求
    SearchRequest secondSearchRequest = new SearchRequest("person");
    searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.termQuery("name", "tom"));
    secondSearchRequest.source(searchSourceBuilder);
    request.add(secondSearchRequest);
    //发送请求
    MultiSearchResponse response = client.msearch(request, RequestOptions.DEFAULT);
}
7.5.1、响应(MultiSearchResponse)
MultiSearchResponse.Item[] responses = response.getResponses();
for (MultiSearchResponse.Item item : responses) {
    //每个item都包含一个searchResponse
    SearchResponse searchResponse = item.getResponse();
    System.out.println(searchResponse.toString());
}

7.6、Search Template API

搜索模板API允许从基于mustache语言的模板执行搜索，也允许预览呈现的模板。

7.6.1、Mustache模板语法

Mustache 是一种轻量级的模板语言，它的语法简洁易懂。以下是 Mustache 的语法规则：

  1. 变量替换

Mustache 用 {{ 和}} 表示变量的替换，例如：

Hello, {{name}}!

在渲染时，{{name}} 会被替换成相应的值，例如：

Hello, John!
  1. 列表迭代

使用{{#}} 和 {{/}} 来表示列表迭代，例如：

<ul>
{{#items}}
  <li>{{.}}</li>
{{/items}}
</ul>

在渲染时，items列表中的每个元素都会被替换成相应的 <li> 元素。

  1. 条件判断

使用 {{#}} 和 {{/} 来表示条件判断，例如：

{{#show}}
  This is shown!
{{/show}}

如果 show 的值为真，则会显示 This is shown!。

  1. 反转条件判断

使用 {{^}} 和 {{/}} 来表示反转条件判断，例如：

{{^hide}}
  This is shown!
{{/hide}}

如果 hide 的值为假，则会显示 This is shown!。

  1. HTML转义

在变量替换时，Mustache 会自动对 HTML 进行转义，以防止 XSS 攻击。如果想要显示 HTML 标签，可以使用三个大括号 {{{ 和 }}} 来表示不转义的变量替换，例如：

{{{html}}}
  1. 注释

使用{{! comment }} 来表示注释，例如：

{{! This is a comment. }}
7.6.2、模板搜索
@Test
public void search_template() throws IOException {
    SearchTemplateRequest request = new SearchTemplateRequest();
    request.setRequest(new SearchRequest("bank"));
    //模板类型
    request.setScriptType(ScriptType.INLINE);
    //模板定义搜索源的结构。它作为字符串传递，因为mustache模板并不总是有效的JSON。
    request.setScript(
            "{" +
                "  \"query\": { \"match\" : { \"{{field}}\" : \"{{value}}\" } }," +
                "  \"size\" : \"{{size}}\"" +
            "}");
    //填充参数
    Map<String, Object> scriptParams = new HashMap<>();
    scriptParams.put("field", "address");
    scriptParams.put("value", "street");
    scriptParams.put("size", 2);
    request.setScriptParams(scriptParams);

    SearchTemplateResponse response = client.searchTemplate(request, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.6.3、注册模板

搜索模板可以通过存储脚本API提前注册。注意，存储的脚本API在高级REST客户端中还不可用，因此在本例中我们使用低级REST客户端。

@Test
public void registered_template() throws IOException {
    Request scriptRequest = new Request("POST", "_scripts/bank_search");
    scriptRequest.setJsonEntity(
            "{" +
                    "  \"script\": {" +
                    "    \"lang\": \"mustache\"," +
                    "    \"source\": {" +
                    "      \"query\": { \"match\" : { \"{{field}}\" : \"{{value}}\" } }," +
                    "      \"size\" : \"{{size}}\"" +
                    "    }" +
                    "  }" +
                    "}");
    //低级客户端注册
    Response scriptResponse = restClient.performRequest(scriptRequest);
    //请求中不需要提供内联脚本，可以直接引用这个已经注册的模板
    SearchTemplateRequest request = new SearchTemplateRequest();
    request.setRequest(new SearchRequest("bank"));
    //模板类型
    request.setScriptType(ScriptType.STORED);
    request.setScript("bank_search");
    //填充参数
    Map<String, Object> params = new HashMap<>();
    params.put("field", "address");
    params.put("value", "street");
    params.put("size", 3);
    request.setScriptParams(params);
    //高级客户端调用
    SearchTemplateResponse response = client.searchTemplate(request, RequestOptions.DEFAULT);
    System.out.println(response.toString());
}
7.6.4、渲染模板、可选参数及响应

渲染模板：给定参数值，可以在不执行搜索的情况下呈现模板

request.setSimulate(true);

SearchTemplateResponse response = client.searchTemplate(request, RequestOptions.DEFAULT);
System.out.println(response.toString());
//没有搜索结果，只渲染模板
System.out.println(new String(response.getSource().array()));
//{"size":"2","query":{"match":{"address":"street"}}}

可选参数：

request.setExplain(true);
request.setProfile(true);

响应：SearchResponse

SearchTemplateResponse response = client.searchTemplate(request, RequestOptions.DEFAULT);
SearchResponse searchResponse = response.getResponse();

7.7、Multi-Search Template API

multiSearchTemplate API在单个http请求中并行执行多个搜索模板请求。

@Test
public void multi_search_template() throws IOException {
    String [] searchTerms = {"street", "hello"};

    MultiSearchTemplateRequest multiRequest = new MultiSearchTemplateRequest();
    for (String searchTerm : searchTerms) {
        SearchTemplateRequest request = new SearchTemplateRequest();
        request.setRequest(new SearchRequest("bank"));

        request.setScriptType(ScriptType.INLINE);
        request.setScript(
                "{" +
                        "  \"query\": { \"match\" : { \"{{field}}\" : \"{{value}}\" } }," +
                        "  \"size\" : \"{{size}}\"" +
                        "}");

        Map<String, Object> scriptParams = new HashMap<>();
        scriptParams.put("field", "address");
        scriptParams.put("value", searchTerm);
        scriptParams.put("size", 1);
        request.setScriptParams(scriptParams);

        multiRequest.add(request);
    }

    MultiSearchTemplateResponse response = client.msearchTemplate(multiRequest, RequestOptions.DEFAULT);
    for (MultiSearchTemplateResponse.Item item : response.getResponses()) {
        if (item.isFailure()) {
            System.out.println(item.getFailureMessage());
        } else {
            SearchTemplateResponse searchTemplateResponse = item.getResponse();
            System.out.println(searchTemplateResponse.toString());
        }
    }
}

7.8、Field Capabilities API

Field Capabilities API允许跨多个索引检索字段的功能。

FieldCapabilitiesRequest包含一个要获取功能的字段列表(应该返回)，以及一个可选的目标索引列表。如果没有提供索引，请求将在所有索引上执行。

注意fields参数支持通配符表示法。例如，提供text_*将导致返回与表达式匹配的所有字段。

@Test
public void field_capabilities() throws IOException {
    FieldCapabilitiesRequest request = new FieldCapabilitiesRequest()
            .fields("address")//检索的字段
            .indices("bank", "person");//索引列表
    //控制如何解析不可用的索引以及如何扩展通配符表达式。
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    FieldCapabilitiesResponse response = client.fieldCaps(request, RequestOptions.DEFAULT);

    //获取address字段的响应
    Map<String, FieldCapabilities> userResponse = response.getField("address");
    //address字段包含type为text的所有索引
    FieldCapabilities textCapabilities = userResponse.get("text");

    //是否可搜索
    boolean isSearchable = textCapabilities.isSearchable();
    //是否可聚合
    boolean isAggregatable = textCapabilities.isAggregatable();
    //所有索引
    String[] indices = textCapabilities.indices();
    //不可搜索的索引
    String[] nonSearchableIndices = textCapabilities.nonSearchableIndices();
    //不可聚合的索引
    String[] nonAggregatableIndices = textCapabilities.nonAggregatableIndices();

    System.out.println(isSearchable);
    System.out.println(isAggregatable);
    System.out.println(indices);
    System.out.println(nonSearchableIndices);
    System.out.println(nonAggregatableIndices);
}

7.9、Ranking Evaluation API

Ranking Evaluation API允许在一组搜索请求上评估排名搜索结果的质量。给定针对每个搜索请求的手动评级文档集，排名评估执行多个搜索请求并计算信息检索指标，如返回结果的平均倒数排名、精度或折扣累积增益。

为了构建RankEvalRequest，首先需要创建一个评估规范(RankEvalSpec)。该规范需要定义将要计算的评估度量，以及每个搜索请求的评级文档列表。创建排名评估请求，然后将规范和目标索引列表作为参数

@Test
public void ranking_evaluation() throws IOException {
    //为了构建RankEvalRequest，您首先需要创建一个评估规范(RankEvalSpec)。
    //该规范需要定义将要计算的评估度量，以及每个搜索请求的评级文档列表。
    //创建排名评估请求，然后将规范和目标索引列表作为参数:

    //创建评估中使用的度量
    EvaluationMetric metric = new PrecisionAtK();
    List<RatedDocument> ratedDocs = new ArrayList<>();
    //添加评级文档，由索引名称、id和评级指定
    ratedDocs.add(new RatedDocument("bank", "1", 1));
    //创建查询
    SearchSourceBuilder searchQuery = new SearchSourceBuilder();
    searchQuery.query(QueryBuilders.matchQuery("address", "street"));
    //将前三个部分组合成一个RatedRequest
    RatedRequest ratedRequest = new RatedRequest("bank_query", ratedDocs, searchQuery);
    List<RatedRequest> ratedRequests = Arrays.asList(ratedRequest);
    //创建排名评估规范
    RankEvalSpec specification = new RankEvalSpec(ratedRequests, metric);
    //创建排名评估请求
    RankEvalRequest request = new RankEvalRequest(specification, new String[] { "bank" });

    RankEvalResponse response = client.rankEval(request, RequestOptions.DEFAULT);

    //通过执行请求返回的RankEvalResponse包含有关总体评估分数的信息、
    //查询集合中每个单独搜索请求的分数、关于搜索命中的详细信息以及关于每个部分结果的度量计算的详细信息。

    System.out.println(response.toString());
    //综合评价结果
    double evaluationResult = response.getMetricScore();
    Map<String, EvalQueryQuality> partialResults = response.getPartialResults();
    //按查询key入关键字的部分结果
    EvalQueryQuality evalQuality = partialResults.get("bank_query");
    //每个部分结果的度量分数
    double qualityLevel = evalQuality.metricScore();
    //评级搜索命中包含一个完全成熟的搜索命中
    List<RatedSearchHit> hitsAndRatings = evalQuality.getHitsAndRatings();
    RatedSearchHit ratedSearchHit = hitsAndRatings.get(2);
    MetricDetail metricDetails = evalQuality.getMetricDetails();
    String metricName = metricDetails.getMetricName();
    PrecisionAtK.Detail detail = (PrecisionAtK.Detail) metricDetails;
}

7.10、Explain API

explain api计算查询和特定文档的分数解释。这可以提供有用的反馈，无论文档是否匹配特定查询。

一个ExplainRequest需要一个索引和一个id来指定一个特定的文档，以及一个由QueryBuilder表示的查询来针对它运行(构建查询的方式)。

@Test
public void explain_request() throws IOException {
    //ExplainRequest需要一个索引和一个id来指定一个特定的文档，
    //以及一个由QueryBuilder表示的查询
    ExplainRequest request = new ExplainRequest("bank", "2");
    request.query(QueryBuilders.matchQuery("address", "place"));
    //可选参数：
    // request.routing("routing");
    // //preference
    // request.preference("_local");
    // //是否获取_sourece字段
    // request.fetchSourceContext(new FetchSourceContext(true));
    // //store_fields
    // request.storedFields(new String[]{"age"});
    ExplainResponse response = client.explain(request, RequestOptions.DEFAULT);

    //被解释的索引id
    String index = response.getIndex();
    //被解析的文档id
    String id = response.getId();
    //被解析的文档是否存在
    boolean exists = response.isExists();
    //指示所解释的文档和所提供的查询之间是否存在匹配
    //(如果lucene解释建模匹配，则返回true，否则返回false，则从后台的lucene解释中检索匹配)。
    boolean match = response.isMatch();
    //指示是否存在此请求的lucene解释。
    boolean hasExplanation = response.hasExplanation();
    //获取lucene解释对象(如果存在)。
    Explanation explanation = response.getExplanation();
    //如果检索到_source或存储字段，则获取GetResult对象。
    GetResult getResult = response.getGetResult();
    //GetResult内部包含两个映射，用于存储获取的_source和存储的字段
    Map<String, Object> source = getResult.getSource();
    Map<String, DocumentField> fields = getResult.getFields();

}

7.11、Count API

CountRequest用于执行查询并获取查询的匹配数。在CountRequest中使用的查询可以用与使用SearchSourceBuilder的SearchRequest中的查询类似的方式设置。

@Test
public void count() throws IOException {
    //创建CountRequest。如果没有参数，这将对所有索引运行。
    CountRequest countRequest = new CountRequest("bank");
            // .routing("routing")//路由
            // .indicesOptions(IndicesOptions.lenientExpandOpen())//索引不存在或扩展匹配
            // .preference("_local");//分片
    //创建一个查询
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.termQuery("age", 22));
    //添加到countrequest
    countRequest.source(searchSourceBuilder);

    CountResponse countResponse = client.count(countRequest, RequestOptions.DEFAULT);

    //命中数量
    long count = countResponse.getCount();
    //HTTP状态码
    RestStatus status = countResponse.status();
    //是否提前中止
    Boolean terminatedEarly = countResponse.isTerminatedEarly();
    //分片级别的执行信息
    int totalShards = countResponse.getTotalShards();
    int skippedShards = countResponse.getSkippedShards();
    int successfulShards = countResponse.getSuccessfulShards();
    int failedShards = countResponse.getFailedShards();
    for (ShardSearchFailure failure : countResponse.getShardFailures()) {

    }
    System.out.println(count);
}

8、Async Search APIs

8.1、Submit Async Search API

SubmitAsyncSearchRequest允许向集群提交异步搜索任务。必需的参数是定义搜索和目标索引的SearchSourceBuilder:

@Test
public void submit_async_search() throws IOException {
    SearchSourceBuilder searchSource = new SearchSourceBuilder()
            .query(QueryBuilders.matchAllQuery());
    String[] indices = new String[] { "bank" };
    SubmitAsyncSearchRequest request = new SubmitAsyncSearchRequest(searchSource, indices);
    //参数
    //等待的最小时间(默认为1秒)
    request.setWaitForCompletionTimeout(TimeValue.timeValueSeconds(30));
    //请求的过期时间(默认为5天)。
    request.setKeepAlive(TimeValue.timeValueMinutes(15));
    //控制如果请求在提供的wait_for_completion时间内完成，是否应该存储结果(默认:false)
    request.setKeepOnCompletion(true);
    //执行请求并以AsyncSearchResponse对象的形式获取响应。
    AsyncSearchResponse response = client.asyncSearch().submit(request, RequestOptions.DEFAULT);

    //SubmitAsyncSearchRequest的异步执行允许在提交请求返回时使用ActionListener回调。
    //注意，这与提交的搜索请求的执行无关，后者总是异步执行的。然而，侦听器等待提交请求本身返回:
    client.asyncSearch()
            .submitAsync(request, RequestOptions.DEFAULT, new ActionListener<AsyncSearchResponse>() {
                @Override
                public void onResponse(AsyncSearchResponse asyncSearchResponse) {

                }

                @Override
                public void onFailure(Exception e) {

                }
            });

    //响应
    //SearchResponse，如果还不可用，则为null
    response.getSearchResponse();
    //异步搜索请求的id，如果没有存储响应，则为空
    response.getId();
    //当响应包含部分结果时为True
    response.isPartial();
    //是否正在运行搜索
    response.isRunning();
    //创建响应的时间
    response.getStartTime();
    //响应到期的时间
    response.getExpirationTime();
    //失败元音，没有则为null
    response.getFailure();
    System.out.println(response.getId());//FnNWTmNhNi1FUXlPNFdISUZpUGVKMHcbd0kydHMzMVdTeVNjM0lEVE5LNlNFUTo1MDc4
    System.out.println(response.getStartTime());//1698162470049
    System.out.println(response.getExpirationTime());//1698163370049
}

8.2、Get Async Search API

GetAsyncSearchRequest允许通过其id获取正在运行的异步搜索任务。必选参数是正在运行的异步搜索的id:

@Test
public void get_async_search() throws IOException {
    GetAsyncSearchRequest request = new GetAsyncSearchRequest("FnNWTmNhNi1FUXlPNFdISUZpUGVKMHcbd0kydHMzMVdTeVNjM0lEVE5LNlNFUTo1MDc4");
    //请求在返回部分结果之前应该等待的最小时间(默认为不等待)。
    request.setWaitForCompletion(TimeValue.timeValueSeconds(30));
    //请求的过期时间(默认为无)
    request.setKeepAlive(TimeValue.timeValueMinutes(15));

    //同步执行
    AsyncSearchResponse response = client.asyncSearch().get(request, RequestOptions.DEFAULT);

    //异步执行
    client.asyncSearch()
            .getAsync(request, RequestOptions.DEFAULT, new ActionListener<AsyncSearchResponse>() {
                @Override
                public void onResponse(AsyncSearchResponse asyncSearchResponse) {

                }

                @Override
                public void onFailure(Exception e) {

                }
            });

    //响应
    //SearchResponse，如果还不可用，则为null
    response.getSearchResponse();
    //异步搜索请求的id，如果没有存储响应，则为null
    response.getId();
    //当响应包含部分结果时为True
    response.isPartial();
    //在搜索还在进行的时候true
    response.isRunning();
    //创建响应的时间(从epoch算起的毫秒)
    response.getStartTime();
    //响应到期的时间(从epoch算起的毫秒)
    response.getExpirationTime();
    //获取失败原因，如果没有失败则为null
    response.getFailure();

    System.out.println(response.toString());
}

8.3、Delete Async Search API

DeleteAsyncSearchRequest允许使用其id删除正在运行的异步搜索任务。必选参数是正在运行的搜索的id

@Test
public void delete_async_search() throws IOException {
    DeleteAsyncSearchRequest request = new DeleteAsyncSearchRequest("FnNWTmNhNi1FUXlPNFdISUZpUGVKMHcbd0kydHMzMVdTeVNjM0lEVE5LNlNFUTo1MDc4");

    //同步提交
    AcknowledgedResponse response = client.asyncSearch().delete(request, RequestOptions.DEFAULT);

    //异步提交
    client.asyncSearch()
            .deleteAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
                @Override
                public void onResponse(AcknowledgedResponse acknowledgedResponse) {

                }

                @Override
                public void onFailure(Exception e) {

                }
            });

    //响应
    System.out.println(response.isAcknowledged());
}
吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch 使用 High Level REST Client 实现搜索等功能实战
Java知音
06-29 854
点击关注公众号，实用技术文章及时了解ES 全称 Elasticsearch 是一款分布式的全文搜索引擎，在互联网公司中，这款搜索引擎一直被程序员们所推崇。常见的使用场景如ELK日志分析，电商APP的商品推荐，社交APP的同城用户推荐等等。在ES的官网文档中，目前主要提供了两种方式访问，一种叫做Low Client，一种叫做High Level Rest Client。在今...
ElasticSearch-RestHighLevelClient常用查询总结
孟孟的博客
04-03 4659
match、match_phrase、query_string、wildcard、regexp、term、terms、nested、range等相关查询总结 ES相关查询Java版本： import cn.hutool.core.collection.ListUtil; import org.apache.lucene.search.join.ScoreMode; import org.elasticsearch.index.query.BoolQueryBuilder; import org.e
使用RestHighLevelClient方式操作Elasticsearch详细步骤 建议收藏
jonssonyan
10-08 9801
一、Maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency>
RestHighLevelClient操作7.10.0（一）ElasticSearch 连接配置
xuzai
12-22 6647
ES 的更新速度非常快，官方推出的 Java 客户端 elasticsearch-rest-high-level-client，它的代码写法跟 DSL 语句很相似，这里我们就采用这种方式进行演练。 RestHighLevelClient操作7.10.0（一）ElasticSearch 连接配置一、查询官方文档二、Maven 引入相关依赖三、ElasticSearch 连接配置1、application.yml 配置文件2、ES 连接参数类3、初始化RestHighLevelClient对象四、swagge.
elasticsearch学习（七）：es客户端RestHighLevelClient
热门推荐
weixin_40482816的博客
09-24 3万+
Java Low Level REST Client：ES官方的低级客户端。低级别的客户端通过http与Elasticearch集群通信。Java High Level REST Client：ES官方的高级客户端。基于上面的低级客户端，也是通过HTTP与ES集群进行通信。它提供了更多的接口。客户端(Client) Jar包的版本尽量不要大于Elasticsearch本体的版本，否则可能出现客户端中使用的某些API在Elasticsearch中不支持。
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
elasticsearch-rest-high-level-client-6.8.3-API文档-中英对照版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
elasticsearch-rest-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-client-6.8.3-sources.jar； 赠送Maven依赖信息文件：elastic...
elasticsearch-rest-client-6.3.0-API文档-中英对照版.zip
06-12
赠送jar包：elasticsearch-rest-client-6.3.0.jar； 赠送原API文档：elasticsearch-rest-client-6.3.0-javadoc.jar； 赠送源代码：elasticsearch-rest-client-6.3.0-sources.jar； 赠送Maven依赖信息文件：elastic...
Elasticsearch 7.x 单机多node部署步骤 X-Pack设置用户密码+安装包
08-24
**Elasticsearch 7.x 单机多node部署步骤** 在Elasticsearch 7.x版本中，单机多node部署是一种常见的优化方案，用于提高数据处理能力。以下是一步步的详细部署过程： 1. **环境准备**: 首先确保你的系统支持...
Elasticsearch文档操作:初学者指南(2023年最新版包含DSL语句的使用和RestHighLevelClient在Java中的使用)
Jacob的博客
05-23 1345
Elasticsearch是一个分布式的RESTful搜索和分析引擎。它是建立在Lucene之上的，Lucene是一个强大的全文搜索引擎。Elasticsearch被设计为可伸缩、容错和易于使用。它被各种各样的组织使用，包括eBay、思Cisco和Spotify。本文提供了在ES中的分别使用原始DSL语句和JavaRestClient实现的CRUD的概述。最后,本文概述了Elasticsearch如何分别使用DSL语句和RestHighLevelClient处理文档。
实用篇-ES-RestClient操作文档
最新发布
keke的博客
11-15 696
实用篇-ES-RestClient操作文档
ElasticSearch RestHighLevelClient 通用操作
大树叶 技术专栏
07-27 6066
项目中使用到ElasticSearch作为搜索引擎。而ES的环境搭建自然是十分简单，且本身就适应于分布式环境，因此这块就不多赘述。而其本身特性和查询语句这篇博文不会介绍，如果有机会会深入介绍。 ​ 所以这篇博文主要还是介绍Java客户端中如何使用查询搜索引擎中的数据。而使用的Java客户端是官方新推出的RestHighLevelClient，使用Http连接查询结果。但是网上相关资料较少，只有官...
Elasticsearch --- RestAPI、RestClient操作文档
乌云的博客
04-28 1240
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。
Elasticsearch7学习笔记——RestHighLevelClient连接
a316883923的博客
10-26 2150
需要的JAR包 <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>7.14.2</version> </dependency> <dependency> <groupId>org.elastic
51、ElasticSearch RestHighLevelClient 索引库、文档
weixin_40968009的博客
11-20 832
ElasticSearch RestHighLevelClient 关于索引库、文档增删改查API
ELK系列——7.0.0 elasticsearch-rest-high-level-client踩坑记（六）
qq_40384985的博客
05-08 4839
前记：今天要用java来连es集群查数据，目前连es的常用办法一般有两种： 1：elasticsearch-rest-high-level-client（这个会随着es的版本同步更新） 2：spring-boot-starter-data-elasticsearch（这个是spring做的es集成包，更新不会很及时） 我习惯用第一种方式，今天在引入的时候： <dep...
Java elasticsearch 7+ 版本 High Level REST Client 使用实例（史上es最全讲解）
Meetyouhere的博客
11-21 7937
elastic search理解（以下 简称es） ES(ElasticSearch)是一款分布式全文检索框架，底层基于基于Lucene实现。ES相当于一个数据库，有 index type 属性，index 是索引，相当于数据库的一张表 ，type 是文档，相当于数据库中的行，包含很多字段。与数据库相比更加智能，有很多全文检索方式。 es相关插件 1.kibana 这是一个e...
Elasticsearch rest-high-level-client 基本操作
qq_34285557的博客
10-25 4443
Elasticsearch rest-high-level-client 基本操作 本篇主要讲解一下 rest-high-level-client 去操作 Elasticsearch , 虽然这个客户端在后续版本中会慢慢淘汰,但是目前大部分公司中使用Elasticsearch 版本都是6.x 所以这个客户端还是有一定的了解 前置准备 准备一个SpringBoot环境 2.2.11 版本 准备一个Elasticsearch 环境 我这里是8.x版本 引入依赖 elasticsearch-rest
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值