_cat

以下所有请求使用GET方式发送

/_cat/nodes

查看所有节点

http://192.168.2.190:9200/_cat/nodes

Elasticsearch 基本操作 - 图1

/_cat/health

查看ES健康状况

http://192.168.2.190:9200/_cat/health

Elasticsearch 基本操作 - 图2

/_cat/master

查看主节点信息

http://192.168.2.190:9200/_cat/master
Elasticsearch 基本操作 - 图3

/_cat/indicies

查看所有索引，也就是mysql中的show databases

http://192.168.2.190:9200/_cat/indices

Elasticsearch 基本操作 - 图4

索引一个文档

保存一条数据，保存在哪个索引的哪个类型下，指定用哪个唯一标识。

PUT 请求

请求方式：PUT

http://192.168.2.190:9200/customer/external/1

Elasticsearch 基本操作 - 图5

带_的这些字段，我们称为元数据，反映了一些当前的基本信息

结果分析

  1. // 返回的这些结果，是当前数据的一些基本信息
  2. {
  3.     "_index": "customer",    // 哪个索引（数据库）下
  4.     "_type": "external",    // 哪个类型（表）下
  5.     "_id": "1",                // id
  6.     "_version": 1,            // 版本，第一次是1，每执行一次版本就会+1
  7.     "result": "created",    // 保存的结果，第一次是created，以后再执行就会变成updated
  8.     "_shards": {            // 分片，集群的时候会用到
  9.         "total": 2,
  10.         "successful": 1,
  11.         "failed": 0
  12.     },
  13.     "_seq_no": 0,            
  14.     "_primary_term": 1        
  15. }
  1. PUT方式，必须要带id，不带id会报错
  2. 第一次是新增操作，再往后则是更新

POST 请求

请求方式：POST

http://192.168.2.190:9200/customer/external/

Elasticsearch 基本操作 - 图6

  1. POST方式，可以携带id，也可以不携带id
  2. 不携带id的话，每一次都是新增，系统会自动为其指定一个唯一id
  3. 携带id的话，它的作用与PUT一样，第一次是新增，再往后则是更新

查看文档

/index/type/id

请求方式：GET

http://192.168.2.190:9200/customer/external/1

结果分析

  1. {
  2.     "_index": "customer",
  3.     "_type": "external",
  4.     "_id": "1",
  5.     "_version": 3,
  6.     "_seq_no": 2,        // 并发控制的字段，用来做乐观锁操作，只要这个数据有变化，这个值就会往上加
  7.     "_primary_term": 1,    // 用来做乐观锁操作，分片发生变化，集群的时候会用到
  8.     "found": true,        // 表示找到了这个数据
  9.     "_source": {        // 这个数据的真正内容
  10.         "name": "John Doe"
  11.     }
  12. }

乐观锁

携带?if_seq_no=当前的值&if_primary_term=当前的值

假设有A、B两个请求，A要将id为1的数据修改为”AAA”，B要将id为1的数据修改为”BBB”，如果不加乐观锁的话，即使有一方先修改成功了，那么后执行的另一方也会覆盖掉它的修改，为了解决这个问题，Elasticsearch推荐使用乐观锁字段，来对更新操作进行控制。

发送请求时，只要提前获取到_seq_no的值，然后让两个请求都带着判断条件进行请求，就可以避免并发修改时的重复修改。

以上述结果为例，假设现在的_seq_no为2，如果A、B要修改id为1的值，就需要发送这样的请求

A：

请求：http://192.168.2.190:9200/customer/external/1?if_seq_no=2&if_primary_term=1

携带数据：

  1. {
  2.     "name": "AAA"
  3. }

B：

请求：http://192.168.2.190:9200/customer/external/1?if_seq_no=2&if_primary_term=1

携带数据：

  1. {
  2.     "name": "BBB"
  3. }

无论是A还是B谁先修改成功，都会使_seq_no发生变化，那么当另一个请求再次修改时，就会修改失败，因为_seq_no的值已经不再是之前的那个值了，如果另一个请求还想修改成功的话，就必须携带最新的_seq_no重新请求。

更新文档

/index/type/id/_update

请求方式：POST

请求地址：http://192.168.2.190:9200/customer/external/1/_update

请求体：

  1. {
  2.     "doc":{
  3.         "name": "CCC"
  4.     }
  5. }

结果分析

第一次执行

  1. {
  2.     "_index": "customer",
  3.     "_type": "external",
  4.     "_id": "1",
  5.     "_version": 13,
  6.     "result": "updated",
  7.     "_shards": {
  8.         "total": 0,
  9.         "successful": 0,
  10.         "failed": 0
  11.     },
  12.     "_seq_no": 19,
  13.     "_primary_term": 1
  14. }

_version、_seq_no相较更新之前，都发生了变化，result更新成功

第二次执行

  2. {
  3.     "_index": "customer",
  4.     "_type": "external",
  5.     "_id": "1",
  6.     "_version": 13,
  7.     "result": "noop",
  8.     "_shards": {
  9.         "total": 0,
  10.         "successful": 0,
  11.         "failed": 0
  12.     },
  13.     "_seq_no": 19,
  14.     "_primary_term": 1
  15. }

result的值变成了noop，而它的意思是没有做任何操作，其它值都没有发生变化

主要是因为POST这种更新方式，会对比原来的数据，如果与原来的一样，则不会进行任何操作。

几种更新文档的区别

携带_update，使用POST方式发送请求

  • 请求体需要放到doc里面
  • 每次修改，都会对比原来的数据，如果与原来的一样，则不会进行任何操作，不一样，则进行修改。

不携带_update，使用POST、PUT方式请求

  • 会直接修改

删除文档&索引

删除文档

请求方式：DELETE

请求地址：http://192.168.2.190:9200/customer/external/1

结果：

  1. {
  2.     "_index": "customer",
  3.     "_type": "external",
  4.     "_id": "1",
  5.     "_version": 16,
  6.     "result": "deleted",    # 已删除
  7.     "_shards": {
  8.         "total": 2,
  9.         "successful": 1,
  10.         "failed": 0
  11.     },
  12.     "_seq_no": 22,
  13.     "_primary_term": 1
  14. }

删除索引

请求方式：DELETE

请求地址：http://192.168.2.190:9200/customer

结果：

  1. {
  2.     "acknowledged": true
  3. }

bulk-批量操作数据

语法格式：

  1. {action:{metadata}}   // 例如index保存记录，update更新
  2. {request body  }
  4. {action:{metadata}}
  5. {request body  }

指定索引和类型的批量操作

  1. POST /customer/external/_bulk
  2. {"index":{"_id":"1"}}
  3. {"name":"John Doe"}
  4. {"index":{"_id":"2"}}
  5. {"name":"John Doe"}

在Kibana中使用dev-tools测试批量操作数据：

Elasticsearch 基本操作 - 图7

对所有索引执行批量操作

  1. POST /_bulk
  2. {"delete":{"_index":"website","_type":"blog","_id":"123"}}
  3. {"create":{"_index":"website","_type":"blog","_id":"123"}}
  4. {"title":"my first blog post"}
  5. {"index":{"_index":"website","_type":"blog"}}
  6. {"title":"my second blog post"}
  7. {"update":{"_index":"website","_type":"blog","_id":"123"}}
  8. {"doc":{"title":"my updated blog post"}}

分别进行了：删除、创建、保存、更新的操作

结果：
Elasticsearch 基本操作 - 图8

结论

  • 这里的批量操作，即使某一个操作执行失败，也不会影响其他操作，它们彼此之间是独立的。