一、must查询

当查询中包含must查询时，相当于逻辑查询中的“与”查询。

命中的文档必须匹配该子查询的结果，并且ES会将该子查询与文档的匹配程度值加入总得分里。

must搜索包含一个数组，可以把其他的term级别的查询及布尔查询放入其中。

1.1 DSL方式

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [                //must查询，数组内可封装各类子查询
        {                      //第一个子查询：城市为北京
          "term": {
            "city": {
              "value": "北京"
            }
          }
        },
        {                    //第二个子查询：价格>=350且价格<=400  
          "range": {
            "price": {
              "gte": 350,
              "lte": 400
            }
          }
        }
      ]
    }
  }
}

1.2 Java 客户端方式

在Java客户端上构建must搜索时，可以使用QueryBuilders.boolQuery().must()进行构建

public void mustSearch(){
    SearchRequest searchRequest=new SearchRequest("hotel"); //新建请求
    SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
    BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
    //构建城市term查询
    TermQueryBuilder termQueryIsReady=QueryBuilders.termQuery("city","北京");
    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price").gte(350).lte(400);                              //构建价格range查询
    //进行关系“与”查询
    boolQueryBuilder.must(termQueryIsReady).must(rangeQueryBuilder);
    searchSourceBuilder.query(boolQueryBuilder);
    searchRequest.source(searchSourceBuilder);  //设置查询
   printResult(searchRequest);                  //打印结果
}

二、should查询

当查询中包含should查询时，表示当前查询为“或”查询。

命中的文档可以匹配该查询中的一个或多个子查询的结果，并且ES会将该查询与文档的匹配程度加入总得分里。

should查询包含一个数组，可以把其他的term级别的查询及布尔查询放入其中。

2.1 DSL方式

GET /hotel/_search
{
  "query": {
    "bool": {
      "should": [                  //shoud查询，数组内可封装各类子查询
        {                          //第一个子查询：城市为北京
          "term": {
            "city": {
              "value": "北京"
            }
          }
        },
        {                          //第二个子查询：城市为天津
          "term": {
            "city": {
              "value": "天津"
            }
          }
        }
      ]
    }
  }
}

2.2 Java 客户端方式

在Java客户端上构建should搜索时，可以使用QueryBuilders.boolQuery().should()进行构建

public void shouldSearch() {
    //新建搜索请求
    SearchRequest searchRequest = new SearchRequest("hotel");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    //构建城市为“北京”的term查询
    TermQueryBuilder termQueryIsReady = QueryBuilders.termQuery("city", "北京");
    //构建城市为“天津”的term查询
    TermQueryBuilder termQueryWritter = QueryBuilders.termQuery("city", "天津");
    //进行关系“或”查询
    boolQueryBuilder.should(termQueryIsReady).should(termQueryWritter);
    searchSourceBuilder.query(boolQueryBuilder);
    searchRequest.source(searchSourceBuilder);   //设置查询
   printResult(searchRequest);                   //打印结果
}

三、must not查询

当查询中包含must not查询时，表示当前查询为“非”查询。

命中的文档不能匹配该查询中的一个或多个子查询的结果，ES会将该查询与文档的匹配程度加入总得分里。

must not查询包含一个数组，可以把其他term级别的查询及布尔查询放入其中。

3.1 DSL方式

GET /hotel/_search
{
  "query": {
    "bool": {
      "must_not": [                  // must_not查询，数组内可封装各类子查询
        {                            //第一个子查询：城市为北京
          "term": {
            "city": {
              "value": "北京"
            }
          }
        },
        {                           //第二个子查询：城市为天津
          "term": {
         "city": {
              "value": "天津"
            }
          }
        }
      ]
    }
  }
}

3.2 Java 客户端方式

在Java客户端上构建must_not搜索时，可以使用QueryBuilders.boolQuery().mustNot()方法进行构建

public void mustNotSearch() {
    //新建搜索请求
    SearchRequest searchRequest = new SearchRequest("hotel");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    //构建城市为“北京”的term查询
    TermQueryBuilder termQueryIsReady = QueryBuilders.termQuery("city", "北京");
    //构建城市为“天津”的term查询
    TermQueryBuilder termQueryWritter = QueryBuilders.termQuery("city", "天津");
    //进行关系“必须不”查询
    boolQueryBuilder.mustNot(termQueryIsReady).mustNot(termQueryWritter);
    searchSourceBuilder.query(boolQueryBuilder);
    searchRequest.source(searchSourceBuilder);     //设置查询
   printResult(searchRequest);                     //打印结果
}

四、filter查询

filter查询即过滤查询，该查询是布尔查询里非常独特的一种查询。

其他布尔查询关注的是查询条件和文档的匹配程度，并按照匹配程度进行打分；

而filter查询关注的是查询条件和文档是否匹配，不进行相关的打分计算，但是会对部分匹配结果进行缓存。

4.1 DSL方式

GET /hotel/_search
{
  "query": {
    "bool": {
      "filter": [            // filter查询，数组内可封装各类子查询
        {                    //第一个子查询：城市为北京
          "term": {
            "city": "北京"
          }
        },
        {                    //第一个子查询：满房状态为否
          "term": {
            "full_room": false
          }
        }
      ]
    }
  }
}

以上是请求城市为北京并且未满房的酒店的查询结果。

4.2 Java 客户端方式

在Java客户端上构建filter搜索时，可以使用QueryBuilders.boolQuery().filter()进行构建

public void filterSearch() {
    SearchRequest searchRequest = new SearchRequest("hotel");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.filter( QueryBuilders.termQuery("city", "北京"));
    boolQueryBuilder.filter(QueryBuilders.termQuery("full_room", false));
    searchSourceBuilder.query(boolQueryBuilder);
    searchRequest.source(searchSourceBuilder);
    printResult(searchRequest);
}