ElasticSearch的核心详解及中文分词

文档

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

{
    "_index": "haoke",
    "_type": "user",
    "_id": "1001",
    "_score": 1,
    "_source": {
        "id": 1001,
        "name": "张三",
        "age": 20,
        "sex": "男"
    }
}

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

2）_index
索引(index)类似于关系型数据库里的“数据库”——它是我们存储和索引关联数据的地方。
事实上，我们的数据被存储和索引在分片(shards)中，索引只是一个把一个或多个分片分组在一起的逻辑空间。然而，这只是一些内部细节——我们的程序完全不用关心分片。对于我们的程序而言，文档存储在索引(index)中。剩下的细节由Elasticsearch关心既可。

3）_type
在应用中，我们使用对象表示一些“事物”，例如一个用户、一篇博客、一个评论，或者一封邮件。每个对象都属于一个类(class)，这个类定义了属性或与对象关联的数据。user类的对象可能包含姓名、性别、年龄和Email地址。

在关系型数据库中，我们经常将相同类的对象存储在一个表里，因为它们有着相同的结构。同理，在Elasticsearch中，我们使用相同类型(type)的文档表示相同的“事物”，因为他们的数据结构也是相同的。

每个类型(type)都有自己的映射(mapping)或者结构定义，就像传统数据库表中的列一样。所有类型下的文档被存储在同一个索引下，但是类型的映射(mapping)会告诉Elasticsearch不同的文档如何被索引。_type的名字可以是大写或小写，不能包含下划线或逗号。

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

查询响应

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

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

curl -GET "http://47.101.129.45:9200/haoke/user/1001?pretty&_source=id,name"

#响应
{
  "_index" : "haoke",
  "_type" : "user",
  "_id" : "1001",
  "_version" : 1,
  "found" : true,
  "_source" : {
    "name" : "张三",
    "id" : 1001
  }
}

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

 curl -GET "http://47.101.129.45:9200/haoke/user/1001/_source?pretty"
 
 curl -GET "http://47.101.129.45:9200/haoke/user/1001/_source?pretty&_source=id,name"
 
 #响应
 {
  "id" : 1001,
  "name" : "张三",
  "age" : 20,
  "sex" : "男"
}

判断文档是否存在

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

curl -i -X HEAD "http://47.101.129.45:9200/haoke/user/1001/?pretty"

#响应
HTTP/1.1 200 OK
content-type: application/json; charset=UTF-8
content-length: 19

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

批量操作

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

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

curl -POST "http://47.101.129.45:9200/haoke/user/_mget?pretty" -H 'Content-Type: application/json' -d '{"ids" : [ "1001", "1002" ]}}'

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

{ action: { metadata }}\n
{ requestbody        }\n
{ action: { metadata }}\n
{ requestbody        }\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": "男"}

curl -X POST "http://47.101.129.45:9200/haoke/user/_bulk?pretty" -H 'Content-Type: application/json' --data-binary '
{"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": "男"}
'

注意最后一行的回车。

批量删除：

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

curl -X POST "http://47.101.129.45:9200/haoke/user/_bulk?pretty" -H 'Content-Type: application/json' --data-binary '
{"delete":{"_index":"haoke","_type":"user","_id":2001}}
{"delete":{"_index":"haoke","_type":"user","_id":2002}}
{"delete":{"_index":"haoke","_type":"user","_id":2003}}
'

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

一次请求多少性能最高？

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

分页

和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

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

curl -GET "http://47.101.129.45:9200/haoke/user/_search?size=1&from=2&pretty"

#响应
{
  "took" : 11,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "haoke",
        "_type" : "user",
        "_id" : "1003",
        "_score" : 1.0,
        "_source" : {
          "id" : 1003,
          "name" : "王五",
          "age" : 30,
          "sex" : "女"
        }
      }
    ]
  }
}

在集群系统中深度分页：
为了理解为什么深度分页是有问题的，让我们假设在一个有5个主分片的索引中搜索。当我们请求结果的第一页（结果1到10）时，每个分片产生自己最顶端10个结果然后返回它们给请求节点(requesting node)，它再排序这所有的50个结果以选出顶端的10个结果。

现在假设我们请求第1000页——结果10001到10010。工作方式都相同，不同的是每个分片都必须产生顶端的10010个结果。然后请求节点排序这50050个结果并丢弃50040个！

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

映射

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

Elasticsearch中支持的类型如下：

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

创建明确类型的索引：

{
    "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"
                }
            }
        }
    }
}

