1.Index API: 创建并建立索引

  1. PUT twitter/tweet/1
  2. {
  3.      "user" : "kimchy",
  4.      "post_date" : "2009-11-15T14:12:12",
  5.      "message" : "trying out Elasticsearch"
  6. }

官方文档参考：Index API。

2.Get API: 获取文档

  1. curl -XGET 'http://localhost:9200/twitter/tweet/1'

官方文档参考：Get API。

3.DELETE API: 删除文档

  1. $ curl -XDELETE 'http://localhost:9200/twitter/tweet/1'

官方文档参考：Delete API。

4.UPDATE API: 更新文档

  1. PUT test/type1/1{ "counter" : 1, "tags" : ["red"]}

官方文档参考：Update API。

5.Multi Get API: 一次批量获取文档

  1. PUT 'localhost:9200/_mget
  2. { 
  3.     "docs" :
  4.     [
  5.        {"_index" : "test", 
  6.          "_type" : "type",
  7.            "_id" : "1" 
  8.         },
  9.        { "_index" : "test",
  10.           "_type" : "type",
  11.             "_id" : "2" 
  12.         }
  13.      ]
  14. }


官方文档参考：Multi Get API。

6.Bulk API: 批量操作，增删改查

6.1.本地文件批量操作

  1. $ curl -s -XPOST localhost:9200/blog/user/_bulk --data-binary @requests
  2. requests文件内容如下
  3. {"index":{"_id":"25"}}
  4. {"name":"黎明","id":25}
  5. {"index":{"_id":"26"}}
  6. {"name":"小明","id":26}
  7. {"index":{"_id":"26"}}
  8. {"name":"雄安","id":27}
  9. {"index":{"_id":"28"}}
  10. {"name":"笑话","id":28}

6.2.resp 方法

  1. curl -H "Content-Type: application/json" -XPOST 'http://47.52.199.51:9200/book/english/_bulk' -d'
  2. {"index":{"_id":"17"}}
  3. {"name":"cddd","id":17}
  4. {"index":{"_id":"18"}}
  5. {"name":"cddd","id":18}
  6. {"index":{"_id":"19"}}
  7. {"name":"cddd","id":19}
  8. {"index":{"_id":"20"}}
  9. {"name":"cddd","id":20}
  10. '

官方文档参考：Bulk API。

7.DELETE By Query API: 查询删除

  1. POST /book/_delete_by_query
  2. {
  3.  　"query":{
  4.    　"match":{
  5.    　"name": "yangxioa"
  6.    　}
  7.  　}
  8. }

7.1.删除所有

  1. POST /book/_delete_by_query
  2. {
  3.     "query":{
  4.         "match_all":{}
  5.     }
  6. }

7.2.支持路由查询（routing=XXX,匹配分片数）

  1. POST twitter/_delete_by_query?routing=1
  2. {
  3.   "query": {
  4.     "range" : {
  5.         "age" : {
  6.            "gte" : 10
  7.         }
  8.     }
  9.   }
  10. }
  1. {
  2.   "took" : 147, // 整个操作从开始到结束的毫秒数
  3.   "timed_out": false, // true如果在通过查询执行删除期间执行的任何请求超时 ，则将此标志设置为。
  4.   "total": 119, // 已成功处理的文档数。
  5.   "deleted": 119, // 已成功删除的文档数。
  6.   "batches": 1,  // 通过查询删除拉回的滚动响应数。
  7.   "version_conflicts": 0, // 按查询删除的版本冲突数。
  8.   "noops": 0, // 对于按查询删除，此字段始终等于零。它只存在，以便通过查询删除，按查询更新和reindex API返回具有相同结构的响应。
  9.   "retries": { // 通过查询删除尝试的重试次数。bulk是重试的批量操作search的数量，是重试的搜索操作的数量。
  10.     "bulk": 0,
  11.     "search": 0
  12.   },
  13.   "throttled_millis": 0, // 请求睡眠符合的毫秒数requests_per_second。
  14.   "requests_per_second": -1.0, // 在通过查询删除期间有效执行的每秒请求数。
  15.   "throttled_until_millis": 0, //在按查询响应删除时，此字段应始终等于零。它只在使用Task API时有意义，它指示下一次（自纪元以来的毫秒数），为了符合，将再次执行受限制的请求
  16.   "failures" : [ ] 
  17.    //如果在此过程中存在任何不可恢复的错误，则会出现故障数组。如果这是非空的，那么请求因为那些失败而中止。逐个查询是使用批处理实现的，
  18.    任何故障都会导致整个进程中止，但当前批处理中的所有故障都会被收集到数组中。您可以使用该conflicts选项来防止reindex在版本冲突中中止。
  19. }

