Elasticsearch学习笔记（上）

小鲁蛋儿

已于 2022-09-27 20:18:15 修改

阅读量741

点赞数 1

文章标签： elasticsearch 搜索引擎

于 2022-05-30 13:37:50 首次发布

本文链接：https://blog.csdn.net/qq_51409098/article/details/125040575

版权

Elasticsearch 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

感谢尚硅谷

视频地址：【尚硅谷】ElasticSearch教程入门到精通（基于ELK技术栈elasticsearch 7.x+8.x新特性）_哔哩哔哩_bilibili

主要内容：

一、Elasticsearch HTTP操作

二、Java API 操作
三、核心概念与系统架构
四、分布式集群原理

一、Elasticsearch HTTP操作

首先介绍一下ElasticSearch的数据格式，有助于对下面操作的理解。

Elasticsearch 是面向文档型数据库，一条数据在这里就是一个文档。我们将 Elasticsearch 里存储文档数据和关系型数据库 MySQL 存储数据的概念进行一个类比。

这里 Types 的概念已经被逐渐弱化，Elasticsearch 6.X 中，一个 index 下已经只能包含一个
type，Elasticsearch 7.X 中, Type 的概念已经被删除了。

1、索引操作

1）创建索引

对比关系型数据库，创建索引就等同于创建数据库

在 Postman 中，向 ES 服务器发 PUT 请求：http://127.0.0.1:9200/shopping

请求后，服务器返回响应

{
    "acknowledged"【响应结果】: true, # true 操作成功
    "shards_acknowledged"【分片结果】: true, # 分片操作成功
    "index"【索引名称】: "shopping"
}

注意：创建索引库的分片数默认 1 片，在 7.0.0 之前的 Elasticsearch 版本中，默认 5 片

2）查看所有索引

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/_cat/indices?v

_cat 表示查看，indices 表示索引。

整体含义就是查看当前 ES服务器中的所有索引，就好像 MySQL 中的 show tables。

服务器响应结果如下

表头	含义
health	当前服务器健康状态： green(集群完整) yellow(单点正常、集群不完整) red(单点不正常)
status	索引打开、关闭状态
index	索引名
uuid	索引统一编号
pri	主分片数量
rep	副本数量
docs.count	可用文档数量
docs.deleted	文档删除状态（逻辑删除）
store.size	主分片和副分片整体占空间大小
pri.store.size	主分片占空间大小

3）查看单个索引

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/shopping

查看索引向 ES 服务器发送的请求路径和创建索引是一致的。但是 HTTP 方法不一致。

请求后，服务器响应结果如下：

结果说明：

{
    "shopping"【索引名】: {
    "aliases"【别名】: {},
    "mappings"【映射】: {},
    "settings"【设置】: {
        "index"【设置 - 索引】: {
            "creation_date"【设置 - 索引 - 创建时间】: "1614265373911",
            "number_of_shards"【设置 - 索引 - 主分片数量】: "1",
            "number_of_replicas"【设置 - 索引 - 副分片数量】: "1",
            "uuid"【设置 - 索引 - 唯一标识】: "eI5wemRERTumxGCc1bAk2A",
            "version"【设置 - 索引 - 版本】: {
                "created": "7080099"
            },
            "provided_name"【设置 - 索引 - 名称】: "shopping"
            }
        }
    }
}

4) 删除索引

在 Postman 中，向 ES 服务器发 DELETE 请求：http://127.0.0.1:9200/shopping

重新访问索引时，服务器返回响应：

2、文档操作

1) 创建文档

索引已经创建好了，接下来我们来创建文档，并添加数据。这里的文档可以类比为关系型数
据库中的表数据，添加的数据格式为 JSON 格式。

在 Postman 中，向 ES 服务器发 POST 请求：http://127.0.0.1:9200/shopping/_doc

请求体内容为：

{
    "title":"小米手机",
    "category":"小米",
    "images":"http://www.gulixueyuan.com/xm.jpg",
    "price":3999.00
}

注意：此处发送请求的方式必须为 POST，不能是 PUT，否则会发生错误

