es 初始化内存

转载

技术领航舵手 2024-10-09 08:09:37

文章标签 es 初始化内存字段 Elastic 数据 文章分类 架构后端开发

3.1、文档

在Elasticsearch中，文档以JSON格式进行存储，可以是复杂的结构，如：

{
  "_index": "haoke",
  "_type": "user",
  "_id": "1005",
  "_version": 1,
  "_score": 1,
  "_source": {
    "id": 1005,
    "name": "孙七",
    "age": 37,
    "sex": "女",
    "card": {
      "card_number": "123456789"
   }
 }
}

其中，card是一个复杂对象，嵌套的Card对象。

元数据（metadata）

一个文档不只有数据。它还包含了元数据(metadata)——关于文档的信息。三个必须的元数据节点是：

节点	说明
_index	文档存储的地方
_type	文档代表的对象的类
_id	文档的唯一标识

_index

索引(index)类似于关系型数据库里的“数据库”——它是我们存储和索引关联数据的地方。

提示：
事实上，我们的数据被存储和索引在分片(shards)中，索引只是一个把一个或多个分片分组在一起的逻辑空
间。然而，这只是一些内部细节——我们的程序完全不用关心分片。对于我们的程序而言，文档存储在索引
(index)中。剩下的细节由Elasticsearch关心既可。

_type

在应用中，我们使用对象表示一些“事物”，例如一个用户、一篇博客、一个评论，或者一封邮件。每个对象都属于一
个类(class)，这个类定义了属性或与对象关联的数据。 user 类的对象可能包含姓名、性别、年龄和Email地址。
在关系型数据库中，我们经常将相同类的对象存储在一个表里，因为它们有着相同的结构。同理，在Elasticsearch
中，我们使用相同类型(type)的文档表示相同的“事物”，因为他们的数据结构也是相同的。
每个类型(type)都有自己的映射(mapping)或者结构定义，就像传统数据库表中的列一样。所有类型下的文档被存储
在同一个索引下，但是类型的映射(mapping)会告诉Elasticsearch不同的文档如何被索引。
_type 的名字可以是大写或小写，不能包含下划线或逗号。我们将使用 blog 做为类型名。

_id
id仅仅是一个字符串，它与 _index 和 _type 组合时，就可以在Elasticsearch中唯一标识一个文档。当创建一个文
档，你可以自定义 _id ，也可以让Elasticsearch帮你自动生成（32位长度）。

3.2、查询响应

3.2.1、pretty

可以在查询url后面添加pretty参数，使得返回的json更易查看。

es 初始化内存_Elastic

3.2.2、指定响应字段

在响应的数据中，如果我们不需要全部的字段，可以指定某些需要的字段进行返回。

GET /haoke/user/1005?_source=id,name
#响应
{
  "_index": "haoke",
  "_type": "user",
  "_id": "1005",
  "_version": 1,
  "found": true,
  "_source": {
    "name": "孙七",
    "id": 1005
 }
}

如不需要返回元数据，仅仅返回原始数据，可以这样：

GET /haoke/user/1005/_source

es 初始化内存_字段_02

还可以这样：

GET /haoke/user/1005/_source?_source=id,name

es 初始化内存_字段_03

3.3、判断文档是否存在

如果我们只需要判断文档是否存在，而不是查询文档内容，那么可以这样：

HEAD /haoke/user/1005

es 初始化内存_数据_04

当然，这只表示你在查询的那一刻文档不存在，但并不表示几毫秒后依旧不存在。另一个进程在这期间可能创
建新文档。

3.4、批量操作

有些情况下可以通过批量操作以减少网络请求。如：批量查询、批量插入数据。

3.4.1、批量查询

POST /haoke/user/_mget
{
 "ids" : [ "1001", "1003" ]
}

结果：

es 初始化内存_es 初始化内存_05

如果，某一条数据不存在，不影响整体响应，需要通过found的值进行判断是否查询到数据。

