1. RESTful介绍

REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。Web 应用程序最重要的 REST 原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。

在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有：应用程序对象、数据库记录、算法等等。每个资源都使用 URI(Universal Resource Identifier) 得到一个唯一的地址。所有资源都共享统一的接口，以便在客户端和服务器之间传输状态。使用的是标准的 HTTP 方法，比如 GET、PUT、POST 和DELETE。

在 REST 样式的 Web 服务中，每个资源都有一个地址。资源本身都是方法调用的目标，方法列表对所有资源都是一样的。这些方法都是标准方法，包括 HTTP GET、POST、PUT、DELETE，还可能包括 HEAD 和OPTIONS。简单的理解就是，如果想要访问互联网上的资源，就必须向资源所在的服务器发出请求，请求体中必须包含资源的网络路径，以及对资源进行的操作(增删改查)。

2. 客户端安装

如果直接通过浏览器向 Elasticsearch 服务器发请求，那么需要在发送的请求中包含HTTP 标准的方法，而 HTTP 的大部分特性且仅支持 GET 和 POST 方法。所以为了能方便地进行客户端的访问，可以使用 Postman（不支持中文但用的人相对较多），Apipost（中国人做的），Apifox（中国人做的） 等api调试工具。

Postman：https://www.postman.com/downloads/

Apipost：https://www.apipost.cn//

Apifox：https://www.apifox.cn/

Postman：老牌且强大的网页调试工具，界面简洁明晰、操作方便快捷，设计得很人性化。但是不支持中文，国人汉化的中文包也停在了9.12.2版本https://github.com/hlmd/postman-cn

Apipost&Apifox：国人做的，支持中文，个人版免费，基本上Postman有的他们都有，还支持协作，支持web版，导出各种文档，生成各种语言的代码。主要是服务器在国内，你的工作空间可以同步到远端，而postman服务器在国外，访问速度很慢，尽量不要注册登录，否则打开会很卡。

3. 数据格式

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

ES 里的 Index 可以看做一个库，而 Types 相当于表，Documents 则相当于表的行。这里 Types 的概念已经被逐渐弱化，Elasticsearch 6.X 中，一个 index 下已经只能包含一个type，Elasticsearch 7.X 中, Type 的概念已经被删除了。

6 用 JSON 作为文档序列化的格式，比如一条用户信息：

{
	"name" : "John",
	"sex" : "Male",
	"age" : 25,
	"birthDate": "1990/05/01",
	"about" : "I love to go rock climbing",
	"interests": [ "sports", "music" ]
}
1
2
3
4
5
6
7
8

4. HTTP操作

4.1 索引操作

创建索引

对比关系型数据库，创建索引就等同于创建数据库
向 ES 服务器发 PUT 请求 ：http://127.0.0.1:9200/shopping

{
	"acknowledged"【响应结果】: true, # true 操作成功
	"shards_acknowledged"【分片结果】: true, # 分片操作成功
	"index"【索引名称】: "shopping"
}
# 注意：创建索引库的分片数默认 1 片，在 7.0.0 之前的 Elasticsearch 版本中，默认 5 片
1
2
3
4
5
6

如果重复添加索引，会返回错误信息

查看单个索引

GET 请求 ：http://127.0.0.1:9200/shopping

查看索引向 ES 服务器发送的请求路径和创建索引是一致的。但是 HTTP 方法不一致。这里
可以体会一下 RESTful 的意义，
请求后，服务器响应结果如下：