服务器响应结果如下：

结果说明：

{
    "_index"【索引】: "shopping",
    "_type"【 类型-文档 】: "_doc",
    "_id"【唯一标识】: "Xhsa2ncBlvF_7lxyCE9G", #可以类比为 MySQL 中的主键，随机生成
    "_version"【版本】: 1,
    "result"【结果】: "created", #这里的 create 表示创建成功
    "_shards"【分片】: {
        "total"【分片 - 总数】: 2,
        "successful"【分片 - 成功】: 1,
        "failed"【分片 - 失败】: 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES 服务器会随机生成一个。如果想要自定义唯一性标识，需要在创建时指定：http://127.0.0.1:9200/shopping/_doc/1

此处需要注意：如果增加数据时明确数据主键，那么请求方式也可以为 PUT

2) 查看文档

查看文档时，需要指明文档的唯一性标识，类似于 MySQL 中数据的主键查询

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/shopping/_doc/1

查询成功后，服务器响应结果：

结果说明：

{
    "_index"【索引】: "shopping",
    "_type"【文档类型】: "_doc",
    "_id": "1",
    "_version": 2,
    "_seq_no": 2,
    "_primary_term": 2,
    "found"【查询结果】: true, # true 表示查找到，false 表示未查找到
    "_source"【文档源信息】: {
        "title": "华为手机",
        "category": "华为",
        "images": "http://www.gulixueyuan.com/hw.jpg",
        "price": 4999.00
    }
}

3) 修改文档

和新增文档一样，输入相同的 URL 地址请求，如果请求体变化，会将原有的数据内容覆盖
在 Postman 中，向 ES 服务器发 POST 请求：http://127.0.0.1:9200/shopping/_doc/1

请求体内容为:

{
    "title":"华为手机",
    "category":"华为",
    "images":"http://www.gulixueyuan.com/hw.jpg",
    "price":4999.00
}

修改成功后，服务器响应结果：

4) 修改字段

修改数据时，也可以只修改某一给条数据的局部信息

在 Postman 中，向 ES 服务器发 POST 请求：http://127.0.0.1:9200/shopping/_update/1

请求体内容为：

{
    "doc": {
        "price":3000.00
    }
}

修改成功后，服务器响应结果：

5) 删除文档

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）
在 Postman 中，向 ES 服务器发 DELETE 请求：http://127.0.0.1:9200/shopping/_doc/1

删除成功，服务器响应结果：

如果删除一个并不存在的文档

6) 条件删除文档

一般删除数据都是根据文档的唯一性标识进行删除，实际操作时，也可以根据条件对多条数
据进行删除

向 ES 服务器发 POST 请求：http://127.0.0.1:9200/shopping/_delete_by_query

请求体内容为：

{
   "query":{
       "match":{
       "price":4000.00
       }
   }
}

删除成功后，服务器响应结果：

参数	说明
took	耗时
timed_out	是否超时
total	总数
deleted	删除数量

3、映射操作

有了索引库，等于有了数据库中的 database。

接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。
创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型
下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

说明：

在Elasticsearch 6.0.0或更高版本中创建的索引只能包含一个映射类型。在5.x中创建的具有多种映射类型的索引将继续像在Elasticsearch 6.x中一样工作。类型将在Elasticsearch 7.0.0中的API中弃用，并在8.0.0中完全删除。

1) 创建映射

在 Postman 中，向 ES 服务器发 PUT 请求：http://127.0.0.1:9200/student/_mapping

student为索引名称，索引必须已经建立

请求体内容为：

{
    "properties": {
        "name":{
            "type": "text",
            "index": true
        },
        "sex":{
            "type": "text",
            "index": false
        },
        "age":{
            "type": "long",
            "index": false
        }
    }
}

服务器响应结果如下：

映射数据说明：

字段名：任意填写

type：类型

类型	具体细分
String 类型	text：可分词 keyword：不可分词，数据会作为完整字段进行匹配
Numerical类型	基本数据类型：long、integer、short、byte、double、float、half_float 浮点数的高精度类型：scaled_float
Date：时间日期类型
Array：数组类型
Object：对象类型