POST /haoke/user/_mget
{
 "ids" : [ "1001", "1006" ]
}

结果：

es 初始化内存_字段_06

3.4.2、_bulk操作

在Elasticsearch中，支持批量的插入、修改、删除操作，都是通过_bulk的api完成的。
请求格式如下：（请求格式不同寻常）

{ action: { metadata }}\n
{ request body    }\n
{ action: { metadata }}\n
{ request body    }\n
...

批量插入数据：

{"create":{"_index":"haoke","_type":"user","_id":2001}}
{"id":2001,"name":"name1","age": 20,"sex": "男"}
{"create":{"_index":"haoke","_type":"user","_id":2002}}
{"id":2002,"name":"name2","age": 20,"sex": "男"}
{"create":{"_index":"haoke","_type":"user","_id":2003}}
{"id":2003,"name":"name3","age": 20,"sex": "男"}

注意最后一行的回车

es 初始化内存_字段_07

响应结果：

{
  "took": 17,
  "errors": false,
  "items": [
   {
      "create": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2001",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 24,
        "_primary_term": 1,
        "status": 201
     }
   },
   {
      "create": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2002",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 0,
        "_primary_term": 1,
        "status": 201
     }
   },
   {
      "create": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2003",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 1,
        "_primary_term": 1,
        "status": 201
     }
   }
 ]
}

批量删除：

{"delete":{"_index":"haoke","_type":"user","_id":2001}}
{"delete":{"_index":"haoke","_type":"user","_id":2002}}
{"delete":{"_index":"haoke","_type":"user","_id":2003}}

由于delete没有请求体，所以，action的下一行直接就是下一个action。

es 初始化内存_Elastic_08

{
  "took": 3,
  "errors": false,
  "items": [
   {
      "delete": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2001",
        "_version": 2,
        "result": "deleted",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 25,
        "_primary_term": 1,
        "status": 200
     }
   },
   {
      "delete": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2002",
        "_version": 2,
        "result": "deleted",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 2,
        "_primary_term": 1,
        "status": 200
     }
   },
   {
      "delete": {
        "_index": "haoke",
        "_type": "user",
        "_id": "2003",
        "_version": 2,
        "result": "deleted",
        "_shards": {
          "total": 1,
          "successful": 1,
          "failed": 0
       },
        "_seq_no": 3,
        "_primary_term": 1,
        "status": 200
     }
   }
 ]
}

其他操作就类似了。
一次请求多少性能最高？

整个批量请求需要被加载到接受我们请求节点的内存里，所以请求越大，给其它请求可用的内存就越小。有一个最佳的bulk请求大小。超过这个大小，性能不再提升而且可能降低。
最佳大小，当然并不是一个固定的数字。它完全取决于你的硬件、你文档的大小和复杂度以及索引和搜索的负载。
幸运的是，这个最佳点(sweetspot)还是容易找到的：试着批量索引标准的文档，随着大小的增长，当性能开始降低，说明你每个批次的大小太大了。开始的数量可以在1000~5000个文档之间，如果你的文档非常大，可以使用较小的批次。
通常着眼于你请求批次的物理大小是非常有用的。一千个1kB的文档和一千个1MB的文档大不相同。一个好的批次最好保持在5-15MB大小间。

3.5、分页

和SQL使用 LIMIT 关键字返回只有一页的结果一样，Elasticsearch接受 from 和 size 参数：

size: 结果数，默认10
from: 跳过开始的结果数，默认0

如果你想每页显示5个结果，页码从1到3，那请求如下：

GET /_search?size=5
GET /_search?size=5&from=5
GET /_search?size=5&from=10

应该当心分页太深或者一次请求太多的结果。结果在返回前会被排序。但是记住一个搜索请求常常涉及多个分
片。每个分片生成自己排好序的结果，它们接着需要集中起来排序以确保整体排序正确。

GET /haoke/user/_search?size=1&from=2

es 初始化内存_数据_09

