ElasticStack入门

作者：鸿纶静火7 | 来源：互联网 | 2023-09-13 15:17

https:blog.csdn.neta185589690articledetails100852581ElasticStack简介如果你没有听说过ElasticStack&#

https://blog.csdn.net/a185589690/article/details/100852581

Elastic Stack简介

如果你没有听说过Elastic Stack&＃xff0c;那你一定听说过ELK&＃xff0c;实际上ELK是三款软件的简称&＃xff0c;分别是ElasticsearchLogstash、Kibana组成&＃xff0c;在发展的过程中&＃xff0c;又有新成员Beats的加入&＃xff0c;所以就形成了Elastic Stack。所以说&＃xff0c;ELK是旧的称呼&＃xff0c;Elastic Stack是新的名字。

官网&＃xff1a;https://www.elastic.co/cn/products/elasticsearch

Elasticsearch

Elasticsearch 基于java&＃xff0c;是个开源分布式搜索引擎&＃xff0c;它的特点有&＃xff1a;分布式&＃xff0c;零配置&＃xff0c;自动发现&＃xff0c;索引自动分片&＃xff0c;索引副本机制&＃xff0c;restful风格接口&＃xff0c;多数据源&＃xff0c;自动搜索负载等。

Logstash

Logstash 基于java&＃xff0c;是一个开源的用于收集,分析和存储日志的工具。

Kibana

Kibana 基于nodejs&＃xff0c;也是一个开源和免费的工具&＃xff0c;Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面&＃xff0c;可以汇总、分析和搜索重要数据日志。

Beats

Beats是elastic公司开源的一款采集系统监控数据的代理agent&＃xff0c;是在被监控服务器上以客户端形式运行的数据收集器的统称&＃xff0c;可以直接把数据发送给Elasticsearch或者通过Logstash发送给Elasticsearch&＃xff0c;然后进行后续的数据分析活动。

Beats由如下组成:

Packetbeat&＃xff1a;是一个网络数据包分析器&＃xff0c;用于监控、收集网络流量信息&＃xff0c;Packetbeat嗅探服务器之间的流量&＃xff0c;解析应用层协议&＃xff0c;并关联到消息的处理&＃xff0c;其支持ICMP (v4 and v6)、DNS、HTTP、Mysql、PostgreSQL、Redis、MongoDB、Memcache等协议&＃xff1b;

Filebeat&＃xff1a;用于监控、收集服务器日志文件&＃xff0c;其已取代 logstash forwarder&＃xff1b;

Metricbeat&＃xff1a;可定期获取外部系统的监控指标信息&＃xff0c;其可以监控、收集 Apache、HAProxy、MongoDB

MySQL、Nginx、PostgreSQL、Redis、System、Zookeeper等服务&＃xff1b;

Winlogbeat&＃xff1a;用于监控、收集Windows系统的日志信息&＃xff1b;

版本说明

Elasticsearch的发展是非常快速的&＃xff0c;所以在ES5.0之前&＃xff0c;ELK的各个版本都不统一&＃xff0c;出现了版本号混乱的状态&＃xff0c;所以从5.0开始&＃xff0c;所有Elastic Stack中的项目全部统一版本号。目前最新版本是6.5.4

下载地址: https://www.elastic.co/cn/downloads/elasticsearch

链接&＃xff1a;https://pan.baidu.com/s/1LchVTTXG4abcJIPvLx7jkA
提取码&＃xff1a;ig8w
复制这段内容后打开百度网盘手机App&＃xff0c;操作更方便哦

包含Ik中文分词器

单机版安装命令:

#创建elsearch用户&＃xff0c;Elasticsearch不支持root用户运行
useradd elsearch

#权限问题,建议不要用root用户传.
#解压安装包到当前目录的 /data/es目录下
tar -xvf elasticsearch-6.5.4.tar.gz -C /data/es/

#修改配置文件
vim conf/elasticsearch.yml
network.host: 172.16.55.185 #绑定的地址

#说明&＃xff1a;在Elasticsearch中如果&＃xff0c;network.host不是localhost或者127.0.0.1的话&＃xff0c;就会认为是生产环境&＃xff0c;会对环境的要求比较高&＃xff0c;我们的开发环境不一定能够满足&＃xff0c;一般情况下需要修改2处配置&＃xff0c;如下&＃xff1a;
#1&＃xff1a;修改jvm启动参数默认1G
vim conf/jvm.options
-Xms128m #根据自己机器情况修改
-Xmx128m
#2&＃xff1a;单个进程中的最大线程数
vim /etc/sysctl.conf
vm.max_map_count&＃61;655360