index：是否索引，默认为 true。
true：字段会被索引，则可以用来进行搜索
false：字段不会被索引，不能用来搜索

store：是否将数据进行独立存储，默认为 false。

当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。

analyzer：分词器，后面会单独写博客说明

2) 查看映射

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_mapping

服务器响应结果如下：

3) 索引映射关联

在 Postman 中，向 ES 服务器发 PUT 请求：http://127.0.0.1:9200/student1

索引可以不存在

{
    "settings": {},
    "mappings": {
        "properties": {
            "name":{
                "type": "text",
                "index": true
            },
            "sex":{
                "type": "text",
                "index": false
            },
            "age":{
                "type": "long",
                "index": false
            }
        }
    }
}

服务器响应结果如下：

4、高级查询

Elasticsearch 提供了基于 JSON 提供完整的查询 DSL 来定义查询

定义数据

# POST /student/_doc/1001
{
    "name":"zhangsan",
    "nickname":"zhangsan",
    "sex":"男",
    "age":30
}
# POST /student/_doc/1002
{
    "name":"lisi",
    "nickname":"lisi",
    "sex":"男",
    "age":20
}
# POST /student/_doc/1003
{
    "name":"wangwu",
    "nickname":"wangwu",
    "sex":"女",
    "age":40
}
# POST /student/_doc/1004
{
    "name":"zhangsan1",
    "nickname":"zhangsan1",
    "sex":"女",
    "age":50
}
# POST /student/_doc/1005
{
    "name":"zhangsan2",
    "nickname":"zhangsan2",
    "sex":"女",
    "age":30
}

1) 查询所有文档

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
    "match_all": {}
    }
}

"query"：这里的 query 代表一个查询对象，里面可以有不同的查询属性
"match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
{查询条件}：查询条件会根据类型的不同，写法也有差异

服务器响应结果如下：

结果说明：

{
    "took【查询花费时间，单位毫秒】" : 1116,
    "timed_out【是否超时】" : false,
    "_shards【分片信息】" : {
        "total【总数】" : 1,
        "successful【成功】" : 1,
        "skipped【忽略】" : 0,
        "failed【失败】" : 0
    },
    "hits【搜索命中结果】" : {
        "total"【搜索条件匹配的文档总数】: {
            "value"【总命中计数的值】: 3,
            "relation"【计数规则】: "eq" # eq 表示计数准确， gte 表示计数不准确
        },
        "max_score【匹配度分值】" : 1.0,
        "hits【命中结果集合】" : []
    }
}

2) 匹配查询

match 匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是 or 的关系

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match": {
            "name":"zhangsan"
        }
    }
}

3) 字段匹配查询

multi_match 与 match 类似，不同的是它可以在多个字段中查询。

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "multi_match": {
            "query": "zhangsan",
            "fields": ["name","nickname"]
        }
    }
}

4) 关键字精确查询

term 查询，精确的关键词匹配查询，不对查询条件进行分词。

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
    "term": {
        "name": {
            "value": "zhangsan"
            }
        }
    }
}

5) 多关键字精确查询

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于 mysql 的 in

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "terms": {
            "name": ["zhangsan","lisi"]
        }
    }
}

6) 指定查询字段

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在_source 的所有字段都返回。
如果我们只想获取其中的部分字段，我们可以添加_source 的过滤

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "_source": ["name","nickname"],
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}

7) 过滤字段

includes：来指定想要显示的字段
excludes：来指定不想要显示的字段

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "_source": {
        "includes": ["name","nickname"]
    },
    "query": {
        "terms": {
            "nickname": ["zhangsan"]
        }
    }
}

8) 组合查询

`bool`把各种其它查询通过`must`（必须）、`must_not`（必须不）、`should`（应该）的方
式进行组合

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
  "query": {
     "bool": {
       "must": [
         {
           "match": {
             "name": "zhangsan"
            }
         }
       ],
       "must_not": [
         {
            "match": {
               "age": "40"
             }
           }
        ],
      "should": [
        {
            "match": {
               "sex": "男"
             }
           }
       ]
    }
  }
}