查看映射：

curl -GET "http://47.101.129.45:9200/demo/_mapping?pretty"

插入数据：

curl -X POST "http://47.101.129.45:9200/demo/_bulk?pretty" -H 'Content-Type: application/json' --data-binary '
{"index":{"_index":"demo","_type":"person"}}
{"name":"张三","age": 20,"mail": "111@qq.com","hobby":"羽毛球、乒乓球、足球"}
{"index":{"_index":"demo","_type":"person"}}
{"name":"李四","age": 21,"mail": "222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"}
{"index":{"_index":"demo","_type":"person"}}
{"name":"王五","age": 22,"mail": "333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"}
{"index":{"_index":"demo","_type":"person"}}
{"name":"赵六","age": 23,"mail": "444@qq.com","hobby":"跑步、游泳"}
{"index":{"_index":"demo","_type":"person"}}
{"name":"孙七","age": 24,"mail": "555@qq.com","hobby":"听音乐、看电影"}
'

测试搜索：

curl -POST "http://47.101.129.45:9200/itcast/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query":{"match":{"hobby":"音乐"}},"highlight": {"fields": {"hobby": {}}}}'

#响应
{
  "took" : 244,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 1.9159472,
    "hits" : [
      {
        "_index" : "demo",
        "_type" : "person",
        "_id" : "yJGbXm4B7Vc5UQFTSINJ",
        "_score" : 1.9159472,
        "_source" : {
          "name" : "孙七",
          "age" : 24,
          "mail" : "555@qq.com",
          "hobby" : "听音乐、看电影"
        },
        "highlight" : {
          "hobby" : [
            "听<em>音</em><em>乐</em>、看电影"
          ]
        }
      },
      {
        "_index" : "demo",
        "_type" : "person",
        "_id" : "xpGbXm4B7Vc5UQFTSINJ",
        "_score" : 1.5506184,
        "_source" : {
          "name" : "王五",
          "age" : 22,
          "mail" : "333@qq.com",
          "hobby" : "羽毛球、篮球、游泳、听音乐"
        },
        "highlight" : {
          "hobby" : [
            "羽毛球、篮球、游泳、听<em>音</em><em>乐</em>"
          ]
        }
      }
    ]
  }
}

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

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

示例：

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query" : {"term":{"age":20}}}}'

#响应
{
  "took" : 6,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "demo",
        "_type" : "person",
        "_id" : "xJGbXm4B7Vc5UQFTSINH",
        "_score" : 1.0,
        "_source" : {
          "name" : "张三",
          "age" : 20,
          "mail" : "111@qq.com",
          "hobby" : "羽毛球、乒乓球、足球"
        }
      }
    ]
  }
}

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

{
    "terms": {
        "tag": ["search", "full_text", "nosql"]
    }
}

示例：

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query" : {"terms":{"age":[20,21]}}}}'

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

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

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

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query" : {"range":{"age":{"gte":20,"lte":22}}}}'

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

{
    "query": {
        "exists": {#必须包含 
            "field": "name"
        }
    }
}

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

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query" : {"exists":{"field":"name"}}}'

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

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

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

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

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query" : {"match":{"age":"26"}}}'

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   }}        
        ]    
    }
}

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query":{"bool":{"must":{"match":{"hobby":"篮球"}},"must_not":{"match":{"hobby":"音乐"}},"should":[{"match": {"hobby":"游泳"}}]}},"highlight": {"fields": {"hobby": {}}}}'

过滤查询

前面讲过结构化查询，Elasticsearch也支持过滤查询，如term、range、match等。
示例：查询年龄为20岁的用户。

{
    "query": {
        "bool": {
            "filter": {
                "term": {
                    "age": 20
                }
            }
        }
    }
}

curl -POST "http://47.101.129.45:9200/demo/person/_search?pretty" -H 'Content-Type: application/json' -d '{"query": {"bool": {"filter": {"term": {"age": 20}}}}}'

查询和过滤的对比:

一条过滤语句会询问每个文档的字段值是否包含着特定值
查询语句会询问每个文档的字段值与特定值的匹配程度如何，一条查询语句会计算每个文档与查询语句的相关性，会给出一个相关性评分 _score，并且按照相关性对匹配到的文档进行排序。这种评分方式非常适用于一个没有完全配置结果的全文本搜索。
一个简单的文档列表，快速匹配运算并存入内存是十分方便的，每个文档仅需要1个字节。这些缓存的过滤结果集与后续请求的结合使用是非常高效的。
查询语句不仅要查找相匹配的文档，还需要计算每个文档的相关性，所以一般来说查询语句要比过滤语句更耗时，并且查询结果也不可缓存。

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