#启动ES服务
su - elsearch
cd bin
./elasticsearch 或 ./elasticsearch -d #后台系统

#通过访问http://172.16.55.185:9200进行测试&＃xff0c;看到如下信息&＃xff0c;就说明ES启动成功了
{
"name": "dSQV6I8",
"cluster_name": "elasticsearch",
"cluster_uuid": "v5GPTWAtT5emxFdjigFg-w",
"version": {
"number": "6.5.4",
"build_flavor": "default",
"build_type": "tar",
"build_hash": "d2ef93d",
"build_date": "2018-12-17T21:17:40.758843Z",
"build_snapshot": false,
"lucene_version": "7.5.0",
"minimum_wire_compatibility_version": "5.6.0",
"minimum_index_compatibility_version": "5.0.0"
},
"tagline": "You Know, for Search"
}

#停止:
输入 jps 查看进程端口号
68709 Jps
68072 Elasticsearch
然后使用kill 68072 结束进程

使用docker安装

#拉取镜像
docker pull elasticsearch:6.5.4

#创建容器
docker create --name elasticsearch --net host -e "discovery.type&＃61;single-node" -e "network.host&＃61;172.16.55.185" elasticsearch:6.5.4

#启动
docker start elasticsearch

#查看日志
docker logs elasticsearch
现在docker安装是开发环境模式&＃xff0c;并没有配置目录挂载等内容.

elasticsearch-head (可视化的管理工具)

由于ES官方并没有为ES提供界面管理工具&＃xff0c;仅仅是提供了后台的服务。elasticsearch-head是一个为ES开发的一个页面客户端工具&＃xff0c;其源码托管于GitHub&＃xff0c;地址为&＃xff1a;https://github.com/mobz/elasticsearch-head

head提供了4种安装方式

1.源码安装&＃xff0c;通过npm run start启动&＃xff08;不推荐&＃xff09;
2.通过docker安装&＃xff08;推荐&＃xff09;
3.通过chrome插件安装&＃xff08;推荐
4.通过ES的plugin方式安装&＃xff08;不推荐)

docker安装

#拉取镜像
docker pull mobz/elasticsearch-head:5
#创建容器
docker create --name elasticsearch-head -p 9100:9100 mobz/elasticsearch-head:5
#启动容器
docker start elasticsearch-head

注意&＃xff1a;
由于前后端分离开发&＃xff0c;所以会存在跨域问题&＃xff0c;需要在服务端做CORS的配置&＃xff0c;如下&＃xff1a;
vim elasticsearch.yml

http.cors.enabled: true
http.cors.allow-origin: "*"
通过chrome插件的方式安装不存在该问题。

chrome插件的方式安装

打开chrome的应用商店&＃xff0c;即可安装

https://chrome.google.com/webstore/detail/elasticsearch-head/ffffmkiejjmecolpflfloofpjologoblkegm

基本概念

索引

1.索引&＃xff08;index&＃xff09;是Elasticsearch对逻辑数据的逻辑存储&＃xff0c;所以它可以分为更小的部分。
2.可以把索引看成关系型数据库的表&＃xff0c;索引的结构是为快速有效的全文索引准备的&＃xff0c;特别是它不存储原始值。
3.可以把Elasticsearch的索引看成MongoDB里的一个集合。
4.Elasticsearch可以把索引存放在一台机器或者分散在多台服务器上&＃xff0c;每个索引有一或多个分片&＃xff08;shard&＃xff09;&＃xff0c;
每个分片可以有多个副本&＃xff08;replica&＃xff09;。

文档

1.存储在Elasticsearch中的主要实体叫文档&＃xff08;document&＃xff09;。用关系型数据库来类比的话&＃xff0c;一个文档相当于数据
库表中的一行记录。
2.Elasticsearch和MongoDB中的文档类似&＃xff0c;都可以有不同的结构&＃xff0c;但Elasticsearch的文档中&＃xff0c;相同字段必须有相同类型。
3.文档由多个字段组成&＃xff0c;每个字段可能多次出现在一个文档里&＃xff0c;这样的字段叫多值字段&＃xff08;multivalued&＃xff09;。
4.每个字段的类型&＃xff0c;可以是文本、数值、日期等。字段类型也可以是复杂类型&＃xff0c;一个字段包含其他子文档或者
数组。

映射

