這篇博文的主題是ES的查詢，因此我整理了盡可能齊全的ES查詢場景，形成下面的圖：

本文基于elasticsearch 7.13.2版本，es從7.0以后，發生了很大的更新。7.3以后，已經不推薦使用TransportClient這個client，取而代之的是Java High Level REST Client。

測試使用的數據示例

首先是，Mysql中的部分測試數據：

Mysql中的一行數據在ES中以一個文檔形式存在：

{
"_index":"person",
"_type":"_doc",
"_id":"4",
"_score":1.0,
"_source":{
"address":"峨眉山",
"modifyTime":"2021-06-291925",
"createTime":"2021-05-141107",
"sect":"峨嵋派",
"sex":"男",
"skill":"降龍十八掌",
"name":"宋青書",
"id":4,
"power":50,
"age":21
}
}

簡單梳理了一下ES JavaAPI的相關體系，感興趣的可以自己研讀一下源碼。

接下來，我們用十幾個實例，迅速上手ES的查詢操作，每個示例將提供SQL語句、ES語句和Java代碼。

1 詞條查詢

所謂詞條查詢，也就是ES不會對查詢條件進行分詞處理，只有當詞條和查詢字符串完全匹配時，才會被查詢到。

1.1 等值查詢-term

等值查詢，即篩選出一個字段等于特定值的所有記錄。

SQL：

select*frompersonwherename='張無忌';

而使用ES查詢語句卻很不一樣（注意查詢字段帶上keyword）：

GET/person/_search
{
"query":{
"term":{
"name.keyword":{
"value":"張無忌",
"boost":1.0
}
}
}
}

ElasticSearch 5.0以后，string類型有重大變更，移除了string類型，string字段被拆分成兩種新的數據類型: text用于全文搜索的，而keyword用于關鍵詞搜索。

查詢結果：

{
"took":0,
"timed_out":false,
"_shards":{//分片信息
"total":1,//總計分片數
"successful":1,//查詢成功的分片數
"skipped":0,//跳過查詢的分片數
"failed":0//查詢失敗的分片數
},
"hits":{//命中結果
"total":{
"value":1,//數量
"relation":"eq"//關系：等于
},
"max_score":2.8526313,//最高分數
"hits":[
{
"_index":"person",//索引
"_type":"_doc",//類型
"_id":"1",
"_score":2.8526313,
"_source":{
"address":"光明頂",
"modifyTime":"2021-06-291656",
"createTime":"2021-05-141633",
"sect":"明教",
"sex":"男",
"skill":"九陽神功",
"name":"張無忌",
"id":1,
"power":99,
"age":18
}
}
]
}
}

Java中構造ES請求的方式：（后續例子中只保留SearchSourceBuilder的構建語句）

/**
*term精確查詢
*
*@throwsIOException
*/

@Autowired
privateRestHighLevelClientclient;

@Test
publicvoidqueryTerm()throwsIOException{
//根據索引創建查詢請求
SearchRequestsearchRequest=newSearchRequest("person");
SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.termQuery("name.keyword","張無忌"));
System.out.println("searchSourceBuilder====================="+searchSourceBuilder);
searchRequest.source(searchSourceBuilder);
SearchResponseresponse=client.search(searchRequest,RequestOptions.DEFAULT);
System.out.println(JSONObject.toJSON(response));
}

仔細觀察查詢結果，會發現ES查詢結果中會帶有_score這一項，ES會根據結果匹配程度進行評分。打分是會耗費性能的，如果確認自己的查詢不需要評分，就設置查詢語句關閉評分：

GET/person/_search
{
"query":{
"constant_score":{
"filter":{
"term":{
"sect.keyword":{
"value":"張無忌",
"boost":1.0
}
}
},
"boost":1.0
}
}
}

Java構建查詢語句：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//這樣構造的查詢條件，將不進行score計算，從而提高查詢效率
searchSourceBuilder.query(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("sect.keyword","明教")));

1.2 多值查詢-terms

多條件查詢類似Mysql里的IN查詢，例如：

select*frompersonswheresectin('明教','武當派');

ES查詢語句：

GET/person/_search
{
"query":{
"terms":{
"sect.keyword":[
"明教",
"武當派"
],
"boost":1.0
}
}
}

Java實現：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.termsQuery("sect.keyword",Arrays.asList("明教","武當派")));
}

1.3 范圍查詢-range

范圍查詢，即查詢某字段在特定區間的記錄。

SQL:

select*frompesonswhereagebetween18and22;

ES查詢語句：