在集群系统中深度分页
为了理解为什么深度分页是有问题的，让我们假设在一个有5个主分片的索引中搜索。当我们请求结果的第一
页（结果1到10）时，每个分片产生自己最顶端10个结果然后返回它们给请求节点(requesting node)，它再
排序这所有的50个结果以选出顶端的10个结果。
现在假设我们请求第1000页——结果10001到10010。工作方式都相同，不同的是每个分片都必须产生顶端的
10010个结果。然后请求节点排序这50050个结果并丢弃50040个！

你可以看到在分布式系统中，排序结果的花费随着分页的深入而成倍增长。这也是为什么网络搜索引擎中任何
语句不能返回多于1000个结果的原因。

3.6、映射

前面我们创建的索引以及插入数据，都是由Elasticsearch进行自动判断类型，有些时候我们是需要进行明确字段类型
的，否则，自动判断的类型和实际需求是不相符的。
自动判断的规则如下：

JSON type	Field type
Boolean: true or false	"boolean"
Whole number: 123	"long"
Floating point: 123.45	"double"
String, valid date: "2014-09-15"	"date"
String: "foo bar"	"string"

Elasticsearch中支持的类型如下：

类型	表示的数据类型
String	string , text , keyword
Whole number	byte , short , integer , long
Floating point	float , double
Boolean	boolean
Date	date

string类型在ElasticSearch 旧版本中使用较多，从ElasticSearch 5.x开始不再支持string，由text和keyword类型替代。
text 类型，当一个字段是要被全文搜索的，比如Email内容、产品描述，应该使用text类型。设置text类型以后，字段内容会被分析，在生成倒排索引以前，字符串会被分析器分成一个一个词项。text类型的字段不用于排序，很少用于聚合。
keyword类型适用于索引结构化的字段，比如email地址、主机名、状态码和标签。如果字段需要进行过滤(比如查找已发布博客中status属性为published的文章)、排序、聚合。keyword类型的字段只能通过精确值搜索到。

创建明确类型的索引：

PUT /admin
{
  "settings": {
    "index": {
      "number_of_shards": "2",
      "number_of_replicas": "0"
   }
 },
  "mappings": {
    "person": {
      "properties": {
        "name": {
          "type": "text"
       },
        "age": {
          "type": "integer"
       },
        "mail": {
          "type": "keyword"
       },
        "hobby": {
          "type": "text"
       }
     }
   }
 }
}

查看映射：

#自己的用户名路径
GET /admin/_mapping

插入数据：

POST /admin/_bulk
{"index":{"_index":"admin","_type":"person"}}
{"name":"张三","age": 20,"mail": "111@qq.com","hobby":"羽毛球、乒乓球、足球"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"李四","age": 21,"mail": "222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"王五","age": 22,"mail": "333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"赵六","age": 23,"mail": "444@qq.com","hobby":"跑步、游泳"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"孙七","age": 24,"mail": "555@qq.com","hobby":"听音乐、看电影"}

es 初始化内存_es 初始化内存_10

测试搜索：

POST /admin/person/_search
{
  "query" : {
    "match" : { 
      "hobby" : "音乐"
   }
 }
}

es 初始化内存_es 初始化内存_11

3.7、结构化查询

3.7.1、term查询

term 主要用于精确匹配哪些值，比如数字，日期，布尔值或 not_analyzed 的字符串(未经分析的文本数据类型)：

{ "term": { "age":   26      }}
 { "term": { "date":  "2014-09-01" }}
 { "term": { "public": true     }}
 { "term": { "tag":   "full_text" }}

示例：

POST /admin/person/_search
{
  "query" : {
    "term" : { 
      "age" : 20
   }
 }
}

es 初始化内存_字段_12

3.7.2、terms查询

terms 跟 term 有点类似，但 terms 允许指定多个匹配条件。如果某个字段指定了多个值，那么文档需要一起去做匹配：