9) 范围查询

range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符

操作符	说明
gt	大于>
gte	大于等于>=
lt	小于<
lte	小于等于<=

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "range": {
            "age": {
            "gte": 30,
            "lte": 35
            }
        }
    }
}

10) 模糊查询

返回包含与搜索字词相似的字词的文档。

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

① 更改字符（box → fox）

② 删除字符（black → lack）

③ 插入字符（sic → sick）

④ 转置两个相邻字符（act → cat）

为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体
或扩展。然后查询返回每个扩展的完全匹配。

通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "fuzzy": {
            "title": {
                "value": "zhangsan",
                "fuzziness": 2
            }
        }
    }
}

11) 单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc
升序。
在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match": {
            "name":"zhangsan"
        }
    },
    "sort": [{
        "age": {
            "order":"desc"
            }
    }]
}

12) 多字段排序

假定我们想要结合使用 age 和 _score 进行查询，并且匹配的结果首先按照年龄排序，然后
按照相关性得分排序

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
                "order": "desc"
            }
        },
        {
            "_score":{
                "order": "desc"
            }
        }
    ]
}

13) 高亮查询

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。

Elasticsearch 可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。在使用 match 查询的同时，加上一个 highlight 属性：

① pre_tags：前置标签
② post_tags：后置标签
③ fields：需要高亮的字段
④ title：这里声明 title 字段需要高亮，后面可以为这个字段设置特有配置，也可以空

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match": {
            "name": "zhangsan"
        }
    },
    "highlight": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>",
        "fields": {
            "name": {}
        }
    }
}

14) 分页查询

from：当前页的起始索引，默认从 0 开始。
size：每页显示多少条

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "match_all": {}
    },
    "sort": [
        {
            "age": {
            "order": "desc"
            }
        }
    ],
    "from": 0,
    "size": 2
}

15) 聚合查询

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

① 对某个字段取最大值 max
在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "max_age":{
            "max":{"field":"age"}
        }
    },
    "size":0
}

② 对某个字段取最小值 min

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "min_age":{
            "min":{"field":"age"}
        }
    },
    "size":0
}

③ 对某个字段求和 sum

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "avg_age":{
            "avg":{"field":"age"}
        }
    },
    "size":0
}

④ 对某个字段的值进行去重之后再取总数

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "distinct_age":{
            "cardinality":{"field":"age"}
        }
    },
    "size":0
}

⑤ State 聚合

stats 聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "stats_age":{
            "stats":{"field":"age"}
        }
    },
    "size":0
}

16) 桶聚合查询

桶聚和相当于 sql 中的 group by 语句 terms 聚合，分组统计

在 Postman 中，向 ES 服务器发 GET 请求：http://127.0.0.1:9200/student/_search

{
    "aggs":{
        "age_groupby":{
            "terms":{"field":"age"}
        }
    },
    "size":0
}

二、Java API 操作

1、pom.xml

Elasticsearch软件是由Java语言开发的，所以也可以通过Java API的方式对Elasticsearch服务进行访问

<dependencies>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>7.8.0</version>
</dependency>
<!-- elasticsearch 的客户端 -->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>7.8.0</version>
    </dependency>
<!-- elasticsearch 依赖 2.x 的 log4j -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.8.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.8.2</version>
    </dependency>
<!-- 用于json转换 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.9</version>
    </dependency>
<!-- junit 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

2、客户端对象

因为早期版本的客户端对象已经不再推荐使用，且在未来版本中会被删除，所以这里我们采
用高级 REST 客户端对象

public class ESTest_Client {
    public static void main(String[] args) throws IOException {
        //创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("192.168.16.106", 9200, "http")));

        /**
         *该处为索引，文档操作，高级查询
         */

        //关闭客户端连接
        client.close();
    }
}

3、索引操作

1）创建索引