所有文档写进索引之前都会先进行分析&＃xff0c;如何将输入的文本分割为词条、哪些词条又会被过滤&＃xff0c;这种行为叫
做映射&＃xff08;mapping&＃xff09;。一般由用户自己定义规则。

文档类型

1.在Elasticsearch中&＃xff0c;一个索引对象可以存储很多不同用途的对象。例如&＃xff0c;一个博客应用程序可以保存文章和
评论。
2.每个文档可以有不同的结构。
3.不同的文档类型不能为相同的属性设置不同的类型。例如&＃xff0c;在同一索引中的所有文档类型中&＃xff0c;一个叫title的字
段必须具有相同的类型。

创建非结构化索引

在Lucene中&＃xff0c;创建索引是需要定义字段名称以及字段的类型的&＃xff0c;在Elasticsearch中提供了非结构化的索引&＃xff0c;就是不需要创建索引结构&＃xff0c;即可写入数据到索引中&＃xff0c;实际上在Elasticsearch底层会进行结构化操作&＃xff0c;此操作对用户是透明的。

可视化界面:

使用请求的方式. 使用postman之类的工具:

#访问
PUT http://172.16.55.185:9200/test1
参数
{ "settings": {
"index": {
"number_of_shards": "2",
"number_of_replicas": "0" }
}
}

解释:
"number_of_shards": "2", #分片数
"number_of_replicas": "0" #副本数

#删除索引
DELETE http://172.16.55.185:9200/test1
参数
{ "acknowledged": true }

插入数据

URL规则: POST http://172.16.55.185:9200/{索引}/{类型}/{id}

POST http://172.16.55.185:9200/test/user/1001

#数据
{ "id":1001, "name":"张三", "age":20, "sex":"男" }

#响应
{ "_index": "test", "_type": "user", "_id": "1", "_version": 1, "result": "created", "_shards": { "total": 1, "successful": 1, "failed": 0 },"_seq_no": 0, "_primary_term": 1 }

说明&＃xff1a;非结构化的索引&＃xff0c;不需要事先创建&＃xff0c;直接插入数据默认创建索引。

不指定id插入数据的时候, 会自动生成id.

更新数据

在Elasticsearch中&＃xff0c;文档数据是不为修改的&＃xff0c;但是可以通过覆盖的方式进行更新。

#全量更新重新插入就会覆盖
PUT http://172.16.55.185:9200/test/user/1001

{ "id":1001, "name":"张三", "age":21, "sex":"女" }

问题来了&＃xff0c;可以局部更新吗&＃xff1f; -- 可以的。
前面不是说&＃xff0c;文档数据不能更新吗&＃xff1f; 其实是这样的&＃xff1a;
在内部&＃xff0c;依然会查询到这个文档数据&＃xff0c;然后进行覆盖操作&＃xff0c;步骤如下&＃xff1a;
1. 从旧文档中检索JSON
2. 修改它
3. 删除旧文档
4. 索引新文档

#注意&＃xff1a;这里多了_update标识
POST http://172.16.55.185:9200/test/user/1001/_update

{"doc":{ "age":23 } }
可以看到数据已经被局部更新了。

删除数据

在Elasticsearch中&＃xff0c;删除文档数据&＃xff0c;只需要发起DELETE请求即可。

DELETE http://172.16.55.185:9200/test/user/1001

需要注意的是&＃xff0c;result表示已经删除&＃xff0c;version也更加了。
如果删除一条不存在的数据&＃xff0c;会响应404&＃xff1a;

说明&＃xff1a;
删除一个文档也不会立即从磁盘上移除&＃xff0c;它只是被标记成已删除。Elasticsearch将会在你之后添加更多索引
的时候才会在后台进行删除内容的清理。

搜索数据

根据id搜索数据

GET http://172.16.55.185:9200/test/user/BbPe_WcB9cFOnF3uebvr

搜索全部数据(默认返回10条数据)

GET http://172.16.55.185:9200/test/user/_search

关键字搜素数据

#查询年龄等于20的用户
GET http://172.16.55.185:9200/test/user/_search?q&＃61;age:20

DSL搜索

Elasticsearch提供丰富且灵活的查询语言叫做DSL查询(Query DSL),它允许你构建更加复杂、强大的查询。
DSL(Domain Specific Language特定领域语言)以JSON请求体的形式出现。

POST http://172.16.55.185:9200/test/user/_search

#请求体
#match只是查询的一种
{
"query" :
{ "match" : { "age" : 20}
}
}

