Day53

文章目录

• 一、说明
• 二、（索引&文档）的增删改查
• • • pXXX）索引-创建
    • pXXX）索引-查询
    • • • （1）查看所有索引
        • （2）查看单个索引
    • pXXX）索引-删除
    • p105）检索es全局信息
    • p106）文档-新增
    • p107）文档-修改
    • • • （1）使用乐观锁更新文档
        • （2）普通更新文档
    • p109）文档-删除
    • pXXX）文档-查询
    • p109）ES的批量操作——bulk
• 三、文档-查询
• • • p110）两种请求方式：
    • 111）Query DSL语言
    • 112）query/match匹配查询1
    • 113）query/match匹配查询2
    • 114）query/multi_math【多字段匹配】
    • 115）query/bool复合查询
    • 116）query/filter【结果过滤】
    • 117）query/term
    • p118）聚合查询
    • pXXX）分页查询
    • pXXX）排序查询
    • pXXX）指定字段查询
    • pXXX）高亮查询
• 四、高级操作
• • • p119）—120）—121）Mapping字段映射
    • p122）分词
    • p123）给vagrant配网
    • p124）ik分词之自定义分词器
• 五、SpringBoot整合ES
• • • p125）SpringBoot整合ES
    • p126）JavaAPI来操做ES1
    • p127）JavaAPI来操做ES2

一、说明

雷丰阳老师讲解谷粒商城时精细的讲过es语法，本节内容摘抄自谷粒商城p105—p127，
视频链接：谷粒商城的ES的完整笔记
笔记链接：谷粒商城的ES的视频
标题里面有pXXX和p105这样式的，其中pXXX就是说从【尚硅谷】ElasticSearch摘抄进来的知识，p105就是说从谷粒商城的ES的视频的105节摘抄来的知识

---

Day52里面讲的ES是用HTTP的方式（也就是说你在postman或Kibana上面发送http请求）来达到操作ES的目的，
Day53里面讲的是JavaAPI的方式（也就是说在IDEA里面编写java代码）来达到操作ES的目的。

关于dockers中es的挂载

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 
-e  "discovery.type=single-node" 
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" 
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml 
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data 
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins 
-d elasticsearch:7.4.2 

ElasticSearch访问路径

Kibana访问路径

二、（索引&文档）的增删改查 pXXX）索引-创建

对比关系型数据库，创建索引就等同于创建数据库。

PUT： http://127.0.0.1:9200/shopping，我们看到这里是PUT请求，为什么不是POST请求？因为PUT请求是幂等性的，也就是说现在你再发送一次相同的请求不会再给你创建出一个一模一样的索引出来，因为之前已经创建完成了，所以就不会再创建了；而POST请求不是幂等性的，它适合添加数据，可以重复添加的那种。

请求后，服务器返回响应：

{
    "acknowledged": true,//响应结果
    "shards_acknowledged": true,//分片结果
    "index": "shopping"//索引名称
}

pXXX）索引-查询 （1）查看所有索引

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

health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   shopping J0WlEhh4R7aDrfIc3AkwWQ   1   1          0            0       208b           208b

表头	含义
health	当前服务器健康状态： green(集群完整) yellow(单点正常、集群不完整) red(单点不正常)
status	索引打开、关闭状态
index	索引名
uuid	索引统一编号
pri	主分片数量
rep	副本数量
docs.count	可用文档数量
docs.deleted	文档删除状态（逻辑删除）
store.size	主分片和副分片整体占空间大小
pri.store.size	主分片占空间大小

（2）查看单个索引

在 Postman 中，向 ES 服务器发 GET 请求 ： http://127.0.0.1:9200/shopping

返回结果如下：

{
    "shopping": {//索引名
        "aliases": {},//别名
        "mappings": {},//映射
        "settings": {//设置
            "index": {//设置 - 索引
                "creation_date": "1617861426847",//设置 - 索引 - 创建时间
                "number_of_shards": "1",//设置 - 索引 - 主分片数量
                "number_of_replicas": "1",//设置 - 索引 - 主分片数量
                "uuid": "J0WlEhh4R7aDrfIc3AkwWQ",//设置 - 索引 - 主分片数量
                "version": {//设置 - 索引 - 主分片数量
                    "created": "7080099"
                },
                "provided_name": "shopping"//设置 - 索引 - 主分片数量
            }
        }
    }
}