官方文档参考：Delete By Query API。

8.update更新api

8.1.脚本更新

  1. POST test/_doc/1/_update
  2.    {
  3.     "script" : {
  4.         "source": "ctx._source.counter += params.count",
  5.         "lang": "painless",// ES语言类型
  6.         "params" : {
  7.             "count" : 4
  8.         }
  9.     }
  10. }

8.2.新增字段

  1. POST test/_doc/1/_update
  2. {
  3.     "script" : "ctx._source.new_field = 'value_of_new_field'"
  4. }

8.3.删除字段

  1. POST test/_doc/1/_update
  2. {
  3.     "script" : "ctx._source.remove('new_field')"
  4. }

8.4.存在就更新

  1. POST test/_doc/1/_update
  2. {
  3.     "script" : {
  4.         "source": "if (ctx._source.tags.contains(params.tag)) { ctx.op = 'delete' } else { ctx.op = 'none' }",
  5.         "lang": "painless",
  6.         "params" : {
  7.             "tag" : "green"
  8.         }
  9.     }
  10. }

8.5.更新部分字段

  1. POST test/_doc/1/_update
  2. {
  3.     "doc" : {
  4.         "name" : "new_name"
  5.     }
  6. }

8.6.upsert：存在就更新，不存在插入

  1. POST test/_doc/1/_update
  2. {
  3.     "script" : {
  4.         "source": "ctx._source.counter += params.count",
  5.         "lang": "painless",
  6.         "params" : {
  7.             "count" : 4
  8.         }
  9.     },
  10.     "upsert" : {
  11.         "counter" : 1
  12.     }
  13. }

官方文档参考：Update 脚本更新API

9.UPDATE BY QUERY API:查询更新

9.1.更新，重新索引

  1. POST twitter/_update_by_query?conflicts=proceed
  2. {
  3.   "took" : 147,
  4.   "timed_out": false,
  5.   "updated": 120,
  6.   "deleted": 0,
  7.   "batches": 1,
  8.   "version_conflicts": 0,
  9.   "noops": 0,
  10.   "retries": {
  11.     "bulk": 0,
  12.     "search": 0
  13.   },
  14.   "throttled_millis": 0,
  15.   "requests_per_second": -1.0,
  16.   "throttled_until_millis": 0,
  17.   "total": 120,
  18.   "failures" : [ ]
  19. }

ES内部自带实现乐观锁控制，先查询出要更新的记录的版本号，更新时匹配版本号时候一致。
所有更新和查询失败都会导致_update_by_query中止并failures在响应中返回。已执行的更新仍然存在。换句话说，该过程不会回滚，只会中止。当第一个失败导致中止时，失败的批量请求返回的所有失败都将在failures元素中返回; 因此，可能存在相当多的失败实体。
如果您只想计算版本冲突，不要导致_update_by_query 中止，您可以conflicts=proceed在URL或"conflicts": "proceed",改配置当第一个冲突时会会继续执行，version_conflicts冲突数量。

9.2.查询更新

  1. POST twitter/_update_by_query?conflicts=proceed
  2. {
  3.   "query": { 
  4.     "term": {
  5.       "user": "kimchy"
  6.     }
  7.   }
  8. }

9.3.查询脚本更新

  1. POST twitter/_update_by_query
  2. {
  3.   "script": {
  4.     "source": "ctx._source.likes++",
  5.     "lang": "painless"
  6.   },
  7.   "query": {
  8.     "term": {
  9.       "user": "kimchy"
  10.     }
  11.   }
  12. }