//创建索引
CreateIndexRequest request = new CreateIndexRequest("user");
CreateIndexResponse createIndexResponse =
        client.indices().create(request, RequestOptions.DEFAULT);

//响应状态
boolean acknowledged = createIndexResponse.isAcknowledged();
System.out.println("索引操作："+acknowledged);

2）查看索引

//获取索引
GetIndexRequest request = new GetIndexRequest("user");
GetIndexResponse getIndexResponse =
        client.indices().get(request, RequestOptions.DEFAULT);

//别名
System.out.println(getIndexResponse.getAliases());
//结构
System.out.println(getIndexResponse.getMappings());
//设置
System.out.println(getIndexResponse.getSettings());

3）删除索引

//删除索引
DeleteIndexRequest request = new DeleteIndexRequest("user");
AcknowledgedResponse response =
        client.indices().delete(request, RequestOptions.DEFAULT);

//响应状态
boolean acknowledged = response.isAcknowledged();
System.out.println("索引操作："+acknowledged);

4、文档操作

1）新增文档

创建数据模型，该处省略构造器，toString()，set，get方法

public class User {
    private String name;
    private String sex;
    private int age;
}

// 插入数据请求
IndexRequest request = new IndexRequest();
// 设置索引及唯一性标识
request.index("user").id("1001");

User user = new User("tom", "男", 8);

// 向ES插入数据，必须将数据转换为 JSON 格式
ObjectMapper mapper = new ObjectMapper();
String userJson = mapper.writeValueAsString(user);
// 添加文档数据
request.source(userJson, XContentType.JSON);

// 客户端发送请求，获取响应对象
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
System.out.println("结果：" + indexResponse.getResult());

2）修改文档

// 修改数据请求
UpdateRequest request = new UpdateRequest();
// 配置修改参数
request.index("user").id("1001");
// 设置请求体，对数据进行修改
request.doc(XContentType.JSON,"sex","女");

// 客户端发送请求，获取响应对象
UpdateResponse updateResponse = client.update(request, RequestOptions.DEFAULT);
System.out.println("结果：" + updateResponse.getResult());

3）查询文档

GetRequest request = new GetRequest();
request.index("user").id("1001");

GetResponse response = client.get(request, RequestOptions.DEFAULT);
System.out.println("查询到的结果：" + response.getSourceAsString());

4）删除文档

DeleteRequest request = new DeleteRequest();
request.index("user").id("1001");

DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
System.out.println("结果：" + response.status());

5）批量删除

BulkRequest request = new BulkRequest();
request.add(new DeleteRequest().index("user").id("1001"));
request.add(new DeleteRequest().index("user").id("1002"));
request.add(new DeleteRequest().index("user").id("1003"));

BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
System.out.println(response.getTook());
System.out.println(response.getItems());

6）批量新增

//批量插入数据
BulkRequest request = new BulkRequest();
request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "张三","age",30,"sex","男"));
request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "name", "李四","age",45,"sex","男"));
request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "王五","age",23,"sex","女"));

BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
System.out.println(response.getTook());
System.out.println(response.getItems());

5、高级查询

模板操作

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
//配置所有参数
request.indices("user");

// 构建查询的请求体
SearchSourceBuilder builder = new SearchSourceBuilder();

/**
* 查询的具体操作
*/

//请求体放到请求对象中
request.source(builder);
//客户端发送请求，获取响应对象
SearchResponse response = client.search(request, RequestOptions.DEFAULT);

SearchHits hits = response.getHits();
for (SearchHit hit : hits) {
//输出每条查询的结果信息
    System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");

1）查询所有对象

builder.query(QueryBuilders.matchAllQuery()));

2）条件查询

builder.query(QueryBuilders.termQuery("age",30)));

3）分页查询

builder.query(QueryBuilders.matchAllQuery());
//当前页其实索引(第一条数据的顺序号)
builder.from(0);
//每页显示多少条
builder.size(2);

4）数据排序

builder.query(QueryBuilders.matchAllQuery());
builder.sort("age", SortOrder.DESC);

5）过滤数据

