第一章、ES概述

1.概念介绍

查询： 宽泛的概念！只要将某个东西查询出来！

  1. 精确查询：
  3. 模糊查询：

搜索： 一种特定的查询！ 搜索一般指 通过某个关键字，检索出和关键字相关的信息！

搜索引擎，不适合使用关系型数据库存储数据！

原因： ①在搜索时，只输入关键字，希望可以得到匹配关键字的所有的数据！如果使用数据库，在查询时一定需要模糊查询，模糊查询会导致索引失效，全表扫描！效率低！

  1. select xxx from xxx where xxx like  %aaa%  //索引失效，有索引，查询引擎不会用
  3. select xxx from xxx where xxx like  aaa%  //索引有效，加速查询
  1. ②关系型数据库查询时，不能分词，联想，得到的不是期望的结果！

2.几个框架

solr : 和es的作用是一样的，都是用于搜索！

  1. solr一般用于中小数据量的静态搜索(数据，很少发生变化)！
  3. es可以用于PB级别数据量的动态搜索(数据可能会不断新增，变化)！

效率上： solr（老大哥）： 小数据量，静态搜索，优于es！

  1.     solr在插入数据时，创建索引会有IO阻塞，效率低！
  3.     es(新人) ：  大数量，动态搜索，优于solr！
  5. es在插入数据时，创建索引，无阻塞！ 不是实时，接近实时搜索，延迟秒级！

依赖： solr 依赖 zk

  1. es不依赖任何框架！

数据类型： solr 丰富： xml,json

  1.  es 单一：  json

扩展性： es更容易扩展，天然集群！

Lucene: 搜索场景，常用的API集合！

  1. 本质是一个框架，可以集成到项目中，提供搜索场景常用的API，方便开发！
  3. 搜索工具包！
  5. 业界公认的非常优秀的搜索框架！

Nutch : 是一个可以直接使用的产品！ 基于lucene提供web浏览器的搜索产品！ 小型google!

ES ： es内置了Lucene，使Lunece变得更好用！ 使用RESTFUL风格，使用ES！

  1.   直接通过浏览器，发送REST请求，使用ES完成数据的CRUD！

3.全文检索和倒排索引

全文检索：

  1. 最初的含义： 提供一个关键字，在整篇文章中，搜索和关键字匹配的片段！
  3. 应用开发含义：    提供一个关键字，在整个数据库中，搜索和关键字匹配的数据！

如果要实现全文检索，必须依赖倒排索引！

索引： 是一种数据结构，加速查询！

  1. 类似一本百科全书的目录，根据目录直接跳转到感兴趣的书页！

正排索引：在mysql中创建的索引，在hbase中创建的索引，都属于正排索引！

  1. 举例： 《唐诗三百首》(数据库)
  3.  目录(正排索引)：  诗名 ------>  哪一页 ------> 诗的内容
  5. 搜索 《静夜思》

倒排索引：

  1. 举例： 《唐诗三百首》(数据库)
  3. 目录(倒排索引)： 存储的不是诗名和页面的对应关系！
  5. 词语   ------>  在哪些诗中出现了，诗是哪一页
  7.     明月-------->  《静夜思》 200页， 《xxx》300页
  9.     搜索：包含明月的古诗有哪些
  11.     搜索引擎都使用倒排索引！

4.ES的特点

天然分片： 数据在写入时，会被分为若干片，每一片会分布到集群的不同节点！

优势： 横向扩容！ 负载均衡！ 提高并行IO能力！

天然集群： 一台ES实例也可以组成一个集群！ 方便扩容！ 如果集群需要增加节点！

  1. 只需要在其他节点安装ES，直接启动，自动在网段中寻找ES集群，自动加入集群！

天然索引： mysql和其他的数据库，需要手动创建索引！ ES在插入数据后自动创建索引！

文档：

https://www.elastic.co/guide/en/elasticsearch/reference/6.6/index.html

5.REST

REST是一种思想和理念！ 推崇使用标准的url路径，表达对资源的操作方式！本质是为了简化和规范url路径的写法！

没有REST之前： 在浏览器发送一个url时，可以随意写