pXXX）索引-删除

在 Postman 中，向 ES 服务器发 DELETE 请求 ： http://127.0.0.1:9200/shopping

返回结果如下：

{
    "acknowledged": true
}

p105）检索es全局信息

对于ElasticSearch中的Get请求的http://192.168.218.128:9200/_cat/nodes我们简记为GET /_cat/nodes，
GET /_cat/nodes：查看所有节点
GET /_cat/health：查看es健康状况
GET /_cat/master：查看主节点
GET /_cat/indicies：查看所有索引 ，等价于mysql数据库的show databases;

p106）文档-新增

①索引———类型————文档 类比于 数据库——数据表———数据

②可以是put亦可以是post：
PUT customer/external/1 :在customer索引下的external类型下保存1号数据
POST customer/external/1 :在customer索引下的external类型下保存1号数据

http://192.168.56.10:9200/customer/external/1

{
 "name":"John Doe"
}

③PUT和POST区别
POST。不指定id为创建。指定id就会修改这个数据，并新增版本号；

• 指定存在的id为更新，而版本号会根据内容变没变而决定版本号递增与否

PUT。PUT必须指定id；由于PUT需要指定id，我们一般用来做修改操作，不指定id会报错。

• 必须指定id
• 版本号总会增加（Put比较莽，哪里会对比数据啊）

p107）文档-修改 （1）使用乐观锁更新文档

PUT http://192.168.56.10:9200/customer/external/1?if_seq_no=18&if_primary_term=6

乐观锁用法：通过“if_seq_no=1&if_primary_term=1”，当序列号匹配的时候，才进行修改，否则不修改。

_seq_no是并发控制字段，每次更新都会+1，用来做乐观锁。
_primary_term也是一个控制字段，当主分片重新分配（如重启），就会变化

（2）普通更新文档

Post带update：POST customer/externel/1/_update，会对比原来的数据，数据如果和原来的相同，则（version和_seq_no）都不变。
Post不带update：POST customer/externel/1，总会重新保存并增加version版本。
Put不能带update： PUT customer/externel/1，总会重新保存并增加version版本。

p109）文档-删除

DELETE customer/external/1 删除哪个索引哪个类型下的哪个文档
DELETE customer 删除整个索引

pXXX）文档-查询

文档查询是相当大的工程，包括条件查询、聚合查询、分页查询等等，所以我们单独作为一个大标题来学习

p109）ES的批量操作——bulk

POST /customer/external/_bulk 对哪个索引哪个类型做批量操作

POST http://192.168.56.10:9200/customer/external/_bulk

//两行为一个整体
{"index":{"_id":"1"}}
{"name":"a"}
{"index":{"_id":"2"}}
{"name":"b"}

//注意在Post里面格式设置成json和text均不可，测试必须要去kibana里Dev Tools

POST /_bulk 对于整个索引执行批量操作

POST /_bulk   //你看批量操做里面它增删查改查都有了
{"delete":{"_index":"website","_type":"blog","_id":"123"}}
{"create":{"_index":"website","_type":"blog","_id":"123"}}
{"title":"my first blog post"}
{"index":{"_index":"website","_type":"blog"}}
{"title":"my second blog post"}
{"update":{"_index":"website","_type":"blog","_id":"123"}}
{"doc":{"title":"my updated blog post"}}

这里的批量操作，当发生某一条执行发生失败时，其他的数据仍然能够接着执行，也就是说彼此之间是独立的。
如果一个单个的动作失败，它将继续处理它后面剩余的动作。当bulk api返回时，它将提供每个动作的状态（与发送的顺序相同），所以您可以检查是否一个指定的动作是否失败了。

三、文档-查询 p110）两种请求方式：