{
  "terms": {
    "tag": [ "search", "full_text", "nosql" ]
   }
}
POST /admin/person/_search
{
  "query" : {
    "terms" : { 
      "age" : [20,21]
   }
 }
}

es 初始化内存_Elastic_13

3.7.3、range查询

range 过滤允许我们按照指定范围查找一批数据：

{
  "range": {
    "age": {
      "gte":  20,
      "lt":  30
   }
 }
}

范围操作符包含：
gt :: 大于
gte :: 大于等于
lt :: 小于
lte :: 小于等于
示例：

POST /admin/person/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 20,
        "lte": 22
     }
   }
 }
}

es 初始化内存_字段_14

3.7.4、exists 查询

exists 查询可以用于查找文档中是否包含指定字段或没有某个字段，类似于SQL语句中的 IS_NULL 条件

{
  "exists":  {
    "field":   "title"
 }
}

这两个查询只是针对已经查出一批数据来，但是想区分出某个字段是否存在的时候使用。
示例：

POST /haoke/user/_search
{
  "query": {
    "exists": {  #必须包含
      "field": "card"
   }
 }
}

es 初始化内存_数据_15

3.6.5、match查询

match 查询是一个标准查询，不管你需要全文本查询还是精确查询基本上都要用到它。
如果你使用 match 查询一个全文本字段，它会在真正查询之前用分析器先分析 match 一下查询字符：

{
  "match": {
    "tweet": "About Search"
 }
}

如果用 match 下指定了一个确切值，在遇到数字，日期，布尔值或者 not_analyzed 的字符串时，它将为你搜索你给定的值：

3.7.6、bool查询

bool 查询可以用来合并多个条件查询结果的布尔逻辑，它包含一下操作符：
must :: 多个查询条件的完全匹配,相当于 and 。
must_not :: 多个查询条件的相反匹配，相当于 not 。
should :: 至少有一个查询条件匹配, 相当于 or 。
这些参数可以分别继承一个查询条件或者一个查询条件的数组：

{
  "bool": {
    "must":   { "term": { "folder": "inbox" }},
    "must_not": { "term": { "tag":   "spam" }},
    "should": [
         { "term": { "starred": true  }},
         { "term": { "unread":  true  }}
   ]
 }
}

3.8、过滤查询

前面讲过结构化查询，Elasticsearch也支持过滤查询，如term、range、match等。

示例：查询年龄为20岁的用户。

POST /admin/person/_search
{
  "query": {
    "bool": {
      "filter": {
        "term": {
          "age": 20
       }
     }
   }
 }
}

结果：

es 初始化内存_字段_16

查询和过滤的对比

一条过滤语句会询问每个文档的字段值是否包含着特定值。
查询语句会询问每个文档的字段值与特定值的匹配程度如何。

一条查询语句会计算每个文档与查询语句的相关性，会给出一个相关性评分 _score，并且按照相关性对匹配到的文档进行排序。这种评分方式非常适用于一个没有完全配置结果的全文本搜索。

一个简单的文档列表，快速匹配运算并存入内存是十分方便的，每个文档仅需要1个字节。这些缓存的过滤结果集与后续请求的结合使用是非常高效的。
查询语句不仅要查找相匹配的文档，还需要计算每个文档的相关性，所以一般来说查询语句要比过滤语句更耗时，并且查询结果也不可缓存。

建议：
做精确匹配搜索时，最好用过滤语句，因为过滤语句可以缓存数据。

4、中文分词

4.1、什么是分词

分词就是指将一个文本转化成一系列单词的过程，也叫文本分析，在Elasticsearch中称之为Analysis。
举例：我是中国人 --> 我/是/中国人

4.2、分词api

指定分词器进行分词

POST /_analyze
{
  "analyzer":"standard",
  "text":"hello world"
}

结果：

es 初始化内存_Elastic_17

在结果中不仅可以看出分词的结果，还返回了该词在文本中的位置。
指定索引分词