举例： 查询1号员工

  1. [http://hadoop102:8088/gmall/getEmployeeById?id=1](http://hadoop102:8088/gmall/getEmployeeById?id=1)
  3. [http://hadoop102:8088/gmall/findEmployeeById?id=1](http://hadoop102:8088/gmall/findEmployeeById?id=1)
  5.     [http://hadoop102:8088/gmall/retreveEmployeeById?id=1](http://hadoop102:8088/gmall/retreveEmployeeById?id=1)
  7.     [http://hadoop102:8088/gmall/queryEmployeeById?id=1](http://hadoop102:8088/gmall/queryEmployeeById?id=1)
  9.     [http://hadoop102:8088/gmall/tongguoidchaxunyuangong?id=1](http://hadoop102:8088/gmall/tongguoidchaxunyuangong?id=1)

规范： /资源/id

可使用不同的请求方式，表达对资源的操作意图！

REST : /Employee/1

  1. 发送GET，代表查询
  3. 发送POST，代表新增
  5. 发送PUT，代表修改
  7. 发送DELETE ,代表删除
  9. 发送HEAD ， 判断是否存在

http://hadoop102:8088/gmall/Emp/1 GET

框架使用RESTFUL的开发理念！这个框架支持REST风格的API操作！

6.B-tree

B(balance)-tree： B树，多路平衡(自愈)树

B+tree： B-tree的改进

LSM树(mysql,hbase)

第二章、ES安装

1.安装包下载

官网: https://www.elastic.co/cn/downloads/elasticsearch

本次学习基于6.6.0版本

ElasticSearch笔记 - 图1

2.将安装包上传到linux上并解压

一.安装

  1. # 1.解压elasticsearch-6.6.0.tar.gz到/opt/module目录下
  2. tar -zxvf elasticsearch-6.6.0.tar.gz -C /opt/module/
  3. # 2.在/opt/module/elasticsearch-6.6.0路径下创建data文件夹
  4. mkdir data
  1. # 3.修改配置文件(config/elasticsearch.yml)
  2. #-----------------------Cluster-----------------------
  3. cluster.name: my-application
  4. #-----------------------Node-----------------------
  5. node.name: node-102
  6. #-----------------------Paths-----------------------
  7. path.data: /opt/module/elasticsearch-6.6.0/data
  8. path.logs: /opt/module/elasticsearch-6.6.0/logs
  9. #-----------------------Memory-----------------------
  10. bootstrap.memory_lock: false
  11. bootstrap.system_call_filter: false
  12. #-----------------------Network-----------------------
  13. network.host: hadoop102 
  14. #-----------------------Discovery-----------------------
  15. discovery.zen.ping.unicast.hosts: ["hadoop102","hadoop103","hadoop104"]
  1. # 4.将 /opt/module/elasticsearch 分发至各节点
  2. xsync /opt/module/elasticsearch
  3. # 5.修改hadoop103,hadoop104上的配置文件(修改node.name,network.host)

二.配置Linux系统环境

参考:http://blog.csdn.net/satiling/article/details/59697916

  1. # 1.借用root权限,编辑/etc/security/limits.conf 添加类似如下内容,注意*不要省略
  2. * soft nofile 65536
  3. * hard nofile 131072
  4. * soft nproc 2048
  5. * hard nproc 4096
  6. # 2.借用root权限修改配置sysctl.conf (/etc/sysctl.conf)
  7. #添加如下配置
  8. vm.max_map_count=655360
  9. #并执行命令
  10. sysctl -p
  11. #3.以上修改的配置分发到各节点
  12. xsync /etc/security/limits.conf
  13. xsync /etc/sysctl.conf
  14. #4.重启linux

三.启动elasticsearch

  1. [atguigu@hadoop102 elasticsearch]$ bin/elasticsearch

打开浏览器访问hadoop102:9200

ElasticSearch笔记 - 图2

群起脚本

  1. [atguigu@hadoop102 bin]$ vi es.sh
  2. #!/bin/bash
  3. es_home=/opt/module/elasticsearch-6.6.0
  4. case $1  in
  5.  "start") {
  6.   for i in hadoop102 hadoop103 hadoop104
  7.   do
  8.     echo "==============$i=============="
  9. ssh $i  "source /etc/profile;${es_home}/bin/elasticsearch >/dev/null 2>&1 &"
  10. sleep 4s;
  11.   done
  13. };;
  14. "stop") {
  15.   for i in hadoop102 hadoop103 hadoop104
  16.   do
  17.     echo "==============$i=============="
  18.     ssh $i "ps -ef|grep $es_home |grep -v grep|awk '{print \$2}'|xargs kill" >/dev/null 2>&1
  19.   done
  21. };;
  22. esac

3.Kibana

一.安装

  1. #1.解压kibana-6.6.0-linux-x86_64.tar.gz到/opt/module下
  2. tar -zxvf kibana-6.6.0-linux-x86_64.tar.gz -C /opt/module/
  3. mv kibana-6.6.0-linux-x86_64/ kibana/
  4. #2.修改配置文件
  5. vim config/kibana.yml
  6. server.port: 5601
  7. server.host: "hadoop102"
  8. eleasticsearch.hosts: ["http://hadoop102:9200"]

二.启动kibana(先启动eleasticsearch)

  1. [atguigu@hadoop102 kibana]$ bin/kibana

打开浏览器访问 hadoop102:5601

ElasticSearch笔记 - 图3

三.修改之前es的启动脚本

  1. #!/bin/bash
  2. es_home=/opt/module/elasticsearch-6.6.0
  3. kibana_home=/opt/module/kibana
  4. case $1  in
  5.  "start") {
  6.   for i in hadoop102 hadoop103 hadoop104
  7.   do
  8.     echo "==============$i=============="
  9. ssh $i  "source /etc/profile;${es_home}/bin/elasticsearch >/dev/null 2>&1 &"
  10. sleep 4s;
  11.   done
  12.   sleep 2s;
  13.   nohup ${kibana_home}/bin/kibana > kibana.log 2>&1 &
  14. };;
  15. "stop") {
  16.   ps -ef | grep ${kibana_home} | grep -v grep | awk '{print $2}'| xargs kill
  17.   for i in hadoop102 hadoop103 hadoop104
  18.   do
  19.     echo "==============$i=============="
  20.     ssh $i "ps -ef|grep $es_home |grep -v grep|awk '{print \$2}'|xargs kill" >/dev/null 2>&1
  21.   done
  22. };;
  23. esac

第三章、ES操作

1.管理性命令

  1. GET /_cat
  3. # 带_xxx，都是系统内置的关键字
  4. #查看节点状况
  5. GET /_cat/nodes?v
  6. #查看健康状况
  7. GET /_cat/health
  8. #查看所有的index
  9. get /_cat/indices

2.index操作

  1. #一个库
  2. #查index
  6. #查看所有的index
  7. GET /_cat/indices
  9. #查看某个index的信息
  10. GET /_cat/indices/.kibana_1
  12. #查看某个index的元数据信息
  13. GET /stu1
  15. ##查看某个index的表结构
  16. GET /.kibana_1/_mapping
  18. #新增Index
  19. #手动创建  需要在创建index时指定mapping信息
  20. #6.0版本一个Index只能创建一个type，名称随意
  21. PUT stu
  22. {
  23.   "mappings": {
  24.     "table1":{
  25.       "properties":{
  26.         "id":{
  27.           "type":"keyword"
  28.         },
  29.         "name":{
  30.           "type":"text"
  31.         },
  32.         "sex":{
  33.           "type":"integer"
  34.         },
  35.         "birth":{
  36.           "type":"date"
  37.         }
  38.       }
  39.     }
  40.   }
  41. }
  45. #自动创建  直接向一个不存在的Index插入数据，在插入数据时，系统根据数据的类型，自动推断mapping，自动创建mapping
  46. # POST  /indexname/typename/id
  47. POST /stu1/table1/1
  48. {
  49.   "id":"1001",
  50.   "name":"jack"
  51. }
  55. #删除index
  56. DELETE /stu1
  59. #修改index   需要执行迁移操作，从一个index读取数据，写入一个新的index
  61. #判断是否存在index  404 - Not Found代表不存在 ，200代表存在
  62. HEAD /stu

3.type操作

  2. #type就等价于index
  3. #7.0之后没有type的概念了，6.0一个index只允许创建一个type，因此index 等价于 type
  5. #查 type  和查index一致
  7. #删除type 就是删除index
  9. #创建type 就是创建index
  11. #判断type是否存在 405 - Method Not Allowed 判断index

4.数据操作

  2. #查
  3. #全表查询
  4. GET /stu/table1/_search
  6. #查询单个元素 GET /indexname/typename/id
  7. # _id才是唯一标识
  8. GET /stu/table1/1
  10. #增
  11. #POST  /indexname/typename/id
  12. POST /stu/table1/2
  13. {
  14.   "id":"tom",
  15.   "name":"tom"
  16. }
  18. #POST也可以实现更新操作，如果当前记录的ID不存在，就insert，存在就update。 更新是全量更新
  19. POST /stu/table1/2
  20. {
  21.   "id":"1003"
  22. }
  25. #POST新增，不指定ID，就随机生成ID
  26. POST /stu/table1/
  27. {
  28.   "id":"tom",
  29.   "name":"tom"
  30. }
  32. #增量更新
  33. #400 : 客户端发送的参数不符合要求
  34. #404 ： 客户端发送的url路径匹配不上
  35. #405 ：  客户端发送的url，对应的请求方式不符合
  36. POST /stu/table1/rx4wNHwBb4g3p3m-lruA/_update
  37. {
  38.   "doc": {
  39.     "id":"1003"
  40.   }
  41. }
  45. #改 PUT
  46. #新增   PUT在新增时，必须指定id!
  47. PUT /stu/table1/3
  48. {
  49.   "id":"1003",
  50.   "name":"marry"
  51. }
  53. #405    /stu/table1/只允许POST，不允许PUT
  54. PUT /stu/table1/
  55. {
  56.   "id":"1003",
  57.   "name":"marry"
  58. }
  60. #id存在就更新，不存在就插入，默认也是全量更新
  61. PUT /stu/table1/3
  62. {
  63.   "name":"jack"
  64. }
  67. #不能增量更新
  68. PUT /stu/table1/rx4wNHwBb4g3p3m-lruA/_update
  69. {
  70.   "doc": {
  71.     "id":"1004"
  72.   }
  73. }
  75. # 4xxx开头的都是客户端错误
  76. # 405: 客户端发送的请求方式错误，例如只允许发POST，你发了PUT
  77. # 400 : 请求参数格式错误。没有按照人家指定的格式发参数
  82. #删
  83. DELETE /stu/table1/rx4wNHwBb4g3p3m-lruA
  86. #判断是否存在
  87. HEAD /stu/table1/rx4wNHwBb4g3p3m-lruA
  89. HEAD /stu/table1/1

5.分词操作

  2. # text(允许分词)   keyword(不允许分词)
  6. # 默认的分词器，用来进行英文分词，按照空格分
  7. GET /_analyze
  8. {
  9.   "text": "I am a teacher!"
  11. }
  13. #不能分词
  14. GET /_analyze
  15. {
  16.   "keyword": "I am a teacher!"
  18. }
  20. # 汉语按照字切分
  21. GET /_analyze
  22. {
  23.   "text": "国庆节快乐"
  25. }
  30. #ik_smart：  智能分词。切分后的所有单词的总字数等于 被切词的总字数   输入总字数=输出总字数
  31. GET /_analyze
  32. {
  33.   "analyzer": "ik_smart", 
  34.   "text": "国庆节快乐"
  36. }
  38. #ik_max_word： 最大化分词。 输入总字数 <= 输出总字数
  39. GET /_analyze
  40. {
  41.   "analyzer": "ik_max_word", 
  42.   "text": "国庆节快乐"
  44. }
  46. #只是切词，没有NLP(自然语言处理)，没有感情，不会思考，听不懂人话
  47. GET /_analyze
  48. {
  49.   "analyzer": "ik_max_word", 
  50.   "text": "爱好抽烟喝酒烫头洗屁股眼子"
  52. }

6.子属性

  1. java中：
  2. public class Person{
  4.     public String name;
  5.     public Address address;
  7. }
  9. public class Address{
  10.         public String provinceName;
  12. }
  14. provinceName称为是Person类的 级联(层级联系)属性， 或子属性(属性的属性)
  16. json中：
  17. person:
  18. {
  19.     age: 20
  20.   address:{
  21.       "provinceName":"广东"
  23.   }
  26. }

注意：

  1.  "name" : {
  2.             "type" : "text",
  3.             "fields" : {
  4.               "aaa" : {
  5.                 "type" : "keyword",
  6.                 "ignore_above" : 256
  7.               }
  8.             }
  9.           }
  11.      text类型的字段，如果将来需要聚合，一定需要为其设置一个子属性，子属性的类型必须是keyword类型！

7.批量导入数据语法

  1. #导入数据：
  2. #_bulk代表批量写
  3. #格式 ：  {"action": {metadata}}\n {data}
  4. # action: insert,update,delete, index(upsert): 存在就更新，不存在就插入
  5. #metadata 指定当前向哪个index，哪个type，哪个id进行写
  6. #_id: id  _index:xxx _type:哪个type

8.DSL中的常见关键字

关键字 含义 类比SQL
query 查询 select
bool 多个组合条件 selext xxx from xxx where age=20 and gender=male
filter 一个过滤条件 where
term 精确匹配 =
match 全文检索，会分词
must 在过滤条件中使用，代表必须包含
fuzzy 模糊音匹配 dick 联想到 nick pick
from 从哪一条开始取,索引从0开始
size 取多少条 limit
_source 只选择某些字段 select 字段
match_phrase 短语匹配，将输入的查询内容整个作为整体进行查询，不切词
multi_match 一次到多个子弹中匹配内容

第四章、聚合

1.结构

  1. aggregations|aggs
  3. "aggregations" : 
  4. {
  5.     --aggregation_name：聚合字段名
  6.     "<aggregation_name>" : 
  7.     {
  8.       --聚合运算的类型，类比,sum,avg,count(Term),min,max    sum(）
  9.         "<aggregation_type>" :
  10.         {
  11.                 --num 对什么字段进行聚合
  12.             <aggregation_body>
  13.         }
  14.         -- 对哪些表进行聚合，类比tablea，不写，将meta写在url
  15.         [,"meta" : {  [<meta_data_body>] } ]?
  17.         --子聚合，在当前聚合的基础上，继续聚合
  18.         [,"aggregations" : { [<sub_aggregation>]+ } ]?
  19.     }
  21. --
  22.     [,"<aggregation_name_2>" : { ... } ]*
  23. }
  25. count 等价于  term 
  26. count(*)  ========  sum(if(gender = 'male',1,0))
  28. select
  29.     a,max(sum_num) --子聚合
  30. from
  31.     (select
  32.         a,b,sum(num) sum_num，max(num) max_num
  33.     from tablea
  34.     where xxx
  35.     group by a,b) tmp
  36. group by a

2.聚合报错

  2.  "type": "illegal_argument_exception",
  3.   "reason": "Fielddata is disabled on text fields by default. Set fielddata=true on [gender] in order to load fielddata in memory by uninverting the inverted index. 
  5.   Note that this can however use significant memory. Alternatively use a keyword field instead."
  7. TEXT类型，因为涉及到分词，无法被聚合！
  9.  解决： 使用KEYWORD类型
  12. a_column(text)
  13. 中国人  ------> 中国，国人，中国人

3.聚合练习

  1. - 见第五章综合练习

第五章、综合练习

  1. #导入测试数据
  2. #建表
  3. PUT /test
  4. {
  5.     "mappings" : {
  6.       "emps" : {
  7.         "properties" : {
  8.           "empid" : {
  9.             "type" : "long"
  10.           },
  11.           "age" : {
  12.             "type" : "long"
  13.           },
  14.           "balance" : {
  15.             "type" : "double"
  16.           },
  17.           "name" : {
  18.             "type" : "text",
  19.             "fields" : {
  20.               "keyword" : {
  21.                 "type" : "keyword",
  22.                 "ignore_above" : 256
  23.               }
  24.             }
  25.           },
  26.            "gender" : {
  27.             "type" : "text",
  28.             "fields" : {
  29.               "keyword" : {
  30.                 "type" : "keyword",
  31.                 "ignore_above" : 256
  32.               }
  33.             }
  34.           },
  35.           "hobby" : {
  36.             "type" : "text",
  37.             "analyzer":"ik_max_word",
  38.             "fields" : {
  39.               "keyword" : {
  40.                 "type" : "keyword",
  41.                 "ignore_above" : 256
  42.               }
  43.             }
  44.           }
  45.         }
  46.       }
  47.     }
  48.   }
  51. #导数据
  52. POST /test/emps/_bulk
  53. {"index":{"_id":"1"}}
  54. {"empid":1001,"age":20,"balance":2000,"name":"李三","gender":"男","hobby":"吃饭睡觉"}
  55. {"index":{"_id":"2"}}
  56. {"empid":1002,"age":30,"balance":2600,"name":"李小三","gender":"男","hobby":"吃粑粑睡觉"}
  57. {"index":{"_id":"3"}}
  58. {"empid":1003,"age":35,"balance":2900,"name":"张伟","gender":"女","hobby":"吃,睡觉"}
  59. {"index":{"_id":"4"}}
  60. {"empid":1004,"age":40,"balance":2600,"name":"张伟大","gender":"男","hobby":"打篮球睡觉"}
  61. {"index":{"_id":"5"}}
  62. {"empid":1005,"age":23,"balance":2900,"name":"大张伟","gender":"女","hobby":"打乒乓球睡觉"}
  63. {"index":{"_id":"6"}}
  64. {"empid":1006,"age":26,"balance":2700,"name":"张大喂","gender":"男","hobby":"打排球睡觉"}
  65. {"index":{"_id":"7"}}
  66. {"empid":1007,"age":29,"balance":3000,"name":"王五","gender":"女","hobby":"打牌睡觉"}
  67. {"index":{"_id":"8"}}
  68. {"empid":1008,"age":28,"balance":3000,"name":"王武","gender":"男","hobby":"打桥牌"}
  69. {"index":{"_id":"9"}}
  70. {"empid":1009,"age":32,"balance":32000,"name":"王小五","gender":"男","hobby":"喝酒,吃烧烤"}
  71. {"index":{"_id":"10"}}
  72. {"empid":1010,"age":37,"balance":3600,"name":"赵六","gender":"男","hobby":"吃饭喝酒"}
  73. {"index":{"_id":"11"}}
  74. {"empid":1011,"age":39,"balance":3500,"name":"张小燕","gender":"女","hobby":"逛街,购物,买"}
  75. {"index":{"_id":"12"}}
  76. {"empid":1012,"age":42,"balance":3400,"name":"李三","gender":"男","hobby":"逛酒吧,购物"}
  77. {"index":{"_id":"13"}}
  78. {"empid":1013,"age":42,"balance":3400,"name":"李球","gender":"男","hobby":"体育场,购物"}
  79. {"index":{"_id":"14"}}
  80. {"empid":1014,"age":22,"balance":3400,"name":"李健身","gender":"男","hobby":"体育场,购物"}
  81. {"index":{"_id":"15"}}
  82. {"empid":1015,"age":22,"balance":3400,"name":"Nick","gender":"男","hobby":"坐飞机,购物"}
  1. #0.查询的两种方式
  2. #①.RESTFUL的查询方式，参数是需要附加在url的后面
  5. #②ES定义的DSL(特定领域语言)，需要根据DSL的语法规则将参数写在请求体中
  8. #1.全表查询，按照年龄降序排序
  9. #① RESTFUL   知道在ES中，不同的参数是什么操作 q代表查询 sort代表排序
  10. GET /test/emps/_search?q=*&sort=age:desc
  12. #②DSL  学习DSL的语法规则
  13. GET /test/emps/_search
  14. {
  15.   "query": {
  16.     "match_all": {
  18.     }
  19.   },
  20.   "sort": [
  21.     {
  22.       "age": {
  23.         "order": "desc"
  24.       }
  25.     }
  26.   ]
  28. }
  31. #2.全表查询，按照年龄降序排序，再按照工资降序排序，只取前5条记录的empid，age，balance
  33. GET /test/emps/_search
  34. {
  35.   "query": {
  36.     "match_all": {}
  37.   },
  38.   "sort": [
  39.     {
  40.       "age": {
  41.         "order": "desc"
  42.       }
  43.     },
  44.     {
  45.       "balance": {
  46.         "order": "desc"
  47.       }
  48.     }
  49.   ],
  50.   "from": 0
  51.   , "size": 5,
  52.   "_source": ["empid","age","balance"]
  53. }
  57. #3.匹配之match分词匹配： 搜索hobby是吃饭睡觉的员工
  58. GET /_analyze
  59. {
  60.   "analyzer": "ik_max_word",
  61.   "text": "吃饭睡觉"
  62. }
  64. GET /test/emps/_search
  65. {
  66.   "query": {
  67.     "match": {
  68.       "hobby": "吃饭睡觉"
  69.     }
  70.   }
  71. }
  73. #4.匹配之match/term不分词匹配： 搜索工资是2000的员工  
  74. #只有text类型可以切词，balance是double类型，无法切词
  75. #ES不建议对无法切词的类型，使用 match
  76. GET /test/emps/_search
  77. {
  78.   "query": {
  79.     "match": {
  80.       "balance": 2000
  81.     }
  82.   }
  83. }
  84. #  匹配之term不分词匹配： 搜索工资是2000的员工 
  85. GET /test/emps/_search
  86. {
  87.   "query": {
  88.     "term": {
  89.       "balance": 2000
  90.     }
  91.   }
  92. }
  93. # 
  94. #5.匹配之match不分词匹配： 搜索hobby是吃饭睡觉的员工
  95. # keyword类型不能切词，只需要使用 一个 keyword类型的hobby就行了
  96. GET /test/emps/_search
  97. {
  98.   "query": {
  99.     "match": {
  100.       "hobby.keyword": "吃饭睡觉"
  101.     }
  102.   }
  103. }
  105. #6.匹配之短语匹配： 搜索hobby是吃饭的员工
  106. GET /test/emps/_search
  107. {
  108.   "query": {
  109.     "match_phrase": {
  110.       "hobby": "吃饭睡觉"
  111.     }
  112.   }
  113. }
  114. #7.匹配之多字段匹配： 搜索name或hobby中带球的员工
  115. GET /test/emps/_search
  116. {
  117.   "query": {
  118.     "multi_match": {
  119.       "query": "球",
  120.       "fields": ["name","hobby"]
  121.     }
  122.   }
  123. }
  124. #8.匹配之多条件匹配，搜索男性中喜欢购物的员工
  125. GET /test/emps/_search
  126. {
  127.   "query": {
  129.     "bool": {
  130.       "must": [
  131.         {
  132.           "match": {
  133.             "hobby": "购物"
  134.           }
  135.         },
  136.         {
  137.           "term": {
  138.             "gender": {
  139.               "value": "男"
  140.             }
  141.           }
  142.         }
  143.       ]
  144.     }
  145.   }
  146. }
  151. #9.匹配之多条件匹配，搜索男性中喜欢购物，还不能爱去酒吧的员工
  152. GET /test/emps/_search
  153. {
  154.   "query": {
  156.     "bool": {
  157.       "must": [
  158.         {
  159.           "match": {
  160.             "hobby": "购物"
  161.           }
  162.         },
  163.         {
  164.           "term": {
  165.             "gender": {
  166.               "value": "男"
  167.             }
  168.           }
  169.         }
  170.       ],
  171.       "must_not": [
  172.         {
  173.           "match": {
  174.             "hobby": "酒吧"
  175.           }
  176.         }
  177.       ]
  178.     }
  179.   }
  180. }
  182. #10.匹配之多条件匹配，搜索男性中喜欢购物，还不能爱去酒吧的员工，最好在20-30之间
  183. #should 加分
  184. GET /test/emps/_search
  185. {
  186.   "query": {
  188.     "bool": {
  189.       "must": [
  190.         {
  191.           "match": {
  192.             "hobby": "购物"
  193.           }
  194.         },
  195.         {
  196.           "term": {
  197.             "gender": {
  198.               "value": "男"
  199.             }
  200.           }
  201.         }
  202.       ],
  203.       "must_not": [
  204.         {
  205.           "match": {
  206.             "hobby": "酒吧"
  207.           }
  208.         }
  209.       ],
  210.       "should": [
  211.         {
  212.           "range": {
  213.             "age": {
  214.               "gt": 20,
  215.               "lt": 30
  216.             }
  217.           }
  218.         }
  219.       ]
  220.     }
  221.   }
  222. }
  223. #11.匹配之多条件匹配，搜索男性中喜欢购物，还不能爱去酒吧的员工，最好在20-30之间，不要40岁以上的
  224. GET /test/emps/_search
  225. {
  226.   "query": {
  228.     "bool": {
  229.       "must": [
  230.         {
  231.           "match": {
  232.             "hobby": "购物"
  233.           }
  234.         },
  235.         {
  236.           "term": {
  237.             "gender": {
  238.               "value": "男"
  239.             }
  240.           }
  241.         }
  242.       ],
  243.       "must_not": [
  244.         {
  245.           "match": {
  246.             "hobby": "酒吧"
  247.           }
  248.         },
  249.         {
  250.           "range": {
  251.             "age": {
  252.               "gt": 40
  253.             }
  254.           }
  255.         }
  256.       ],
  257.       "should": [
  258.         {
  259.           "range": {
  260.             "age": {
  261.               "gt": 20,
  262.               "lt": 30
  263.             }
  264.           }
  265.         }
  266.       ]
  267.     }
  268.   }
  269. }
  273. GET /test/emps/_search
  274. {
  275.   "query": {
  277.     "bool": {
  278.       "must": [
  279.         {
  280.           "match": {
  281.             "hobby": "购物"
  282.           }
  283.         },
  284.         {
  285.           "term": {
  286.             "gender": {
  287.               "value": "男"
  288.             }
  289.           }
  290.         }
  291.       ],
  292.       "must_not": [
  293.         {
  294.           "match": {
  295.             "hobby": "酒吧"
  296.           }
  297.         }
  298.       ],
  299.       "should": [
  300.         {
  301.           "range": {
  302.             "age": {
  303.               "gt": 20,
  304.               "lt": 30
  305.             }
  306.           }
  307.         }
  308.       ],
  309.       "filter": {
  310.         "range": {
  311.           "age": {
  312.             "lte": 40
  313.           }
  314.         }
  315.       }
  316.     }
  317.   }
  318. }
  320. #12.匹配之字段模糊联想匹配，搜索Nick
  321. GET /test/emps/_search
  322. {
  323.   "query": {
  324.     "fuzzy": {
  325.       "name": "Dick"
  326.     }
  327.   }
  329. }
  330. #13.聚合之单聚合，统计男女员工各多少人
  331. #如果想取全部的聚合结果，size >= 分组数
  332. GET /test/emps/_search
  333. {
  334.   "aggs": {
  335.     "gendercount": {
  336.       "terms": {
  337.         "field": "gender.keyword",
  338.         "size": 2
  339.       }
  340.     }
  341.   }
  342. }
  344. #14.聚合之先查询再聚合，统计喜欢购物的男女员工各多少人
  345. GET /test/emps/_search
  346. {
  347.   "query": {
  348.     "match": {
  349.       "hobby": "购物"
  350.     }
  351.   }, 
  352.   "aggs": {
  353.     "gendercount": {
  354.       "terms": {
  355.         "field": "gender.keyword",
  356.         "size": 2
  357.       }
  358.     }
  359.   }
  360. }
  361. #15.聚合之多聚合，统计喜欢购物的男女员工各多少人，及这些人总体的平均年龄
  362. GET /test/emps/_search
  363. {
  364.   "query": {
  365.     "match": {
  366.       "hobby": "购物"
  367.     }
  368.   }, 
  369.   "aggs": {
  370.     "gendercount": {
  371.       "terms": {
  372.         "field": "gender.keyword",
  373.         "size": 2
  374.       }
  375.     },
  376.     "avgage":{
  377.       "avg": {
  378.         "field": "age"
  379.       }
  380.     }
  381.   }
  382. }
  383. #16.聚合之多聚合和嵌套聚合，统计喜欢购物的男女员工各多少人，及这些人不同性别的平均年龄
  385. GET /test/emps/_search
  386. {
  387.   "query": {
  388.     "match": {
  389.       "hobby": "购物"
  390.     }
  391.   },
  392.   "aggs": {
  393.     "gendercount": {
  394.       "terms": {
  395.         "field": "gender.keyword",
  396.         "size": 2
  397.       },
  398.       "aggs": {
  399.         "avgage": {
  400.           "avg": {
  401.             "field": "age"
  402.           }
  403.         }
  404.       }
  405.     }
  406.   }
  407. }

第六章、别名

1.对应关系

别名和索引是N对N的关系！

1个别名 对于 N个索引！

1个索引可以拥有多个别名！

别名的主要应用场景：

  1. 在hive中有分区表，常见按照数据的日期分区。比如表ods_a,按照dt分区
  3.     / ods_a /  dt= 2021-07-07
  5.     / ods_a /  dt= 2021-07-08
  7. 只查询某一天的数据，使用分区字段进行过滤
  9.     where dt=  2021-07-07
  11. 如果是全表查询，不加where过滤！

在ES中，如何实现一个分区表的效果？

  1. 要实现分区的效果：
  3.     只能将每天产生的数据，放入到一个独立的index中
  5. 2021-07-07  ----------> ods_a_2021-07-07_index
  7.     2021-07-08  ----------> ods_a_2021-07-08_index
  9.        只查询某一天的数据，只查询某个对应的index
  11. 2021-07-07 ------>  GET ods_a_2021-07-07_index
  13.        查询这个月的所有数据？
  15. 这个月的index在创建时，为它们赋予一个别名  2021-07_index
  17.     使用别名查询：  GET  2021-07_index
  19. 查询每一天所有的数据？
  21. 每个index在创建时，为它们赋予一个别名  ods_a_index
  23. 使用别名查询：  GET  ods_a_index

2.别名练习

  1. #别名的查询
  3. #查询所有的别名
  4. GET /_cat/aliases?v
  6. #查某个index的别名
  7. GET /movie_index/_alias
  9. #增
  10. #在创建Index时，直接指定
  11. PUT movie_index
  12. {  
  13.   "aliases": {
  14.     "movie1": {},
  15.      "movie2": {}
  16.   },
  17.   "mappings": {
  18.     "movie_type":{
  19.       "properties": {
  20.         "id":{
  21.           "type": "long"
  22.         },
  23.         "name":{
  24.           "type": "text",
  25.           "analyzer": "ik_smart"
  26.         }
  27.       }
  28.     }
  29.   }
  30. }
  33. #为已经创建好的index，添加别名
  34. POST _aliases
  35. {
  36.   "actions": [
  37.     {
  38.       "add": {
  39.         "index": "movie_index",
  40.         "alias": "movie3"
  41.       }
  42.     }
  43.   ]
  44. }
  46. #使用别名来引用一个index的子集
  47. POST _aliases
  48. {
  49.   "actions": [
  50.     {
  51.       "add": {
  52.         "index": "test",
  53.         "alias": "man",
  54.         "filter": {
  55.           "term": {
  56.             "gender": "男"
  57.           }
  58.         }
  59.       }
  60.     }
  61.   ]
  62. }
  64. GET /man/_search
  66. #将movie_index的别名 movie3删除，为test添加movie3
  68. POST _aliases
  69. {
  70.   "actions": [
  71.     {
  72.       "remove": {
  73.         "index": "movie_index",
  74.         "alias": "movie3"
  75.       }
  76.     },
  77.     {
  78.       "add": {
  79.         "index": "test",
  80.         "alias": "movie3"
  81.       }
  82.     }
  83.   ]
  84. }

第七章、模版

1.模版练习

  1. #查看
  3. #查看当前所有定义的模板
  4. GET /_cat/templates
  6. #新增
  7. #index_patterns 指当你创建的索引名称符合当前模板的index_patterns时，调用模板帮你创建index
  8. PUT /_template/template_movie2020
  9. {
  10.   "index_patterns": ["movie_test*"],
  11.   "aliases" : { 
  12.     "{index}-query": {},
  13.     "movie_test-query":{}
  14.   },
  15.   "mappings": { 
  16. "_doc": {
  17.       "properties": {
  18.         "id": {
  19.           "type": "keyword"
  20.         },
  21.         "movie_name": {
  22.           "type": "text",
  23.           "analyzer": "ik_smart"
  24.         }
  25.       }
  26.     }
  27.   }
  28. }
  30. GET /test
  32. #Rejecting mapping update to [movie_index] as the final mapping would have more than 1 type: [movie_type, t1]
  34. #movie2 是一个别名,指向movie_index
  35. # PUT /movie_index/t1/1
  36. # movie_index 的唯一type 是movie_type,你又指定了t1，冲突了
  37. PUT /movie2/t1/1
  38. {
  39.   "name":"jack"
  40. }
  42. GET /_cat/aliases
  44. GET /movie_index
  48. PUT /hahah/t1/1
  49. {
  50.   "name":"jack"
  51. }
  53. GET /movie_test2
  55. PUT /movie_test2/_doc/1
  56. {
  57.   "name":"jack"
  58. }
  60. HEAD /_template/template_movie2020

第八章、Java API操作

1.准备工作

新建maven工程,导入依赖

  1. <dependency>
  2.         <groupId>org.apache.httpcomponents</groupId>
  3.         <artifactId>httpclient</artifactId>
  4.         <version>4.5.5</version>
  5.     </dependency>
  7.     <dependency>
  8.         <groupId>org.apache.httpcomponents</groupId>
  9.         <artifactId>httpmime</artifactId>
  10.         <version>4.3.6</version>
  11.     </dependency>
  13.     <dependency>
  14.         <groupId>io.searchbox</groupId>
  15.         <artifactId>jest</artifactId>
  16.         <version>5.3.3</version>
  17.     </dependency>
  19.     <dependency>
  20.         <groupId>net.java.dev.jna</groupId>
  21.         <artifactId>jna</artifactId>
  22.         <version>4.5.2</version>
  23.     </dependency>
  25.     <dependency>
  26.         <groupId>org.codehaus.janino</groupId>
  27.         <artifactId>commons-compiler</artifactId>
  28.         <version>2.7.8</version>
  29.     </dependency>
  31.     <dependency>
  32.         <groupId>org.elasticsearch</groupId>
  33.         <artifactId>elasticsearch</artifactId>
  34.         <version>6.6.0</version>
  35.     </dependency>
  36.     <dependency>
  37.             <groupId>org.projectlombok</groupId>
  38.             <artifactId>lombok</artifactId>
  39.             <version>1.18.12</version>
  40.             <scope>provided</scope>
  41.    </dependency>

javabean(Emp.java)

  1. package com.atgugu.esdemo.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @NoArgsConstructor
  8. @AllArgsConstructor
  9. @Data
  10. public class Emp {
  11.     private String empid;
  12.     private Integer age;
  13.     private Double balance;
  14.     private String name;
  15.     private String gender;
  16.     private String hobby;
  17. }

2.读数据

  1. package com.atgugu.esdemo;
  3. import com.atgugu.esdemo.pojo.Emp;
  4. import io.searchbox.client.JestClient;
  5. import io.searchbox.client.JestClientFactory;
  6. import io.searchbox.client.config.HttpClientConfig;
  7. import io.searchbox.core.Search;
  8. import io.searchbox.core.SearchResult;
  10. import java.io.IOException;
  11. import java.util.List;
  13. /**
  14.  * 一般步骤
  15.  *    1.创建一个客户端
  16.  *    2.连接服务端
  17.  *    3.准备命令
  18.  *    4.发送命令
  19.  *    5.如果是查询,接收服务端返回的结果
  20.  *    -------------------------------------
  21.  *    Jest客户端大量使用以下两种模式
  22.  *    工厂模式: new 对象Factory().get对象()
  23.  *    建筑者模式: new 对象Builder().build()
  24.  *    在建筑者模式中大量使用了java语法糖
  25.  *    A.B() 返回 A
  26.  *    -------------------------------------
  27.  */
  29. public class ReadDemo01 {
  30.     public static void main(String[] args) throws IOException {
  31.         //建厂
  32.         JestClientFactory jestClientFactory = new JestClientFactory();
  33.         //设置连接的集群地址
  34.         HttpClientConfig httpClientConfig = (new HttpClientConfig.Builder("http://hadoop102:9200")).build();
  36.         jestClientFactory.setHttpClientConfig(httpClientConfig);
  37.         //获取连接
  38.         JestClient jestClient = jestClientFactory.getObject();
  40.         String queryString = "{\n" +
  41.                 "  \"query\": {\n" +
  42.                 "    \"match\": {\n" +
  43.                 "      \"hobby\": \"购物\"\n" +
  44.                 "    }\n" +
  45.                 "  },\n" +
  46.                 "  \"aggs\": {\n" +
  47.                 "    \"gendercount\": {\n" +
  48.                 "      \"terms\": {\n" +
  49.                 "        \"field\": \"gender.keyword\",\n" +
  50.                 "        \"size\": 2\n" +
  51.                 "      },\n" +
  52.                 "      \"aggs\": {\n" +
  53.                 "        \"avgage\": {\n" +
  54.                 "          \"avg\": {\n" +
  55.                 "            \"field\": \"age\"\n" +
  56.                 "          }\n" +
  57.                 "        }\n" +
  58.                 "      }\n" +
  59.                 "    }\n" +
  60.                 "  }\n" +
  61.                 "}";
  62.         // 使用 GET /test/emps/_search
  63.         Search search = new Search.Builder(queryString)
  64.                 .addIndex("test")
  65.                 .addType("emps")
  66.                 .build();
  67.         SearchResult searchResult = jestClient.execute(search);
  68.         //遍历返回最后的结果
  69.         System.out.println("total:"+ searchResult.getTotal());
  70.         System.out.println("max_score:"+ searchResult.getMaxScore());
  71.         List<SearchResult.Hit<Emp, Void>> hits = searchResult.getHits(Emp.class);
  72.         for (SearchResult.Hit<Emp, Void> hit : hits) {
  73.             System.out.println("_index:"+hit.index);
  74.             System.out.println("_type:"+hit.type);
  75.             System.out.println("_id:"+hit.id);
  76.             System.out.println("_source:"+hit.source);
  77.         }
  78.         //关闭
  79.         jestClient.shutdownClient();
  80.     }
  82. }

3.读数据(面向对象)

  1. package com.atgugu.esdemo;
  3. import com.atgugu.esdemo.pojo.Emp;
  4. import io.searchbox.client.JestClient;
  5. import io.searchbox.client.JestClientFactory;
  6. import io.searchbox.client.config.HttpClientConfig;
  7. import io.searchbox.core.Search;
  8. import io.searchbox.core.SearchResult;
  9. import io.searchbox.core.search.aggregation.AvgAggregation;
  10. import io.searchbox.core.search.aggregation.MetricAggregation;
  11. import io.searchbox.core.search.aggregation.TermsAggregation;
  12. import org.elasticsearch.index.query.MatchQueryBuilder;
  13. import org.elasticsearch.search.aggregations.AggregationBuilders;
  14. import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
  15. import org.elasticsearch.search.builder.SearchSourceBuilder;
  17. import java.io.IOException;
  18. import java.util.List;
  20. /**
  21.  * 一般步骤
  22.  *    1.创建一个客户端
  23.  *    2.连接服务端
  24.  *    3.准备命令
  25.  *    4.发送命令
  26.  *    5.如果是查询,接收服务端返回的结果
  27.  *    -------------------------------------
  28.  *    Jest客户端大量使用以下两种模式
  29.  *    工厂模式: new 对象Factory().get对象()
  30.  *    建筑者模式: new 对象Builder().build()
  31.  *    在建筑者模式中大量使用了java语法糖
  32.  *    A.B() 返回 A
  33.  *    -------------------------------------
  34.  */
  36. public class ReadDemo02 {
  37.     public static void main(String[] args) throws IOException {
  38.         //建厂
  39.         JestClientFactory jestClientFactory = new JestClientFactory();
  40.         //设置连接的集群地址
  41.         HttpClientConfig httpClientConfig = (new HttpClientConfig.Builder("http://hadoop102:9200")).build();
  43.         jestClientFactory.setHttpClientConfig(httpClientConfig);
  44.         //获取连接
  45.         JestClient jestClient = jestClientFactory.getObject();
  46.         //创建一个对象,通过这个对象,将查询条件封装
  47.         //封装match
  48.         MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("hobby", "购物");
  49.         //封装aggs
  50.         TermsAggregationBuilder aggregationBuilder  = AggregationBuilders.terms("gendercount").field("gender.keyword").size(2)
  51.                 .subAggregation(AggregationBuilders.avg("avgage").field("age"));
  52.         //将match放入query
  53.         String querySource = new SearchSourceBuilder().query(matchQueryBuilder).aggregation(aggregationBuilder).toString();
  55.         // 使用 GET /test/emps/_search
  56.         Search search = new Search.Builder(querySource)
  57.                 .addIndex("test")
  58.                 .addType("emps")
  59.                 .build();
  60.         SearchResult searchResult = jestClient.execute(search);
  61.         //遍历返回最后的结果
  62.         System.out.println("total:"+ searchResult.getTotal());
  63.         System.out.println("max_score:"+ searchResult.getMaxScore());
  64.         List<SearchResult.Hit<Emp, Void>> hits = searchResult.getHits(Emp.class);
  65.         for (SearchResult.Hit<Emp, Void> hit : hits) {
  66.             System.out.println("_index:"+hit.index);
  67.             System.out.println("_type:"+hit.type);
  68.             System.out.println("_id:"+hit.id);
  69.             System.out.println("_source:"+hit.source);
  70.         }
  71.         MetricAggregation aggregations = searchResult.getAggregations();
  72.         TermsAggregation genderCount = aggregations.getTermsAggregation("gendercount");
  73.         List<TermsAggregation.Entry> buckets = genderCount.getBuckets();
  74.         for (TermsAggregation.Entry bucket : buckets) {
  75.             System.out.println(bucket.getKey() + ":" + bucket.getCount());
  76.             AvgAggregation avgage = bucket.getAvgAggregation("avgage");
  77.             System.out.println(avgage.getAvg());
  78.         }
  79.         //关闭
  80.         jestClient.shutdownClient();
  81.     }
  83. }

4.写数据(新增)

  1. package com.atgugu.esdemo;
  3. import com.atgugu.esdemo.pojo.Emp;
  4. import io.searchbox.client.JestClient;
  5. import io.searchbox.client.JestClientFactory;
  6. import io.searchbox.client.config.HttpClientConfig;
  7. import io.searchbox.core.DocumentResult;
  8. import io.searchbox.core.Index;
  11. import java.io.IOException;
  12. import java.util.List;
  14. /**
  15.  *  新增或修改:index
  16.  *  删除:Delete
  17.  *
  18.  */
  20. public class WriteDemo01 {
  21.     public static void main(String[] args) throws IOException {
  22.         //建厂
  23.         JestClientFactory jestClientFactory = new JestClientFactory();
  24.         //设置连接的集群地址
  25.         HttpClientConfig httpClientConfig = (new HttpClientConfig.Builder("http://hadoop102:9200")).build();
  27.         jestClientFactory.setHttpClientConfig(httpClientConfig);
  28.         //获取连接
  29.         JestClient jestClient = jestClientFactory.getObject();
  30.         //将写的数据封装为一个对象
  31.         Emp emp = new Emp("1018", 30, 22.22, "jack", "男", "吃饭");
  32.         //PUT /test/emps/16
  33.         Index index = new Index.Builder(emp)
  34.                 .type("emps")
  35.                 .index("test")
  36.                 .id("18")
  37.                 .build();
  40.         DocumentResult result = jestClient.execute(index);
  41.         System.out.println(result.getResponseCode());
  42.         //关闭
  43.         jestClient.shutdownClient();
  44.     }
  46. }

5.写数据(批量写)

  1. package com.atgugu.esdemo;
  3. import com.atgugu.esdemo.pojo.Emp;
  4. import io.searchbox.client.JestClient;
  5. import io.searchbox.client.JestClientFactory;
  6. import io.searchbox.client.config.HttpClientConfig;
  7. import io.searchbox.core.*;
  9. import java.io.IOException;
  11. /**
  12.  *  新增或修改:index
  13.  *  删除:Delete
  14.  *  批量写:Bulk
  15.  *
  16.  */
  18. public class WriteDemo02 {
  19.     public static void main(String[] args) throws IOException {
  20.         //建厂
  21.         JestClientFactory jestClientFactory = new JestClientFactory();
  22.         //设置连接的集群地址
  23.         HttpClientConfig httpClientConfig = (new HttpClientConfig.Builder("http://hadoop102:9200")).build();
  25.         jestClientFactory.setHttpClientConfig(httpClientConfig);
  26.         //获取连接
  27.         JestClient jestClient = jestClientFactory.getObject();
  28.         //将写的数据封装为一个对象
  29.         Emp emp = new Emp("1018", 30, 22.22, "jack", "男", "吃饭");
  30.         //PUT /test/emps/16
  31.         Index index = new Index.Builder(emp)
  32.                 .type("emps")
  33.                 .index("test")
  34.                 .id("16")
  35.                 .build();
  36.         Delete delete = new Delete.Builder("18").index("test").type("emps").build();
  37.         //将多次操作组装到一个Bulk中
  38.         Bulk bulk = new Bulk.Builder()
  39.                 .addAction(index)
  40.                 .addAction(delete).build();
  43.         BulkResult bulkResult = jestClient.execute(bulk);
  44.         System.out.println(bulkResult.getResponseCode());
  45.         //关闭
  46.         jestClient.shutdownClient();
  47.     }
  49. }