也可以同时在多个索引和多个类型上完成这一切，就像搜索API一样：
POST twitter，blog / _doc，post / _update_by_query
routing则路由将复制到滚动查询，将进程限制为与该路由值匹配的分片：
POST twitter/_update_by_query?routing=1
默认情况下，_update_by_query使用1000的滚动批次。可以使用scroll_sizeURL参数更改批量大小：
POST twitter/_update_by_query?scroll_size=100

9.4.使用TASK API获取所有正在运行的逐个查询请求的状态

GET _tasks?detailed=true&actions=*byquery
结果：

  1. {
  2.   "nodes" : {
  3.     "r1A2WoRbTwKZ516z6NEs5A" : {
  4.       "name" : "r1A2WoR",
  5.       "transport_address" : "127.0.0.1:9300",
  6.       "host" : "127.0.0.1",
  7.       "ip" : "127.0.0.1:9300",
  8.       "attributes" : {
  9.         "testattr" : "test",
  10.         "portsfile" : "true"
  11.       },
  12.       "tasks" : {
  13.         "r1A2WoRbTwKZ516z6NEs5A:36619" : {
  14.           "node" : "r1A2WoRbTwKZ516z6NEs5A",
  15.           "id" : 36619,
  16.           "type" : "transport",
  17.           "action" : "indices:data/write/update/byquery",
  18.           "status" : {    
  19.             "total" : 6154,
  20.             "updated" : 3500,
  21.             "created" : 0,
  22.             "deleted" : 0,
  23.             "batches" : 4,
  24.             "version_conflicts" : 0,
  25.             "noops" : 0,
  26.             "retries": {
  27.               "bulk": 0,
  28.               "search": 0
  29.             }
  30.             "throttled_millis": 0
  31.           },
  32.           "description" : ""
  33.         }
  34.       }
  35.     }
  36.   }
  37. }

使用任务ID，您可以直接查找任务：
GET /_tasks/taskId:1
可以使用任务取消API取消任何按查询更新：
POST _tasks/task_id:1/_cancel
手动切片：

  1. POST twitter/_update_by_query
  2. {
  3.   "slice": {
  4.     "id": 0,
  5.     "max": 2
  6.   },
  7.   "script": {
  8.     "source": "ctx._source['extra'] = 'test'"
  9.   }
  10. }

官方文档参考：Update By Query API

10.Reindex API：重新索引

10.1.复制整个索引

最基本的形式_reindex只是将文档从一个索引复制到另一个索引。这会将twitter索引中的文档复制到new_twitter索引中(前提是要有相同的索引类型)：

  1. POST _reindex
  2. {
  3.   "source": {
  4.     "index": "twitter"
  5.   },
  6.   "dest": {
  7.     "index": "new_twitter"
  8.   }
  9. }

10.2.复制匹配的文档

  1. POST _reindex
  2. {
  3.   "source": {
  4.     "index": "twitter",
  5.     "type": "_doc",
  6.     "query": {
  7.       "term": {
  8.         "user": "kimchy"
  9.       }
  10.     }
  11.   },
  12.   "dest": {
  13.     "index": "new_twitter"
  14.   }
  15. }

10.3.复制多个索引文档

  1. POST _reindex
  2. {
  3.   "source": {
  4.     "index": ["book", "blog"],
  5.     "type": ["english", "user"]
  6.   },
  7.   "dest": {
  8.     "index": "book1"
  9.   }
  10.  }

ES 6.3只支持一个索引一个类型，所以上面这个并没有实验成功！提示：
“reason”: “Rejecting mapping update to [book1] as the final mapping would have more than 1 type: [english, user]”

10.4.是否覆盖版本号

  1. POST reindex 
  2. {
  3.   "source": {
  4.     "index": ["book"],
  5.     "type": ["english"]
  6.   },
  7.   "dest": {
  8.     "index": "book1",
  9.     "version_type":"external"
  10.   }
  11.  }

