• 万字长文带你学习ElasticSearch

    ElasticStack技术栈

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

    从ELK到ElasticStack

    全系的 ElasticStack 技术栈包括：

    ElasticStack技术栈

    Elasticsearch

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

    Logstash

    Logstash 基于 Java，是一个开源的用于收集,分析和存储日志的工具。

    Kibana

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

    Beats

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

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

    • Filebeat：用于监控、收集服务器日志文件，其已取代 logstash forwarder；

    • Metricbeat：可定期获取外部系统的监控指标信息，其可以监控、收集 Apache、HAProxy、MongoDB MySQL、Nginx、PostgreSQL、Redis、System、Zookeeper等服务；

    Beats和Logstash其实都可以进行数据的采集，但是目前主流的是使用Beats进行数据采集，然后使用 Logstash进行数据的分割处理等，早期没有Beats的时候，使用的就是Logstash进行数据的采集。

    ElasticSearch快速入门

    简介

    官网：https://www.elastic.co/

    ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful Web 接口。Elasticsearch 是用 Java 开发的，并作为 Apache 许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。

    我们建立一个网站或应用程序，并要添加搜索功能，但是想要完成搜索工作的创建是非常困难的。我们希望搜索解决方案要运行速度快，我们希望能有一个零配置和一个完全免费的搜索模式，我们希望能够简单地使用JSON通过HTTP来索引数据，我们希望我们的搜索服务器始终可用，我们希望能够从一台开始并扩展到数百台，我们要实时搜索，我们要简单的多租户，我们希望建立一个云的解决方案。因此我们利用Elasticsearch来解决所有这些问题及可能出现的更多其它问题。

    ElasticSearch 是 Elastic Stack 的核心，同时 Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，能够解决不断涌现出的各种用例。作为 Elastic Stack 的核心，它集中存储您的数据，帮助您发现意料之中以及意料之外的情况。

    Elasticsearch 的发展是非常快速的，所以在 ES5.0 之前，ELK 的各个版本都不统一，出现了版本号混乱的状态，所以从 5.0 开始，所有 Elastic Stack 中的项目全部统一版本号。本篇将基于 6.5.4 版本进行学习。

    下载

    到官网下载：https://www.elastic.co/cn/downloads/

    下载

    选择对应版本的数据，这里我使用的是 Linux 来进行安装，所以就先下载好 ElasticSearch 的 Linux 安装包

    拉取Docker容器

    因为我们需要部署在 Linux 下，为了以后迁移 ElasticStack 环境方便，我们就使用 Docker 来进行部署，首先我们拉取一个带有 ssh 的 Centos 镜像

    1. # 拉取镜像
    2. docker pull moxi/centos_ssh
    3. # 制作容器
    4. docker run --privileged -d -it -h ElasticStack --name ElasticStack -p 11122:22 -p 9200:9200 -p 5601:5601 -p 9300:9300 -v /etc/localtime:/etc/localtime:ro  moxi/centos_ssh /usr/sbin/init

    然后直接远程连接 11122 端口即可

    单机版安装

    因为 ElasticSearch 不支持 root 用户直接操作，因此我们需要创建一个elsearch用户

    1. # 添加新用户
    2. useradd elsearch
    3.  
    4. # 创建一个soft目录，存放下载的软件
    5. mkdir /soft
    6.  
    7. # 进入，然后通过xftp工具，将刚刚下载的文件拖动到该目录下
    8. cd /soft
    9.  
    10. # 解压缩
    11. tar -zxvf elasticsearch-7.9.1-linux-x86_64.tar.gz
    12.  
    13. #重命名
    14. mv elasticsearch-7.9.1/ elsearch

    因为刚刚我们是使用 root 用户操作的，所以我们还需要更改一下 /soft 文件夹的所属，改为 elsearch 用户

    chown elsearch:elsearch /soft/ -R

    然后在切换成 elsearch 用户进行操作

    1. # 切换用户
    2. su - elsearch

    然后我们就可以对我们的配置文件进行修改了

    1. # 进入到 elsearch下的config目录
    2. cd /soft/elsearch/config

    然后找到下面的配置

    1. #打开配置文件
    2. vim elasticsearch.yml 
    3.  
    4. #设置ip地址，任意网络均可访问
    5. network.host: 0.0.0.0 

    在 Elasticsearch 中如果network.host 不是 localhost 或者127.0.0.1 的话，就会认为是生产环境，而生产环境的配置要求比较高，我们的测试环境不一定能够满足，一般情况下需要修改两处配置，如下：

    1. # 修改jvm启动参数
    2. vim conf/jvm.options
    3.  
    4. #根据自己机器情况修改
    5. -Xms128m 
    6. -Xmx128m

    然后在修改第二处的配置，这个配置要求我们到宿主机器上来进行配置

    1. # 到宿主机上打开文件
    2. vim /etc/sysctl.conf
    3. # 增加这样一条配置，一个进程在VMAs(虚拟内存区域)创建内存映射最大数量
    4. vm.max_map_count=655360
    5. # 让配置生效
    6. sysctl -p

    启动ElasticSearch

    首先我们需要切换到 elsearch 用户

    su - elsearch

    然后在到 bin目录下，执行下面

    1. # 进入bin目录
    2. cd /soft/elsearch/bin
    3. # 后台启动
    4. ./elasticsearch -d

    启动成功后，访问下面的 URL

    http://202.193.56.222:9200/

    如果出现了下面的信息，就表示已经成功启动了

    ELastic启动成功

    如果你在启动的时候，遇到过问题，那么请参考下面的错误分析~

    错误分析

    错误情况1

    如果出现下面的错误信息

    1. java.lang.RuntimeException: can not run elasticsearch as root
    2.     at org.elasticsearch.bootstrap.Bootstrap.initializeNatives(Bootstrap.java:111)
    3.     at org.elasticsearch.bootstrap.Bootstrap.setup(Bootstrap.java:178)
    4.     at org.elasticsearch.bootstrap.Bootstrap.init(Bootstrap.java:393)
    5.     at org.elasticsearch.bootstrap.Elasticsearch.init(Elasticsearch.java:170)
    6.     at org.elasticsearch.bootstrap.Elasticsearch.execute(Elasticsearch.java:161)
    7.     at org.elasticsearch.cli.EnvironmentAwareCommand.execute(EnvironmentAwareCommand.java:86)
    8.     at org.elasticsearch.cli.Command.mainWithoutErrorHandling(Command.java:127)
    9.     at org.elasticsearch.cli.Command.main(Command.java:90)
    10.     at org.elasticsearch.bootstrap.Elasticsearch.main(Elasticsearch.java:126)
    11.     at org.elasticsearch.bootstrap.Elasticsearch.main(Elasticsearch.java:92)
    12. For complete error details, refer to the log at /soft/elsearch/logs/elasticsearch.log
    13. [root@e588039bc613 bin]# 2020-09-22 02:59:39,537121 UTC [536] ERROR CLogger.cc@310 Cannot log to named pipe /tmp/elasticsearch-5834501324803693929/controller_log_381 as it could not be opened for writing
    14. 2020-09-22 02:59:39,537263 UTC [536] INFO  Main.cc@103 Parent process died - ML controller exiting

    就说明你没有切换成 elsearch 用户，因为不能使用 root 用户去操作 ElasticSearch

    su - elsearch

    错误情况2

    [1]:max file descriptors [4096] for elasticsearch process is too low, increase to at least[65536]

    解决方法：切换到 root 用户，编辑 limits.conf 添加如下内容

    1. vi /etc/security/limits.conf
    2.  
    3. # ElasticSearch添加如下内容:
    4. * soft nofile 65536
    5. * hard nofile 131072
    6. * soft nproc 2048
    7. * hard nproc 4096

    错误情况3

    1. [2]: max number of threads [1024] for user [elsearch] is too low, increase to at least
    2. [4096]

    也就是最大线程数设置的太低了，需要改成 4096

    1. #解决：切换到root用户，进入limits.d目录下修改配置文件。
    2. vi /etc/security/limits.d/90-nproc.conf
    3. #修改如下内容：
    4. * soft nproc 1024
    5. #修改为
    6. * soft nproc 4096

    错误情况4

    1. [3]: system call filters failed to install; check the logs and fix your configuration
    2. or disable system call filters at your own risk

    解决：Centos6 不支持 SecComp，而 ES5.2.0 默认 bootstrap.system_call_filter 为 true

    1. vim config/elasticsearch.yml
    2. # 添加
    3. bootstrap.system_call_filter: false
    4. bootstrap.memory_lock: false

    错误情况5

    1. [elsearch@e588039bc613 bin]$ Exception in thread "main" org.elasticsearch.bootstrap.BootstrapException: java.nio.file.AccessDeniedException: /soft/elsearch/config/elasticsearch.keystore
    2. Likely root cause: java.nio.file.AccessDeniedException: /soft/elsearch/config/elasticsearch.keystore
    3.     at java.base/sun.nio.fs.UnixException.translateToIOException(UnixException.java:90)
    4.     at java.base/sun.nio.fs.UnixException.rethrowAsIOException(UnixException.java:111)
    5.     at java.base/sun.nio.fs.UnixException.rethrowAsIOException(UnixException.java:116)
    6.     at java.base/sun.nio.fs.UnixFileSystemProvider.newByteChannel(UnixFileSystemProvider.java:219)
    7.     at java.base/java.nio.file.Files.newByteChannel(Files.java:375)
    8.     at java.base/java.nio.file.Files.newByteChannel(Files.java:426)
    9.     at org.apache.lucene.store.SimpleFSDirectory.openInput(SimpleFSDirectory.java:79)
    10.     at org.elasticsearch.common.settings.KeyStoreWrapper.load(KeyStoreWrapper.java:220)
    11.     at org.elasticsearch.bootstrap.Bootstrap.loadSecureSettings(Bootstrap.java:240)
    12.     at org.elasticsearch.bootstrap.Bootstrap.init(Bootstrap.java:349)
    13.     at org.elasticsearch.bootstrap.Elasticsearch.init(Elasticsearch.java:170)
    14.     at org.elasticsearch.bootstrap.Elasticsearch.execute(Elasticsearch.java:161)
    15.     at org.elasticsearch.cli.EnvironmentAwareCommand.execute(EnvironmentAwareCommand.java:86)
    16.     at org.elasticsearch.cli.Command.mainWithoutErrorHandling(Command.java:127)
    17.     at org.elasticsearch.cli.Command.main(Command.java:90)
    18.     at org.elasticsearch.bootstrap.Elasticsearch.main(Elasticsearch.java:126)
    19.     at org.elasticsearch.bootstrap.Elasticsearch.main(Elasticsearch.java:92)

    我们通过排查，发现是因为 /soft/elsearch/config/elasticsearch.keystore 存在问题

    也就是说该文件还是所属于root 用户，而我们使用 elsearch 用户无法操作，所以需要把它变成 elsearch

    chown elsearch:elsearch elasticsearch.keystore

    错误情况6

    1. [1]: the default discovery settings are unsuitable for production use; at least one of [discovery.seed_hosts, discovery.seed_providers, cluster.initial_master_nodes] must be configured
    2. ERROR: Elasticsearch did not exit normally - check the logs at /soft/elsearch/logs/elasticsearch.log

    继续修改配置 elasticsearch.yaml

    1. # 取消注释，并保留一个节点
    2. node.name: node-1
    3. cluster.initial_master_nodes: ["node-1"]

    ElasticSearchHead可视化工具

    由于 ES 官方没有给 ES 提供可视化管理工具，仅仅是提供了后台的服务，elasticsearch-head 是一个为 ES 开发的一个页面客户端工具，其源码托管于Github

    Github地址：https://github.com/mobz/elasticsearch-head

    head提供了以下安装方式

    • 源码安装，通过npm run start 启动（不推荐）

    • 通过docker安装（推荐）

    • 通过chrome插件安装（推荐）

    • 通过 ES 的plugin方式安装（不推荐）

    通过Docker方式安装

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

    通过浏览器进行访问：

    浏览器访问

    注意： 由于前后端分离开发，所以会存在跨域问题，需要在服务端做 CORS 的配置，如下：

    1. vim elasticsearch.yml
    2.  
    3. http.cors.enabled: true http.cors.allow-origin: "*"

    若通过 Chrome 插件的方式安装不存在该问题

    通过Chrome插件安装

    打开 Chrome 的应用商店，即可安装 https://chrome.google.com/webstore/detail/elasticsearch-head/ffmkiejjmecolpfloofpjologoblkegm

    Chrome插件安装

    我们也可以新建索引

    新建索引

    推荐使用 Chrome 插件的方式安装，如果网络环境不允许，就采用其它方式安装。

    ElasticSearch中的基本概念

    索引

    索引是 Elasticsearch 对逻辑数据的逻辑存储，所以它可以分为更小的部分。

    可以把索引看成关系型数据库的表，索引的结构是为快速有效的全文索引准备的，特别是它不存储原始值。

    Elasticsearch 可以把索引存放在一台机器或者分散在多台服务器上，每个索引有一或多个分片（shard），每个分片可以有多个副本（replica）。

    文档

    • 存储在 Elasticsearch 中的主要实体叫文档（document）。用关系型数据库来类比的话，一个文档相当于数据库表中的一行记录。

    • Elasticsearch 和 MongoDB 中的文档类似，都可以有不同的结构，但 Elasticsearch 的文档中，相同字段必须有相同类型。

    • 文档由多个字段组成，每个字段可能多次出现在一个文档里，这样的字段叫多值字段（multivalued）。 每个字段的类型，可以是文本、数值、日期等。字段类型也可以是复杂类型，一个字段包含其他子文档或者数 组。

    映射

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

    文档类型

    • 在 Elasticsearch 中，一个索引对象可以存储很多不同用途的对象。例如，一个博客应用程序可以保存文章和评论。

    • 每个文档可以有不同的结构。

    • 不同的文档类型不能为相同的属性设置不同的类型。例如，在同一索引中的所有文档类型中，一个叫 title 的字段必须具有相同的类型。

    RESTful API

    在 Elasticsearch 中，提供了功能丰富的 RESTful API 的操作，包括基本的 CRUD、创建索引、删除索引等操作。

    创建非结构化索引

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

    创建空索引

    1. PUT /haoke
    2. {
    3.     "settings": {
    4.         "index": {
    5.         "number_of_shards": "2", #分片数
    6.         "number_of_replicas": "0" #副本数
    7.         }
    8.     }
    9. }

    删除索引

    1. #删除索引
    2. DELETE /haoke
    3. {
    4.     "acknowledged": true
    5. }

    插入数据

    URL 规则： POST /{索引}/{类型}/{id}

    1. POST /haoke/user/1001
    2. #数据
    3. {
    4. "id":1001,
    5. "name":"张三",
    6. "age":20,
    7. "sex":"男"
    8. }

    使用 postman 操作成功后

    操作成功

    我们通过 ElasticSearchHead 进行数据预览就能够看到我们刚刚插入的数据了

    ElasticSearchHead插件浏览

    说明：非结构化的索引，不需要事先创建，直接插入数据默认创建索引。不指定id插入数据：

    自动生成ID

    更新数据

    在 Elasticsearch 中，文档数据是不能修改的，但是可以通过覆盖的方式进行更新。

    1. PUT /haoke/user/1001
    2. {
    3. "id":1001,
    4. "name":"张三",
    5. "age":21,
    6. "sex":"女"
    7. }

    覆盖成功后的结果如下：

    更新数据

    可以看到数据已经被覆盖了。问题来了，可以局部更新吗？ -- 可以的。前面不是说，文档数据不能更新吗？ 其实是这样的：在内部，依然会查询到这个文档数据，然后进行覆盖操作，步骤如下：

    1. 从旧文档中检索JSON

    2. 修改它

    3. 删除旧文档

    4. 索引新文档

    1. #注意：这里多了_update标识
    2. POST /haoke/user/1001/_update
    3. {
    4.     "doc":{
    5.         "age":23
    6.     }
    7. }

    更新操作

    可以看到，数据已经是局部更新了

    删除索引

    在 Elasticsearch 中，删除文档数据，只需要发起 DELETE 请求即可，不用额外的参数

    DELETE 1 /haoke/user/1001

    删除索引

    需要注意的是，result 表示已经删除，version 也增加了。

    如果删除一条不存在的数据，会响应 404

    删除一个文档也不会立即从磁盘上移除，它只是被标记成已删除。Elasticsearch将会在你之后添加更多索引的时候才会在后台进行删除内容的清理。【相当于批量操作】

    搜索数据

    根据id搜索数据

    1. GET /haoke/user/BbPe_WcB9cFOnF3uebvr
    2. #返回的数据如下
    3. {
    4.     "_index": "haoke",
    5.     "_type": "user",
    6.     "_id": "BbPe_WcB9cFOnF3uebvr",
    7.     "_version": 8,
    8.     "found": true,
    9.     "_source": { #原始数据在这里
    10.         "id": 1002,
    11.         "name": "李四",
    12.         "age": 40,
    13.         "sex": "男"
    14.         }
    15. }

    搜索全部数据

    GET 1 /haoke/user/_search

    注意，使用查询全部数据的时候，默认只会返回10条

    关键字搜索数据

    1. #查询年龄等于20的用户
    2. GET /haoke/user/_search?q=age:20

    结果如下：

    DSL搜索

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

    1. POST /haoke/user/_search
    2. #请求体
    3. {
    4.     "query" : {
    5.         "match" : { #match只是查询的一种
    6.             "age" : 20
    7.         }
    8.     }
    9. }

    实现：查询年龄大于30岁的男性用户。

    1. POST /haoke/user/_search
    2. #请求数据
    3. {
    4.     "query": {
    5.         "bool": {
    6.             "filter": {
    7.                     "range": {
    8.                         "age": {
    9.                         "gt": 30
    10.                     }
    11.                 }
    12.             },
    13.             "must": {
    14.                 "match": {
    15.                     "sex": "男"
    16.                 }
    17.             }
    18.         }
    19.     }
    20. }

    查询出来的结果

    全文搜索

    1. POST /haoke/user/_search
    2. #请求数据
    3. {
    4.     "query": {
    5.         "match": {
    6.             "name": "张三 李四"
    7.         }
    8.     }
    9. }

    高亮显示：只需要在添加一个 highlight 即可

    1. POST /haoke/user/_search
    2. #请求数据
    3. {
    4.     "query": {
    5.         "match": {
    6.             "name": "张三 李四"
    7.         }
    8.     }
    9.     "highlight": {
    10.         "fields": {
    11.             "name": {}
    12.         }
    13.     }
    14. }

    聚合

    在 Elasticsearch 中，支持聚合操作，类似SQL中的group by操作。

    1. POST /haoke/user/_search
    2. {
    3.     "aggs": {
    4.         "all_interests": {
    5.             "terms": {
    6.                 "field": "age"
    7.             }
    8.         }
    9.     }
    10. }

    结果如下，我们通过年龄进行聚合

    从结果可以看出，年龄30的有2条数据，20的有一条，40的一条。

    ElasticSearch核心详解

    文档

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

    1. {
    2.     "_index": "haoke",
    3.     "_type": "user",
    4.     "_id": "1005",
    5.     "_version": 1,
    6.     "_score": 1,
    7.     "_source": {
    8.         "id": 1005,
    9.         "name": "孙七",
    10.         "age": 37,
    11.         "sex": "女",
    12.         "card": {
    13.             "card_number": "123456789"
    14.          }
    15.     }
    16. }

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

    元数据（metadata）

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

    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位长度）

    查询响应

    pretty

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

    指定响应字段

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

    1. GET /haoke/user/1005?_source=id,name
    2. #响应
    3. {
    4.     "_index": "haoke",
    5.     "_type": "user",
    6.     "_id": "1005",
    7.     "_version": 1,
    8.     "found": true,
    9.     "_source": {
    10.         "name": "孙七",
    11.         "id": 1005
    12.      }
    13. }

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

    GET /haoke/1 user/1005/_source

    还可以这样：

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

    判断文档是否存在

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

    HEAD /haoke/user/1005

    通过发送一个head请求，来判断数据是否存在

    判断数据是否存在

    HEAD 1 /haoke/user/1006

    数据不存在

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

    批量操作

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

    批量查询

    1. POST /haoke/user/_mget
    2. {
    3.     "ids" : [ "1001", "1003" ]
    4. }

    结果：

    批量查询

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

    1. POST /haoke/user/_mget
    2. {
    3.     "ids" : [ "1001", "1006" ]
    4. }

    也就是说，一个数据的存在不会影响其它数据的返回

    bulk操作

    在Elasticsearch 中，支持批量的插入、修改、删除操作，都是通过 bulk 的 api 完成的。

    请求格式如下：（请求格式不同寻常）

    1. { action: { metadata }}
    2. { request body }
    3. { action: { metadata }}
    4. { request body }
    5. ...

    批量插入数据：

    1. {"create":{"_index":"haoke","_type":"user","_id":2001}}
    2. {"id":2001,"name":"name1","age": 20,"sex": "男"}
    3. {"create":{"_index":"haoke","_type":"user","_id":2002}}
    4. {"id":2002,"name":"name2","age": 20,"sex": "男"}
    5. {"create":{"_index":"haoke","_type":"user","_id":2003}}
    6. {"id":2003,"name":"name3","age": 20,"sex": "男"}

    注意最后一行的回车：

    批量删除：

    1. {"delete":{"_index":"haoke","_type":"user","_id":2001}}
    2. {"delete":{"_index":"haoke","_type":"user","_id":2002}}
    3. {"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，那请求如下：

    1. GET /_search?size=5
    2. GET /_search?size=5&from=5
    3. GET /_search?size=5&from=10

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

    GET /haoke/user/_1 search?size=1&from=2

    在集群系统中深度分页

    为了理解为什么深度分页是有问题的，让我们假设在一个有 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 类型的字段只能通过精 确值搜索到。

    创建明确类型的索引：

    如果你要像之前旧版版本一样兼容自定义 type ,需要将 include_type_name=true 携带

    1. put http://202.193.56.222:9200/itcast?include_type_name=true
    2. {
    3.     "settings":{
    4.         "index":{
    5.             "number_of_shards":"2",
    6.             "number_of_replicas":"0"
    7.         }
    8.     },
    9.     "mappings":{
    10.         "person":{
    11.             "properties":{
    12.                 "name":{
    13.                     "type":"text"
    14.                 },
    15.                 "age":{
    16.                     "type":"integer"
    17.                 },
    18.                 "mail":{
    19.                     "type":"keyword"
    20.                 },
    21.                 "hobby":{
    22.                     "type":"text"
    23.                 }
    24.             }
    25.         }
    26.     }
    27. }

    查看映射

    GET /itcast/_mapping

    插入数据

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

    测试搜索

    1. POST /itcast/person/_search
    2. {
    3.     "query":{
    4.         "match":{
    5.             "hobby":"音乐"
    6.         }
    7.     }
    8. }

    结构化查询

    term查询

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

    1. { "term": { "age": 26 }}
    2. { "term": { "date": "2014-09-01" }}
    3. { "term": { "public": true }}
    4. { "term": { "tag": "full_text" }}

    示例

    1. POST /itcast/person/_search
    2. {
    3.     "query":{
    4.         "term":{
    5.             "age":20
    6.         }
    7.     }
    8. }

    terms查询

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

    1. {
    2.     "terms":{
    3.         "tag":[
    4.             "search",
    5.             "full_text",
    6.             "nosql"
    7.         ]
    8.     }
    9. }

    示例：

    1. POST /itcast/person/_search
    2. {
    3.     "query":{
    4.         "terms":{
    5.             "age":[
    6.                 20,
    7.                 21
    8.             ]
    9.         }
    10.     }
    11. }

    range查询

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

    1. {
    2.     "range":{
    3.         "age":{
    4.             "gte":20,
    5.             "lt":30
    6.         }
    7.     }
    8. }

    范围操作符包含：

    • gt : 大于

    • gte:: 大于等于

    • lt : 小于

    • lte: 小于等于

    示例：

    1. POST /itcast/person/_search
    2. {
    3.     "query":{
    4.         "range":{
    5.             "age":{
    6.                 "gte":20,
    7.                 "lte":22
    8.             }
    9.         }
    10.     }
    11. }

    exists 查询

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

    1. {
    2.     "exists": {
    3.         "field": "title"
    4.     }
    5. }

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

    1. POST /haoke/user/_search
    2. {
    3.     "query": {
    4.         "exists": { #必须包含
    5.             "field": "card"
    6.         }
    7.     }
    8. }

    match查询

    match 查询是一个标准查询，不管你需要全文本查询还是精确查询基本上都要用到它。

    如果你使用 match 查询一个全文本字段，它会在真正查询之前用分析器先分析match 一下查询字符：

    1. {
    2.     "match": {
    3.         "tweet": "About Search"
    4.     }
    5. }

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

    1. { "match": { "age": 26 }}
    2. { "match": { "date": "2014-09-01" }}
    3. { "match": { "public": true }}
    4. { "match": { "tag": "full_text" }}

    bool查询

    • bool 查询可以用来合并多个条件查询结果的布尔逻辑，它包含一下操作符：

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

    • must_not :: 多个查询条件的相反匹配，相当于 not 。

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

    这些参数可以分别继承一个查询条件或者一个查询条件的数组：

    1. {
    2.     "bool":{
    3.         "must":{
    4.             "term":{
    5.                 "folder":"inbox"
    6.             }
    7.         },
    8.         "must_not":{
    9.             "term":{
    10.                 "tag":"spam"
    11.             }
    12.         },
    13.         "should":[
    14.             {
    15.                 "term":{
    16.                     "starred":true
    17.                 }
    18.             },
    19.             {
    20.                 "term":{
    21.                     "unread":true
    22.                 }
    23.             }
    24.         ]
    25.     }
    26. }

    过滤查询

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

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

    1. POST /itcast/person/_search
    2. {
    3.     "query":{
    4.         "bool":{
    5.             "filter":{
    6.                 "term":{
    7.                     "age":20
    8.                 }
    9.             }
    10.         }
    11.     }
    12. }

    查询和过滤的对比

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

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

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

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

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

    建议：

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

    中文分词

    什么是分词

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

    举例：我是中国人 --> 我/是/中国人

    分词api

    指定分词器进行分词

    1. POST /_analyze
    2. {
    3.     "analyzer":"standard",
    4.     "text":"hello world"
    5. }

    结果如下

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

    指定索引分词

    1. POST /itcast/_analyze
    2. {
    3.     "analyzer": "standard",
    4.     "field": "hobby",
    5.     "text": "听音乐"
    6. }

    ....博主太懒了字数太多了，不想写了....文章已经做成PDF，有需要的朋友可以私信我免费获取！

     

  • 相关阅读:
    基于Javaee的影视创作论坛的设计与实现(源码开放)
    【四十八讲】事件-监听器
    面试官：RocketMQ是什么，它有什么特性与使用场景？
    【数据结构】B : DS图应用--最短路径
    【自适应滤波】基于FxLMS的样条自适应滤波算法分析（Matlab代码实现）
    springboot整合mybatisPlus全技巧（2-常用开发技巧：通用字段插入）
    使用 gitbook 制作自己的 html 文档
    学习nginx的一点记录
    Mybatis——动态SQL及缓存
    LLaMA模型指令微调 字节跳动多模态视频大模型 Valley 论文详解
  • 原文地址：https://blog.csdn.net/weixin_70730532/article/details/125599010