中文分词

1）什么是分词
分词就是指将一个文本转化成一系列单词的过程，也叫文本分析，在Elasticsearch中称之为Analysis。
举例：我是中国人--> 我/是/中国人
2）分词api
1.指定分词器进行分词

curl -POST "http://47.101.129.45:9200/_analyze?pretty" -H 'Content-Type: application/json' -d '{"analyzer":"standard","text":"hello world"}'

#响应
{
  "tokens" : [
    {
      "token" : "hello",
      "start_offset" : 0,
      "end_offset" : 5,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "world",
      "start_offset" : 6,
      "end_offset" : 11,
      "type" : "<ALPHANUM>",
      "position" : 1
    }
  ]
}

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

2.指定索引分词

curl -POST "http://47.101.129.45:9200/demo/_analyze?pretty" -H 'Content-Type: application/json' -d '{"analyzer":"standard","field": "hobby","text":"听音乐"}'

#响应
 
{
  "tokens" : [
    {
      "token" : "听",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "音",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "乐",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    }
  ]
}

3）内置分词
1.Standard 标准分词，按单词切分，并且会转化成小写

curl -POST "http://47.101.129.45:9200/_analyze?pretty" -H 'Content-Type: application/json' -d '{"analyzer":"standard","text":"A man becomes learned by asking questions."}'

#响应
{
  "tokens" : [
    {
      "token" : "a",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "man",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "<ALPHANUM>",
      "position" : 1
    },
    {
      "token" : "becomes",
      "start_offset" : 6,
      "end_offset" : 13,
      "type" : "<ALPHANUM>",
      "position" : 2
    },
    {
      "token" : "learned",
      "start_offset" : 14,
      "end_offset" : 21,
      "type" : "<ALPHANUM>",
      "position" : 3
    },
    {
      "token" : "by",
      "start_offset" : 22,
      "end_offset" : 24,
      "type" : "<ALPHANUM>",
      "position" : 4
    },
    {
      "token" : "asking",
      "start_offset" : 25,
      "end_offset" : 31,
      "type" : "<ALPHANUM>",
      "position" : 5
    },
    {
      "token" : "questions",
      "start_offset" : 32,
      "end_offset" : 41,
      "type" : "<ALPHANUM>",
      "position" : 6
    }
  ]
}

2.Keyword分词器，意思是传入就是关键词，不做分词处理。

curl -POST "http://47.101.129.45:9200/_analyze?pretty" -H 'Content-Type: application/json' -d '{"analyzer":"keyword","text":"A man becomes learned by asking questions."}'

#响应
{
  "tokens" : [
    {
      "token" : "A man becomes learned by asking questions.",
      "start_offset" : 0,
      "end_offset" : 42,
      "type" : "word",
      "position" : 0
    }
  ]
}

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）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇（姓名、地名处理）等分词处理。优化的词典存储，更小的内存占用。

K分词器 Elasticsearch插件地址：https://github.com/medcl/elas...

#安装方法：将下载到的elasticsearch-analysis-ik-6.5.4.zip解压到/elasticsearch/plugins/ik目录下即可。

#如果使用docker运行
docker cp elasticsearch-analysis-ik-6.5.4.zip elasticsearch:/usr/share/elasticsearch/plugins/

#进入容器
docker exec -it elasticsearch /bin/bash

mkdir /usr/share/elasticsearch/plugins/ik
cd /usr/share/elasticsearch/plugins/ik
mv elasticsearch-analysis-ik-6.5.4.zip ik

unzip elasticsearch-analysis-ik-6.5.4.zip

#重启容器即可
docker restart elasticsearch

测试：

curl -POST "http://47.101.129.45:9200/_analyze?pretty" -H 'Content-Type: application/json' -d '{"analyzer":"ik_max_word","text":"我是中国人"}'

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

ElasticSearch的核心详解及中文分词

文档

查询响应

判断文档是否存在

批量操作

分页

映射

过滤查询

中文分词

Jello

引用和评论

vue开发插件上传npm

Helm3-安装带有ik分词的ElasticSearch

Elasticsearch 8.x 重要变化（qbit）

关于 Elasticsearch 同义词的困惑（qbit）

Elasticsearch搭建、结合spring boot、简单示例

Docker如何修改Elasticsearch容器的密码

Elasticsearch 8 RAG 技术分享