#查询年龄大于30岁的男性用户。
#请求数据
{ "query": { "bool": { "filter": {"range": { "age": { "gt": 30 } } },"must": { "match": { "sex": "男" } } } } }

#gt 大于的意思

#must match是匹配.
#filter range是过滤

全文搜索

POST http://172.16.55.185:9200/test/user/_search
#请求数据
{ "query": { "match": { "name": "张三李四" } } }

这样会查出来张三和李四两条数据.其实是分词器的作用.

高亮显示 : highlight fields 里面是要高亮的字段

POST http://172.16.55.185:9200/haoke/user/_search

{ "query": { "match": { "name": "张三李四"} },"highlight": { "fields": { "name": {} } } }

聚合在Elasticsearch中&＃xff0c;支持聚合操作&＃xff0c;类似SQL中的group by操作。

POST http://172.16.55.185:9200/test/user/_search
{ "aggs": { "all_interests": { "terms": { "field": "age" } } } }

核心

文档

在Elasticsearch中&＃xff0c;文档以JSON格式进行存储&＃xff0c;可以是复杂的结构&＃xff0c;如&＃xff1a;

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

其中&＃xff0c;card是一个复杂对象&＃xff0c;嵌套的Card对象。
一个文档不只有数据。它还包含了元数据(metadata)——关于文档的信息。三个必须的元数据节点是&＃xff1a;

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

_index

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

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

_type

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

_id

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

查询响应

pretty

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

格式化数据.postman的话就不需要了.postman自动格式化了.

指定响应字段

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

GET http://172.16.55.185:9200/test/user/1005?_source&＃61;id,name
#响应
{ "_index": "test", "_type": "user", "_id": "1005", "_version": 1, "found": true, "_source": { "name": "孙七", "id": 1005 } }

如果只返回元数据. 不会返回_index 这些数据. 只返回存放的实体类.
GET http://172.16.55.185:9200/test/user/1005/_source?_source&＃61;id,name

判断文档是否存在

如果我们只需要判断文档是否存在&＃xff0c;而不是查询文档内容&＃xff0c;那么可以这样&＃xff1a;

HEAD http://172.16.55.185:9200/test/user/1005

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

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

批量查询

POST http://172.16.55.185:9200/test/user/_mget

{ "ids" : [ "1001", "1003" ] }

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

POST http://172.16.55.185:9200/haoke/user/_mget

{ "ids" : [ "1001", "1006" ] }

#查询不到found &＃61; false

_bulk操作

在Elasticsearch中&＃xff0c;支持批量的插入、修改、删除操作&＃xff0c;都是通过_bulk的api完成的。请求格式如下&＃xff1a;&＃xff08;请求格式不同寻常&＃xff09;

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

#注意最后一行的回车。

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

批量删除

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

#由于delete没有请求体&＃xff0c;所以&＃xff0c;action的下一行直接就是下一个action。

其他操作就类似了。

一次请求多少性能最高&＃xff1f;

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

分页

和SQL使用 LIMIT 关键字返回只有一页的结果一样&＃xff0c;Elasticsearch接受 from 和 size 参数&＃xff1a;

size: 结果数&＃xff0c;默认10 . from: 跳过开始的结果数&＃xff0c;默认0

如果你想每页显示5个结果&＃xff0c;页码从1到3&＃xff0c;那请求如下&＃xff1a;
GET /_search?size&＃61;5
GET /_search?size&＃61;5&from&＃61;5
GET /_search?size&＃61;5&from&＃61;10

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

GET http://172.16.55.185:9200/haoke/user/_search?size&＃61;1&from&＃61;2

在集群系统中深度分页

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

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

映射

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

自动判断的规则如下&＃xff1a;
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中支持的类型如下&＃xff1a;
类型表示的数据类型
String string , text , keyword
Whole number byte , short , integer , long
Floating point float , double
Boolean boolean
Date date

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

创建明确类型的索引&＃xff1a;

PUT http://172.16.55.185:9200/test1

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

#查看映射&＃xff1a;

GET http://172.16.55.185:9200/test1/_mapping

结构化查询

term查询

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

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

示例&＃xff1a;
POST http://172.16.55.185:9200/test1/person/_search
{ "query" : { "term" : { "age" : 20 } } }

terms查询

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

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

示例&＃xff1a;
POST http://172.16.55.185:9200/test/person/_search
{ "query" : { "terms" : { "age" : [20,21] } } }

range查询

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

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

