前置文章：
Elasticsearch-RestClient基础

零、本文纲要

• 一、查询DSL
  0、基础查询语法
  1、查询所有&全文检索
  2、精确查询
  3、地理查询
  4、复合查询
• 二、搜索结果处理
  1、排序
  2、分页
  3、高亮
• 三、RestClient查询
  1、match_all查询
  2、全文检索查询
  3、精确查询
  4、复合查询
  5、排序和分页
  6、高亮
  7、距离排序
  8、组合查询

一、查询DSL

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。

• ① 查询所有：查询出所有数据，一般测试用。例如：match_all；
• ② 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：match_query、multi_match_query；
• ③ 精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：ids、range、term；
• ④ 地理（geo）查询：根据经纬度查询。例如：geo_distance、geo_bounding_box；
• ⑤ 复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：bool、function_score。

0、基础查询语法

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

1、查询所有&全文检索

• ① match_all查询所有

GET /indexName/_search
{
    "query": {
        "match_all": {}
    }
}

• ② match根据一个字段查询

GET /indexName/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

• ③ multi_match根据多个字段查询

GET /indexName/_search
{
  "query": {
    "multi_match" : {
      "query":    "TEXT",
      "fields": [ "FIELD1", "*FIELD2" ] 
    }
  }
}

实例：

# match_all查询所有
GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}
# match根据一个字段查询
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "外滩"
    }
  }
}
# multi_match根据多个字段查询
GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "外滩如家",
      "fields": ["name","brand","business"]
    }
  }
}

• ④ match和multi_match的区别

Ⅰ match：根据一个字段查询；
Ⅱ multi_match：根据多个字段查询，参与查询字段越多，查询性能越差。

2、精确查询

• ① term根据词条精确查询

GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

• ② range根据值的范围查询

GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": value,
        "lte": value
      }
    }
  }
}

实例：

# term根据词条精确查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "上海"
      }
    }
  }
}
# range根据值的范围查询
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 300,
        "lt": 350
      }
    }
  }
}

• ③ 常见的精确查询

Ⅰ term：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段；
Ⅱ range：根据数值范围查询，可以是数值、日期的范围。

3、地理查询

• ① geo_bounding_box矩形范围查询

GET /indexName/_search
{
  "query": {
        "geo_bounding_box": {
          "FIELD": { 
            "top_left": {
              "lat":  value,
              "lon": value
            },
            "bottom_right": {
              "lat":  value,
              "lon": value
            }
          }
        }
  }
}

• ② geo_distance圆形范围查询

GET /indexName/_search
{
  "query": {
        "geo_distance": {
          "distance": "XXkm", 
          "FIELD": { 
            "lat":  value,
            "lon": value
          }
        }
  }
}

实例：

# geo_bounding_box矩形范围查询
GET /hotel/_search
{
  "query": {
        "geo_bounding_box": {
          "location": { 
            "top_left": {
              "lat":  40.8,
              "lon": -74.0
            },
            "bottom_right": {
              "lat":  40.7,
              "lon": -73.0
            }
          }
        }
  }
}
# geo_distance圆形范围查询
GET /hotel/_search
{
  "query": {
        "geo_distance": {
          "distance": "1km", 
          "location": { 
            "lat":  40.715,
            "lon": -73.988
          }
        }
  }
}

4、复合查询

• ① function_score算分查询

官方文档：Function score query。

GET /indexName/_search
{
  "query": {
    "function_score": {
      "query": { "match": {"FIELD": "TEXT"} }, //原始查询条件
      "functions": [
        {
          "filter": { "term": { "FIELD": "TEXT" } }, //过滤条件
          "weight": VALUE //算分函数：script_score、weight、random_score、field_value_factor
        }
      ],
      "boost_mode": "MODE" //加权模式：multiply、replace、sum、avg、max、min
    }
  }
}