//包含
String[] includes = {"name"};
//不包含
String[] excludes = {};
builder.fetchSource(includes,excludes);

6）Bool查询

BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
// 必须包含
boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
// 一定不含
boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhangsan"));
// 可能包含
boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));

builder.query(boolQueryBuilder);

7）范围查询

RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
//大于等于
rangeQuery.gte(30);
//小于
rangeQuery.lt(40);
builder.query(rangeQuery);

8）模糊查询

//偏差为1
FuzzyQueryBuilder fuzziness =
             QueryBuilders.fuzzyQuery("name", "王五").fuzziness(Fuzziness.ONE);
builder.query(fuzziness);

9）高亮查询

//设置查询方式
builder.query(QueryBuilders.matchAllQuery());

//构建高亮字段
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font color='red'>") //设置标签前缀
           .postTags("</font>") //设置标签后缀
           .field("name"); //设置高亮字段

//设置高亮构建对象
builder.highlighter(highlightBuilder);

10）聚合查询

MaxAggregationBuilder aggregation = AggregationBuilders.max("maxAge").field("age");
builder.aggregation(aggregation);

11）分组查询

TermsAggregationBuilder aggregationBuilder =  
    AggregationBuilders.terms("ageGroup").field("age");
builder.aggregation(aggregationBuilder);

三、核心概念与系统架构

1、核心概念

1）索引（Index ）

一个索引就是一个拥有几分相似特征的文档的集合。

比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识（必须全部是小写字母），并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。在一个集群中，可以定义任意多的索引。

能搜索的数据必须索引，这样的好处是可以提高查询速度，比如：新华字典前面的目录就是索引的意思，目录可以提高查询速度。

Elasticsearch 索引的精髓：一切设计都是为了提高搜索的性能。

2）类型（Type ）

在一个索引中，你可以定义一种或多种类型。

一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。不同的版本，类型发生了不同的变化。

版本	Type
5.x	支持多种 type
6.x	只能有一种 type
7.x	默认不再支持自定义索引类型（默认类型为：_doc）

3）文档（Document ）

一个文档是一个可被索引的基础信息单元，也就是一条数据。

比如：你可以拥有某一个客户的文档，某一个产品的一个文档，当然，也可以拥有某个订单的一个文档。文档以 JSON（Javascript Object Notation）格式来表示，而 JSON 是一个到处存在的互联网数据交互格式。

在一个 index/type 里面，你可以存储任意多的文档。

4）字段（Field ）

相当于是数据表的字段，对文档数据根据不同属性进行的分类标识。

5）映射（Mapping ）

mapping 是处理数据的方式和规则方面做一些限制。

如：某个字段的数据类型、默认值、分析器、是否被索引等等。这些都是映射里面可以设置的，其它就是处理 ES 里面数据的一些使用规则设置也叫做映射，按着最优规则处理数据对性能提高很大，因此才需要建立映射，并且需要思考如何建立映射才能对性能更好。

6）分片（Shards ）

一个索引可以存储超出单个节点硬件限制的大量数据。

比如，一个具有 10 亿文档数据的索引占据 1TB 的磁盘空间，而任一节点都可能没有这样大的磁盘空间。或者单个节点处理搜索请求，响应太慢。为了解决这个问题，Elasticsearch 提供了将索引划分成多份的能力，每一份就称之为分片。当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置到集群中的任何节点上。

分片很重要，主要有两方面的原因：

允许你水平分割 / 扩展你的内容容量。
允许你在分片之上进行分布式的、并行的操作，进而提高性能/吞吐量。

至于一个分片怎样分布，它的文档怎样聚合和搜索请求，是完全由 Elasticsearch 管理的，对于作为用户的你来说，这些都是透明的，无需过分关心。

被混淆的概念是，一个 Lucene 索引我们在 Elasticsearch 称作分片。一个Elasticsearch索引是分片的集合。当Elasticsearch在索引中搜索的时候，他发送查询到每一个属于索引的分片(Lucene索引)。

7）副本（Replicas）

在一个网络 / 云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因消失了，这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch 允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片(副本)。