①请求参数方式检索：GET bank/_search?q=*&sort=account_number:asc，其中GET bank/_search表示检索bank下所有信息，包括type和docs；q=*表示查询所有；sort=account_number是排序字段排序字段；asc表示升序

②uri+请求体进行检索（最常用的方式，这种方式被我们称为Query DSL语言）

GET /bank/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "account_number": "asc" },
    { "balance":"desc"}
  ]
}

返回内容：

• took – 花费多少ms搜索
• timed_out – 是否超时
• _shards – 多少分片被搜索了，以及多少成功/失败的搜索分片
• max_score –文档相关性最高得分
• hits.total.value - 多少匹配文档被找到
• hits.sort - 结果的排序key（列），没有的话按照score排序
• hits._score - 相关得分 (not applicable when using match_all)
• 检索了1000条数据，但是根据相关性算法，只返回10条

111）Query DSL语言

GET bank/_search
{
  "query": {  #查询的字段
    "match_all": {}  #查询所有的索引
  },
  "from": 0,  #从第几条文档开始查
  "size": 5,  #from+size限定，完成分页功能；
  "_source":["balance"],  #指定要返回的字段
  "sort": [
    {
      "account_number": {  # 返回结果按哪个列排序
        "order": "desc"  # 降序
      }
    }
  ]
}

112）query/match匹配查询1

①如果是非字符串，会进行精确匹配。

GET bank/_search
{
  "query": {
    "match": {
      "account_number": 20  #返回account_number=20的数据（对数字是精确匹配）
    }
  }
}

查询结果：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,  // 得到一条
      "relation" : "eq"
    },
    "max_score" : 1.0,  # 最大得分
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "account",
        "_id" : "20",
        "_score" : 1.0,
        "_source" : {  # 该条文档信息
          "account_number" : 20,
          "balance" : 16418,
          "firstname" : "Elinor",
          "lastname" : "Ratliff",
          "age" : 36,
          "gender" : "M",
          "address" : "282 Kings Place",
          "employer" : "Scentric",
          "email" : "elinorratliff@scentric.com",
          "city" : "Ribera",
          "state" : "WA"
        }
      }
    ]
  }
}

②如果是字符串，会进行全文检索

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill lane"
    }
  }
}

# 查询出的结果有"mill lane"(得分9.80)，有只含mill的"mill road"，也有只含lane的"lane tol"，这种模糊匹配到的无非就是得分低一点

113）query/match匹配查询2

match_phrase：不拆分字符串进行检索

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill road"   #就是说不要匹配只有mill或只有road的，要找能够匹配mill road一整个子串（结果是"990 Mill Road"）
    }
  }
}

字段.keyword：必须全匹配上才检索成功

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address".keyword: "mill road"   #就是说要和"mill road"完全equal，所以匹配不到
    }
  }
}

114）query/multi_math【多字段匹配】

GET bank/_search
{
  "query": {
    "multi_match": {  #前面的match仅指定了一个字段。
      "query": "mill road",
      "fields": ["state","address"]  #查找state和address里面有mill road字符串的
    }
  }
}

#会进行分词查询，也就是说state和address里面有mill road或只有mill或只有road字符串的都会匹配上

115）query/bool复合查询

• must：必须达到must所列举的所有条件
• must_not：必须不匹配must_not所列举的所有条件。
• should：应该满足should所列举的条件。满足条件最好，不满足也可以，满足得分更高

GET bank/_search
{
   "query":{
        "bool":{   
             "must":[ #必须符合查询gender=m，并且address=mill的数据
              {"match":{"address":"mill"}},
              {"match":{"gender":"M"}}
             ]
         }
    }
}

GET bank/_search
{
  "query": {
    "bool": {  #查询gender=m，并且address=mill的数据，但是age不等于38的
      "must": [
        { "match": { "gender": "M" }},
        { "match": {"address": "mill"}}
      ],
      "must_not": [  
        { "match": { "age": "38" }}
      ]
   }
}

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "gender": "M"
          }
        },
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "age": "18"
          }
        }
      ],
      "should": [
        {
          "match": {
            "lastname": "Wallace" #lastName最好是Wallace的数据
          }
        }
      ]
    }
  }
}