POST /admin/_analyze
{
  "analyzer": "standard",
  "field": "hobby",
  "text": "听音乐"
}

es 初始化内存_Elastic_18

4.4、中文分词

中文分词的难点在于，在汉语中没有明显的词汇分界点，如在英语中，空格可以作为分隔符，如果分隔不正确就会造
成歧义。
如：
我/爱/炒肉丝
我/爱/炒/肉丝
常用中文分词器，IK、jieba、THULAC等，推荐使用IK分词器。

IK Analyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包。从2006年12月推出1.0版开始，
IKAnalyzer已经推出了3个大版本。最初，它是以开源项目Luence为应用主体的，结合词典分词和文法分析算
法的中文分词组件。新版本的IK Analyzer 3.0则发展为面向Java的公用分词组件，独立于Lucene项目，同时提
供了对Lucene的默认优化实现。
采用了特有的“正向迭代最细粒度切分算法“，具有80万字/秒的高速处理能力采用了多子处理器分析模式，支
持：英文字母（IP地址、Email、URL）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇
（姓名、地名处理）等分词处理。优化的词典存储，更小的内存占用。

IK分词器 Elasticsearch插件地址：https://github.com/medcl/elasticsearch-analysis-ik

#安装方法：将下载到的elasticsearch-analysis-ik-6.5.4.zip解压到/elasticsearch/plugins/ik目录下
即可。
mkdir es/plugins/ik
cp elasticsearch-analysis-ik-6.5.4.zip ./es/plugins/ik
#解压
unzip elasticsearch-analysis-ik-6.5.4.zip
#重启
./bin/elasticsearch

测试：

POST /_analyze
{
  "analyzer": "ik_max_word",
  "text": "我是中国人"
}

结果：

{
  "tokens": [
   {
      "token": "我",
      "start_offset": 0,
      "end_offset": 1,
      "type": "CN_CHAR",
      "position": 0
   },
   {
      "token": "是",
      "start_offset": 1,
      "end_offset": 2,
      "type": "CN_CHAR",
      "position": 1
   },
   {
      "token": "中国人",
      "start_offset": 2,
      "end_offset": 5,
      "type": "CN_WORD",
      "position": 2
   },
   {
      "token": "中国",
      "start_offset": 2,
      "end_offset": 4,
      "type": "CN_WORD",
      "position": 3
   },
   {
      "token": "国人",
      "start_offset": 3,
      "end_offset": 5,
      "type": "CN_WORD",
      "position": 4
   }
 ]
}

可以看到，已经对中文进行了分词。

5、全文搜索

全文搜索两个最重要的方面是：

相关性（Relevance）它是评价查询与其结果间的相关程度，并根据这种相关程度对结果排名的一种能力，这种计算方式可以是 TF/IDF 方法、地理位置邻近、模糊相似，或其他的某些算法。
分词（Analysis）它是将文本块转换为有区别的、规范化的 token 的一个过程，目的是为了创建倒排索引以及查询倒排索引。

5.1、构造数据

PUT /admin
{
  "settings": {
    "index": {
      "number_of_shards": "1",
      "number_of_replicas": "0"
   }
 },
  "mappings": {
    "person": {
      "properties": {
        "name": {
          "type": "text"
       },
        "age": {
          "type": "integer"
       },
        "mail": {
          "type": "keyword"
       },
        "hobby": {
          "type": "text",
          "analyzer":"ik_max_word"
       }
     }
   }
 }
}

批量插入数据：

POST http://172.16.55.185:9200/admin/_bulk
{"index":{"_index":"admin","_type":"person"}}
{"name":"张三","age": 20,"mail": "111@qq.com","hobby":"羽毛球、乒乓球、足球"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"李四","age": 21,"mail": "222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"王五","age": 22,"mail": "333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"赵六","age": 23,"mail": "444@qq.com","hobby":"跑步、游泳、篮球"}
{"index":{"_index":"admin","_type":"person"}}
{"name":"孙七","age": 24,"mail": "555@qq.com","hobby":"听音乐、看电影、羽毛球"}