范围操作符包含&＃xff1a;
gt :: 大于
gte :: 大于等于
lt :: 小于
lte :: 小于等于

示例&＃xff1a;
POST http://172.16.55.185:9200/test1/person/_search
{ "query": { "range": { "age": { "gte": 20, "lte": 22 } } } }

exists 查询

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

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

#这两个查询只是针对已经查出一批数据来&＃xff0c;但是想区分出某个字段是否存在的时候使用。
示例&＃xff1a;
POST http://172.16.55.185:9200/test1/user/_search
{ "query": { "exists": {"field": "card" } } }

#必须包含

match查询

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

{ "match": { "tweet": "About Search" } }
如果用 match 下指定了一个确切值&＃xff0c;在遇到数字&＃xff0c;日期&＃xff0c;布尔值或者 not_analyzed 的字符串时&＃xff0c;它将为你搜索你给定的值
{ "match": { "age": 26 }}
{ "match": { "date": "2014-09-01" }}
{ "match": { "public": true }}
{ "match": { "tag": "full_text" }}

bool查询

bool 查询可以用来合并多个条件查询结果的布尔逻辑&＃xff0c;它包含一下操作符&＃xff1a;

must :: 多个查询条件的完全匹配,相当于 and 。

must_not :: 多个查询条件的相反匹配&＃xff0c;相当于 not 。

should :: 至少有一个查询条件匹配, 相当于 or 。

这些参数可以分别继承一个查询条件或者一个查询条件的数组&＃xff1a;
{ "bool":
{ "must": { "term": { "folder": "inbox" }},
"must_not": { "term": { "tag": "spam" }},
"should": [ { "term": { "starred": true }},
{ "term": { "unread": true }} ] } }

过滤查询

Elasticsearch也支持过滤查询&＃xff0c;如term、range、match等。

查询年龄为20岁的用户。
POST http://172.16.55.185:9200/test1/person/_search
{ "query": { "bool": { "filter": { "term": { "age": 20 } } } } }

查询和过滤的对比

一条过滤语句会询问每个文档的字段值是否包含着特定值。

查询语句会询问每个文档的字段值与特定值的匹配程度如何。

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

一个简单的文档列表&＃xff0c;快速匹配运算并存入内存是十分方便的&＃xff0c; 每个文档仅需要1个字节。这些缓存的过滤结
果集与后续请求的结合使用是非常高效的。

查询语句不仅要查找相匹配的文档&＃xff0c;还需要计算每个文档的相关性&＃xff0c;所以一般来说查询语句要比过滤语句更耗时&＃xff0c;并且查询结果也不可缓存.

建议&＃xff1a;

做精确匹配搜索时&＃xff0c;最好用过滤语句&＃xff0c;因为过滤语句可以缓存数据。

中文分词

分词

分词就是指将一个文本转化成一系列单词的过程&＃xff0c;也叫文本分析&＃xff0c;在Elasticsearch中称之为Analysis。

举例&＃xff1a;我是中国人 --> 我/是/中国人

分词api

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

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

指定索引分词

POST http://172.16.55.185:9200/test/_analyze
{ "analyzer": "standard", "field": "hobby", "text": "听音乐" }

内置分词

Standard:Standard 标准分词&＃xff0c;按单词切分&＃xff0c;并且会转化成小写

POST http://172.16.55.185:9200/_analyze
{ "analyzer": "standard", "text": "A man becomes learned by asking questions." }

返回结果:
{
   "tokens": [{
       "token": "a",
       "start_offset": 0,
       "end_offset": 1,
       "type": "",
       "position": 0
   }, {
       "token": "man",
       "start_offset": 2,
       "end_offset": 5,
       "type": "",
       "position": 1
   }, {
       "token": "becomes",
       "start_offset": 6,
       "end_offset": 13,
       "type": "",
       "position": 2
   }, {
       "token": "learned",
       "start_offset": 14,
       "end_offset": 21,
       "type": "",
       "position": 3
   }, {
       "token": "by",
       "start_offset": 22,
       "end_offset": 24,
       "type": "",
       "position": 4
   }, {
       "token": "asking",
       "start_offset": 25,
       "end_offset": 31,
       "type": "",
       "position": 5
   }, {
       "token": "questions",
       "start_offset": 32,
       "end_offset": 41,
       "type": "",
       "position": 6
   }]
}

Simple :Simple分词器&＃xff0c;按照非单词切分&＃xff0c;并且做小写处理