GET/person/_search
{
"query":{
"range":{
"age":{
"from":10,
"to":20,
"include_lower":true,
"include_upper":true,
"boost":1.0
}
}
}
}

Java構建查詢條件：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.rangeQuery("age").gte(10).lte(30));
}

1.4 前綴查詢-prefix

前綴查詢類似于SQL中的模糊查詢。

SQL：

select*frompersonswheresectlike'武當%';

ES查詢語句：

{
"query":{
"prefix":{
"sect.keyword":{
"value":"武當",
"boost":1.0
}
}
}
}

Java構建查詢條件：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.prefixQuery("sect.keyword","武當"));

1.5 通配符查詢-wildcard

通配符查詢，與前綴查詢類似，都屬于模糊查詢的范疇，但通配符顯然功能更強。

SQL：

select*frompersonswherenamelike'張%忌';

ES查詢語句：

{
"query":{
"wildcard":{
"sect.keyword":{
"wildcard":"張*忌",
"boost":1.0
}
}
}
}

Java構建查詢條件：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.wildcardQuery("sect.keyword","張*忌"));

2 復合查詢

前面的例子都是單個條件查詢，在實際應用中，我們很有可能會過濾多個值或字段。先看一個簡單的例子：

select*frompersonswheresex='女'andsect='明教';

這樣的多條件等值查詢，就要借用到組合過濾器了，其查詢語句是：