116）query/filter【结果过滤】

• must 贡献得分
• should 贡献得分
• must_not 不贡献得分
• filter 不贡献得分
• 上面的must和should影响相关性得分，而must_not和filter一样，就是个过滤器

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "filter": {
        "range": {
          "balance": {
            "gte": "10000",
            "lte": "20000"
          }
        }
      }
    }
  }
}

117）query/term

• term用法和match一样。但是有一个规范就是：文本字段text查询用match，其他非text字段（比如age、id什么的）匹配用term。
• 因为term查询其实是精确匹配，es存储text值时用分词方式（这种方式不精确），所以要搜索text值，使用match。

GET bank/_search
{
  "query": {
    "term": {
      "age": "28"
    }
  }
}

p118）聚合查询

聚合操作看视频，非常地清除

• terms：看值的可能性分布，会合并锁查字段，给出计数即可
• avg：看值的分布平均

①搜索address中包含mill的所有人的（年龄分布、平均年龄、薪资分布），但不显示这些人的详情

# 注意根据缩进看层次！！！
GET bank/_search
{
  "query": { # 查询出包含mill的
    "match": {
      "address": "Mill"
    }
  },
  "aggs": { #基于查询聚合
    "ageAgg": {  # 聚合的名字，随便起
      "terms": { # 看值的可能性分布
        "field": "age",
        "size": 10
      }
    },
    "ageAvg": { 
      "avg": { # 看age值的平均
        "field": "age"
      }
    },
    "balanceAvg": {
      "avg": { # 看balance的平均
        "field": "balance"
      }
    }
  },
  "size": 0  # 不看详情
}

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4, // 命中4条
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : { // 第一个聚合的结果
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 38,  # age为38的有2条
          "doc_count" : 2
        },
        {
          "key" : 28,
          "doc_count" : 1
        },
        {
          "key" : 32,
          "doc_count" : 1
        }
      ]
    },
    "ageAvg" : { // 第二个聚合的结果
      "value" : 34.0  # balance字段的平均值是34
    },
    "balanceAvg" : {  // 第三个聚合的结果
      "value" : 25208.0
    }
  }
}

②查询所有人的（年龄分布（并且基于年龄分布求这些年龄段的这些人的平均薪资））

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": { # 第一个聚合，看分布
        "field": "age",
        "size": 100
      },
      "aggs": { # 基于第一个聚合的结果的再聚合
        "ageAvg": { #平均
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}

{
  "took" : 49,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 31,  
          "doc_count" : 61,
          "ageAvg" : {
            "value" : 28312.918032786885  //31岁的有61个，平均薪资是28312
          }
        },
        {
          "key" : 39,
          "doc_count" : 60,
          "ageAvg" : {
            "value" : 25269.583333333332  //39岁的有60个，平均薪资是25269
          }
        },
		..............
		..............
      ]
    }
  }
}

③查出所有年龄分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资
【基于年龄段[男人(平均薪资)]、[女人(平均薪资)]、[总体平均薪资]】

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {  #  看age分布
        "field": "age",
        "size": 100
      },
      "aggs": { # 子聚合
        "genderAgg": {
          "terms": { # 看gender分布
            "field": "gender.keyword" # 注意这里，文本字段应该用.keyword
          },
          "aggs": { # 子聚合
            "balanceAvg": {
              "avg": { # 男性的平均
                "field": "balance"
              }
            }
          }
        },
        "ageBalanceAvg": {
          "avg": { #age分布的平均（男女）
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}

{
  "took" : 119,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 31, //31岁的有61个
          "doc_count" : 61,
          "genderAgg" : { //看31岁人群中性别分布
            "doc_count_error_upper_bound" : 0,
            "sum_other_doc_count" : 0,
            "buckets" : [
              {
                "key" : "M",  //31岁人群中男人有35个
                "doc_count" : 35,
                "balanceAvg" : {
                  "value" : 29565.628571428573  //31岁人群中男人有35个，平均薪资是29565
                }
              },
              {
                "key" : "F", //31岁人群中女人有26个
                "doc_count" : 26,
                "balanceAvg" : {
                  "value" : 26626.576923076922  //31岁人群中女人有26个，平均薪资是26626
                }
              }
            ]
          },
          "ageBalanceAvg" : {
            "value" : 28312.918032786885  //31岁人群中平均薪资28312
          }
        }
      ]
        .......//省略其他
    }
  }
}