“external”:表示使用source的版本号覆盖dest的版本号，当source的版本号<=dest的版本号会提示冲突，“internal”:表示保持dest的版本号自增。

10.5.只复制不存在的记录，已经存在的记录提示冲突

  1. POST _reindex
  2.  {
  3.   "source": {
  4.     "index": ["book"],
  5.     "type": ["english"]
  6.   },
  7.   "dest": {
  8.     "index": "book1",
  9.     "op_type": "create"
  10.   }
  11.  }

默认情况下，版本冲突会中止该_reindex过程，但可以通过"conflicts": "proceed"请求正文中的设置对它们进行计数

10.6.排序复制指定数量

  1. POST _reindex
  2. {
  3.     "size":10,
  4.     "source": {
  5.         "index": ["book"],
  6.         "sort": { "name": "desc" }
  7.       },
  8.      "dest": {
  9.         "index": "book1",
  10.         "op_type": "create"
  11.       }
  12. }

如果报错禁止排序：Fielddata is disabled on text fields by…
聚合这些操作用单独的数据结构(fielddata)缓存到内存里了，需要单独开启：

  1. PUT book/_mapping/english
  2. {
  3.   "properties": {
  4.     "name": { 
  5.       "type":     "text",
  6.       "fielddata": true
  7.     }
  8.   }
  9. }

10.7.复制部分字段

  1. POST _reindex
  2. {"source": {
  3.     "index": "book",
  4.      "_source": ["age", "name"]
  5.   },
  6.   "dest": {
  7.     "index": "book1"
  8.   }
  9. }

10.8.过滤修改元数据再复制

  1. POST _reindex
  2. {
  3.   "size":2,
  4.   "source": {
  5.     "index": "book",
  6.      "_source": ["age", "name"]
  7.   },
  8.   "dest": {
  9.     "index": "book1",
  10.     "routing": "=age" // 根据age进行路由
  11.   },
  12.   "script": {
  13.     "source": "if (ctx._source.age == 12) {ctx._source.age++}",
  14.     "lang": "painless"
  15.   }
  16. }

就像在_update_by_query，您可以设置ctx.op更改在目标索引上执行的操作：
noop设置ctx.op = "noop"脚本是否确定不必在目标索引中编制索引。这种无操作将noop在响应机构的计数器中报告。delete``ctx.op = "delete"如果脚本确定必须从目标索引中删除文档，请进行 设置 。

10.9.从远程复制

  1. POST _reindex
  2. {
  3.   "source": {
  4.     "remote": {
  5.       "host": "http://otherhost:9200",
  6.       "username": "user",
  7.       "password": "pass"
  8.     },
  9.     "index": "source",
  10.     "query": {
  11.       "match": {
  12.         "test": "data"
  13.       }
  14.     }
  15.   },
  16.   "dest": {
  17.     "index": "dest"
  18.   }
  19. }

10.10.查看重建索引任务

  1. GET _tasks?detailed=true&actions=*reindex

官方文档参考：Reindex API

11.term Vectors:分词api

11.1. term的基本信息

  1. # term_freq：在在该字段中的频率
  2. # position：词在该字段中的位置
  3. # start_offset：从什么偏移量开始的
  4. # end_offset: 到什么偏移量结束

11.2 term的统计信息

如果启用了term的统计信息，即term_statistics设为true，那么有哪些统计信息呢？

  1. # doc_freq： 该词在文档中出现的频率
  2. # ttf：total term frequency的缩写，一个term在所有document中出现的频率

11.3字段的统计信息

  1. 如果启用了字段统计信息，即field_statistics设为true,那么有哪些统计信息呢？
  2. # sum_doc_freq: 一个字段中所有term的文档频率之和
  3. # doc_count: 有多少个文档包含这个字段
  4. # sum_ttf：sum total term frequency的缩写，一个字段中的每一个term的在所有文档出现之和
  5. term statistics和field statistics并不精准，不会被考虑有的doc可能被删除了

11.4采集term信息的方式

采集term信息的方式有两种：index-time(从已经存储的索引中查看) 和 query-time（及时生成）

