本章主要介绍ES的基础操作，具体包括索引、映射和文档的相关操作。其中，在文档操作中将分别介绍单条操作和批量操作。在生产实践中经常会通过程序对文档进行操作，因此在介绍文档操作时会分别介绍DSL请求形式和Java的高级REST编码形式。
1 索引操作
本节主要介绍索引的相关操作，涉及创建、删除、关闭和打开索引，以及索引别名的操作。其中，索引别名的操作在生产环境中使用比较广泛，可以和关闭或删除索引配合使用。在生产环境中使用索引时，一定要慎重操作，因为稍有不慎就会导致数据的丢失或异常。
1.1 创建索引
使用ES构建搜索引擎的第一步是创建索引。在创建索引时，可以按照实际需求对索引进行主分片和副分片设置。ES创建索引的请求类型为PUT，其请求形式如下：
PUT /${index_name}
{ "settings":{
…
}
"mappings":{
…
}
}
其中：变量index_name就是创建的目标索引名称；可以在settings子句内部填写索引相关的设置项，如主分片个数和副分片个数等；可以在mappings子句内部填写数据组织结构，即数据映射。
在第1章中曾介绍过创建索引hotel的语句，但是当时的主分片个数使用的是系统默认值（默认值为5），并且没有使用副分片个数（默认值为0）。假设设置主分片个数为15，副分片个数为2，则相应的DSL如下：
PUT /hotel
{
"settings" : {
"number_of_shards" : 15, //指定主分片个数
"number_of_replicas" : 2 //指定副分片个数
},
"mappings":{
"properties":{
…
}
}
}
1.2 删除索引
ES中删除索引的请求类型是DELETE，其请求形式如下：
DELETE /${index_name}
其中，${index_name}就是将要被删除的索引的名称，例如执行下面的删除命令：
DELETE /hotel
系统返回信息如下：
{
"acknowledged" : true //操作成功，通知信息
}
通过返回信息可知，目标索引hotel已经被删除。
1.3 关闭索引
在有些场景下，某个索引暂时不使用，但是后期可能又会使用，这里的使用是指数据写入和数据搜索。这个索引在某一时间段内属于冷数据或者归档数据，这时可以使用索引的关闭功能。索引关闭时，只能通过ES的API或者监控工具看到索引的元数据信息，但是此时该索引不能写入和搜索数据，待该索引被打开后，才能写入和搜索数据。先把索引hotel关闭，请求形式如下：
POST /hotel/_close
此时可以尝试进行数据写入：
POST /hotel/_doc/002
{
"title":"阳光夏日酒店",
"city":"北京",
"price":788.00
} "
ES返回信息如下：
{
"error" : {
"root_cause" : [
{
"type" : "index_closed_exception", //提示异常类型为索引已经关闭
"reason" : "closed",
"index_uuid" : "TIYkM2N5SCKlnmCOXuJPmg",
"index" : "hotel" //当前索引名称
}
],
"type" : "index_closed_exception",
"reason" : "closed",
"index_uuid" : "TIYkM2N5SCKlnmCOXuJPmg",
"index" : "hotel"
},
"status" : 400
}
根据上面的信息可知，索引关闭时写入数据将会报错。下面可以尝试进行数据搜索：
GET /hotel/_search
{
"query": {
"match": { //使用match搜索
"title": "再来"
}
}
}
ES返回的信息和进行写入请求时的返回信息是一样的，印证了索引在关闭时不能提供搜索服务的规定。
1.4 打开索引
索引关闭后，需要开启读写服务时可以将其设置为打开状态。下面的示例是把处于关闭状态的hotel索引设置为打开状态。
POST /hotel/_open
1.5 索引别名
顾名思义，别名是指给一个或者多个索引定义另外一个名称，使索引别名和索引之间可以建立某种逻辑关系。
可以用别名表示别名和索引之间的包含关系。例如，我们建立了1月、2月、3月的用户入住酒店的日志索引，假设当前日期是4月1日，需要搜索过去的3个月的日志索引，如果分别去3个索引中进行搜索，这种编码方案比较低效。此时可以创建一个别名last_three_month，设置前面的3个索引的别名为last_three_month，然后在last_three_month中进行搜索即可。如图3.1所示，last_three_month包含january_log、february_log和march_log3个索引，用户请求在last_three_month中进行搜索时，ES会在上述3个索引中进行搜索。
下面进行演示，首先依次建立january_log、february_log和march_log3个索引。创建索引january_log的DSL如下：
PUT /january_log
{
"mappings":{
"properties":{
"uid":{ //用户ID字段
"type":"keyword"
},
"hotel_id":{ //酒店ID字段
"type":"keyword"
},
"check_in_date":{ //入住日期字段
"type":"keyword"
}
}
}
}
因为这3个索引除了索引名称不一样，其他的参数都是一样的，所以创建索引february_log和march_log的DSL不再赘述。
下面分别在3个索引中写入同一用户在不同月份的入住记录。
在索引january_log中写入记录的DSL如下：
POST /january_log/_doc/001
{ //写入的文档数据
"uid":"001",
"hotel_id":"92772",
"check_in_date":"2021-01-05"
}
在索引february_log中写入记录的DSL如下：
POST /february_log/_doc/001
{ //写入的文档数据
"uid":"001",
"hotel_id":"33224",
"check_in_date":"2021-02-23"
}
在索引march_log中写入记录的DSL如下：
POST /march_log/_doc/001
{ //写入的文档数据
"uid":"001",
"hotel_id":"92772",
"check_in_date":"2021-03-28"
}
现在建立别名last_three_month，设置上面3个索引的别名为last_three_month，请求的DSL如下：
POST /_aliases
{
"actions": [
{
"add": { //为索引january_log建立别名last_three_month
"index": "january_log",
"alias": "last_three_month"
}
},
{
"add": { //为索引february_log建立别名last_three_month
"index": "february_log",
"alias": "last_three_month"
}
},
{
"add": { //为索引march_log建立别名last_three_month
"index": "march_log",
"alias": "last_three_month"
}
}
]
}
此时，请求在索引last_three_month中搜索uid为001的用户的入住记录，搜索的DSL如下：
GET /last_three_month/_search
{
"query": {
"term": { //搜索uid为001的文档
"uid": "001"
}
}
}
搜索结果返回的数据如下：
{
…
"hits" : {
…
"hits" : [
{ //索引february_log中命中的文档信息
"_index" : "february_log",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.2876821,
"_source" : {
"uid" : "001",
"hotel_id" : "33224",
"check_in_date" : "2021-02-23"
}
},
{ //索引january_log中命中的文档信息
"_index" : "january_log",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.2876821,
"_source" : {
"uid" : "001",
"hotel_id" : "92772",
"check_in_date" : "2021-01-05"
}
},
{ //索引march_log中命中的文档信息
"_index" : "march_log",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.2876821,
"_source" : {
"uid" : "001",
"hotel_id" : "92772",
"check_in_date" : "2021-03-28"
}
}
]
}
}
由上面的结果可知，当请求搜索last_three_month的数据时，ES将请求转发到了january_log、february_log和march_log3个索引中。
需要指出的是，在默认情况下，当一个别名只指向一个索引时，写入数据的请求可以指向这个别名，如果这个别名指向多个索引（就像上面的例子），则写入数据的请求是不可以指向这个别名的。例如，向last_three_month中写入一条数据：
POST /last_three_month/_doc/002
{ //向别名索引last_three_month中写入数据
"uid":"002",
"hotel_id":"92772",
"check_in_date":"2021-01-28"
}
ES返回的报错信息如下：
{
"error" : {
"root_cause" : [
{ //无法写入数据的报错信息
"type" : "illegal_argument_exception",
"reason" : "no write index is defined for alias [last_three_month].
The write index may be explicitly disabled using is_write_index=false or
the alias points to multiple indices without one being designated as a write
index"
}
],
//无法写入数据的报错信息
"type" : "illegal_argument_exception",
"reason" : "no write index is defined for alias [last_three_month]. The
write index may be explicitly disabled using is_write_index=false or the
alias points to multiple indices without one being designated as a write
index"
},
"status" : 400 //返回状态码
}
根据上面的报错信息可知，在默认情况下，ES不能确定向last_three_month写入数据时的转发对象。这种情况需要在别名设置时，将目标索引的is_write_index属性值设置为true来指定该索引可用于执行数据写入操作。例如设置january_log为数据写入转发对象，对应的DSL如下：
POST /_aliases
{
"actions": [
{
"add": { //设置january_log为索引别名last_three_month的数据写入转发对象
"index": "january_log",
"alias": "last_three_month",
"is_write_index":true
}
}
]
}
此时可以再向last_three_month中写入上面的数据，不再赘述。
ES返回的结果如下：
{
"_index" : "january_log", //实际被写入的索引名称
"_type" : "_doc",
"_id" : "002", //文档ID
"_version" : 1, //文档版本
"result" : "created", //写入成功标识
"_shards" : {
"total" : 2,
"successful" : 1, //写入成功状态码
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 1
}
根据上面的结果可知，将索引别名last_three_month的数据写入转发对象设置为索引january_log之后，再向last_three_month发起写入数据的请求时，ES会将该请求转发到索引january_log中。
引入别名之后，还可以用别名表示索引之间的替代关系。这种关系一般是在某个索引被创建后，有些参数是不能更改的（如主分片的个数），但随着业务发展，索引中的数据增多，需要更改索引参数进行优化。我们需要平滑地解决该问题，既要更改索引的设置，又不能改变索引名称，这时就可以使用索引别名。
假设一个酒店的搜索别名设置为hotel，初期创建索引hotel_1时，主分片个数设置为5，然后设置hotel_1的别名为hotel。此时客户端使用索引别名hotel进行搜索请求，该请求会转发到索引hotel_1中。假设此时酒店索引中的新增数据急剧增长，索引分片需要扩展，需要将其扩展成为10个分片的索引。但是一个索引在创建后，主分片个数已经不能更改，因此只能考虑使用索引替换来完成索引的扩展。这时可以创建一个索引hotel_2，除了将其主分片个数设置为10外，其他设置与hotel_1相同。当hotel_2的索引数据准备好后，删除hotel_1的别名hotel，同时，置hotel_2的别名为hotel。此时客户端不用进行任何改动，继续使用hotel进行搜索请求时，该请求会转发给索引hotel_2。如果服务稳定，最后将hotel_1删除即可。此时借助别名就完成了一次索引替换工作。
如图3.2所示，在左图中，hotel索引别名暂时指向hotel_1，hotel_2做好了数据准备；在右图中，hotel索引别名指向hotel_2，完成了索引的扩展切换。
下面进行演示。首先建立索引hotel_1，设置其主分片个数为5，其他信息与创建索引时保持一致。
PUT /hotel_1
{
"settings": {
"number_of_shards" : 5, //设置主分片个数为5
"number_of_replicas" : 2 //设置副分片个数为2
},
"mappings":{…}
}
在数据写入端向hotel_1写入搜索数据，请求的DSL如下：
POST /hotel_1/_doc/001
{ //写入的文档数据
"title":"好再来酒店",
"city":"青岛",
"price":578.23
}
建立别名hotel，请求的DSL如下：
POST /_aliases
{
"actions": [
{
"add": { //为索引hotel_1建立别名hotel
"index": "hotel_1",
"alias": "hotel"
}
}
]
}
在搜索请求端使用hotel进行搜索，假设在title字段中搜索“再来”，搜索的DSL如下：
GET /hotel/_search
{
"query": { //在hotel中搜索
"match": {
"title": "再来"
}
}
}
ES返回的数据如下：
{
…
"hits" : {
…
"hits" : [ //命中的文档信息
{
"_index" : "hotel_1", //索引hotel_1上命中的文档
"_type" : "_doc",
"_id" : "001",
"_score" : 0.5753642,
"_source" : { //具体的文档信息
"title" : "好再来酒店",
"city" : "青岛",
"price" : 578.23
}
}
]
}
}
通过搜索结果可以看出，因为只有索引hotel_1的别名为hotel，所以向索引别名hotel发起搜索请求时ES会将搜索请求全部转发给索引hotel_1。
假设过一段时间后酒店索引的分片需要扩展。通过变更索引的方式可以完成扩展。建立索引hotel_2，并设置主分片个数为10，设置副分片个数为2，请求的DSL如下：
PUT /hotel_2
{
"settings": {
"number_of_shards" : 10, //设置主分片数为10
"number_of_replicas" : 2 //设置副分片数为2
},
"mappings":{…}
}
在数据写入端向索引hotel_2中写入搜索数据，请求的DSL如下：
POST /hotel_2/_doc/001
{ //向索引hotel_2中写入的文档数据
"title":"好再来酒店",
"city":"青岛",
"price":578.23
}
此时hotel_2中的数据已经准备完毕，现在变更别名设置，删除hotel_1的索引别名，设置索引hotel_2的别名为hotel2，请求的DSL如下：
POST /_aliases
{
"actions": [
{
"remove": { //删除索引hotel_1的别名hotel
"index": "hotel_1",
"alias": "hotel"
}
},
{
"add": { //增加索引hotel_2的别名hotel
"index": "hotel_2",
"alias": "hotel"
}
}
]
}
再执行前面的搜索，返回结果如下：
{
…
"hits" : {
…
"hits" : [
{ //命中索引hotel_2中的文档
"_index" : "hotel_2",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.5753642,
"_source" : {
"title" : "好再来酒店",
"city" : "青岛",
"price" : 578.23
}
}
]
}
}
通过搜索结果可以看出，请求hotel索引进行搜索时，搜索已经从转发给hotel_1变更为转发给hotel_2。因此，索引别名在这种需要变更索引的情况下，搜索端不需要任何变更即可完成切换，这在实际的生产环境中是非常方便的。
2 映射操作
在使用数据之前，需要构建数据的组织结构。这种组织结构在关系型数据库中叫作表结构，在ES中叫作映射。作为无模式搜索引擎，ES可以在数据写入时猜测数据类型，从而自动创建映射。但有时ES创建的映射中的数据类型和目标类型可能不一致。当需要严格控制数据类型时，还是需要用户手动创建映射。
本节首先介绍映射的创建、查看和修改操作，然后详细介绍ES中的基本数据类型和复杂的数据类型，并且会对常用的类型用法进行示范，最后介绍映射的常用参数和动态映射的使用。
2.1 查看映射
在ES中写入文档请求的类型是GET，其请求形式如下：
GET /${index_name}/_mapping
上面的index_name就是索引名称。查看索引hotel的mappings，请求的DSL如下：
GET /hotel/_mapping
ES的返回结果如下：
{
"hotel" : {
"mappings" : {
"properties" : {
"city" : { //定义city字段类型为keyword
"type" : "keyword"
},
"price" : { //定义price字段类型为double
"type" : "double"
},
"title" : { //定义title字段类型为text
"type" : "text"
}
}
}
}
}
通过返回信息可见，查看索引hotel的mappings时，返回的信息和建立该索引时的信息是一致的。
2.2 扩展映射
可能有的读者看到标题时会有疑问：映射不能修改吗？为什么是扩展呢？答案是，映射中的字段类型是不可以修改的，但是字段可以扩展。最常见的扩展方式是增加字段和为object（对象）类型的数据新增属性。下面的DSL示例为扩展hotel索引，并增加tag字段。
POST /hotel/_mapping
{
"properties": {
"tag": { //索引中新增字段tag，类型为keyword
"type": "keyword"
}
}
}
查看索引hotel的mappings，返回结果如下：
{
"hotel" : {
"mappings" : {
"properties" : {
"city" : { //原有的city字段，类型为keyword
"type" : "keyword"
},
"price" : { //原有的price字段，类型为double
"type" : "double"
},
"tag" : { //新增tag字段，类型为keyword
"type" : "keyword"
},
"title" : { //原有的title字段，类型为text
"type" : "text"
}
}
}
}
}
由返回结果可知，tag字段已经被添加到索引hotel中。
2.3 基本的数据类型
1 keyword类型
keyword类型是不进行切分的字符串类型。这里的“不进行切分”指的是：在索引时，对keyword类型的数据不进行切分，直接构建倒排索引；在搜索时，对该类型的查询字符串不进行切分后的部分匹配。keyword类型数据一般用于对文档的过滤、排序和聚合。
在现实场景中，keyword经常用于描述姓名、产品类型、用户ID、URL和状态码等。keyword类型数据一般用于比较字符串是否相等，不对数据进行部分匹配，因此一般查询这种类型的数据时使用term查询。
例如，建立一个人名索引，可以设定姓名字段为keyword字段：
PUT /user
{
"mappings": {
"properties": {
"user_name":{ //定义user_name字段类型为keyword
"type": "keyword"
}
}
}
}
现在写入一条数据，请求的DSL如下：
POST /user/_doc/001
{ //写入数据
"user_name":"张三"
}
下面查询刚刚写入的数据，请求的DSL如下：
GET /user/_search
{
"query": {
"term": { //term查询
"user_name": {
"value": "张三"
}
}
}
}
返回的结果信息如下：
{
…
"hits" : [
{ //返回命中的文档
"_index" : "user",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.2876821,
"_source" : {
"user_name" : "张三"
}
}
]
}
}
由搜索结果可以看出，使用term进行全字符串匹配“张三”可以搜索到命中文档。
下面的DSL使用match搜索姓名中带有“张”的记录：
GET /user/_search
{
"query": {
"match": { //使用match搜索
"user_name": "张"
}
}
}
返回结果如下：
{
…
"hits" : {
"total" : { //没有命中文档
"value" : 0,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ] //命中文档的集合为空
}
}
由搜索结果可见，对keyword类型使用match搜索进行匹配是不会命中文档的。
2 text类型
text类型是可进行切分的字符串类型。这里的“可切分”指的是：在索引时，可按照相应的切词算法对文本内容进行切分，然后构建倒排索引；在搜索时，对该类型的查询字符串按照用户的切词算法进行切分，然后对切分后的部分匹配打分。
例如，一个酒店搜索项目，我们希望可以根据酒店名称即title字段进行模糊匹配，因此可以设定title字段为text字段，建立酒店索引的DSL如下：
PUT /hotel
{
"mappings":{
"properties":{
"title":{ //定义title字段类型为text
"type":"text"
}
…
}
}
}
现在写入一条数据：
POST /hotel/_doc/001
{ //写入数据
"title":"文雅酒店"
}
下面先按照普通的term进行搜索，观察能否搜索到刚刚写入的文档，请求的DSL如下：
GET /hotel/_search
{
"query": {
"term": { //使用term搜索
"title": {
"value": "文雅酒店"
}
}
}
}
返回结果如下：
{
…
"hits" : {
"total" : { //使用term搜索text类型数据时没有命中文档
"value" : 0,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ] //命中的文档集合为空
}
}
根据返回结果可知，上面的请求并没有搜索到文档。term搜索用于搜索值和文档对应的字段是否完全相等，而对于text类型的数据，在建立索引时ES已经进行了切分并建立了倒排索引，因此使用term没有搜索到数据。一般情况下，搜索text类型的数据时应使用match搜索。关于match搜索的具体使用，后面的章节会详细介绍，本节仅进行简单的使用：
GET /hotel/_search
{
"query": {
"match": { //使用match搜索
"title": "文雅"
}
}
}
返回结果如下：
{
…
"hits" : {
"total" : {
"value" : 1, //有一个文档被命中
"relation" : "eq"
},
"max_score" : 0.5753642,
"hits" : [ //命中的文档数据
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "001",
"_score" : 0.5753642,
"_source" : {
"title" : "文雅酒店"
}
}
]
}
}
3 数值类型
ES支持的数值类型有long、integer、short、byte、double、float、half_float、scaled_float和unsigned_long等。各类型所表达的数值范围可以参考官方文档，网址为https://www.elastic.co/guide/en/elasticsearch/reference/current/number.html。为节约存储空间并提升搜索和索引的效率，在实际应用中，在满足需求的情况下应尽可能选择范围小的数据类型。比如，年龄字段的取值最大值不会超过200，因此选择byte类型即可。数值类型的数据也可用于对文档进行过滤、排序和聚合。以酒店搜索为例，酒店的索引除了包含酒店名称和城市之外，还需要定义价格、星级和评论数等，创建索引的DSL如下：
PUT /hotel
{
"mappings":{
"properties":{
"title":{
"type":"text"
},
"city":{
"type":"keyword"
},
"price":{ //定义价格字段，类型为double
"type":"double"
},
"star":{ //定义星级字段，类型为byte
"type":"byte"
},
"comment_count":{ //定义评论数字段，类型为integer
"type":"integer"
}
}
}
}
对于数值型数据，一般使用term搜索或者范围搜索。例如，搜索价格为350～400（包含350和400）元的酒店，搜索的DSL如下：
GET /hotel/_search
{
"query": {
"range": { //定义range查询
"price": {
"gte": 350,
"lte": 400
}
}
}
}
4 布尔类型
布尔类型使用boolean定义，用于业务中的二值表示，如商品是否售罄，房屋是否已租，酒店房间是否满房等。写入或者查询该类型的数据时，其值可以使用true和false，或者使用字符串形式的"true"和"false"。下面的DSL定义索引中“是否满房”的字段为布尔类型：
PUT /hotel
{
"mappings":{
"properties":{
"title":{
"type":"text"
},
"city":{
"type":"keyword"
},
"price":{
"type":"double"
},
"full_room":{ //定义是否满房的字段，类型为boolean
"type": "boolean"
}
}
}
}
下面的DSL将查询满房的酒店：
GET /hotel/_search
{
"query": {
"term": {
"full_room": { //使用term查询boolean类型的数据
"value": "true"
}
}
}
}
5 日期类型
在ES中，日期类型的名称为date。ES中存储的日期是标准的UTC格式。下面定义索引hotel，该索引有一个create_time字段，现在把它定义成date类型。定义date类型请求的DSL如下：
PUT /hotel
{
"mappings":{
"properties":{
"title":{
"type":"text"
},
"city":{
"type":"keyword"
},
"price":{
"type":"double"
},
"create_time":{ //定义create_time字段，类型为date
"type":"date"
}
}
}
}
一般使用如下形式表示日期类型数据：
- 格式化的日期字符串。
- 毫秒级的长整型，表示从1970年1月1日0点到现在的毫秒数。
- 秒级别的整型，表示从1970年1月1日0点到现在的秒数。
日期类型的默认格式为strict_date_optional_time||epoch_millis。其中，strict_date_optional_time的含义是严格的时间类型，支持yyyy-MM-dd、yyyyMMdd、yyyyMMddHHmmss、yyyy-MM-ddTHH:mm:ss、yyyy-MM-ddTHH:mm:ss.SSS和yyyy-MM-ddTHH:mm:ss.SSSZ等格式，epoch_millis的含义是从1970年1月1日0点到现在的毫秒数。
下面写入索引的文档中有一个create_time字段是日期格式的字符串，请求的DSL如下：
POST /hotel/_doc/001
{ //写入数据
"title":"好再来酒店",
"city":"青岛",
"price":578.23,
"create_time":"20210115"
}
搜索日期型数据时，一般使用ranges查询。例如，搜索创建日期为2015年的酒店，请求的DSL如下：
GET /hotel/_search
{
"query": {
"range": { //使用range搜索日期型数据
"create_time": {
"gte": "20150101",
"lt": "20160101"
}
}
}
}
日期类型默认不支持yyyy-MM-dd HH:mm:ss格式，如果经常使用这种格式，可以在索引的mapping中设置日期字段的format属性为自定义格式。下面的示例将设置create_time字段的格式为yyyy-MM-dd HH:mm:ss：
PUT /hotel
{
"mappings":{
"properties":{
"title":{
"type":"text"
},
"city":{
"type":"keyword"
},
"price":{
"type":"double"
},
"create_time":{ //指定日期型字段的格式
"type":"date",
"format": "yyyy-MM-dd HH:mm:ss"
}
}
}
}
此时如果再写入以前的数据，系统将报错。报错信息如下：
{
"error" : {
"root_cause" : [
{ //日期格式解析异常
"type" : "mapper_parsing_exception",
"reason" : "failed to parse field [create_time] of type [date] in
document with id '001'. Preview of field's value: '20210115'"
}
],
"type" : "mapper_parsing_exception",
"reason" : "failed to parse field [create_time] of type [date] in document
with id '001'. Preview of field's value: '20210115'", //日期格式解析异常
"caused_by" : {
"type" : "illegal_argument_exception",
"reason" : "failed to parse date field [20210115] with format [yyyy-
MM-dd HH:mm:ss]",
"caused_by" : {
"type" : "date_time_parse_exception",
"reason" : "Text '20210115' could not be parsed at index 0"
}
}
},
"status" : 400
}
根据错误信息可知，错误的原因是写入的数据格式和定义的数据格式不同。此时需要写入的格式为yyyy-MM-dd HH:mm:ss的文档，请求的DSL如下：
POST /hotel/_doc/001
{ //写入数据
"title":"好再来酒店",
"city":"青岛",
"price":578.23,
"create_time":"2021-01-15 01:23:30" //写入符合自定义格式的日期数据
}
2.4 复杂的数据类型
1 数组类型
ES数组没有定义方式，其使用方式是开箱即用的，即无须事先声明，在写入时把数据用中括号[]括起来，由ES对该字段完成定义。当然，如果事先已经定义了字段类型，在写数据时以数组形式写入，ES也会将该类型转为数组。例如，为hotel索引增加一个标签字段，名称为tag，请求的DSL如下：
PUT /hotel/_mapping
{
"properties": {
"tag": { //增加tag字段，类型为keyword
"type": "keyword"
}
}
}
查看一下索引hotel的mapping：
{
"hotel" : {
"mappings" : {
"properties" : {
"city" : { //原有的city字段，类型为keyword
"type" : "keyword"
},
"price" : { //原有的price字段，类型为double
"type" : "double"
},
"tag" : { //增加tag字段，类型为keyword
"type" : "keyword"
},
"title" : { //原有的title字段，类型为text
"type" : "text"
}
}
}
}
}
通过返回的mapping信息来看，新增的tag字段与普通的keyword类型字段没什么区别，现在写入一条数据：
POST /hotel/_doc/001
{ //写入数据
"title":"好再来酒店",
"city":"青岛",
"price":578.23,
"tag":["有车位","免费WIFI"] //写入字符串数组数据
}
查看一下写入的数据，ES返回的信息如下：
{
…
"_source" : {
"title" : "好再来酒店",
"city" : "青岛",
"price" : 578.23,
"tag" : [ //tag字段自动转换为字符串数组类型
"有车位",
"免费WIFI"
]
}
}
通过以上信息可以看到，写入的数据的tag字段已经是数组类型了。那么，数组类型的数据如何搜索呢？
数组类型的字段适用于元素类型的搜索方式，也就是说，数组元素适用于什么搜索，数组字段就适用于什么搜索。例如，在上面的示例中，数组元素类型是keyword，该类型可以适用于term搜索，则tag字段也可以适用于term搜索，搜索的DSL如下：
GET /hotel/_search
{
"query": {
"term": { //使用term搜索数组类型的数据
"tag": {
"value": "有车位"
}
}
}
}
ES中的空数组可以作为missing field，即没有值的字段，下面的DSL将插入一条tag为空的数组：
POST /hotel/_doc/002
{
"title":"环球酒店",
"city":"青岛",
"price":530.00,
"tag":[] //写入空数组
}
2 对象类型
在实际业务中，一个文档需要包含其他内部对象。例如，在酒店搜索需求中，用户希望酒店信息中包含评论数据。评论数据分为好评数量和差评数量。为了支持这种业务，在ES中可以使用对象类型。和数组类型一样，对象类型也不用事先定义，在写入文档的时候ES会自动识别并转换为对象类型。
下面将在hotel索引中添加一条记录，请求的DSL如下：
POST /hotel/_doc/001
{ //写入数据
"title": "好再来酒店",
"city": "青岛",
"price": 578.23,
"comment_info": { //评论数据
"properties": {
"favourable_comment":199, //好评数据
"negative_comment": 68 //差评数据
}
}
}
执行以上DSL后，索引hotel增加了一个字段comment_info，它有两个属性，分别是favourable_comment和negative_comment，二者的类型都是long。下面查看mapping进行验证：
{
"hotel" : {
"mappings" : {
"properties" : {
"city" : {
"type" : "keyword"
},
"comment_info" : { //评论数据
"properties" : {
"properties" : {
"properties" : {
"favourable_comment" : { //好评数据，类型为long
"type" : "long"
},
"negative_comment" : { //差评数据，类型为long
"type" : "long"
}
}
}
}
},
"create_time" : {
"type" : "date",
"format" : "yyyy-MM-dd HH"
},
"price" : {
"type" : "double"
},
"title" : {
"type" : "text"
}
}
}
}
}
根据对象类型中的属性进行搜索，可以直接用“.”操作符进行指向。例如，搜索hotel索引中好评数大于200的文档，请求的DSL如下：
GET /hotel/_search
{
"query": {
"range": { //使用range搜索对象类型数据
"comment_info.properties.favourable_comment": {
"gte": 209
}
}
}
}
当然，对象内部还可以包含对象。例如，评论信息字段comment_info可以增加前3条好评数据，请求的DSL如下：
POST /hotel/_doc/001
{ //写入数据
"title": "好再来酒店",
"city": "青岛",
"price": 578.23,
"comment_info": {
"properties": {
"favourable_comment": 199,
"negative_comment": 68,
"top3_favourable_comment": { //新增字段
"top1": { //增加的第一条评论数据
"content": "干净整洁的一家酒店",
"score": 87
},
"top2": { //增加的第二条评论数据
"content": "服务周到，停车方便",
"score": 89
},
"top3": { //增加的第三条评论数据
"content": "闹中取静，环境优美",
"score": 90
}
}
}
}
}
以上请求，对文档的comment_info字段增加了前3条评论的内容和评分数据。
3 地理类型
在移动互联网时代，用户借助移动设备产生的消费也越来越多。例如，用户需要根据某个地理位置来搜索酒店，此时可以把酒店的经纬度数据设置为地理数据类型。该类型的定义需要在mapping中指定目标字段的数据类型为geo_point类型，示例如下：
PUT /hotel
{
"mappings": {
"properties": {
"title": {
"type": "text"
},
"city": {
"type": "keyword"
},
"price": {
"type": "double"
},
"create_time": {
"type": "date"
},
"location": { //定义字段location，类型为geo_point
"type": "geo_point"
}
}
}
}
其中，location字段定义为地理类型，现在向索引中写入一条酒店文档，DSL如下：
POST /hotel/_doc/001
{
"title": "文雅酒店",
"city": "北京",
"price": 556,
"create_time": "2021-01-15",
"location": { //写入geo_point类型数据，lat为纬度，lon为经度
"lat": 40.012134,
"lon": 116.497553
}
}
2.5 动态映射
当字段没有定义时，ES可以根据写入的数据自动定义该字段的类型，这种机制叫作动态映射。其实，在前面的章节中我们已经用到了ES的动态映射机制。在介绍数组类型和对象类型时提到，这两种类型都不需要用户提前定义，ES将根据写入的数据自动创建mapping中对应的字段并指定类型。对于基本类型，如果字段没有定义，ES在将数据存储到索引时会进行自动映射，如表3.1所示为自动映射时的JSON类型和索引数据类型的对应关系。
在一般情况下，如果使用基本类型数据，最好先把数据类型定义好，因为ES的动态映射生成的字段类型可能会与用户的预期有差别。例如，写入数据时，由于ES对于未定义的字段没有类型约束，如果同一字段的数据形式不同（有的是字符型，有的是数值型），则ES动态映射生成的字段类型和用户的预期可能会有偏差。提前定义好数据类型并将索引创建语句纳入SVN或Git管理范围是良好的编程习惯，同时还能增强项目代码的连贯性和可读性。
2.6 多字段
针对同一个字段，有时需要不同的数据类型，这通常表现在为了不同的目的以不同的方式索引相同的字段。例如，在订单搜索系统中，既希望能够按照用户姓名进行搜索，又希望按照姓氏进行排列，可以在mapping定义中将姓名字段先后定义为text类型和keyword类型，其中，keyword类型的字段叫作子字段，这样ES在建立索引时会将姓名字段建立两份索引，即text类型的索引和keyword类型的索引。订单搜索索引的定义如下：
PUT /hotel_order
{
"mappings": {
"properties": {
"order_id": { //定义order_id字段类型为keyword
"type": "keyword"
},
"user_id": { //定义user_id字段类型为keyword
"type": "keyword"
},
"user_name": { //定义user_name字段类型为text
"type": "text",
"fields": { //定义user_name多字段
//定义user_name字段的子字段user_name_keyword，并定义其类型为keyword
"user_name_keyword": {
"type": "keyword"
}
}
},
"hotel_id": { //定义hotel_id字段类型为keyword
"type": "keyword"
}
}
}
}
可以看出，正常定义user_name字段之后，使用fields定义其子字段的定义方式和普通字段的定义方式相同。
为方便演示，写入如下数据：
POST /_bulk
{"index":{"_index":"hotel_order","_id":"001"}}
{"order_id":"001","user_id":"user_00x","user_name":"Michael Jordan","hotel_id":"h001"}
{"index":{"_index":"hotel_order","_id":"002"}}
{"order_id":"002","user_id":"user_00a","user_name":"Stephen Jordan","hotel_id":"h0500"}
{"index":{"_index":"hotel_order","_id":"003"}}
{"order_id":"003","user_id":"user_30e","user_name":"Tim Jordan","hotel_id":"h0520"}
{"index":{"_index":"hotel_order","_id":"004"}}
{"order_id":"004","user_id":"user_430","user_name":"Kobe Jordan","hotel_id":"h0600"}
可以在普通搜索中使用user_name字段，DSL如下：
GET /hotel_order/_search
{
"query": {
"match": { //match搜索使用text类型的字段
"user_name": "Jordan"
}
},
"sort": { //排序使用子字段
"user_name.user_name_keyword": "asc"
}
}
搜索结果如下：
{
…
"hits" : {
…
"max_score" : null,
"hits" : [ //命中文档列表
{
…
"_id" : "004",
"_score" : null,
"_source" : {
…
"user_name" : "Kobe Jordan"
},
"sort" : [ //按照姓名全称排序
"Kobe Jordan"
]
},
{
"_index" : "hotel_order",
"_type" : "_doc",
"_id" : "001",
"_score" : null,
"_source" : {
…
"user_name" : "Michael Jordan"
},
"sort" : [ //按照姓名全称排序
"Michael Jordan"
]
},
{
"_index" : "hotel_order",
"_type" : "_doc",
"_id" : "002",
"_score" : null,
"_source" : {
…
"user_name" : "Stephen Jordan"
},
"sort" : [ //按照姓名全称排序
"Stephen Jordan"
]
},
…
]
}
}
根据以上结果可知，搜索Jordan之后，添加的4个文档都命中并且排序时是按照用户姓名的全称进行排序的。
3 文档操作
使用ES构建搜索引擎时需要经常对文档进行操作。除了简单的单条文档操作，有时还需要进行批量操作。本节将介绍文档的各种日常操作。此外，在生产环境中，对文档的批量操作一般需要借助编程语言来完成，因此在介绍DSL的同时本节还将演示Java客户端的使用。
3.1 单条写入文档
在ES中写入文档请求的类型是POST，其请求形式如下：
POST /${index_name}/_doc/${_id}
{ //写入的文档数据
…
}
上面的_id就是ES中的文档_id，这种请求方式是用户直接定义_id值，不使用ES生成的_id。请求的数据体即为写入的文档数据，格式是JSON形式。例如，在目标索引中写入下面数据：
POST /hotel/_doc/001
{ //写入的文档数据在URL中已经指定_id，因此在数据中需要指定_id
"title":"好再来酒店",
"city":"青岛",
"price":578.23
}
ES返回的结果如下：
{
"_index" : "hotel", //当前文档对应的索引
"_type" : "_doc",
"_id" : "001", //文档的_id
"_version" : 1,
"result" : "created",
"_shards" : { //写入影响的分片信息
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 2,
"_primary_term" : 9
}
由以上结果可知，向hotel索引中写入文档成功。另外，ES在返回结果中还会显示文档的版本，这里因为文档刚刚建立，所以当前值为1。
当然，用户也可以不指定文档_id，该_id值将由ES自动生成，其请求形式如下：
POST /${index_name}/_doc
{ //写入的文档数据
…
}
例如，写入上面的文档时不指定文档_id，请求的DSL如下：
POST /hotel/_doc
{ //写入的文档数据，url中不指定_id
"title":"好再来酒店",
"city":"青岛",
"price":578.23
}
在Java高级REST客户端中，单条写入文档需要创建IndexRequest对象并设置对应的索引和_id字段名称，执行时调用客户端的index()方法并把IndexRequest对象传入即可。index()方法返回IndexResponse对象，通过该对象可以获取当前请求的索引名称、文档_id和版本等。下面的代码演示了向索引中添加单条文档的方法。
public void singleIndexDoc(Map<String, Object> dataMap, String
indexName, String indexId) {
IndexRequest indexRequest = new IndexRequest(indexName).id(indexId).
source(dataMap); //构建IndexRequest对象并设置对应的索引和_id字段名称
try {
IndexResponse indexResponse = client.index(indexRequest,
RequestOptions.DEFAULT); //执行写入
//通过IndexResponse获取索引名称
String index = indexResponse.getIndex();
String id = indexResponse.getId();//通过IndexResponse获取文档ID
//通过IndexResponse获取文档版本
Long version = indexResponse.getVersion();
System.out.println("index=" + index + ",id=" + id + ",version="
+ version );
} catch (Exception e) {
e.printStackTrace();
}
}
3.2 批量写入文档
在ES中批量写入文档请求的类型是POST，其请求形式如下：
POST /_bulk //批量请求
{"index":{"_index":"${index_name}"}} //指定批量写入的索引
{…} //设定写入的文档内容
{"index":{"_index":"${index_name}"}}
{…} //设定写入的文档内容
请求体的第一行表示写入的第一条文档对应的元数据，其中，index_name表示写入的目标索引，第2行表示数据体，第3行表示写入的第二条文档对应的元数据，第4行表示数据体。以此类推，在一次请求里可以写入多条数据。下面将向hotel索引中批量写入两条酒店数据：
POST /_bulk //批量请求
{"index":{"_index":"hotel"}} //指定批量请求的索引，不指定文档_id
{"title": "文雅酒店","city": "北京","price": 556.00} //写入的数据
{"index":{"_index":"hotel"}} //指定批量请求的索引，不指定文档_id
{"title": "嘉怡假日酒店","city": "北京","price": 337.00} //写入的数据
上面的DSL写入索引中的文档_id是ES自动生成的。如果需要指定_id，则应该在元数据中添加_id。例如，下面的DSL将向酒店索引中添加文档_id为001和002两条文档：
POST /_bulk //批量请求
{"index":{"_index":"hotel","_id":"001"}} //指定批量请求的索引
{"title": "文雅酒店","city": "北京","price": 556.00} //写入的数据，指定文档_id
{"index":{"_index":"hotel","_id":"002"}} //指定批量请求的索引
//写入的数据，指定文档_id
{"title": "嘉怡假日酒店","city": "北京","price": 337.00}
在实际使用过程中需要批量写入的文档比较多，有时甚至上千条或者上万条，这时如果使用Kibana的请求页面就很不方便了。一般使用Linux系统中的curl命令进行数据的批量写入。curl命令支持上传文件，用户可以将批量写入的JSON数据保存到文件中，然后使用curl命令进行提交。
在ES单机环境下登录服务器，然后执行curl命令将上述两个文档批量写入hotel索引中：
curl -s –XPOST '127.0.0.1:9200/_bulk?preety' --data-binary "@bulk_doc.json"
其中，bulk_doc.json是文件名称，文件内容如下：
{"index":{"_index":"hotel","_id":"001"}} //指定批量请求的索引
{"title": "文雅酒店","city": "北京","price": 556.00} //写入的数据，指定文档_id
{"index":{"_index":"hotel","_id":"002"}} //指定批量请求的索引
//写入的数据，指定文档_id
{"title": "嘉怡假日酒店","city": "北京","price": 337.00}
在Java高级REST客户端中，批量写入文档需要创建BulkRequest对象并设置对应的索引名称。对于多条预写入的文档，可构建多个IndexRequest对象并调用BulkRequest.add()方法添加这些IndexRequest对象，执行时调用客户端的bulk()方法并把BulkRequest对象传入即可。bulk()方法返回BulkResponse对象，通过该对象可以获取当前请求的状态。以下代码演示了向索引中批量添加文档的方法：
public void bulkIndexDoc(String indexName, String docIdKey, List<Map<String, Object>> recordMapList) {
//构建批量操作BulkRequest对象
BulkRequest bulkRequest = new BulkRequest(indexName);
for (Map<String, Object> dataMap : recordMapList) { //遍历数据
//获取主键作为ES索引的主键
String docId = dataMap.get(docIdKey).toString();
IndexRequest indexRequest = new IndexRequest().id(docId).source(dataMap); //构建IndexRequest对象
bulkRequest.add(indexRequest); //添加IndexRequest
}
bulkRequest.timeout(TimeValue.timeValueSeconds(5)); //设置超时时间
try {
BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT); //执行批量写入
if (bulkResponse.hasFailures()) { //判断执行状态
System.out.println("bulk fail,message:" + bulkResponse.buildFailureMessage());
}
} catch (IOException e) {
e.printStackTrace();
}
}
@GetMapping("/bulkIndex")
public void bulkIndex() {
String indexName = "hotel_oder_1";
String docIdKey = "id";
List<Map<String, Object>> list = Lists.newArrayList();
Map<String, Object> r_map = Maps.newHashMap();
r_map.put("id", "001");
r_map.put("title", "如家酒店");
r_map.put("price", 10000);
r_map.put("address", "济南");
list.add(r_map);
Map<String, Object> bj_map = Maps.newHashMap();
bj_map.put("id", "002");
bj_map.put("title", "如家酒店");
bj_map.put("price", 10000);
bj_map.put("address", "北京");
list.add(bj_map);
esService.bulkIndexDoc(indexName, docIdKey, list);
}
3.3 更新单条文档
在ES中更新索引的请求类型是POST，其请求形式如下：
POST /${index_name}/_update/${_id}
{ //需要更新的数据，在URL中指定文档_id
…
}
上面的_id就是将要修改的ES文档中的_id，修改后的字段和值将会填写到大括号中，其格式是JSON形式。例如把_id为001的文档修改成下面的数据：
POST /hotel/_update/001
{//需要更新的数据，在url中指定文档_id
"doc": { //更新后的数据
"title": "好再来酒店",
"city": "北京",
"price": 659.45
}
}
执行上述命令后，ES返回的结果如下：
{
"_index" : "hotel", //更新的索引名称
"_type" : "_doc",
"_id" : "001", //更新的文档_id
"_version" : 2,
"result" : "updated", //更新成功信息
"_shards" : { //更新影响的分片信息
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 3,
"_primary_term" : 9
}
通过结果可知，已经成功更新文档信息，并且本次修改后文档的版本变为2。下面根据_id搜索文档的命令进行验证：
GET /hotel/_doc/001
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "001",
"_version" : 2,
"_seq_no" : 3,
"_primary_term" : 9,
"found" : true,
"_source" : {
"title" : "好再来酒店",
"city" : "北京",
"price" : 659.45
}
}
通过返回的结果可知，文档001的对应字段已经被修改成目标数据，并且文档的版本已经更新为2。
在Java高级REST客户端中，更新单条文档需要创建UpdateRequest对象并设置对应的索引和_id字段名称，执行时，调用客户端的update()方法并把UpdateRequest对象传入即可。index()方法返回UpdateResponse对象，通过该对象可以获取当前请求的索引名称、文档_id和版本等。以下代码演示了向索引中添加单条文档的方法：
public void singleUpdate(String indexName, String docIdKey, Map<String,
Object> recordMap) {
UpdateRequest updateRequest = new UpdateRequest(indexName, docIdKey);
updateRequest.doc(recordMap);
try {
UpdateResponse updateResponse=client.update(updateRequest,
RequestOptions.DEFAULT);
//通过IndexResponse获取索引名称
String index = updateResponse.getIndex();
//通过IndexResponse获取文档ID
String id = updateResponse.getId();
//通过IndexResponse获取文档版本
Long version = updateResponse.getVersion();
System.out.println("index=" + index + ",id=" + id + ",version="
+version);
} catch (IOException e) {
e.printStackTrace();
}
}
@GetMapping("/singleUpdate")
public void singleUpdate() {
String indexName = "hotel_oder_1";
String docIdKey = "001";
Map<String, Object> recordMap = Maps.newHashMap();
recordMap.put("title", "_如家酒店");
esService.singleUpdate(indexName, docIdKey, recordMap);
}
除了普通的update功能，ES还提供了upsert。upsert即是update和insert的合体字，表示更新/插入数据。如果目标文档存在，则执行更新逻辑；否则执行插入逻辑。以下DSL演示了upsert的应用：
POST /hotel/_update/001
{
"doc": {
"title": "好再来酒店",
"city": "北京",
"price": 659.45
},
"upsert": {
"title": "好再来酒店",
"city": "北京",
"price": 659.45
}
}
执行以上DSL后，如果文档001存在，则执行更新逻辑，将doc内容更新到文档中；否则执行插入逻辑，将upsert的内容写入文档中。
编写Java代码时执行upsert的逻辑和update相似，不同的是构建完成后需调用UpdateRequest.upsert()将插入的对象传入。下面的代码演示了使用upsert向索引中更新/插入数据的方法。
public void singleUpsert(String index, String docIdKey, Map<String,
Object> recordMap,Map<String, Object> upRecordMap) {
//构建UpdateRequest
UpdateRequest updateRequest = new UpdateRequest(index, docIdKey);
updateRequest.doc(recordMap); //设置更新逻辑
updateRequest.upsert(upRecordMap); //设置插入逻辑
try {
//执行upsert命令
client.update(updateRequest, RequestOptions.DEFAULT);
} catch (IOException e) {
e.printStackTrace();
}
}
3.4 批量更新文档
与批量写入文档相似，批量更新文档的请求形式如下：
POST /_bulk //批量请求
//指定批量更新的索引和文档_id
{"update":{"_index":"${index_name}","_id":"${_id}"}}
{"doc":{ …}#JSON数据} //设定更新的文档内容
//指定批量更新的索引和文档_id
{"update":{"_index":"${index_name}","_id":"${_id}"}}
{"doc":{ …}#JSON数据} //设定更新的文档内容
注意，与批量写入文档不同的是，批量更新文档必须在元数据中填写需要更新的文档_id。下面的DSL将批量更新_id为001和002的文档：
POST /_bulk //批量请求
//指定批量更新的索引和文档_id
{"update":{"_index":"hotel","_id":"001"}}
//设定更新的文档内容
{"doc":{"title": "文雅豪情酒店","city": "北京","price": 556.00}}
{"update":{"_index":"hotel","_id":"002"}} //指定批量更新的索引和文档_id
//设定更新的文档内容
{"doc":{"title": "嘉怡七天酒店","city": "北京","price": 337.00}}
在Java客户端接口中，批量更新文档需要创建BulkRequest对象并设置对应的索引名称。对于多条需要更新的文档，可构建多个UpdateRequest对象并调用BulkRequest.add()方法添加这些UpdateRequest对象，执行时，调用客户端的bulk()方法并把BulkRequest对象传入即可。以下代码演示了向索引中批量更新文档的方法：
public void bulkUpdate(String index, String docIdKey, List<Map<String,
Object>> recordMapList) {
BulkRequest bulkRequest = new BulkRequest();//构建BulkRequest对象
for (Map<String, Object> dataMap : recordMapList) {//遍历数据列表
String docId = dataMap.get(docIdKey).toString();
dataMap.remove(docId); //将ID字段从map中删除
//创建UpdateRequest对象
bulkRequest.add(new UpdateRequest(index, docId).doc(dataMap));
}
try {
BulkResponse bulkResponse = client.bulk(bulkRequest, Request
Options.DEFAULT); //执行批量更新
if (bulkResponse.hasFailures()) { //判断状态
System.out.println("bulk fail,message:" + bulkResponse.
buildFailureMessage());
}
} catch (Exception e) {
e.printStackTrace();
}
}
@GetMapping("/bulkUpdate")
public void bulkUpdate() {
String indexName = "hotel_order";
String docIdKey = "id";
List<Map<String, Object>> recordMapList = Lists.newArrayList();
Map<String, Object> r_recordMap = Maps.newHashMap();
r_recordMap.put("user_name", "_如家酒店");
r_recordMap.put("id", "001");
Map<String, Object> bj_recordMap = Maps.newHashMap();
bj_recordMap.put("user_name", "__如家酒店");
bj_recordMap.put("id", "002");
recordMapList.add(r_recordMap);
recordMapList.add(bj_recordMap);
esService.bulkUpdate(indexName, docIdKey, recordMapList);
}
3.5 根据条件更新文档
在索引数据的更新操作中，有些场景需要根据某些条件同时更新多条数据，类似于在RDBMS中使用update table table_name set…where…更新一批数据。为了满足这样的需求，ES为用户提供了_update_by_query功能，其请求形式如下：
POST /${index_name}/_update_by_query
{
"query": { //条件更新的查询条件
…
},
"script": { //条件更新的具体更新脚本代码
…
}
}
上面的query用于指定更新数据的匹配条件，相当于SQL中的where语句；script用于指定具体的更新操作，相当于SQL的set内容。script的知识点将在后面的章节中进行介绍，这里仅简单应用一下，请求的DSL如下：
POST /hotel/_update_by_query
{
"query": { //更新文档的查询条件：城市为北京的文档
"term": {
"city": {
"value": "北京"
}
}
},
"script": { //条件更新的更新脚本，将城市改为“上海”
"source": "ctx._source['city']='上海'",
"lang": "painless"
}
}
执行以上DSL后，ES将先搜索城市为“北京”的酒店，然后把这些酒店的城市字段的值改为“上海”。
在Java高级REST客户端中，执行根据条件更新文档，需要创建UpdateByQueryRequest对象并设置对应的索引名称，类似于DSL中的query子句，通过调用UpdateByQuery Request.setQuery()方法设置查询逻辑，script子句通过调用UpdateByQueryRequest.setScript()方法设置更新逻辑，然后执行客户端的updateByQuery()方法并把UpdateByQueryRequest对象传入即可。以下代码演示了根据城市字段查找文档然后更新城市字段的方法：
public void updateCityByQuery(String index,String oldCity,String
newCity) {
UpdateByQueryRequest updateByQueryRequest=new UpdateByQueryRequest
(index); //构建UpdateByQueryRequest对象
//设置按照城市查找文档的query
updateByQueryRequest.setQuery(new TermQueryBuilder("city",oldCity));
updateByQueryRequest.setScript(new Script("ctx._source['city']=
'"+newCity+"';")); //设置更新城市字段的脚本逻辑
try {
client.updateByQuery(updateByQueryRequest,RequestOptions.
DEFAULT); //执行更新
} catch (IOException e) {
e.printStackTrace();
}
}
@GetMapping("/updateHotelByQuery")
public void updateHotelByQuery() {
String indexName = "hotel_order";
esService.updateHotelByQuery(indexName, "001", "_BJ如家酒店");
}
如果更新所有文档中的某个字段应该如何操作呢？其实，_update_by_query中的query子句可以不定义，这种情况下ES会选中所有的文档执行script中的内容。以下为修改所有酒店中城市为“上海”的DSL：
POST /hotel/_update_by_query
{
"script": { //更新所有文档中的城市为“上海”
"source": "ctx._source['city']='上海'",
"lang": "painless"
}
}
3.6删除单条文档
在ES中删除文档的请求的类型是DELETE，其请求形式如下：
DELETE /${index_name}/_doc/${_id}
上面的_id就是将要删除的ES文档的_id。执行下面的删除命令：
DELETE /hotel/_doc/001
返回的结果如下：
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "001", //删除的文档_id
"_version" : 1,
"result" : "deleted", //删除成功
"_shards" : { //删除请求影响的分片信息
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 9
}
在Java高级REST客户端中，执行删除文档需要创建DeleteRequest对象并设置对应的索引名称与删除文档的_id，然后执行客户端的delete()方法并把DeleteRequest对象传入即可。以下代码演示了根据_id删除文档的方法：
public void singleDelete(String index, String docId) {
//构建删除请求
DeleteRequest deleteRequest=new DeleteRequest(index,docId);
try {
client.delete(deleteRequest, RequestOptions.DEFAULT);//执行删除
} catch (IOException e) {
e.printStackTrace();
}
}
3.7 批量删除文档
与批量写入和更新文档不同的是，批量删除文档不需要提供JSON数据，其请求形式如下：
POST /_bulk
//批量删除文档，指定文档_id
{"delete":{"_index":"${index_name}","_id":"${_id}"}}
//批量删除文档，指定文档_id
{"update":{"_index":"${index_name}","_id":"${_id}"}}
例如，下面的DSL将批量删除_id为001和002的文档：
POST /_bulk
{"delete":{"_index":"hotel","_id":"001"}} //批量删除文档，指定文档_id为“001”
{" delete ":{"_index":"hotel","_id":"002"}} //批量删除文档，指定文档_id为“002”
和批量写入文档相似，在Java客户端接口中，批量删除文档需要创建BulkRequest对象并设置对应的索引名称。对于多条需要删除的文档，可构建多个DeleteRequest对象并调用BulkRequest.add()方法添加这些DeleteRequest对象，执行时，调用客户端的bulk()方法并把BulkRequest对象传入即可。示例如下：
public void bulkDelete(String index, String docIdKey, List<String>
docIdList) {
BulkRequest bulkRequest = new BulkRequest(); //构建BulkRequest对象
for (String docId : docIdList) { //遍历文档_id列表
//构建删除请求
DeleteRequest deleteRequest=new DeleteRequest(index,docId);
bulkRequest.add(deleteRequest); //创建UpdateRequest对象
}
try {
BulkResponse bulkResponse = client.bulk(bulkRequest,RequestOptions.
DEFAULT); //执行批量删除
if (bulkResponse.hasFailures()) { //判断状态
System.out.println("bulk fail,message:" + bulkResponse.build
FailureMessage());
}
} catch (Exception e) {
e.printStackTrace();
}
}
3.8 根据条件删除文档
和条件更新操作类似，有些场景需要根据某些条件同时删除多条数据，类似于在RDBMS中使用delete table_name where…删除一批数据。为了满足这样的需求，ES为用户提供了_delete_by_query功能，其请求形式如下：
POST /${index_name}/_delete_by_query
{ //删除文档的查询条件
"query": {
…
}
}
query子句用于指定删除数据的匹配条件，相当于SQL中的where语句。下面的DSL将把city为北京的文档删除
POST /hotel/_delete_by_query
{
"query": { //条件删除文档的查询条件：城市为“北京”的文档
"term": {
"city": {
"value": "北京"
}
}
}
}
在Java高级REST客户端中，执行条件删除文档需要创建DeleteByQueryRequest对象并设置对应的索引名称类似于DSL中的query子句，通过调用DeleteByQueryRequest.setQuery()方法设置查询逻辑，然后执行客户端的deleteByQuery()方法并把DeleteByQueryRequest对象传入即可。以下代码演示了根据城市删除文档的方法：
public void deleteByQuery(String index,String city) {
//构建DeleteByQueryRequest对象
DeleteByQueryRequest deleteByQueryRequest=new DeleteByQueryRequest(index);
//设置按照城市查找文档的query
deleteByQueryRequest.setQuery(new TermQueryBuilder("city",city));
try {
//执行删除命令
client.deleteByQuery(deleteByQueryRequest,RequestOptions.DEFAULT);
} catch (IOException e) {
e.printStackTrace();
}
}