{
	"shopping"【索引名】: {
		"aliases"【别名】: {},
		"mappings"【映射】: {},
		"settings"【设置】: {
			"index"【设置 - 索引】: {
				"creation_date"【设置 - 索引 - 创建时间】: "1614265373911",
				"number_of_shards"【设置 - 索引 - 主分片数量】: "1",
				"number_of_replicas"【设置 - 索引 - 副分片数量】: "1",
				"uuid"【设置 - 索引 - 唯一标识】:"eI5wemRERTumxGCc1bAk2A",
				"version"【设置 - 索引 - 版本】: {
					"created": "7080099"
				},
				"provided_name"【设置 - 索引 - 名称】: "shopping"
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

查看所有索引

GET 请求 ：http://127.0.0.1:9200/_cat/indices?v

这里请求路径中的_cat 表示查看的意思，indices 表示索引，所以整体含义就是查看当前 ES服务器中的所有索引，就好像 MySQL 中的 show tables 的感觉，服务器响应结果如下：

删除索引

DELETE 请求 ：http://127.0.0.1:9200/shopping

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

4.2 文档操作

创建文档

这里的文档可以类比为关系型数据库中的表数据，添加的数据格式为 JSON 格式。
POST 请求 ：http://127.0.0.1:9200/shopping/_doc
请求体内容为：（请求体必须要有，否则会返回错误信息）

{
	"title":"小米手机",
	"category":"小米",
	"images":"http://www.gulixueyuan.com/xm.jpg",
	"price":3999.00
}
1
2
3
4
5
6

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

由于在学习中发现Apipost6.x版本出现了点问题，我切换成5.x版本了。界面上会和上面的截图有所出入。
问题原因是Apipost6.x版本会对响应码201做重定向处理，导致ES服务器收到的是Get请求。错误信息如上图所示。已经反馈给官方，后续版本会进行修复。
国产还需继续努力啊。

正常服务器响应结果如下：

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

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

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

查看单个文档

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

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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

修改文档（全量修改）

和新增文档一样，输入相同的 URL 地址请求，如果请求体变化，会将原有的数据内容覆盖。
POST/PUT 请求 ：http://127.0.0.1:9200/shopping/_doc/1

{
	"title":"小米手机",
	"category":"小米",
	"images":"http://www.gulixueyuan.com/xm.jpg",
	"price":2999.00
}
1
2
3
4
5
6

{
	"_index": "shopping",
	"_type": "_doc",
	"_id": "1",
	"_version"【版本】: 2,
	"result"【结果】: "updated", # updated 表示数据被更新
	"_shards": {
		"total": 2,
		"successful": 1,
		"failed": 0
		},
	"_seq_no": 2,
	"_primary_term": 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

修改字段（局部修改）

修改数据时，也可以只修改某一给条数据的局部信息
POST 请求 ：http://127.0.0.1:9200/shopping/_update/1
请求体内容为：

{
	"doc": {
		"price":3000.00
	}
}
1
2
3
4
5

根据唯一性标识，查询文档数据，文档数据已经更新

删除文档

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）。

DELETE 请求 ：http://127.0.0.1:9200/shopping/_doc/1

{
	"_index": "shopping",
	"_type": "_doc",
	"_id": "1",
	"_version"【版本】: 4, #对数据的操作，都会更新版本
	"result"【结果】: "deleted", # deleted 表示数据被标记为删除
	"_shards": {
		"total": 2,
		"successful": 1,
		"failed": 0
	},
	"_seq_no": 4,
	"_primary_term": 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

删除后再查询当前文档信息

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

{
	"_index": "shopping",
	"_type": "_doc",
	"_id": "1",
	"_version": 1,
	"result"【结果】: "not_found", # not_found 表示未查找到
	"_shards": {
		"total": 2,
		"successful": 1,
		"failed": 0
	},
	"_seq_no": 5,
	"_primary_term": 2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

条件删除文档

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

1. 首先分别增加多条数据:

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

{
	"title":"华为手机",
	"category":"华为",
	"images":"http://www.gulixueyuan.com/hw.jpg",
	"price":4000.00
}
1
2
3
4
5
6
7
8
9
10
11
12
13

POST 请求 ：http://127.0.0.1:9200/shopping/_delete_by_query
请求体内容为：

{
	"query":{
		"match":{
			"price":4000.00
		}
	}
}
1
2
3
4
5
6
7

{
	"took"【耗时】: 6,
	"timed_out"【是否超时】: false,
	"total"【总数】: 1,
	"deleted"【删除数量】: 1,
	"batches": 1,
	"version_conflicts": 0,
	"noops": 0,
	"retries": {
		"bulk": 0,
		"search": 0
	},
	"throttled_millis": 0,
	"requests_per_second": -1,
	"throttled_until_millis": 0,
	"failures": []
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.3 映射操作

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

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

创建映射

• 创建索引student
  PUT 请求 ：http://127.0.0.1:9200/student
• 创建映射
  PUT 请求 ：http://127.0.0.1:9200/student/_mapping
  
  映射数据说明：
• 字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price
• type：类型，Elasticsearch 中支持的数据类型非常丰富，说几个关键的：
  • String 类型，又分两种：
    • text：可分词
    • keyword：不可分词，数据会作为完整字段进行匹配
  • Numerical：数值类型，分两类
    • 基本数据类型：long、integer、short、byte、double、float、half_float
    • 浮点数的高精度类型：scaled_float
  • Date：日期类型
  • Array：数组类型
  • Object：对象
• index：是否索引，默认为 true，也就是说你不进行任何配置，所有字段都会被索引。
  • true：字段会被索引，则可以用来进行搜索
  • false：字段不会被索引，不能用来搜索
• store：是否将数据进行独立存储，默认为 false
  原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。
• analyzer：分词器，这里的 ik_max_word 即使用 ik 分词器,后面会有专门的章节学习

查看映射

GET 请求 ：http://127.0.0.1:9200/student/_mapping

索引映射关联

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
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

相当于创建索引的时候进行映射关联

4.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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

查看索引库中所有文档

GET/POST 请求 ：http://127.0.0.1:9200/_search

查看指定索引下所有文档

GET/POST 请求 ：http://127.0.0.1:9200/student/_search

{
	"took"【查询花费时间，单位毫秒】: 1,
	"timed_out"【是否超时】: false,
	"_shards"【分片信息】: {
		"total"【总数】: 1,
		"successful"【成功】: 1,
		"skipped"【忽略】: 0,
		"failed"【失败】: 0
	},
	"hits"【搜索命中结果】: {
		"total"【搜索条件匹配的文档总数】: {
			"value"【总命中计数的值】: 5,
			"relation"【计数规则】: "eq" # eq 表示计数准确， gte 表示计数不准确
		},
		"max_score"【匹配度分值】: 1,
		"hits"【命中结果集合】: [
			... ...
		]
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

条件匹配查询

1. 路径拼接参数查询（推荐第二种）

GET/POST 请求 ：http://127.0.0.1:9200/student/_search?q=name:zhangsan

2. 请求体携带参数查询（推荐）

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

GET/POST 请求 ：http://127.0.0.1:9200/shopping/_search
请求体内容为：

{
    "query": {
        "match":{
            "name":"zhangsan"
        }
    }
}
1
2
3
4
5
6
7

字段匹配查询

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"multi_match": {
			"query": "zhangsan",
			"fields": ["name","nickname"]
		}
	}
}
1
2
3
4
5
6
7
8

关键字精确查询

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"term": {
			"name": {
				"value": "zhangsan"
			}
		}
	}
}
1
2
3
4
5
6
7
8
9

多关键字精确查询

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"terms": {
			"name": ["zhangsan","lisi"]
		}
	}
}
1
2
3
4
5
6
7

指定查询字段

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"_source": ["name","nickname"],
	"query": {
		"terms": {
			"nickname": ["zhangsan"]
		}
	}
}
1
2
3
4
5
6
7
8

过滤字段

我们也可以通过：

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"_source": {
		"includes": ["name","sex"],
		"excludes": ["nickname"]
	},
	"query": {
		"terms": {
			"nickname": ["zhangsan"]
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11

组合查询

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"bool": {
			"must": [
				{
					"match": {
						"name": "zhangsan"
					}
				}
			],
			"must_not": [
				{
					"match": {
						"age": "40"
					}
				}
			],
			"should": [
				{
					"match": {
						"sex": "男"
					}
				}
			]
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

错误说明：
age 在映射中是不能被索引的，无法查看。（后面的范围查询也会遇到）

这是由于在创建索引映射的时候 age 和 sex 的index设为了false，以下为错误截图。
如果大家想测试的话建议重新建个索引，然后进行映射关联 age和sex的index设置为true

正常结果返回应该为：

范围查询

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"range": {
			"age": {
				"gte": 30,
				"lte": 35
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10

模糊查询

返回包含与搜索字词相似的字词的文档。
编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

• 更改字符（box → fox）
• 删除字符（black → lack）
• 插入字符（sic → sick）
• 转置两个相邻字符（act → cat）

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

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"fuzzy": {
			"name": {
				"value": "zhangsan"
			}
		}
	}
}
1
2
3
4
5
6
7
8
9

GET 请求 ：http://127.0.0.1:9200/student/_search

{
   "query": {
   	"fuzzy": {
   		"name": {
   			"value": "zhangsan",
   			"fuzziness": 2
   		}
   	}
   }
}
1
2
3
4
5
6
7
8
9
10

单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc升序。

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"match": {
			"name": "zhangsan"
		}
	},
	"sort": [
		{
			"age": {
				"order": "desc"
			}
		}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

多字段排序

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

GET 请求：http://127.0.0.1:9200/student/_search

{
	"query": {
		"match_all": {}
	},
	"sort": [
		{
			"age": {
				"order": "desc"
			}
		},
		{
			"_score": {
				"order": "desc"
			}
		}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

高亮查询

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

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

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

GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"query": {
		"match_all": {}
	},
	"from": 0,
	"size": 2
}
1
2
3
4
5
6
7

全量查询

（一般配合使用分页使用，因为数据量大的时候… …）
GET/POST 请求 ：http://127.0.0.1:9200/student/_search
请求体内容为：

{
    "query": {
        "match_all":{
        }
    }
}
1
2
3
4
5
6

分页查询

from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size
size：每页显示多少条、

GET/POST 请求 ：http://127.0.0.1:9200/student/_search
请求体内容为：

{
	"query": {
		"match_all": {}
	},
	"from": 0,
	"size": 2
}
1
2
3
4
5
6
7

聚合查询

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

• 对某个字段取最大值 max
  GET 请求 ：http://127.0.0.1:9200/student/_search

{
	"aggs": {
		"max_age": {
			"max": {
				"field": "age"
			}
		}
	},
	"size": 0
}
1
2
3
4
5
6
7
8
9
10

• 对某个字段取最小值 min

{
	"aggs": {
		"min_age": {
			"min": {
				"field": "age"
			}
		}
	},
	"size": 0
}
1
2
3
4
5
6
7
8
9
10

• 对某个字段求和 sum

{
	"aggs": {
		"sum_age": {
			"sum": {
				"field": "age"
			}
		}
	},
	"size": 0
}
1
2
3
4
5
6
7
8
9
10

• 对某个字段取平均值 avg

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

• State 聚合

桶聚合查询