11.5 index-time方式

需要在mapping配置一下，然后建立索引的时候，就直接生成这些词条和文档的统计信息

  1. PUT /website
  3. {
  5.    "mappings": {
  7.        "article":{
  9.            "properties":{
  11.                "text":{
  13.                    "type": "text",
  15.                    "term_vector": "with_positions_offsets",
  17.                    "store": "true",
  19.                    "analyzer" : "fulltext"
  21.                 }
  23.             }
  25.         }
  27.     },
  29.    "settings": {
  31.        "analysis": {
  33.            "analyzer": {
  35.                "fulltext":{
  37.                    "type": "custom",
  39.                    "tokenizer": "whitespace",
  41.                    "filter": [
  43.                         "lowercase",
  45.                        "type_as_payload"
  47.                    ]
  49.                }
  51.             }
  53.         }
  55.     }
  57. }

11.6 query-time方式

即之前没有在mapping里配置过，而是通过查询的方式产生这些统计信息

  1. POST /ecommerce/music/1/_termvectors
  2. {
  3.    "fields":["desc"],
  4.    "offsets":true,
  5.    "payloads":true,
  6.    "positions":true,
  7.    "term_statistics":true,
  8.    "field_statistics" : true
  9. }

11.7 手动指定analyzer来生成termvector

我么可以通过指定per_field_analyzer设置一个分词器对该字段文本进行分词。

  1. POST /ecommerce/music/1/_termvectors
  2. {
  3.    "fields":["desc"],
  4.    "offsets":true,
  5.    "payloads":true,
  6.    "positions":true,
  7.    "term_statistics":true,
  8.    "field_statistics" : true,
  9.    "per_field_analyzer":{
  10.        "text":"standard"
  11.     }
  12. }

11.8 在线文档及时生成termvector

  1. POST book/english/_termvectors
  2. {
  3.   "doc" : {
  4.     "name" : "hellow word",
  5.     "text" : "twitter test test test"
  6.   },
  7.   "fields": ["name"],
  8.   "per_field_analyzer" : {
  9.     "name":"standard"
  10.   }
  11. }

response
ES系列四、ES6.3常用api之文档类api - 图1

  1. {
  2.   "_index": "book",
  3.   "_type": "english",
  4.   "_version": 0,
  5.   "found": true,
  6.   "took": 1,
  7.   "term_vectors": {
  8.     "name": {
  9.       "field_statistics": {
  10.         "sum_doc_freq": 632,
  11.         "doc_count": 30,
  12.         "sum_ttf": 991
  13.       },
  14.       "terms": {
  15.         "hellow": {
  16.           "term_freq": 1,
  17.           "tokens": [
  18.             {
  19.               "position": 0,
  20.               "start_offset": 0,
  21.               "end_offset": 6
  22.             }
  23.           ]
  24.         },
  25.         "word": {
  26.           "term_freq": 1,
  27.           "tokens": [
  28.             {
  29.               "position": 1,
  30.               "start_offset": 7,
  31.               "end_offset": 11
  32.             }
  33.           ]
  34.         }
  35.       }
  36.     }
  37.   }
  38. }

11.9 term的统计信息

我们可以根据term的统计信息，过滤出我么想看的统计结果，比如过滤掉一些出现频率过低的term,比如我要过滤出该字段最多只有10个term，而且那些term在该字段中出现的频率为2，且

  1. POST /ecommerce/music/1/_termvectors
  2. {
  3.    "fields":["desc"],
  4.    "offsets":true,
  5.    "payloads":true,
  6.    "positions":true,
  7.    "term_statistics":true,
  8.    "field_statistics" : true,
  9.    "filter":{
  10.        "max_num_terms":10, // 返回的最大分词输
  11.        "min_term_freq" : 2, // 忽略低于源文档中出现的次数
  12.        "min_doc_freq" : 1  // 忽略低于所有文档中出现的次数
  13.     }
  14. }