复制分片之所以重要，有两个主要原因：

在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要（original/primary）分片置于同一节点上是非常重要的。
扩展你的搜索量/吞吐量，因为搜索可以在所有的副本上并行运行。

总之，每个索引可以被分成多个分片。一个索引也可以被复制 0 次（意思是没有复制）或多次。一旦复制了，每个索引就有了主分片（作为复制源的原来的分片）和复制分片（主分片的拷贝）之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后，你可以在任何时候动态地改变复制的数量，但是你事后不能改变分片的数量。默认情况下，Elasticsearch 中的每个索引被分片 1 个主分片和 1 个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有 1 个主分片和另外 1 个复制分片（1 个完全拷贝），这样的话每个索引总共就有 2 个分片，我们需要根据索引需要确定分片个数。

8）分配（Allocation）

将分片分配给某个节点的过程，包括分配主分片或者副本。如果是副本，还包含从主分片复制数据的过程。这个过程是由 master 节点完成的。

2、系统架构

一个运行中的 Elasticsearch 实例称为一个节点，而集群是由一个或者多个拥有相同cluster.name 配置的节点组成，它们共同承担数据和负载的压力。当有节点加入集群中或者从集群中移除节点时，集群将会重新平均分布所有的数据。

当一个节点被选举成为主节点时，它将负责管理集群范围内的所有变更，例如增加、删除索引，或者增加、删除节点等。而主节点并不需要涉及到文档级别的变更和搜索等操作，所以当集群只拥有一个主节点的情况下，即使流量的增加它也不会成为瓶颈。任何节点都可以成为主节点。我们的示例集群就只有一个节点，所以它同时也成为了主节点。

作为用户，我们可以将请求发送到集群中的任何节点，包括主节点。每个节点都知道任意文档所处的位置，并且能够将我们的请求直接转发到存储我们所需文档的节点。无论我们将请求发送到哪个节点，它都能负责从各个包含我们所需文档的节点收集回数据，并将最终结果返回給客户端。 Elasticsearch 对这一切的管理都是透明的。

四、分布式集群原理

1、单节点集群

我们在包含一个空节点的集群内创建名为 users 的索引，为了演示目的，我们将分配 3个主分片和一份副本（每个主分片拥有一个副本分片）

{
    "settings" : {
        "number_of_shards" : 3,
        "number_of_replicas" : 1
    }
}

我们的集群现在是拥有一个索引的单节点集群。所有 3 个主分片都被分配在 node-1 。

通过 elasticsearch-head 插件查看集群情况

集群健康值:yellow( 3 of 6 ) : 表示当前集群的全部主分片都正常运行，但是副本分片没有全部处在正常状态

: 3 个主分片正常

: 3 个副本分片都是 Unassigned —— 它们都没有被分配到任何节点。在同一个节点上既保存原始数据又保存副本是没有意义的，因为一旦失去了那个节点，我们也将丢失该节点上的所有副本数据。

当前我们的集群是正常运行的，但是在硬件故障时有丢失数据的风险。

2、故障转移（两节点）

当集群中只有一个节点在运行时，意味着会有一个单点故障问题——没有冗余。幸运的是，我们只需再启动一个节点即可防止数据丢失。当你在同一台机器上启动了第二个节点时，只要它和第一个节点有同样的 cluster.name 配置，它就会自动发现集群并加入到其中。但是在不同机器上启动节点的时候，为了加入到同一集群，你需要配置一个可连接到的单播主机列表。之所以配置为使用单播发现，以防止节点无意中加入集群。只有在同一台机器上运行的节点才会自动组成集群。

如果启动了第二个节点，我们的集群将会拥有两个节点的集群 : 所有主分片和副本分片都已被分配。

通过 elasticsearch-head 插件查看集群情况

集群健康值:green( 6 of 6 ) : 表示所有 6 个分片（包括 3 个主分片和 3 个副本分片）都在正常运行。

： 3 个主分片正常

