"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-29 16:48:56",
"createTime" : "2021-05-14 16:50:33",
"sect" : "明教",
"sex" : "男",
"skill" : "九阳神功",
"name" : "张无忌",
"id" : 1,
"power" : 99,
"age" : 18
}
}
]
}
}
**Java中构造ES请求的方式：**（后续例子中只保留SearchSourceBuilder的构建语句）
/**
-
term精确查询
-
@throws IOException
*/
@Autowired
private RestHighLevelClient client;
@Test
public void queryTerm() throws IOException {
// 根据索引创建查询请求
SearchRequest searchRequest = new SearchRequest("person");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.termQuery("name.keyword", "张无忌"));
System.out.println("searchSourceBuilder=====================" + searchSourceBuilder);
searchRequest.source(searchSourceBuilder);
SearchResponse response = 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构建查询语句：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 这样构造的查询条件，将不进行score计算，从而提高查询效率
searchSourceBuilder.query(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("sect.keyword", "明教")));
[]( )1.2 多值查询-terms
-------------------------------------------------------------------------
多条件查询类似Mysql里的IN查询，例如：
select * from persons where sect in('明教','武当派');
**ES查询语句：**
GET /person/_search
{
"query": {
"terms": {
"sect.keyword": [
"明教",
"武当派"
],
"boost": 1.0
}
}
}
**Java实现：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.termsQuery("sect.keyword", Arrays.asList("明教", "武当派")));
}
[]( )1.3 范围查询-range
-------------------------------------------------------------------------
范围查询，即查询某字段在特定区间的记录。
**SQL:**
select * from pesons where age between 18 and 22;
**ES查询语句：**
GET /person/_search
{
"query": {
"range": {
"age": {
"from": 10,
"to": 20,
"include_lower": true,
"include_upper": true,
"boost": 1.0
}
}
}
}
**Java构建查询条件：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.rangeQuery("age").gte(10).lte(30));
}
[]( )1.4 前缀查询-prefix
--------------------------------------------------------------------------
前缀查询类似于SQL中的模糊查询。
**SQL：**
select * from persons where sect like '武当%';
**ES查询语句：**
{
"query": {
"prefix": {
"sect.keyword": {
"value": "武当",
"boost": 1.0
}
}
}
}
**Java构建查询条件：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.prefixQuery("sect.keyword","武当"));
[]( )1.5 通配符查询-wildcard
-----------------------------------------------------------------------------
通配符查询，与前缀查询类似，都属于模糊查询的范畴，但通配符显然功能更强。
**SQL：**
select * from persons where name like '张%忌';
**ES查询语句：**
{
"query": {
"wildcard": {
"sect.keyword": {
"wildcard": "张*忌",
"boost": 1.0
}
}
}
}
**Java构建查询条件：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.wildcardQuery("sect.keyword","张*忌"));
[]( )2 复合查询
=================================================================
前面的例子都是单个条件查询，在实际应用中，我们很有可能会过滤多个值或字段。先看一个简单的例子：
select * from persons where sex = '女' and sect = '明教';
这样的多条件等值查询，就要借用到组合过滤器了，其查询语句是：
{
"query": {
"bool": {
"must": [
{
"term": {
"sex": {
"value": "女",
"boost": 1.0
}
}
},
{
"term": {
"sect.keywords": {
"value": "明教",
"boost": 1.0
}
}
}
],
"adjust_pure_negative": true,
"boost": 1.0
}
}
}
Java构造查询语句：
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
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构建查询语句：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
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
age between 30 and 40
and
sect != '明教'
and
(address = '峨眉山' OR skill = '暗器')
用 `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构建这个查询条件：**
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
BoolQueryBuilder boolQueryBuilder = 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构建查询语句：
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
searchSourceBuilder.query(QueryBuilders.boolQuery()
.filter(QueryBuilders.termQuery("sex", "男"))
);
**方式二，和must、must\_not同级，相当于子查询：**
select * from (select * from persons where sect = '明教')) a where sex = '女';
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：
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
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:
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 构建查询语句
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：**
select max(age) from persons;
**ES：**
GET /person/_search
{
"aggregations": {
"max_age": {
"max": {
"field": "age"
}
}
}
}
**Java：**
@Autowired
private RestHighLevelClient client;
@Test
public void maxQueryTest() throws IOException {
// 聚合查询条件
AggregationBuilder aggBuilder = AggregationBuilders.max("max_age").field("age");
SearchRequest searchRequest = new SearchRequest("person");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 将聚合查询条件构建到SearchSourceBuilder中
searchSourceBuilder.aggregation(aggBuilder);
System.out.println("searchSourceBuilder----->" + searchSourceBuilder);
searchRequest.source(searchSourceBuilder);
// 执行查询，获取SearchResponse
SearchResponse response = 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类似，其他统计查询也很简单：
AggregationBuilder minBuilder = AggregationBuilders.min("min_age").field("age");
AggregationBuilder avgBuilder = AggregationBuilders.avg("min_age").field("age");
AggregationBuilder sumBuilder = AggregationBuilders.sum("min_age").field("age");
AggregationBuilder countBuilder = AggregationBuilders.count("min_age").field("age");
[]( )3.2 去重查询
-------------------------------------------------------------------
**案例：查询一共有多少个门派。**
**SQL：**
select count(distinct sect) from persons;
ES：
{
"aggregations": {
"sect_count": {
"cardinality": {
"field": "sect.keyword"
}
}
}
}
Java：
@Test
public void cardinalityQueryTest() throws IOException {
// 创建某个索引的request
SearchRequest searchRequest = new SearchRequest("person");
// 查询条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 聚合查询
AggregationBuilder aggBuilder = AggregationBuilders.cardinality("sect_count").field("sect.keyword");
searchSourceBuilder.size(0);
// 将聚合查询构建到查询条件中
searchSourceBuilder.aggregation(aggBuilder);
System.out.println("searchSourceBuilder----->" + searchSourceBuilder);
searchRequest.source(searchSourceBuilder);
// 执行查询，获取结果
SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(JSONObject.toJSON(response));
}
[]( )3.3 分组聚合
-------------------------------------------------------------------
### []( )3.3.1 单条件分组
**案例：查询每个门派的人数**
## 总结：绘上一张Kakfa架构思维大纲脑图（xmind）
其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？
若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理
梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。
* Kafka入门
* 为什么选择Kafka
* Kafka的安装、管理和配置
* Kafka的集群
* 第一个Kafka程序
* Kafka的生产者
* Kafka的消费者
* 深入理解Kafka
* 可靠的数据传递
* Spring和Kafka的整合
* SpringBoot和Kafka的整合
* Kafka实战之削峰填谷
* 数据管道和流式处理(了解即可)
**相关阅读docs.qq.com/doc/DSmxTbFJ1cmN1R2dB**