pXXX）分页查询

在 Postman 中，向 ES 服务器发 GET请求 ： http://127.0.0.1:9200/shopping/_search，附带JSON体如下：

{
	"query":{
		"match_all":{}
	},
	"from":0,
	"size":2
}

返回结果如下：

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 6,
            "relation": "eq"
        },
        "max_score": 1,
        "hits": [
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "ANQqsHgBaKNfVnMbhZYU",
                "_score": 1,
                "_source": {
                    "title": "小米手机",
                    "category": "小米",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 3999
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "A9R5sHgBaKNfVnMb25Ya",
                "_score": 1,
                "_source": {
                    "title": "小米手机",
                    "category": "小米",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                }
            }
        ]
    }
}

pXXX）排序查询

如果你想通过排序查出价格最高的手机，在 Postman 中，向 ES 服务器发 GET请求 ： http://127.0.0.1:9200/shopping/_search，附带JSON体如下：

{
	"query":{
		"match_all":{}
	},
	"sort":{
		"price":{
			"order":"desc"
		}
	}
}

返回结果如下：

{
    "took": 96,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 6,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "ANQqsHgBaKNfVnMbhZYU",
                "_score": null,
                "_source": {
                    "title": "小米手机",
                    "category": "小米",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 3999
                },
                "sort": [
                    3999
                ]
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "A9R5sHgBaKNfVnMb25Ya",
                "_score": null,
                "_source": {
                    "title": "小米手机",
                    "category": "小米",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "sort": [
                    1999
                ]
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "BNR5sHgBaKNfVnMb7pal",
                "_score": null,
                "_source": {
                    "title": "小米手机",
                    "category": "小米",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "sort": [
                    1999
                ]
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "BtR6sHgBaKNfVnMbX5Y5",
                "_score": null,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "sort": [
                    1999
                ]
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "B9R6sHgBaKNfVnMbZpZ6",
                "_score": null,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "sort": [
                    1999
                ]
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "CdR7sHgBaKNfVnMbsJb9",
                "_score": null,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "sort": [
                    1999
                ]
            }
        ]
    }
}

pXXX）指定字段查询

如果你想查询指定字段，在 Postman 中，向 ES 服务器发 GET请求 ： http://127.0.0.1:9200/shopping/_search，附带JSON体如下：

{
	"query":{
		"match_all":{}
	},
	"_source":["title"]
}

返回结果如下：