{
"query":{
"bool":{
"must":[
{
"term":{
"sex":{
"value":"女",
"boost":1.0
}
}
},
{
"term":{
"sect.keywords":{
"value":"明教",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"boost":1.0
}
}
}

Java構造查詢語句：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("sex","女"))
.must(QueryBuilders.termQuery("sect.keyword","明教"))
);

2.1 布爾查詢

布爾過濾器（bool filter）屬于復合過濾器（compound filter）的一種 ，可以接受多個其他過濾器作為參數，并將這些過濾器結合成各式各樣的布爾（邏輯）組合。

bool 過濾器下可以有4種子條件，可以任選其中任意一個或多個。filter是比較特殊的，這里先不說。

{
"bool":{
"must":[],
"should":[],
"must_not":[],
}
}

• must：所有的語句都必須匹配，與 ‘=’ 等價。
• must_not：所有的語句都不能匹配，與 ‘!=’ 或 not in 等價。
• should：至少有n個語句要匹配，n由參數控制。

精度控制：

所有 must 語句必須匹配，所有 must_not 語句都必須不匹配，但有多少 should 語句應該匹配呢？默認情況下，沒有 should 語句是必須匹配的，只有一個例外：那就是當沒有 must 語句的時候，至少有一個 should 語句必須匹配。

我們可以通過 minimum_should_match 參數控制需要匹配的 should 語句的數量，它既可以是一個絕對的數字，又可以是個百分比：

GET/person/_search
{
"query":{
"bool":{
"must":[
{
"term":{
"sex":{
"value":"女",
"boost":1.0
}
}
}
],
"should":[
{
"term":{
"address.keyword":{
"value":"峨眉山",
"boost":1.0
}
}
},
{
"term":{
"sect.keyword":{
"value":"明教",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"minimum_should_match":"1",
"boost":1.0
}
}
}

Java構建查詢語句：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("sex","女"))
.should(QueryBuilders.termQuery("address.word","峨眉山"))
.should(QueryBuilders.termQuery("sect.keyword","明教"))
.minimumShouldMatch(1)
);

最后，看一個復雜些的例子，將bool的各子句聯合使用：

select
*
from
persons
where
sex='女'
and
agebetween30and40
and
sect!='明教'
and
(address='峨眉山'ORskill='暗器')

用 Elasticsearch 來表示上面的 SQL 例子：

GET/person/_search
{
"query":{
"bool":{
"must":[
{
"term":{
"sex":{
"value":"女",
"boost":1.0
}
}
},
{
"range":{
"age":{
"from":30,
"to":40,
"include_lower":true,
"include_upper":true,
"boost":1.0
}
}
}
],
"must_not":[
{
"term":{
"sect.keyword":{
"value":"明教",
"boost":1.0
}
}
}
],
"should":[
{
"term":{
"address.keyword":{
"value":"峨眉山",
"boost":1.0
}
}
},
{
"term":{
"skill.keyword":{
"value":"暗器",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"minimum_should_match":"1",
"boost":1.0
}
}
}

用Java構建這個查詢條件：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
BoolQueryBuilderboolQueryBuilder=QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("sex","女"))
.must(QueryBuilders.rangeQuery("age").gte(30).lte(40))
.mustNot(QueryBuilders.termQuery("sect.keyword","明教"))
.should(QueryBuilders.termQuery("address.keyword","峨眉山"))
.should(QueryBuilders.rangeQuery("power.keyword").gte(50).lte(80))
.minimumShouldMatch(1);//設置should至少需要滿足幾個條件

//將BoolQueryBuilder構建到SearchSourceBuilder中
searchSourceBuilder.query(boolQueryBuilder);

2.2 Filter查詢

query和filter的區別：query查詢的時候，會先比較查詢條件，然后計算分值，最后返回文檔結果；而filter是先判斷是否滿足查詢條件，如果不滿足會緩存查詢結果（記錄該文檔不滿足結果），滿足的話，就直接緩存結果，filter不會對結果進行評分，能夠提高查詢效率。

filter的使用方式比較多樣，下面用幾個例子演示一下。

方式一，單獨使用：

{
"query":{
"bool":{
"filter":[
{
"term":{
"sex":{
"value":"男",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"boost":1.0
}
}
}

單獨使用時，filter與must基本一樣，不同的是filter不計算評分，效率更高。

Java構建查詢語句：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.filter(QueryBuilders.termQuery("sex","男"))
);

方式二，和must、must_not同級，相當于子查詢：

select*from(select*frompersonswheresect='明教'))awheresex='女';

ES查詢語句：

{
"query":{
"bool":{
"must":[
{
"term":{
"sect.keyword":{
"value":"明教",
"boost":1.0
}
}
}
],
"filter":[
{
"term":{
"sex":{
"value":"女",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"boost":1.0
}
}
}

Java：

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("sect.keyword","明教"))
.filter(QueryBuilders.termQuery("sex","女"))
);

方式三，將must、must_not置于filter下，這種方式是最常用的：

{
"query":{
"bool":{
"filter":[
{
"bool":{
"must":[
{
"term":{
"sect.keyword":{
"value":"明教",
"boost":1.0
}
}
},
{
"range":{
"age":{
"from":20,
"to":35,
"include_lower":true,
"include_upper":true,
"boost":1.0
}
}
}
],
"must_not":[
{
"term":{
"sex.keyword":{
"value":"女",
"boost":1.0
}
}
}
],
"adjust_pure_negative":true,
"boost":1.0
}
}
],
"adjust_pure_negative":true,
"boost":1.0
}
}
}

Java:

SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//構建查詢語句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.filter(QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("sect.keyword","明教"))
.must(QueryBuilders.rangeQuery("age").gte(20).lte(35))
.mustNot(QueryBuilders.termQuery("sex.keyword","女")))
);

3 聚合查詢

接下來，我們將用一些案例演示ES聚合查詢。

3.1 最值、平均值、求和

案例：查詢最大年齡、最小年齡、平均年齡。

SQL：

selectmax(age)frompersons;

ES：

GET/person/_search
{
"aggregations":{
"max_age":{
"max":{
"field":"age"
}
}
}
}

Java：

@Autowired
privateRestHighLevelClientclient;

@Test
publicvoidmaxQueryTest()throwsIOException{
//聚合查詢條件
AggregationBuilderaggBuilder=AggregationBuilders.max("max_age").field("age");
SearchRequestsearchRequest=newSearchRequest("person");
SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//將聚合查詢條件構建到SearchSourceBuilder中
searchSourceBuilder.aggregation(aggBuilder);
System.out.println("searchSourceBuilder----->"+searchSourceBuilder);

searchRequest.source(searchSourceBuilder);
//執行查詢，獲取SearchResponse
SearchResponseresponse=client.search(searchRequest,RequestOptions.DEFAULT);
System.out.println(JSONObject.toJSON(response));
}

使用聚合查詢，結果中默認只會返回10條文檔數據（當然我們關心的是聚合的結果，而非文檔）。返回多少條數據可以自主控制：

GET/person/_search
{
"size":20,
"aggregations":{
"max_age":{
"max":{
"field":"age"
}
}
}
}

而Java中只需增加下面一條語句即可：

searchSourceBuilder.size(20);

與max類似，其他統計查詢也很簡單：

AggregationBuilderminBuilder=AggregationBuilders.min("min_age").field("age");
AggregationBuilderavgBuilder=AggregationBuilders.avg("min_age").field("age");
AggregationBuildersumBuilder=AggregationBuilders.sum("min_age").field("age");
AggregationBuildercountBuilder=AggregationBuilders.count("min_age").field("age");

3.2 去重查詢

案例：查詢一共有多少個門派。

SQL：

selectcount(distinctsect)frompersons;

ES：

{
"aggregations":{
"sect_count":{
"cardinality":{
"field":"sect.keyword"
}
}
}
}

Java：

@Test
publicvoidcardinalityQueryTest()throwsIOException{
//創建某個索引的request
SearchRequestsearchRequest=newSearchRequest("person");
//查詢條件
SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//聚合查詢
AggregationBuilderaggBuilder=AggregationBuilders.cardinality("sect_count").field("sect.keyword");
searchSourceBuilder.size(0);
//將聚合查詢構建到查詢條件中
searchSourceBuilder.aggregation(aggBuilder);
System.out.println("searchSourceBuilder----->"+searchSourceBuilder);

searchRequest.source(searchSourceBuilder);
//執行查詢，獲取結果
SearchResponseresponse=client.search(searchRequest,RequestOptions.DEFAULT);
System.out.println(JSONObject.toJSON(response));
}

3.3 分組聚合

3.3.1 單條件分組

案例：查詢每個門派的人數

SQL：

selectsect,count(id)frommytest.personsgroupbysect;

ES：

{
"size":0,
"aggregations":{
"sect_count":{
"terms":{
"field":"sect.keyword",
"size":10,
"min_doc_count":1,
"shard_min_doc_count":0,
"show_term_doc_count_error":false,
"order":[
{
"_count":"desc"
},
{
"_key":"asc"
}
]
}
}
}
}

Java：

SearchRequestsearchRequest=newSearchRequest("person");
SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
searchSourceBuilder.size(0);
//按sect分組
AggregationBuilderaggBuilder=AggregationBuilders.terms("sect_count").field("sect.keyword");
searchSourceBuilder.aggregation(aggBuilder);

3.3.2 多條件分組

案例：查詢每個門派各有多少個男性和女性

SQL：

selectsect,sex,count(id)frommytest.personsgroupbysect,sex;

ES：

{
"aggregations":{
"sect_count":{
"terms":{
"field":"sect.keyword",
"size":10
},
"aggregations":{
"sex_count":{
"terms":{
"field":"sex.keyword",
"size":10
}
}
}
}
}
}

3.4 過濾聚合

前面所有聚合的例子請求都省略了 query ，整個請求只不過是一個聚合。這意味著我們對全部數據進行了聚合，但現實應用中，我們常常對特定范圍的數據進行聚合，例如下例。

案例：查詢明教中的最大年齡。這涉及到聚合與條件查詢一起使用。

SQL：

selectmax(age)frommytest.personswheresect='明教';

ES：

GET/person/_search
{
"query":{
"term":{
"sect.keyword":{
"value":"明教",
"boost":1.0
}
}
},
"aggregations":{
"max_age":{
"max":{
"field":"age"
}
}
}
}

Java：

SearchRequestsearchRequest=newSearchRequest("person");
SearchSourceBuildersearchSourceBuilder=newSearchSourceBuilder();
//聚合查詢條件
AggregationBuildermaxBuilder=AggregationBuilders.max("max_age").field("age");
//等值查詢
searchSourceBuilder.query(QueryBuilders.termQuery("sect.keyword","明教"));
searchSourceBuilder.aggregation(maxBuilder);

另外還有一些更復雜的查詢例子。

案例：查詢0-20，21-40，41-60，61以上的各有多少人。

SQL：

select
sum(casewhenage<=20then1else0end)ageGroup1,
sum(casewhenage>20andage<=40then1else0end)ageGroup2,
sum(casewhenage>40andage<=60then1else0end)ageGroup3,
sum(casewhenage>60andage<=200then1else0end)ageGroup4
from
mytest.persons;

ES：

{
"size":0,
"aggregations":{
"age_avg":{
"range":{
"field":"age",
"ranges":[
{
"from":0.0,
"to":20.0
},
{
"from":21.0,
"to":40.0
},
{
"from":41.0,
"to":60.0
},
{
"from":61.0,
"to":200.0
}
],
"keyed":false
}
}
}
}

查詢結果：

"aggregations":{
"age_avg":{
"buckets":[
{
"key":"0.0-20.0",
"from":0.0,
"to":20.0,
"doc_count":3
},
{
"key":"21.0-40.0",
"from":21.0,
"to":40.0,
"doc_count":13
},
{
"key":"41.0-60.0",
"from":41.0,
"to":60.0,
"doc_count":4
},
{
"key":"61.0-200.0",
"from":61.0,
"to":200.0,
"doc_count":1
}
]
}
}

以上是ElasticSearch查詢的全部內容，豐富詳實，堪比操作手冊，強烈建議收藏！

審核編輯 ：李倩