POST http://172.16.55.185:9200/_analyze
{ "analyzer": "simple", "text": "If the document doesn&＃39;t already exist" }

结果

{
   "tokens": [{
       "token": "if",
       "start_offset": 0,
       "end_offset": 2,
       "type": "word",
       "position": 0
   }, {
       "token": "the",
       "start_offset": 3,
       "end_offset": 6,
       "type": "word",
       "position": 1
   }, {
       "token": "document",
       "start_offset": 7,
       "end_offset": 15,
       "type": "word",
       "position": 2
   }, {
       "token": "doesn",
       "start_offset": 16,
       "end_offset": 21,
       "type": "word",
       "position": 3
   }, {
       "token": "t",
       "start_offset": 22,
       "end_offset": 23,
       "type": "word",
       "position": 4
   }, {
       "token": "already",
       "start_offset": 24,
       "end_offset": 31,
       "type": "word",
       "position": 5
   }, {
       "token": "exist",
       "start_offset": 32,
       "end_offset": 37,
       "type": "word",
       "position": 6
   }]
}

Whitespace :Whitespace是按照空格切分。

POST http://172.16.55.185:9200/_analyze
{ "analyzer": "whitespace", "text": "If the document doesn&＃39;t already exist" }

结果:
{
   "tokens": [{
       "token": "If",
       "start_offset": 0,
       "end_offset": 2,
       "type": "word",
       "position": 0
   }, {
       "token": "the",
       "start_offset": 3,
       "end_offset": 6,
       "type": "word",
       "position": 1
   }, {
       "token": "document",
       "start_offset": 7,
       "end_offset": 15,
       "type": "word",
       "position": 2
   }, {
       "token": "doesn&＃39;t",
       "start_offset": 16,
       "end_offset": 23,
       "type": "word",
       "position": 3
   }, {
       "token": "already",
       "start_offset": 24,
       "end_offset": 31,
       "type": "word",
       "position": 4
   }, {
       "token": "exist",
       "start_offset": 32,
       "end_offset": 37,
       "type": "word",
       "position": 5
   }]
}

Stop :Stop分词器&＃xff0c;是去除Stop Word语气助词&＃xff0c;如the、an等。

POST http://172.16.55.185:9200/_analyze
{ "analyzer": "stop", "text": "If the document doesn&＃39;t already exist" }

结果:
{
   "tokens": [{
       "token": "document",
       "start_offset": 7,
       "end_offset": 15,
       "type": "word",
       "position": 2
   }, {
       "token": "doesn",
       "start_offset": 16,
       "end_offset": 21,
       "type": "word",
       "position": 3
   }, {
       "token": "t",
       "start_offset": 22,
       "end_offset": 23,
       "type": "word",
       "position": 4
   }, {
       "token": "already",
       "start_offset": 24,
       "end_offset": 31,
       "type": "word",
       "position": 5
   }, {
       "token": "exist",
       "start_offset": 32,
       "end_offset": 37,
       "type": "word",
       "position": 6
   }]
}

Keyword:Keyword分词器&＃xff0c;意思是传入就是关键词&＃xff0c;不做分词处理。

POST http://172.16.55.185:9200/_analyze
{ "analyzer": "keyword", "text": "If the document doesn&＃39;t already exist" }

结果:
{
   "tokens": [{
       "token": "If the document doesn&＃39;t already exist",
       "start_offset": 0,
       "end_offset": 37,
       "type": "word",
       "position": 0
   }]
}

中文分词

中文分词的难点在于&＃xff0c;在汉语中没有明显的词汇分界点&＃xff0c;如在英语中&＃xff0c;空格可以作为分隔符&＃xff0c;如果分隔不正确就会

造成歧义。如&＃xff1a;我/爱/炒肉丝我/爱/炒/肉丝

常用中文分词器&＃xff0c;IK、jieba、THULAC等&＃xff0c;推荐使用IK分词器。

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

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

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

#如果使用docker运行
docker cp /tmp/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
unzip elasticsearch-analysis-ik-6.5.4.zip
#重启容器即可
docker restart elasticsearch

测试:
POST http://172.16.55.185:9200/_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
   }]
}

————————————————
版权声明&＃xff1a;本文为CSDN博主「单人影i」的原创文章&＃xff0c;遵循 CC 4.0 BY-SA 版权协议&＃xff0c;转载请附上原文出处链接及本声明。
原文链接&＃xff1a;https://blog.csdn.net/a185589690/article/details/100852581