：当第二个节点加入到集群后，3 个副本分片将会分配到这个节点上——每个主分片对应一个副本分片。这意味着当集群内任何一个节点出现问题时，我们的数据都完好无损。所有新近被索引的文档都将会保存在主分片上，然后被并行的复制到对应的副本分片上。这就保证了我们既可以从主分片又可以从副本分片上获得文档。

3、水平扩容（三节点）

怎样为我们的正在增长中的应用程序按需扩容呢？当启动了第三个节点，我们的集群将会拥有三个节点的集群 : 为了分散负载而对分片进行重新分配。

通过 elasticsearch-head 插件查看集群情况

集群健康值:green( 6 of 6 ) : 表示所有 6 个分片（包括 3 个主分片和 3 个副本分片）都在正常运行。

Node 1 和 Node 2 上各有一个分片被迁移到了新的 Node 3 节点，现在每个节点上都拥有2个分片，而不是之前的 3 个。这表示每个节点的硬件资源（CPU, RAM, I/O）将被更少的分片所共享，每个分片的性能将会得到提升。

分片是一个功能完整的搜索引擎，它拥有使用一个节点上的所有资源的能力。我们这个拥有 6 个分片（3 个主分片和 3 个副本）的索引可以最大扩容到 6 个节点，每个节点上存在一个分片，并且每个分片拥有所在节点的全部资源。

但是如果我们想要扩容超过 6 个节点怎么办呢？

主分片的数目在索引创建时就已经确定了下来。实际上，这个数目定义了这个索引能够存储的最大数据量。（实际大小取决于你的数据、硬件和使用场景。）但是，读操作——搜索和返回数据——可以同时被主分片或副本分片所处理，所以当你拥有越多的副本分片时，也将拥有越高的吞吐量。

在运行中的集群上是可以动态调整副本分片数目的，我们可以按需伸缩集群。让我们把
副本数从默认的 1 增加到 2

{
    "number_of_replicas" : 2
}

users 索引现在拥有 9 个分片：3 个主分片和 6 个副本分片。这意味着我们可以将集群扩容到 9 个节点，每个节点上一个分片。相比原来 3 个节点时，集群搜索性能可以提升 3 倍。

通过 elasticsearch-head 插件查看集群情况

当然，如果只是在相同节点数目的集群上增加更多的副本分片并不能提高性能，因为每个分片从节点上获得的资源会变少。你需要增加更多的硬件资源来提升吞吐量。但是更多的副本分片数提高了数据冗余量：按照上面的节点配置，我们可以在失去 2 个节点的情况下不丢失任何数据。

4、应对故障

我们关闭第一个节点，这时集群的状态为:关闭了一个节点后的集群。

我们关闭的节点是一个主节点。而集群必须拥有一个主节点来保证正常工作，所以发生的第一件事情就是选举一个新的主节点： Node 2 。在我们关闭 Node 1 的同时也失去了主分片 1 和 2 ，并且在缺失主分片的时候索引也不能正常工作。如果此时来检查集群的状况，我们看到的状态将会为 red ：不是所有主分片都在正常工作。

幸运的是，在其它节点上存在着这两个主分片的完整副本，所以新的主节点立即将这些分片在 Node 2 和 Node 3 上对应的副本分片提升为主分片，此时集群的状态将会为yellow。这个提升主分片的过程是瞬间发生的，如同按下一个开关一般.

为什么我们集群状态是 yellow 而不是 green 呢？

虽然我们拥有所有的三个主分片，但是同时设置了每个主分片需要对应 2 份副本分片，而此
时只存在一份副本分片。所以集群不能为 green 的状态，不过我们不必过于担心：如果我
们同样关闭了 Node 2 ，我们的程序依然可以保持在不丢任何数据的情况下运行，因为
Node 3 为每一个分片都保留着一份副本。

如果我们重新启动 Node 1 ，集群可以将缺失的副本分片再次进行分配，那么集群的状态也将恢复成之前的状态。如果 Node 1 依然拥有着之前的分片，它将尝试去重用它们，同时仅从主分片复制发生了修改的数据文件。和之前的集群相比，只是 Master 节点切换了。