{
    "took": 5,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 6,
            "relation": "eq"
        },
        "max_score": 1,
        "hits": [
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "ANQqsHgBaKNfVnMbhZYU",
                "_score": 1,
                "_source": {
                    "title": "小米手机"
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "A9R5sHgBaKNfVnMb25Ya",
                "_score": 1,
                "_source": {
                    "title": "小米手机"
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "BNR5sHgBaKNfVnMb7pal",
                "_score": 1,
                "_source": {
                    "title": "小米手机"
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "BtR6sHgBaKNfVnMbX5Y5",
                "_score": 1,
                "_source": {
                    "title": "华为手机"
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "B9R6sHgBaKNfVnMbZpZ6",
                "_score": 1,
                "_source": {
                    "title": "华为手机"
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "CdR7sHgBaKNfVnMbsJb9",
                "_score": 1,
                "_source": {
                    "title": "华为手机"
                }
            }
        ]
    }
}

pXXX）高亮查询

在 Postman 中，向 ES 服务器发 GET请求 ： http://127.0.0.1:9200/shopping/_search，附带JSON体如下：

{
	"query":{
		"match_phrase":{
			"category" : "为"
		}
	},
    "highlight":{
        "fields":{
            "category":{}//<----高亮这字段
        }
    }
}

返回结果如下：

{
    "took": 100,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 3,
            "relation": "eq"
        },
        "max_score": 0.6931471,
        "hits": [
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "BtR6sHgBaKNfVnMbX5Y5",
                "_score": 0.6931471,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "highlight": {
                    "category": [
                        "华为"//<------高亮一个为字。
                    ]
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "B9R6sHgBaKNfVnMbZpZ6",
                "_score": 0.6931471,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "highlight": {
                    "category": [
                        "华为"
                    ]
                }
            },
            {
                "_index": "shopping",
                "_type": "_doc",
                "_id": "CdR7sHgBaKNfVnMbsJb9",
                "_score": 0.6931471,
                "_source": {
                    "title": "华为手机",
                    "category": "华为",
                    "images": "http://www.gulixueyuan.com/xm.jpg",
                    "price": 1999
                },
                "highlight": {
                    "category": [
                        "华为"
                    ]
                }
            }
        ]
    }
}

四、高级操作 p119）—120）—121）Mapping字段映射

1.关于类型
以前是索引———类型————文档 类比于 数据库——数据表———数据
从7.0版本以后不再有"类型"的说法了，文档就是直接存储在索引下面

2.关于Mapping字段映射

3.新加映射

基于上一步的age、email、name字段的映射，我们现在想要新加一个字段的映射时得这么做

PUT /my_index/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false #表示该字段只是一个冗余存储的字段，不能被拿去检索。
    }
  }
}

4.修改映射

不能更新映射：对于已经存在的字段映射，我们不能更新。更新必须创建新的索引，进行数据迁移。

有点麻烦，需要的话请看视频：p121修改映射与数据迁移

p122）分词

介绍了在linux里面安装es的分词器—安装ik分词
介绍了软件Xshell5和Xftp5的使用

//使用默认分词器测试：
GET _analyze
{
   "text":"我是中国人"
}


//使用ik分词器测试
GET _analyze
{
   "analyzer": "ik_smart", 
   "text":"我是中国人"
}

p123）给vagrant配网 p124）ik分词之自定义分词器

我们装一个nginx，把自定义分词写到nginx的某个文件里，然后让ik分词器给nginx发送请求，拉取最新的词库

1.关于docker中nginx的安装与挂载

docker run -p 80:80 --name nginx 
 -v /mydata/nginx/html:/usr/share/nginx/html 
 -v /mydata/nginx/logs:/var/log/nginx 
 -v /mydata/nginx/conf/:/etc/nginx 
 -d nginx:1.10

2.自定义分词

在/mydata/nginx/html就是你的nginx的自定义html页面的目录，
你在里面建了一个es目录存放es相关的配置，现在在/mydata/nginx/html/es下创建fenci.txt存放你要自定义的分词，里面写了“乔碧罗”和“尚硅谷”
然后修改ik的配置让它读取/mydata/nginx/html/es/fenci.txt，这样ik就可以根据里面的自定义分词进行分词

五、SpringBoot整合ES p125）SpringBoot整合ES

建议看完【尚硅谷】ElasticSearch的p49—p53讲了SpringBoot集成ES，再回来看这个视频。
这个在当初我做的ElasticSearch的笔记里面写的很清楚

p126）JavaAPI来操做ES1

p126讲的实际上就是【尚硅谷】ElasticSearch的p18—p28是用JavaAPI来编码操做ES，而且只讲了冰山一角，没必要去做什么笔记
这个在当初我做的ElasticSearch的笔记里面写的很清楚

p127）JavaAPI来操做ES2

p127讲的实际上就是【尚硅谷】ElasticSearch的p18—p28是用JavaAPI来编码操做ES，而且只讲了冰山一角，没必要去做什么笔记
这个在当初我做的ElasticSearch的笔记里面写的很清楚