11.10 term过滤参数说明

  1. max_num_terms：每个字段必须返回的最大分词数。默认为25。
  2. min_term_freq：忽略源文档中低于此频率的单词。默认为1。
  3. max_term_freq：忽略源文档中超过此频率的单词。默认为无限制。
  4. min_doc_freq：忽略至少在这么多文档中没有出现的分词。默认为1。
  5. max_doc_freq：忽略超过这么多文档中出现的单词。默认为无限制。
  6. min_word_length：最小字长，低于该字长将被忽略。默认为0。
  7. max_word_length：最大字长，高于该字长将被忽略。默认为unbounded（0）。

官方文档参考：Term Vector Api

12 批量返回分词：Multi termvectors API

采集term信息的方式有两种：index-time(从已经存储的索引中查看) 和 query-time（及时生成）

12.1 index-time

  1. POST /_mtermvectors
  2. {
  3.    "docs": [
  4.       {
  5.          "_index": "twitter",
  6.          "_type": "_doc",
  7.          "_id": "2",
  8.          "term_statistics": true
  9.       },
  10.       {
  11.          "_index": "twitter",
  12.          "_type": "_doc",
  13.          "_id": "1",
  14.          "fields": [
  15.             "message"
  16.          ]
  17.       }
  18.    ]
  19. }

url中指定索引：

  1. POST /twitter/_mtermvectors
  2. {
  3.    "docs": [
  4.       {
  5.          "_type": "_doc",
  6.          "_id": "2",
  7.          "fields": [
  8.             "message"
  9.          ],
  10.          "term_statistics": true
  11.       },
  12.       {
  13.          "_type": "_doc",
  14.          "_id": "1"
  15.       }
  16.    ]
  17. }

url中指定索引类型：

  1. POST /twitter/_doc/_mtermvectors
  2. {
  3.    "docs": [
  4.       {
  5.          "_id": "2",
  6.          "fields": [
  7.             "message"
  8.          ],
  9.          "term_statistics": true
  10.       },
  11.       {
  12.          "_id": "1"
  13.       }
  14.    ]
  15. }

如果索引类型和字段都相同：

  1. POST /twitter/_doc/_mtermvectors
  2. {
  3.     "ids" : ["1", "2"],
  4.     "parameters": {
  5.         "fields": [
  6.                 "message"
  7.         ],
  8.         "term_statistics": true
  9.     }
  10. }

12.2及时批量生成

  1. POST_mtermvectors
  2. {
  3.    "docs": [
  4.       {
  5.          "_index": "book",
  6.          "_type": "english",
  7.          "doc" : {
  8.             "name" : "John Doe",
  9.             "message" : "twitter test test test"
  10.          },
  11.           "fields": ["name"],
  12.           "per_field_analyzer" : {
  13.           "name":"standard"
  14.          }
  15.       },
  16.       {
  17.          "_index": "book",
  18.          "_type": "english",
  19.          "doc" : {
  20.            "name" : "Jane Doe",
  21.            "message" : "Another twitter test ..."
  22.          },
  23.           "fields": ["name"],
  24.           "per_field_analyzer" : {
  25.           "name":"standard"
  26.          }
  27.       }
  28.    ]
  29. }