function_score query定义的三要素：
Ⅰ 过滤条件：哪些文档要加分；
Ⅱ 算分函数：如何计算function score；
Ⅲ 加权方式：function score 与 query score如何运算。

• ② bool query复合查询

官方文档：Boolean query。

GET /indexName/_search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "FIELD" : "TEXT" }
      },
      "filter": {
        "term" : { "FIELD" : "TEXT" }
      },
      "must_not" : {
        "range" : {
          "FIELD" : { "gte" : VALUE, "lte" : VALUE}
        }
      },
      "should" : [
        { "term" : { "FIELD" : "TEXT" } },
        { "term" : { "FIELD" : "TEXT" } }
      ],
      "minimum_should_match" : 1
    }
  }
}

bool query四种逻辑关系：
Ⅰ must：必须匹配的条件，可以理解为“与”；
Ⅱ should：选择性匹配的条件，可以理解为“或”；
Ⅲ must_not：必须不匹配的条件，不参与打分；
Ⅳ filter：必须匹配的条件，不参与打分。

二、搜索结果处理

1、排序

ES支持对搜索结果排序，默认是根据相关度算分（_score）来排序。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

GET /indexName/_search
{
  "query" : {
    "match_all" : { }
  },
  "sort" : [
    { "FIELD" : "MODE"} // desc、asc
  ]
}

GET /indexName/_search
{
  "query" : {
    "term" : { "user" : "kimchy" }
  },
  "sort" : [
    {
      "_geo_distance" : {
          "FIELD" : [lat, lon],
          "order" : "asc",
          "unit" : "km"
      }
    }
  ]
}

实例：

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "score": {
        "order": "desc"
      },
      "price": {
        "order": "asc"
      }
    }
  ]
}

# 121.612534,31.035087
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location": {
          "lat": 31.035087,
          "lon": 121.612534
        },
        "order": "asc",
        "unit": "km"
      }
    }
  ]
}

2、分页

ES默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。ES中通过修改from、size参数来控制要返回的分页结果。

GET /indexName/_search
{
  "query" : {
    "match_all" : { }
  },
  "from": PAGE,
  "size": PAGESIZE,
  "sort" : [
    { "FIELD" : "MODE"} // desc、asc
  ]
}

• ① from + size：
  优点：支持随机翻页
  缺点：深度分页问题，默认查询上限（from + size）是10000
  场景：百度、京东、谷歌、淘宝这样的随机翻页搜索
• ② after search：
  优点：没有查询上限（单次查询的size不超过10000）
  缺点：只能向后逐页查询，不支持随机翻页
  场景：没有随机翻页需求的搜索，例如手机向下滚动翻页
• ③ scroll：
  优点：没有查询上限（单次查询的size不超过10000）
  缺点：会有额外内存消耗，并且搜索结果是非实时的
  场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。

实例：

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ],
  "from": 0,
  "size": 5
}

3、高亮

高亮：就是在搜索结果中把搜索关键字突出显示。

GET /indexName/_search
{
    "query" : {
        "match" : {
            "FIELD" : "TEXT"
        }
    },
    "highlight": {
        "fields" : {
            "FIELD" : { // 指定高亮的字段
                "pre_tags": "<em>", //标记高亮字段的前置标签
                "post_tags": "</em>" //标记高亮字段的后置标签
            }
        }
    }
}

实例：

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}

三、RestClient查询

1、match_all查询

步骤：
① 获取request对象；
② 设置DSL语句；
③ 发送请求request，获取响应response；
④ 处理响应response，返回结果。

    @Test
    void matchAll(){
        try {
            // 1. 获取request对象
            SearchRequest request = new SearchRequest("hotel");

            // 2. 设置查询条件
            request.source()
                    .query(QueryBuilders.matchAllQuery());

            // 3. 发送请求，获得响应
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);

            // 4. 处理查询结果输出
            handleResponse(response);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

matchAll.png

封装处理响应的方法：

    private void handleResponse(SearchResponse response) throws IOException {
        // 4. 获取搜索内容
        long count = response.getHits().getTotalHits().value;
        System.out.println("搜索到的条数为：" + count + "条。");

        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            // 4.1 将资源json串转换为对象
            HotelDoc hotelDoc = JSON.parseObject(hit.getSourceAsString(), HotelDoc.class);
            // 4.2 打印输出对象
            System.out.println(hotelDoc);
        }
    }