结果：

es 初始化内存_es 初始化内存_19

5.2、单词搜索

POST /admin/person/_search
{
"query":{
"match":{
"hobby":"音乐"
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}

结果：

{
  "took": 9,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
 },
  "hits": {
    "total": 2,
    "max_score": 0.6841192,
    "hits": [
     {
        "_index": "admin",
        "_type": "person",
        "_id": "Uv0cDWgBR-bSw8-LpdkZ",
        "_score": 0.6841192,
        "_source": {
          "name": "王五",
          "age": 22,
          "mail": "333@qq.com",
          "hobby": "羽毛球、篮球、游泳、听音乐"
       },
        "highlight": {
          "hobby": [
            "羽毛球、篮球、游泳、听<em>音乐</em>"
         ]
       }
     },
     {
        "_index": "admin",
        "_type": "person",
        "_id": "VP0cDWgBR-bSw8-LpdkZ",
        "_score": 0.6841192,
        "_source": {
          "name": "孙七",
          "age": 24,
          "mail": "555@qq.com",
          "hobby": "听音乐、看电影、羽毛球"
       },
        "highlight": {
          "hobby": [
            "听<em>音乐</em>、看电影、羽毛球"
         ]
       }
     }
   ]
 }
}

过程说明：
1. 检查字段类型
爱好 hobby 字段是一个 text 类型（指定了IK分词器），这意味着查询字符串本身也应该被分词。
2. 分析查询字符串。
将查询的字符串 “音乐” 传入IK分词器中，输出的结果是单个项音乐。因为只有一个单词项，所以 match 查询执行的是单个底层 term 查询。
3. 查找匹配文档。
用 term 查询在倒排索引中查找 “音乐” 然后获取一组包含该项的文档，本例的结果是文档：3 、5 。

4. 为每个文档评分。
用 term 查询计算每个文档相关度评分 _score ，这是种将词频（term frequency，即词 “音乐” 在相关文档的
hobby 字段中出现的频率）和反向文档频率（inverse document frequency，即词 “音乐” 在所有文档的
hobby 字段中出现的频率），以及字段的长度（即字段越短相关度越高）相结合的计算方式。

5.3、多词搜索

POST /admin/person/_search
{
"query":{
"match":{
"hobby":"音乐 篮球"
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}

结果：

{
  "took": 3,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
 },
  "hits": {
    "total": 4,
    "max_score": 1.3192271,
    "hits": [
     {
        "_index": "admin",
        "_type": "person",
        "_id": "Uv0cDWgBR-bSw8-LpdkZ",
        "_score": 1.3192271,
        "_source": {
          "name": "王五",
          "age": 22,
          "mail": "333@qq.com",
          "hobby": "羽毛球、篮球、游泳、听音乐"
       },
        "highlight": {
          "hobby": [
            "羽毛球、<em>篮球</em>、游泳、听<em>音乐</em>"
         ]
        }
     },
     {
        "_index": "admin",
        "_type": "person",
        "_id": "VP0cDWgBR-bSw8-LpdkZ",
        "_score": 0.81652206,
        "_source": {
          "name": "孙七",
          "age": 24,
          "mail": "555@qq.com",
          "hobby": "听音乐、看电影、羽毛球"
       },
        "highlight": {
          "hobby": [
            "听<em>音乐</em>、看电影、羽毛球"
         ]
       }
     },
     {
        "_index": "admin",
        "_type": "person",
        "_id": "Vf0gDWgBR-bSw8-LOdm_",
        "_score": 0.6987338,
        "_source": {
          "name": "赵六",
          "age": 23,
          "mail": "444@qq.com",
          "hobby": "跑步、游泳、篮球"
       },
        "highlight": {
          "hobby": [
            "跑步、游泳、<em>篮球</em>"
         ]
       }
     },
     {
        "_index": "admin",
        "_type": "person",
        "_id": "Uf0cDWgBR-bSw8-LpdkZ",
        "_score": 0.50270504,
        "_source": {
          "name": "李四",
          "age": 21,
          "mail": "222@qq.com",
          "hobby": "羽毛球、乒乓球、足球、篮球"
       },
        "highlight": {
          "hobby": [
            "羽毛球、乒乓球、足球、<em>篮球</em>"
         ]
       }
     }
   ]
 }
}

结果：

es 初始化内存_字段_20

可以看到结果符合预期。

前面我们测试了“OR” 和 “AND”搜索，这是两个极端，其实在实际场景中，并不会选取这2个极端，更有可能是选取这
种，或者说，只需要符合一定的相似度就可以查询到数据，在Elasticsearch中也支持这样的查询，通过
minimum_should_match来指定匹配度，如：70%；

示例：

{
"query":{
"match":{
"hobby":{
"query":"游泳 羽毛球",
"minimum_should_match":"80%"
}
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}
#结果：省略显示
"hits": {
    "total": 4, #相似度为80%的情况下，查询到4条数据
    "max_score": 1.621458,
    "hits": [
   .........
   }
#设置40%进行测试：
{
"query":{
"match":{
"hobby":{
"query":"游泳 羽毛球",
"minimum_should_match":"40%"
}
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}
#结果：
"hits": {
    "total": 5,  #相似度为40%的情况下，查询到5条数据
    "max_score": 1.621458,
    "hits": [
   ........
 }

相似度应该多少合适，需要在实际的需求中进行反复测试，才可得到合理的值。

5.4、组合搜索

在搜索时，也可以使用过滤器中讲过的bool组合查询，示例：

POST /admin/person/_search
{
"query":{
"bool":{
"must":{
"match":{
"hobby":"篮球"
}
},
"must_not":{
"match":{
"hobby":"音乐"
}
},
"should":[
{
"match": {
"hobby":"游泳"
}
}
]
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}

上面搜索的意思是：
搜索结果中必须包含篮球，不能包含音乐，如果包含了游泳，那么它的相似度更高。

结果：

es 初始化内存_字段_21

评分的计算规则
bool 查询会为每个文档计算相关度评分 _score ，再将所有匹配的 must 和 should 语句的分数 _score 求和，
最后除以 must 和 should 语句的总数。
must_not 语句不会影响评分；它的作用只是将不相关的文档排除。

默认情况下，should中的内容不是必须匹配的，如果查询语句中没有must，那么就会至少匹配其中一个。当然了，
也可以通过minimum_should_match参数进行控制，该值可以是数字也可以的百分比。
示例：

POST /admin/person/_search
{
"query":{
"bool":{
"should":[
        {
    "match": {
"hobby":"游泳"
}
},
{
"match": {
"hobby":"篮球"
}
},
{
"match": {
"hobby":"音乐"
}
}
],
"minimum_should_match":2
}
},
"highlight": {
    "fields": {
      "hobby": {}
   }
 }
}

minimum_should_match为2，意思是should中的三个词，至少要满足2个。

结果：

es 初始化内存_es 初始化内存_22

5.5、权重

有些时候，我们可能需要对某些词增加权重来影响该条数据的得分。如下：

搜索关键字为“游泳篮球”，如果结果中包含了“音乐”权重为10，包含了“跑步”权重为2。

POST /admin/person/_search
{
  "query": {
    "bool": {
      "must": {
        "match": {
          "hobby": {
            "query": "游泳篮球",
            "operator": "and"
         }
       }
     },
      "should": [
       {
          "match": {
            "hobby": {
              "query": "音乐",
              "boost": 10
           }
         }
       },
       {
          "match": {
            "hobby": {
              "query": "跑步",
              "boost": 2
           }
         }
       }
     ]
   }
 },
  "highlight": {
    "fields": {
      "hobby": {}
   }
 }
}

结果：

es 初始化内存_Elastic_23