response:

  1. {
  2.   "docs": [
  3.     {
  4.       "_index": "book",
  5.       "_type": "english",
  6.       "_version": 0,
  7.       "found": true,
  8.       "took": 2,
  9.       "term_vectors": {
  10.         "name": {
  11.           "field_statistics": {
  12.             "sum_doc_freq": 632,
  13.             "doc_count": 30,
  14.             "sum_ttf": 991
  15.           },
  16.           "terms": {
  17.             "doe": {
  18.               "term_freq": 1,
  19.               "tokens": [
  20.                 {
  21.                   "position": 1,
  22.                   "start_offset": 5,
  23.                   "end_offset": 8
  24.                 }
  25.               ]
  26.             },
  27.             "john": {
  28.               "term_freq": 1,
  29.               "tokens": [
  30.                 {
  31.                   "position": 0,
  32.                   "start_offset": 0,
  33.                   "end_offset": 4
  34.                 }
  35.               ]
  36.             }
  37.           }
  38.         }
  39.       }
  40.     },
  41.     {
  42.       "_index": "book",
  43.       "_type": "english",
  44.       "_version": 0,
  45.       "found": true,
  46.       "took": 0,
  47.       "term_vectors": {
  48.         "name": {
  49.           "field_statistics": {
  50.             "sum_doc_freq": 632,
  51.             "doc_count": 30,
  52.             "sum_ttf": 991
  53.           },
  54.           "terms": {
  55.             "doe": {
  56.               "term_freq": 1,
  57.               "tokens": [
  58.                 {
  59.                   "position": 1,
  60.                   "start_offset": 5,
  61.                   "end_offset": 8
  62.                 }
  63.               ]
  64.             },
  65.             "jane": {
  66.               "term_freq": 1,
  67.               "tokens": [
  68.                 {
  69.                   "position": 0,
  70.                   "start_offset": 0,
  71.                   "end_offset": 4
  72.                 }
  73.               ]
  74.             }
  75.           }
  76.         }
  77.       }
  78.     }
  79.   ]
  80. }

12.3.返回该索引全部文档的分词统计

  1. POST book/_search
  2. {  
  3.     "size" : 0,  
  4.     "aggs" : {   
  5.         "messages" : {   
  6.             "terms" : {   
  7.              "size" : 10,
  8.               "field" : "name"
  9.             }  
  10.         }  
  11.     }
  12. }

官方文档参考：Multi termvectors API

13.refresh

ES的索引数据是写入到磁盘上的。但这个过程是分阶段实现的，因为IO的操作是比较费时的。

  1. 先写到内存中，此时不可搜索
  2. 默认经过 1s 之后会(refresh)被写入 lucene 的底层文件 segment 中 ，此时可以搜索到
  3. flush之后才会写入磁盘

以上过程由于随时可能被中断导致数据丢失，所以每一个过程都会有 translog 记录，如果中间有任何一步失败了，等服务器重启之后就会重试，保证数据写入。translog也是先存在内存里的，然后默认5秒刷一次写到硬盘里。
在 index ，Update , Delete , Bulk 等操作中，可以设置 refresh 的值。取值如下：

13.1.refresh=true

更新数据之后，立刻对相关的分片(包括副本) 刷新，这个刷新操作保证了数据更新的结果可以立刻被搜索到。

13.2.refresh=wait_for

这个参数表示，刷新后返回。刷新不会立刻进行，而是等待一段时间才刷新 ( index.refresh_interval)，默认时间是 1 秒。刷新时间间隔可以通过index 的配置动态修改。或者直接手动刷新 POST /twitter/_refresh

13.3.refresh=false

refresh 的默认值，立即返回。更新数据之后不立刻刷新，在返回结果之后的某个时间点会自动刷新，也就是随机的，看es服务器的运行情况。
那么选择哪种刷新方式？

  1. wait_for 和 true 对比，前者每次会积累一定的工作量再去刷新
  2. true 是低效的，因为每次实时刷新会产生很小的 segment，随后这些零碎的小段会被合并到效率更高的大 segment 中。也就是说使用 true 的代价在于，在 index 阶段会创建这些小的 segment，在搜索的时候也是搜索这些小的 segment，在合并的时候去将小的 segment 合并到大的 segment 中
  3. 不要在多个请求中对每一条数据都设置 refresh=wait_for ， 用bulk 去批量更新，然后在单个的请求中设置 refresh=wait_for 会好一些
  4. 如果 index.refresh_interval: -1 ，将会禁用刷新，那带上了 refresh=wait_for 参数的请求实际上刷新的时间是未知的。如果 index.refresh_interval 的值设置的比默认值( 1s )更小，比如 200 ms，那带上了 refresh=wait_for 参数的请求将很快刷新，但是仍然会产生一些低效的segment。
  5. refresh=wait_for 只会影响到当前需要强制刷新的请求，refresh=true 却会影响正在处理的其他请求。所以如果想尽可能小的缩小影响范围时，应该用 refresh=wait_for

官方文档参考：Refresh api