处理响应.png

2、全文检索查询

• ① match单字段查询

            // 1. match 单字段查询
            QueryBuilders.matchQuery("all", "如家");

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  }
}

• ② multi_match多字段查询

            // 2. multiMatch 多字段查询
            QueryBuilders.multiMatchQuery("如家", "name", "business");

GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "如家",
      "fields": ["name","brand","business"]
    }
  }
}

3、精确查询

• ① term查询

            // 3. term 查询
            QueryBuilders.termQuery("city", "杭州");

GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "杭州"
      }
    }
  }
}

• ② range查询

            // 4. range 查询
            QueryBuilders.rangeQuery("price").gte(100).lte(300);

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lt": 300
      }
    }
  }
}

4、复合查询

            // 2. 设置DSL语句
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            // 2.1 添加must条件
            boolQuery.must(QueryBuilders.termQuery("name", "上海"));
            // 2.2 添加filter条件
            boolQuery.filter(QueryBuilders.rangeQuery("price").lte("250"));
            // 2.3 设置查询
            request.source()
                    .query(boolQuery);

复合查询.png

5、排序和分页

            // 2. 设置DSL语句
            request.source().query(QueryBuilders.matchQuery("name", "如家"));
            // 2.1 排序
            request.source().sort("price", SortOrder.ASC);
            // 2.2 分页
            request.source().from((page - 1) * pageSize).size(pageSize); // 此处from从0开始计数，第0条

排序和分页.png

6、高亮

• ① 高亮DSL准备

// 2.2 设置高亮结果
request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));

设置高亮结果.png

• ② 解析高亮结果

            // 3. 发送请求获取结果
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);

            long value = response.getHits().getTotalHits().value;
            System.out.println("查询到的结果条数为：" + value + "条。");

            // 4. 解析结果
            SearchHit[] hits = response.getHits().getHits();
            // 遍历解析封装
            for (SearchHit hit : hits) {
                // 4.1 获取hotelDoc对象
                HotelDoc hotelDoc = JSON.parseObject(hit.getSourceAsString(), HotelDoc.class);
                // 4.2 处理高亮
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                if (!CollectionUtils.isEmpty(highlightFields)){
                    // 4.2.1 获取高亮字段结果
                    HighlightField highlightField = highlightFields.get("name");
                    if (highlightField != null){
                        // 4.2.2 取出高亮结果数组中的第一个元素，就是酒店名称
                        String name = highlightField.getFragments()[0].toString();
                        hotelDoc.setName(name);
                    }
                }
                // 5. 打印结果
                System.out.println(hotelDoc);
            }

解析高亮结果.png

7、距离排序

// 2.3 距离排序
String location = params.getLocation();
if (location != null && !"".equals(location)){
    request.source().sort(SortBuilders
            .geoDistanceSort("location", new GeoPoint(location))
            .order(SortOrder.ASC)
            .unit(DistanceUnit.KILOMETERS)
    );
}

距离排序.png

8、组合查询

// 2. 算分控制
FunctionScoreQueryBuilder functionScoreQuery =
        QueryBuilders.functionScoreQuery(
                // 原始查询，相关性算分的查询
                boolQuery,
                // function score的数组
                new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        // 其中的一个function score元素
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                // 过滤条件
                                QueryBuilders.termQuery("isAD", true),
                                // 算分函数：权重算分相乘
                                ScoreFunctionBuilders.weightFactorFunction(10)
                        )
                });
request.source().query(functionScoreQuery);

image.png

四、结尾

以上即为Query DSL的部分内容，感谢阅读。