日志注意事项

• 日志颗粒度：（级别：DEBUG、INFO、WARNING、ERROR 等）
• 日志格式化：方便阅读分析（时间戳、日志级别、请求 ID、模块名称、错误信息等，统一使用 Log4j、logback 等）
• 异常处理：（捕获异常错误信息、堆栈跟踪等，以便于日后排查）
• 日志存储和管理：输出到文件、数据库、日志服务器等，确保合理的日志轮转和备份策略，有效的日志管理和监控机制。
• 敏感信息保护：在日志输出时，注意敏感信息的处理，如密码、个人身份信息等，应进行脱敏处理或者在合适的级别下去除。
• 日志审计和安全：对于敏感操作或重要日志事件，可以考虑加入审计日志，记录相关的操作细节和安全事件，以便追踪和监控系统的安全性。
• 性能影响：日志输出可能对系统的性能产生一定的影响，要谨慎选择日志输出的频率和内容，避免频繁的输出大量冗余信息。
• 异步日志：尽量采用异步方式进行，避免阻塞主线程，可以利用线程池等机制一部处理日志消息。（Logback 默认情况下是同步输出日志，可以调整配置）

SpringBoot3.X 整合 logback 配置示例

SLF4J(Simple Logging Facade for Java)

• 把不同的日志系统实现了具体的抽象化，提供统一的日志使用接口
• 具体的日志系统实现有：log4j、logback
• logback、log4j 是一个作者，logback 有更好的特性，可以取代 log4，是 slf4j 的原生实现日志系统
• log4j、logback 可以单独的使用，也可以绑定 slf4j 一起使用
• 编码规范不建议直接使用 log4j、logback。sl4j，日后更换框架所带来的成本会很低

src/main/resources/logback.xml

 1<?xml version="1.0" encoding="UTF-8"?>
 2<configuration>
 3    <!-- 日志路径 -->
 4    <property name="LOG_HOME" value="C:\\Users\\chao1\\Desktop\\tmp\\log"/>
 5
 6    <!-- 打印到控制台 -->
 7    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
 8        <encoder>
 9            <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
10        </encoder>
11    </appender>
12
13    <!-- 打印到日志文件 -->
14    <appender name="rollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
15        <file>${LOG_HOME}/soulboy.log</file>
16        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
17            <!-- 按天回滚 daily -->
18            <fileNamePattern>${LOG_HOME}/soulboy.%d{yyyy-MM-dd}.log</fileNamePattern>
19            <!-- 保留30天的日志 -->
20            <maxHistory>30</maxHistory>
21        </rollingPolicy>
22        <encoder>
23            <pattern>%d{yyyy-MM-dd HH🇲🇲ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
24        </encoder>
25    </appender>
26
27    <!-- 指定某个类单独打印日志 -->
28    <logger name="net.xdclass.controller.ProductController" level="INFO" additivity="false">"
29        <appender-ref ref="console"/>
30        <appender-ref ref="rollingFile"/>
31    </logger>
32
33    <!-- 其他所有类打印日志的 -->
34    <root level="INFO" additivity="false">
35        <appender-ref ref="rollingFile"/>
36        <appender-ref ref="console"/>
37    </root>
38</configuration>

Elastic Stack

    核心产品包括 Elasticsearch、Kibana、Beats 和 Logstash（也称为 ELK Stack）等等。能够安全可靠地从任何来源获取任何格式的数据，然后对数据进行搜索、分析和可视化。
ELK = Elasticsearch + Logstash + Kibana， 随着 Beats 的加入，原本的 ELK 体系变为了 Elastic Stack, Elastic Stack = Elasticsearch + Logstash + Kibana + Beats。

Elasticsearch
一个分布式实时艘索和分析引擎，高性能和可伸缩性闻名，能够快速地存储、搜索和分析大量结构化和非结构化数据基于java开发，它是Elastic Stack的核心组件，提供分布式数据存储和搜索能力。

Logstash
是一个用于数据收集、转换和传输的数据处理引擎，支持从各种来源(如文件、日志、数据库等)收集数据。基于java开发，并对数据进行结构化、过滤和转换，然后将数据发送到Elasticsearch等目标存储或分析系统。

Kibana
基于node.js开发，数据可视化和仪表盘工具，连接到Elasticsearch，通过简单易用的用户界面创建各种图表、图形和仪表盘帮助用户快速探索和理解数据，并进行强大的数据分析和可视化。

Beats
是轻量级的数据收集器，用于收集和发送各种类型的数据到Elasticsearch或Logstash，Beats提供了多种插件和模块，用于收集和传输日志、指标数据、网络数据和安全数据等。
如果只是单纯的为了收集日志，使用logstash就有点大材小用了，另外有点浪费资源而beats是轻量级的用来收集日志的，而logstash更加专注一件事，那就是数据转换，格式化，等处理工作

JDK17 安装

Linux服务器安装JDK17+ElasticSearch8.X，Elasticsearch是使用Java开发的，8.1版本的ES需要JDK17及以上版本

 1### 解压
 2[root@localhost /]# mkdir -pv /usr/local/software/elk/jdk17
 3[root@localhost tmp]# tar -zxvf jdk-17_linux-x64_bin.tar.gz
 4[root@localhost tmp]# mv jdk-17.0.7  /usr/local/software/elk/jdk17
 5
 6### 配置环境变量
 7[root@localhost tmp]# vim /etc/profile
 8JAVA_HOME=/usr/local/software/elk/jdk17
 9CLASSPATH=$JAVA_HOME/lib/
10PATH=$PATH:$JAVA_HOME/bin
11export PATH JAVA_HOME CLASSPATH
12
13[root@localhost tmp]# source /etc/profile
14[root@localhost tmp]# java -version
15java version "17.0.7" 2023-04-18 LTS

安装 ElasticSearc8.X

 1### 解压
 2[root@localhost tmp]# tar -zxvf elasticsearch-8.4.1-linux-x86_64.tar.gz
 3[root@localhost tmp]# mv elasticsearch-8.4.1 /usr/local/software/elk/
 4
 5### 新建一个用户，安全考虑，elasticsearch默认不允许以root账号运行
 6创建用户：useradd es_user
 7设置密码：passwd es_user	12345678
 8[root@localhost tmp]# chgrp -R es_user /usr/local/software/elk/elasticsearch-8.4.1
 9[root@localhost tmp]# chown -R es_user /usr/local/software/elk/elasticsearch-8.4.1
10[root@localhost tmp]# chmod -R 777 /usr/local/software/elk/elasticsearch-8.4.1
11
12### 修改文件和进程最大打开数,需要root用户,如果系统本身有这个文件最大打开数和进程最大打开数配置，则不用
13# 在文件内容最后添加后面两行(切记*不能省略)
14[root@localhost tmp]# vim /etc/security/limits.conf
15* soft nofile 65536
16* hard nofile 65536
17
18### 修改虚拟内存空间，默认太小
19# 在配置文件中改配置 最后一行上加上
20[root@localhost tmp]# vim /etc/sysctl.conf
21vm.max_map_count=262144
22#执行 sysctl -p(立即生效)
23[root@localhost tmp]# sysctl -p
24vm.max_map_count = 262144
25
26### 修改elasticsearch的JVM内存，机器内存不足，常规线上推荐16到24G内存
27[root@localhost tmp]# vim /usr/local/software/elk/elasticsearch-8.4.1/config/jvm.options
28-Xms1g
29-Xmx1g
30
31### 修改 elasticsearch相关配置
32[root@localhost tmp]# vim /usr/local/software/elk/elasticsearch-8.4.1/config/elasticsearch.yml
33cluster.name: my-application
34node.name: node-1
35path.data: /usr/local/software/elk/elasticsearch-8.4.1/data
36path.logs: /usr/local/software/elk/elasticsearch-8.4.1/logs
37network.host: 0.0.0.0
38http.port: 9200
39cluster.initial_master_nodes: ["node-1"]
40xpack.security.enabled: false
41xpack.security.enrollment.enabled: false
42ingest.geoip.downloader.enabled: false
43
44配置说明
45cluster.name: 指定Elasticsearch集群的名称。所有具有相同集群名称的节点将组成一个集群。
46node.name: 指定节点的名称。每个节点在集群中应该具有唯一的名称。
47path.data: 指定用于存储Elasticsearch索引数据的路径。
48path.logs: 指定Elasticsearch日志文件的存储路径。
49network.host: 指定节点监听的网络接口地址。0.0.0.0表示监听所有可用的网络接口，开启远程访问连接
50http.port: 指定节点上的HTTP服务监听的端口号。默认情况下，Elasticsearch的HTTP端口是9200。
51cluster.initial_master_nodes: 指定在启动集群时作为初始主节点的节点名称。
52xpack.security.enabled: 指定是否启用Elasticsearch的安全特性。在这里它被禁用（false），意味着不使用安全功能。
53xpack.security.enrollment.enabled: 指定是否启用Elasticsearch的安全认证和密钥管理特性。在这里它被禁用（false）。
54ingest.geoip.downloader.enabled: 指定是否启用GeoIP数据库下载功能。在这里它被禁用（false）
55
56
57### 启动ElasticSearch
58# 切换到es_user用户启动, 进入bin目录下启动， &为后台启动,再次提示es消息时 Ctrl + c 跳出
59[es_user@localhost bin]$ su es_user
60[es_user@localhost bin]$ cd /usr/local/software/elk/elasticsearch-8.4.1/bin
61[es_user@localhost bin]$ ./elasticsearch &
62[es_user@localhost bin]$ su root
63Password:
64[root@localhost bin]# yum install -y lsof
65[root@localhost bin]# lsof -i:9200
66COMMAND  PID    USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
67java    3649 es_user  408u  IPv6  94785      0t0  TCP *:wap-wsp (LISTEN)
68
69### 常见命令，可以用postman访问（网络安全组记得开发端口）
70
71#查看集群健康情况
72http://192.168.10.68:9200/_cluster/health
73
74#查看分片情况
75http://192.168.10.68:9200/_cat/shards?v=true&pretty
76
77#查看节点分布情况
78http://192.168.10.68:9200/_cat/nodes?v=true&pretty
79
80#查看索引列表
81http://192.168.10.68:9200/_cat/indices?v=true&pretty

安装 Kibana8.X

 1### 解压
 2[root@localhost tmp]# tar -zxvf kibana-8.4.1-linux-x86_64.tar.gz
 3[root@localhost tmp]# mv kibana-8.4.1 /usr/local/software/elk/
 4
 5### 授权
 6[root@localhost tmp]# chgrp -R es_user /usr/local/software/elk/kibana-8.4.1
 7[root@localhost tmp]# chown -R es_user /usr/local/software/elk/kibana-8.4.1
 8[root@localhost tmp]# chmod -R 777 /usr/local/software/elk/kibana-8.4.1
 9
10### 修改配置文件
11[root@localhost tmp]# vim /usr/local/software/elk/kibana-8.4.1/config/kibana.yml
12server.port: 5601
13server.host: "0.0.0.0"
14elasticsearch.hosts: ["http://192.168.10.68:9200"]
15i18n.locale: "zh-CN" #汉化
16
17### 启动
18[root@localhost tmp]# su es_user
19[es_user@localhost tmp]$ cd /usr/local/software/elk/kibana-8.4.1/bin/
20[es_user@localhost bin]$ ./kibana &
21
22### 访问
23http://192.168.10.68:5601
24
25#查看集群健康情况
26GET /_cluster/health
27
28#查看分片情况
29GET /_cat/shards?v=true&pretty
30
31#查看节点分布情况
32GET /_cat/nodes?v=true&pretty
33
34#查看索引列表
35GET /_cat/indices?v=true&pretty
36
37# 控制台
38http://192.168.10.68:5601/app/dev_tools#/console

logstash->Elasticsearch->kibana

 1### 解压
 2[root@localhost tmp]# tar -zxvf logstash-8.4.1-linux-x86_64.tar.gz
 3[root@localhost tmp]# mv logstash-8.4.1 /usr/local/software/elk/
 4
 5### 准备nginx日志文件
 6[root@localhost tmp]# mkdir /usr/local/software/elk/log
 7[root@localhost tmp]# touch /usr/local/software/elk/log/access.log
 8[root@localhost tmp]# vim /usr/local/software/elk/log/access.log
 92023/12/15 14:39:29 [error] 29#29: *465 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
1010.42.0.1 - - [15/Dec/2023:14:39:29 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1110.42.0.1 - - [15/Dec/2023:14:39:30 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1210.42.0.1 - - [15/Dec/2023:14:39:32 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1310.42.0.1 - - [15/Dec/2023:14:40:07 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1410.42.0.1 - - [15/Dec/2023:14:41:11 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2118 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
152023/12/15 14:41:18 [error] 29#29: *476 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
1610.42.0.1 - - [15/Dec/2023:14:41:18 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1710.42.0.1 - - [15/Dec/2023:14:41:18 +0000] "GET /favicon.ico HTTP/1.1" 404 284 "http://182.112.39.117:8088/coupon-server/api/coupon/v1/page_coupon" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1810.42.0.1 - - [15/Dec/2023:14:42:39 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2118 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
1910.42.0.1 - - [15/Dec/2023:14:42:41 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
202023/12/15 14:42:41 [error] 29#29: *485 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
2110.42.0.1 - - [15/Dec/2023:14:42:41 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2210.42.0.1 - - [15/Dec/2023:14:42:47 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2310.42.0.1 - - [15/Dec/2023:14:42:48 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2410.42.0.1 - - [15/Dec/2023:14:42:48 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2510.42.0.1 - - [15/Dec/2023:14:42:59 +0000] "GET /favicon.ico HTTP/1.1" 404 284 "http://182.112.39.117:8088/coupon-server/api/coupon/v1/page_coupon" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2610.42.0.1 - - [15/Dec/2023:14:43:01 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
272023/12/15 14:43:01 [error] 29#29: *498 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
2810.42.0.1 - - [15/Dec/2023:14:43:01 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
2910.42.0.1 - - [15/Dec/2023:14:43:02 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2117 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3010.42.0.1 - - [15/Dec/2023:14:43:02 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3110.42.0.1 - - [15/Dec/2023:14:43:02 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3210.42.0.1 - - [15/Dec/2023:14:43:03 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3310.42.0.1 - - [15/Dec/2023:14:43:33 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3410.42.0.1 - - [15/Dec/2023:14:43:35 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2117 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
352023/12/15 14:43:37 [error] 29#29: *513 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
3610.42.0.1 - - [15/Dec/2023:14:43:37 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3710.42.0.1 - - [15/Dec/2023:14:43:38 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 59 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3810.42.0.1 - - [15/Dec/2023:14:43:40 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2125 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
3910.42.0.1 - - [15/Dec/2023:14:44:16 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
4010.42.0.1 - - [15/Dec/2023:14:44:39 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
412023/12/15 14:44:39 [error] 29#29: *524 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
4210.42.0.1 - - [15/Dec/2023:14:44:39 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
4310.42.0.1 - - [15/Dec/2023:14:45:26 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2118 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
4410.42.0.1 - - [15/Dec/2023:14:45:41 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
452023/12/15 14:45:43 [error] 29#29: *531 connect() failed (111: Connection refused) while connecting to upstream, client: 10.42.0.1, server: alipaytest.ddns.net, request: "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1", upstream: "http://192.168.10.28:8888/coupon-server/api/coupon/v1/page_coupon", host: "182.112.39.117:8088"
4610.42.0.1 - - [15/Dec/2023:14:45:43 +0000] "GET /coupon-server/api/coupon/v1/page_coupon HTTP/1.1" 200 2110 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64)
47
48### 修改配置文件
49[root@localhost bin]# vim /usr/local/software/elk/logstash-8.4.1/config/test-logstash.conf
50input {
51        file {
52                path => "/usr/local/software/elk/log/access.log"
53                start_position => "beginning"
54                stat_interval => "3"
55                type => "nginx-access-log"
56        }
57}
58
59output {
60        if [type] == "nginx-access-log" {
61                elasticsearch {
62                        hosts => ["http://192.168.10.68:9200"]
63                        index => "nginx-accesslog-%{+YYYY.MM.dd}"
64                }
65        }
66}
67
68### 启动
69[root@localhost bin]# cd /usr/local/software/elk/logstash-8.4.1/bin/
70[root@localhost bin]# ./logstash -f /usr/local/software/elk/logstash-8.4.1/config/test-logstash.conf &

FileBeat->[logstash]->Elasticsearch->kibana

 1### 解压
 2[root@localhost tmp]# tar -zxvf filebeat-8.4.1-linux-x86_64.tar.gz
 3[root@localhost tmp]# mv filebeat-8.4.1-linux-x86_64 /usr/local/software/elk/
 4[root@localhost tmp]# touch /usr/local/software/elk/filebeat-8.4.1-linux-x86_64/test-filebeat.yml
 5
 6### 修改filebeat的配置文件
 7[root@localhost tmp]# vim /usr/local/software/elk/filebeat-8.4.1-linux-x86_64/test-filebeat.yml
 8filebeat.inputs:
 9- type: log
10  paths: ["/tmp/access.log*"]
11  encoding: UTF-8
12  fields:
13    service: nginx-access-log
14
15output.logstash:
16  hosts: ["192.168.10.68:5044"]
17
18
19### 修改logstash的配置文件
20[root@localhost tmp]# touch /usr/local/software/elk/logstash-8.4.1/config/test-beat-logstash.conf
21[root@localhost tmp]# vim /usr/local/software/elk/logstash-8.4.1/config/test-beat-logstash.conf
22input {
23  beats {
24    port => 5044
25  }
26}
27
28output {
29  if [type] == "nginx-access-log" {
30    elasticsearch {
31      hosts => ["http://192.168.10.68:9200"]
32      index => "nginx-accesslog-%{+YYYY.MM.dd}"
33    }
34  }
35
36  if [fields][service] == "nginx-access-log" {
37    elasticsearch {
38      hosts => ["http://192.168.10.68:9200"]
39      index => "beat-nginx-accesslog-%{+YYYY.MM.dd}"
40    }
41  }
42}
43
44### 启动logstash
45[root@localhost tmp]# cd /usr/local/software/elk/logstash-8.4.1/bin/
46[root@localhost bin]# ./logstash -f /usr/local/software/elk/logstash-8.4.1/config/test-beat-logstash.conf &
47[root@localhost bin]# lsof -i:5044
48COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
49java    2224 root   96u  IPv6  22858      0t0  TCP *:lxi-evntsvc (LISTEN)
50
51### 启动filebeat
52[root@localhost bin]# cd /usr/local/software/elk/filebeat-8.4.1-linux-x86_64/
53[root@localhost filebeat-8.4.1-linux-x86_64]# ./filebeat -e -c test-filebeat.yml &
54
55### 查找进程并且kill掉
56[root@localhost bin]# ps -ef | grep filebeat

多服务日志收集于存储配置

logstash 配置

 1### 
 2
 3[root@localhost tmp]# cat /usr/local/software/elk/logstash-8.4.1/config/test-beat-logstash.conf
 4input {
 5  beats {
 6    port => 5044
 7  }
 8}
 9
10output {
11  if [type] == "nginx-access-log" {
12    elasticsearch {
13      hosts => ["http://192.168.10.68:9200"]
14      index => "nginx-accesslog-%{+YYYY.MM.dd}"
15    }
16  }
17
18  if [fields][service] == "nginx-access-log" {
19    elasticsearch {
20      hosts => ["http://192.168.10.68:9200"]
21      index => "beat-nginx-accesslog-%{+YYYY.MM.dd}"
22    }
23  }
24  if [fields][service] == "solo-access-log" {
25    elasticsearch {
26      hosts => ["http://192.168.10.68:9200"]
27      index => "solo-nginx-accesslog-%{+YYYY.MM.dd}"
28    }
29  }
30  if [fields][service] == "abc1024-access-log" {
31    elasticsearch {
32      hosts => ["http://192.168.10.68:9200"]
33      index => "abc1024-nginx-accesslog-%{+YYYY.MM.dd}"
34    }
35  }
36}

filebeat 配置

 1[root@localhost tmp]# cat /usr/local/software/elk/filebeat-8.4.1-linux-x86_64/test-filebeat.yml
 2filebeat.inputs:
 3- type: log
 4  paths: ["/tmp/access.log"]
 5  encoding: UTF-8
 6  fields:
 7    service: nginx-access-log
 8
 9- type: log
10  paths: ["/tmp/solo_access.log"]
11  encoding: UTF-8
12  fields:
13    service: solo-access-log
14
15- type: log
16  paths: ["/tmp/abc1024.log"]
17  encoding: UTF-8
18  fields:
19    service: abc1024-access-log
20
21output.logstash:
22  hosts: ["192.168.10.68:5044"]

ElasticSearch

是⼀个开源，是⼀个基于 Apache Lucene 库构建的 RESTFul 搜索引擎. Elasticsearch 是在 Solr 之后几年推出的。

它提供了⼀个分布式，多租户能力的全文搜索引擎，具有 HTTP Web 界⾯（REST）和无架构 JSON 文档（‌指的是没有预定义结构的JSON数据。）。Elasticsearch的官方客户端库提供Java，Groovy，PHP，Ruby，Perl，Python，.NET和Javascript。

应用场景

业界产品应用场景

维基百科、Stack Overflow、GitHub

核心概念

在新版 Elasticsearch 中，文档 document 就是一行记录(json)，而这些记录存在于索引库(index)中, 索引名称必须是小写

分片（shards）

• 数据量特大，没有足够大的硬盘空间来一次性存储，且一次性搜索那么多的数据，响应跟不上
• ES 提供把数据进行分片存储，这样方便进行拓展和提高吞吐

副本（replicas）

分片的拷贝，当主分片不可用的时候，副本就充当主分片进行使用；索引分片的备份，shard 和 replica 一般存储在不同的节点上，用来提高高可靠性

元数据

Elasticsearch 中以 “ _” 开头的属性都成为元数据，都有自己特定的意思

ES 默认为一个索引创建 1 个主分片和 1 个副本，在创建索引的时候使用 settings 属性指定，每个 分片 必须有 零到多个副本

索引一旦创建成功，主分片 primary shard 数量不可以变(只能重建索引)，副本数量可以改变

正排索引和倒排索引

正排索引 (Forward Index )

正排索引用于快速访问和提取文档的内容

将文档的内容按照文档的顺序进行索引，每个文档对应一个索引条目，包含了文档的各个字段的内容

在数据库系统中，将正排索引类比为表格的结构，每一行是一个记录，每一列是一个字段

正排索引的优劣

例子
假设我们有三个文档的标题和内容

• 文档 1：标题 "Apple iPhone 12"，内容 "The latest iPhone model"
• 文档 2：标题 "Samsung Galaxy S21"，内容 "Powerful Android smartphone"
• 文档 3：标题 "Microsoft Surface Laptop"，内容 "Thin and lightweight laptop"

正排索引的结构示意图如下：

倒排索引（Inverted Index）

倒排索引用于快速定位和检索包含特定词语的文档

根据关键词构建的索引结构，记录了每个关键词出现在哪些文档或数据记录中，适用于全文搜索和关键词检索的场景
;它将文档或数据记录划分成关键词的集合，并记录每个关键词所出现的位置和相关联的文档或数据记录的信息

倒排索引的优劣

例子

• 例子假设 使用以下文档构建倒排索引
  • 文档 1：标题 "Apple iPhone 12"，内容 "The latest iPhone model"
  • 文档 2：标题 "Samsung Galaxy S21"，内容 "Powerful Android smartphone"
  • 文档 3：标题 "Microsoft Surface Laptop"，内容 "Thin and lightweight laptop Apple"

倒排索引的结构示意图如下：

索引 Index 核心操作

#查看索引列表

 1# 查看索引列表
 2GET /_cat/indices?v=true&pretty
 3
 4# 查看分片情况（主分片和副本分片需要在不同的服务器上，否则副本分片显示UNASSIGNED ）
 5GET /_cat/shards?v=true&pretty
 6
 7# 创建索引
 8PUT /soulboy_shop
 9{
10  "settings": {
11    "number_of_shards": 2,
12    "number_of_replicas": 1
13  }
14}
15
16# 查看索引是否存在( 结果是200 和 404)
17HEAD /soulboy_shop
18
19# 获取索引（Get Index）
20GET /soulboy_shop
21
22# 更新索引设置（Update Index Settings）
23PUT /soulboy_shop/_settings
24{
25  "settings": {
26    "number_of_replicas": 2
27  }
28}
29
30# 删除索引（Delete Index）
31DELETE /soulboy_shop
32
33# 查看集群健康情况
34GET /_cluster/health
35
36# 查看节点分布情况
37GET /_cat/nodes?v=true&pretty

Document 核心操作

真正的数据，存储一条数据就是一份文档，存储格式为 JOSN，等同于 MySQL 中的一条数据

 1# 查询文档
 2GET /soulboy_shop/_doc/1
 3
 4# 新增文档（需要指定ID）
 5PUT /soulboy_shop/_doc/1
 6{
 7  "id":5555,
 8  "title":"葵花宝典",
 9  "pv":144
10}
11
12# 新增文档（不指定ID或者指定ID都可以）,如果不指定id会自动生成id QPaOdZEBfJIIaWpZZ95i
13POST /soulboy_shop/_doc
14{
15  "id":6666,
16  "title":"九阳神功",
17  "pv":244
18}
19GET /soulboy_shop/_doc/QPaOdZEBfJIIaWpZZ95i
20
21# 修改（put和post都行，需要指定id）
22POST /soulboy_shop/_doc/QPaOdZEBfJIIaWpZZ95i
23{
24  "id":6666,
25  "title":"九阳神功",
26  "pv":399,
27  "uv":88
28}
29GET /soulboy_shop/_doc/QPaOdZEBfJIIaWpZZ95i
30
31# 搜索
32GET /soulboy_shop/_search
33took        字段表示该操作的耗时（单位为毫秒）
34timed_out   字段表示是否超时
35hits        字段表示搜到的记录，数组形式
36total       返回记录数
37max_score   最高的匹配程度
38sd
39# 删除数据
40DELETE /soulboy_shop/_doc/PvaLdZEBfJIIaWpZvd49

Mapping

类似于数据库中的表结构定义 schema，定义索引中的字段的名称，字段的数据类型，比如字符串、数字、布尔等

Dynamic Mapping（动态映射）

• 用于在索引文档时自动检测和定义字段的数 sdasdada 据类型
• 当我们向索引中添加新文档时，Elasticsearch 会自动检测文档中的各个字段，并根据它们的值来尝试推断字段类型
• 动态映射具备自动解析和创建字段的便利性，但在某些情况下，由于字段类型的不确定性，动态映射可能会带来一些问题，例如字段解析错误、字段类型不一致等，如果对字段类型有明确的要求，最好在索引创建前通过显式映射定义来指定字段类型
• 常见的字段类型包括 文本（text）、关键词（keyword）、日期（date）、数值（numeric）等

常见的数据类型

• 如果需要进行全文本检索，并且希望根据分词结果计算相关性得分，以获得最佳的匹配结果，则选择 text 字段类型。
• 如果需要进行精确匹配、排序或聚合操作，并且不需要对内容进行分词，则选择 keyword 字段类型。

  1# 指定索引库字段类型mapping
  2PUT /my_index
  3{
  4  "mappings": {
  5    "properties": {
  6      "id": {
  7        "type": "keyword"
  8      },
  9      "title": {
 10        "type": "text"
 11      },
 12      "price": {
 13        "type": "float"
 14      }
 15    }
 16  }
 17}
 18GET /my_index/_mapping
 19DELETE /my_index
 20
 21
 22### 创建索引并插入文档
 23# 创建索引(指定字段和数据类型)
 24PUT /my_index
 25{
 26  "mappings": {
 27    "properties": {
 28      "title": {
 29        "type": "text"
 30      },
 31      "tags": {
 32        "type": "keyword"
 33      },
 34      "publish_date": {
 35        "type": "date"
 36      },
 37      "rating": {
 38        "type": "float"
 39      },
 40      "is_published": {
 41        "type": "boolean"
 42      },
 43      "author": {
 44        "properties": {
 45          "name": {
 46            "type": "text"
 47          },
 48          "age": {
 49            "type": "integer"
 50          }
 51        }
 52      },
 53      "comments": {
 54        "type": "nested",
 55        "properties": {
 56          "user": {
 57            "type": "keyword"
 58          },
 59          "message": {
 60            "type": "text"
 61          }
 62        }
 63      }
 64    }
 65  }
 66}
 67# 并插入文档
 68POST /my_index/_doc/1
 69{
 70  "title": "ElasticSearch学习资料",
 71  "tags": ["search", "big data", "distributed system", "soulboy"],
 72  "publish_date": "2025-01-01",
 73  "rating": 4.5,
 74  "is_published": true,
 75  "author": {
 76    "name": "John Doe",
 77    "age": 30
 78  },
 79  "comments": [
 80    {
 81      "user": "Alice",
 82      "message": "Great article!"
 83    },
 84    {
 85      "user": "Bob",
 86      "message": "Very informative."
 87    }
 88  ]
 89}
 90GET /my_index/_mapping
 91GET /my_index/_doc/1
 92
 93# 查询匹配关键词的文档
 94GET /my_index/_search
 95{
 96  "query": {
 97    "match": {
 98      "title": "ElasticSearch"
 99    }
100  }
101}
102
103# 查询匹配关键词的文档(keyword数据类型必须精准匹配)
104GET /my_index/_search
105{
106  "query": {
107    "match": {
108      "tags": "big data"
109    }
110  }
111}

ES 默认分词器

在 Elasticsearch 中，分词（tokenization）是将文本内容拆分成独立的单词或词项（tokens）的过程

分词是搜索引擎在建立索引和执行查询时的关键步骤，将文本拆分成单词，并构建倒排索引，可以实现更好的搜索和检索效果。

 1假设我们有两个产品标题：
 2
 3"Apple iPhone 12 Pro Max 256GB"
 4
 5"Samsung Galaxy S21 Ultra 128GB"
 6
 7使用默认的标准分词器（Standard Tokenizer），这些标题会被分割为以下令牌：
 8
 9标题1：["Apple", "iPhone", "12", "Pro", "Max", "256GB"]
10
11标题2：["Samsung", "Galaxy", "S21", "Ultra", "128GB"]
12
13分词器根据标点符号和空格将标题拆分为独立的词语(令牌)。当我们执行搜索时，可以将查询进行分词，并将其与标题中的令牌进行匹配。
14
15例如
16  如果我们搜索"iPhone 12"，使用默认的分词器，它会将查询分解为["iPhone", "12"]，然后与令牌进行匹配。 
17  对于标题1，令牌["iPhone", "12"]匹配，它与查询相符。 标题2中没有与查询相符的令牌

分词规则

分词规则是指定义如何将文本进行拆分的规则和算法。

Elasticsearch 使用一系列的分词器（analyzer）和 标记器（tokenizer）来处理文本内容

分词器
分词器通常由一个或多个标记器组成，用于定义分词的具体规则，默认的 Standard 分词器

常见的分词器，如 Standard分词器、Simple分词器、Whitespace分词器、IK分词等，还支持自定义分词器

 1### 标点符号切分
 2标点符号会被删除，并将连字符分隔为两个独立的词。
 3例如，"Let's go!" 会被切分为 "Let", "s", "go"。
 4
 5### 小写转换
 6所有的文本会被转换为小写形式。
 7例如，"Hello World" 会被切分为 "hello", "world"。
 8
 9### 停用词过滤
10停用词（stop words）是在搜索中没有实际意义的常见词，停用词会被过滤掉，不会作为独立的词进行索引和搜索。
11例如， "a", "an", "the" 等。
12
13### 词干提取
14通过应用Porter2词干提取算法，将单词还原为其原始形式。
15例如，running -> run、swimming -> swim、jumped -> jump
16
17### 词分隔
18按照空格将文本切分成词项（tokens）

使用指定 ES 分词器查看分词后的存储效果

 1# 使用指定ES分词器查看分词后的存储效果（中文分词效果不好）
 2GET /_analyze
 3{
 4  "analyzer": "standard",
 5  "text": "我是一头小象，我喜欢吃饭和睡觉，我喜欢伺候哥哥。"
 6}
 7
 8# 字段是text类型（中文分词效果不好）
 9POST /my_index/_analyze
10{
11  "field": "title",
12  "text": "今天我在油管学习数字孪"
13}
14
15# 字段是keyword类型
16POST /my_index/_analyze
17{
18  "field": "tags",
19  "text": ["This is","Spring Boot" ]
20}

IK 中文分词器配置

在 Elasticsearch 8.X 中，分词（tokenization）是将文本内容拆分成独立的单词或词项（tokens）的过程。默认的Standard分词器对中文支持不是很友好

  1# 使用指定ES分词器查看分词后的存储效果
  2GET /_analyze
  3{
  4  "analyzer": "standard",
  5  "text": "我是一头小象，我喜欢吃饭和睡觉，我喜欢伺候哥哥。"
  6}
  7
  8# 输出结果
  9{
 10  "tokens": [
 11    {
 12      "token": "我",
 13      "start_offset": 0,
 14      "end_offset": 1,
 15      "type": "<IDEOGRAPHIC>",
 16      "position": 0
 17    },
 18    {
 19      "token": "是",
 20      "start_offset": 1,
 21      "end_offset": 2,
 22      "type": "<IDEOGRAPHIC>",
 23      "position": 1
 24    },
 25    {
 26      "token": "一",
 27      "start_offset": 2,
 28      "end_offset": 3,
 29      "type": "<IDEOGRAPHIC>",
 30      "position": 2
 31    },
 32    {
 33      "token": "头",
 34      "start_offset": 3,
 35      "end_offset": 4,
 36      "type": "<IDEOGRAPHIC>",
 37      "position": 3
 38    },
 39    {
 40      "token": "小",
 41      "start_offset": 4,
 42      "end_offset": 5,
 43      "type": "<IDEOGRAPHIC>",
 44      "position": 4
 45    },
 46    {
 47      "token": "象",
 48      "start_offset": 5,
 49      "end_offset": 6,
 50      "type": "<IDEOGRAPHIC>",
 51      "position": 5
 52    },
 53    {
 54      "token": "我",
 55      "start_offset": 7,
 56      "end_offset": 8,
 57      "type": "<IDEOGRAPHIC>",
 58      "position": 6
 59    },
 60    {
 61      "token": "喜",
 62      "start_offset": 8,
 63      "end_offset": 9,
 64      "type": "<IDEOGRAPHIC>",
 65      "position": 7
 66    },
 67    {
 68      "token": "欢",
 69      "start_offset": 9,
 70      "end_offset": 10,
 71      "type": "<IDEOGRAPHIC>",
 72      "position": 8
 73    },
 74    {
 75      "token": "吃",
 76      "start_offset": 10,
 77      "end_offset": 11,
 78      "type": "<IDEOGRAPHIC>",
 79      "position": 9
 80    },
 81    {
 82      "token": "饭",
 83      "start_offset": 11,
 84      "end_offset": 12,
 85      "type": "<IDEOGRAPHIC>",
 86      "position": 10
 87    },
 88    {
 89      "token": "和",
 90      "start_offset": 12,
 91      "end_offset": 13,
 92      "type": "<IDEOGRAPHIC>",
 93      "position": 11
 94    },
 95    {
 96      "token": "睡",
 97      "start_offset": 13,
 98      "end_offset": 14,
 99      "type": "<IDEOGRAPHIC>",
100      "position": 12
101    },
102    {
103      "token": "觉",
104      "start_offset": 14,
105      "end_offset": 15,
106      "type": "<IDEOGRAPHIC>",
107      "position": 13
108    },
109    {
110      "token": "我",
111      "start_offset": 16,
112      "end_offset": 17,
113      "type": "<IDEOGRAPHIC>",
114      "position": 14
115    },
116    {
117      "token": "喜",
118      "start_offset": 17,
119      "end_offset": 18,
120      "type": "<IDEOGRAPHIC>",
121      "position": 15
122    },
123    {
124      "token": "欢",
125      "start_offset": 18,
126      "end_offset": 19,
127      "type": "<IDEOGRAPHIC>",
128      "position": 16
129    },
130    {
131      "token": "伺",
132      "start_offset": 19,
133      "end_offset": 20,
134      "type": "<IDEOGRAPHIC>",
135      "position": 17
136    },
137    {
138      "token": "候",
139      "start_offset": 20,
140      "end_offset": 21,
141      "type": "<IDEOGRAPHIC>",
142      "position": 18
143    },
144    {
145      "token": "哥",
146      "start_offset": 21,
147      "end_offset": 22,
148      "type": "<IDEOGRAPHIC>",
149      "position": 19
150    },
151    {
152      "token": "哥",
153      "start_offset": 22,
154      "end_offset": 23,
155      "type": "<IDEOGRAPHIC>",
156      "position": 20
157    }
158  ]
159}

IK 分词器

是一个基于 Java 开发的开源中文分词器，用于将中文文本拆分成单个词语（词项）是针对中文语言的特点和需求而设计的，可以有效处理中文分词的复杂性和多样性 IK 分词器多个版本

安装 IK 分词器

 1### 解压，上传到Elastic Search的plugins目录
 2[root@localhost plugins]# pwd
 3/usr/local/software/elk/elasticsearch-8.4.1/plugins
 4[root@localhost plugins]# ls
 5elasticsearch-analysis-ik-8.4.1
 6
 7### 重启Elastic Search即可
 8# 找出elasticsearch的进程id (1453)
 9ps -ef | grep elasticsearch
10
11# 杀死进程elasticsearch的进程id (1453)
12kill -9 1453
13
14# 启动Elastic Search
15[es_user@localhost bin]$ su es_user
16[es_user@localhost bin]$ cd /usr/local/software/elk/elasticsearch-8.4.1/bin
17[es_user@localhost bin]$ ./elasticsearch &
18
19# 关闭Elasticsearch节点
20bin/elasticsearch -d

验证 IK 分词器是否生效

• ik_smart：会做最粗粒度的拆分
• ik_max_word（常用）： 会将文本做最细粒度的拆分

  1# 使用指定IK分词器查看分词后的存储效果
  2GET /_analyze
  3{
  4  "analyzer": "ik_smart",
  5  "text": "我是一头小象，我喜欢吃饭和睡觉，我喜欢伺候哥哥。"
  6}
  7
  8# 使用指定IK分词器查看分词后的存储效果
  9GET /_analyze
 10{
 11  "analyzer": "ik_max_word",
 12  "text": "我是一头小象，我喜欢吃饭和睡觉，我喜欢伺候哥哥。"
 13}
 14
 15# ik_smart 输出结果
 16{
 17  "tokens": [
 18    {
 19      "token": "我",
 20      "start_offset": 0,
 21      "end_offset": 1,
 22      "type": "CN_CHAR",
 23      "position": 0
 24    },
 25    {
 26      "token": "是",
 27      "start_offset": 1,
 28      "end_offset": 2,
 29      "type": "CN_CHAR",
 30      "position": 1
 31    },
 32    {
 33      "token": "一头",
 34      "start_offset": 2,
 35      "end_offset": 4,
 36      "type": "CN_WORD",
 37      "position": 2
 38    },
 39    {
 40      "token": "小象",
 41      "start_offset": 4,
 42      "end_offset": 6,
 43      "type": "CN_WORD",
 44      "position": 3
 45    },
 46    {
 47      "token": "我",
 48      "start_offset": 7,
 49      "end_offset": 8,
 50      "type": "CN_CHAR",
 51      "position": 4
 52    },
 53    {
 54      "token": "喜欢",
 55      "start_offset": 8,
 56      "end_offset": 10,
 57      "type": "CN_WORD",
 58      "position": 5
 59    },
 60    {
 61      "token": "吃饭",
 62      "start_offset": 10,
 63      "end_offset": 12,
 64      "type": "CN_WORD",
 65      "position": 6
 66    },
 67    {
 68      "token": "和",
 69      "start_offset": 12,
 70      "end_offset": 13,
 71      "type": "CN_CHAR",
 72      "position": 7
 73    },
 74    {
 75      "token": "睡觉",
 76      "start_offset": 13,
 77      "end_offset": 15,
 78      "type": "CN_WORD",
 79      "position": 8
 80    },
 81    {
 82      "token": "我",
 83      "start_offset": 16,
 84      "end_offset": 17,
 85      "type": "CN_CHAR",
 86      "position": 9
 87    },
 88    {
 89      "token": "喜欢",
 90      "start_offset": 17,
 91      "end_offset": 19,
 92      "type": "CN_WORD",
 93      "position": 10
 94    },
 95    {
 96      "token": "伺候",
 97      "start_offset": 19,
 98      "end_offset": 21,
 99      "type": "CN_WORD",
100      "position": 11
101    },
102    {
103      "token": "哥哥",
104      "start_offset": 21,
105      "end_offset": 23,
106      "type": "CN_WORD",
107      "position": 12
108    }
109  ]
110}
111
112# ik_max_word 输出结果
113{
114  "tokens": [
115    {
116      "token": "我",
117      "start_offset": 0,
118      "end_offset": 1,
119      "type": "CN_CHAR",
120      "position": 0
121    },
122    {
123      "token": "是",
124      "start_offset": 1,
125      "end_offset": 2,
126      "type": "CN_CHAR",
127      "position": 1
128    },
129    {
130      "token": "一头",
131      "start_offset": 2,
132      "end_offset": 4,
133      "type": "CN_WORD",
134      "position": 2
135    },
136    {
137      "token": "一",
138      "start_offset": 2,
139      "end_offset": 3,
140      "type": "TYPE_CNUM",
141      "position": 3
142    },
143    {
144      "token": "头",
145      "start_offset": 3,
146      "end_offset": 4,
147      "type": "COUNT",
148      "position": 4
149    },
150    {
151      "token": "小象",
152      "start_offset": 4,
153      "end_offset": 6,
154      "type": "CN_WORD",
155      "position": 5
156    },
157    {
158      "token": "我",
159      "start_offset": 7,
160      "end_offset": 8,
161      "type": "CN_CHAR",
162      "position": 6
163    },
164    {
165      "token": "喜欢吃",
166      "start_offset": 8,
167      "end_offset": 11,
168      "type": "CN_WORD",
169      "position": 7
170    },
171    {
172      "token": "喜欢",
173      "start_offset": 8,
174      "end_offset": 10,
175      "type": "CN_WORD",
176      "position": 8
177    },
178    {
179      "token": "吃饭",
180      "start_offset": 10,
181      "end_offset": 12,
182      "type": "CN_WORD",
183      "position": 9
184    },
185    {
186      "token": "和",
187      "start_offset": 12,
188      "end_offset": 13,
189      "type": "CN_CHAR",
190      "position": 10
191    },
192    {
193      "token": "睡觉",
194      "start_offset": 13,
195      "end_offset": 15,
196      "type": "CN_WORD",
197      "position": 11
198    },
199    {
200      "token": "我",
201      "start_offset": 16,
202      "end_offset": 17,
203      "type": "CN_CHAR",
204      "position": 12
205    },
206    {
207      "token": "喜欢",
208      "start_offset": 17,
209      "end_offset": 19,
210      "type": "CN_WORD",
211      "position": 13
212    },
213    {
214      "token": "伺候",
215      "start_offset": 19,
216      "end_offset": 21,
217      "type": "CN_WORD",
218      "position": 14
219    },
220    {
221      "token": "哥哥",
222      "start_offset": 21,
223      "end_offset": 23,
224      "type": "CN_WORD",
225      "position": 15
226    }
227  ]
228}

Query DSL

  Query DSL（Domain-Specific Language）是一种用于构建搜索查询的强大的领域特定查询语言。类似关系数据库的SQL查询语法，ES 中用 JSON 结构化的方式定义、执行各种查询操作，在ES中进行高级搜索和过滤

• Query DSL 提供了更多种类的查询和过滤语句，以满足不同的搜索需求。
• 可以根据具体的业务需求和数据结构，结合不同的查询方式来构建复杂的搜索和过滤操作

准备数据

 1# 创建索引
 2PUT /soulboy_shop_v1
 3{
 4  "settings": {
 5    "number_of_shards": 2,
 6    "number_of_replicas": 0
 7  },
 8  "mappings": {
 9    "properties": {
10      "id": {
11        "type": "keyword"
12      },
13      "title": {
14        "type": "keyword"
15      },
16      "summary": {
17        "type": "text"
18      },
19      "price": {
20        "type": "float"
21      }
22    }
23  }
24}
25
26# 导入数据
27PUT /soulboy_shop_v1/_bulk
28{ "index": { "_index": "soulboy_shop_v1" } }
29{ "id": "1", "title": "Spring Boot","summary":"this is a summary Spring Boot video", "price": 9.99 }
30{ "index": { "_index": "soulboy_shop_v1" } }
31{ "id": "2", "title": "java","summary":"this is a summary java video", "price": 19.99 }
32{ "index": { "_index": "soulboy_shop_v1" } }
33{ "id": "3", "title": "Spring Cloud","summary":"this is a summary Spring Cloud video", "price": 29.99 }
34{ "index": { "_index": "soulboy_shop_v1" } }
35{ "id": "4", "title": "Spring_Boot", "summary":"this is a summary Spring_Boot video","price": 59.99 }
36{ "index": { "_index": "soulboy_shop_v1" } }
37{ "id": "5", "title": "SpringBoot","summary":"this is a summary SpringBoot video", "price": 0.99 }
38
39GET /soulboy_shop_v1/_search

基本查询

基本语法

1GET /索引库名/_search 
2{ 
3  "query":{ 
4    "查询类型":{
5    
6    }
7}

match

  用于执行全文搜索，它会将搜索查询与指定字段中的文本进行匹配

1# 模糊查询title包含elasticsearch的document
2GET /my_index/_search
3{
4  "query": {
5    "match": {
6      "title": "elasticsearch"
7    }
8  }
9}

term
  用于精确匹配一个指定字段的关键词，不进行分词处理。

1# 精确匹配tags中含有"big data"的标签
2GET /my_index/_search
3{
4  "query": {
5    "term": {
6      "tags": "big data"
7    }
8  }
9}

查询建议

• match 在匹配时会对所查找的关键词进行分词，然后分词匹配查找；term 会直接对关键词进行查找
• 一般业务里面需要模糊查找的时候，更多选择 match，而精确查找时选择 term 查询

查询全部数据（match_all）

1GET /soulboy_shop_v1/_search
2{
3  "query": {
4    "match_all": {}
5  }
6}

有条件查询数据

• match，对查询内容进行分词, 然后进行查询,多个词条之间是 or 的关系
• 然后在与文档里面的分词进行匹配，匹配度越高分数越高越前面

 1# 有条件查询数据
 2GET /soulboy_shop_v1/_search
 3{
 4  "query": {
 5    "match": {
 6      "summary": "Spring"
 7    }
 8  }
 9}
10
11# 包括多个词  Spring  or Java
12GET /soulboy_shop_v1/_search
13{
14  "query": {
15    "match": {
16      "summary": "Spring Java"
17    }
18  }
19}

完整关键词查询

• term 查询，不会将查询条件分词，直接与文档里面的分词进行匹配
• 虽然 match 也可以完成，但是 match 查询会多一步进行分词，浪费资源

获取指定字段

• 某些情况场景下，不需要返回全部字段，太废资源，可以指定 source 返回对应的字段

 1# 获取指定字段
 2GET /soulboy_shop_v1/_search
 3{
 4"_source":["price","title"],
 5  "query": {
 6    "term": {
 7      "title": {
 8        "value": "Spring Boot"
 9      }
10    }
11  }
12}
13
14# 返回数据
15{
16  "took": 0,
17  "timed_out": false,
18  "_shards": {
19    "total": 2,
20    "successful": 2,
21    "skipped": 0,
22    "failed": 0
23  },
24  "hits": {
25    "total": {
26      "value": 1,
27      "relation": "eq"
28    },
29    "max_score": 1.2039728,
30    "hits": [
31      {
32        "_index": "soulboy_shop_v1",
33        "_id": "EVoeeJEBm34NyhWJFaXn",
34        "_score": 1.2039728,
35        "_source": {
36          "price": 9.99,
37          "title": "Spring Boot"
38        }
39      }
40    ]
41  }
42}

范围查询

 1# 获取指定字段 5~100(包含头尾)
 2GET /soulboy_shop_v1/_search
 3{
 4  "query": {
 5    "range": {
 6      "price": {
 7        "gte": 5,
 8        "lte": 100
 9      }
10    }
11  }
12}

分页、排序查询

分页查询

• 可以使用 from 和 size 参数进行分页查询
• 可以指定要跳过的文档数量（from）和需要返回的文档数量（size）

1# 分页查询
2GET /soulboy_shop_v1/_search
3{
4  "size": 3,
5  "from": 0,
6  "query": {
7    "match_all": {}
8  }
9}

查询结果排序

• sort 字段可以进行排序 desc 和 asc

 1# 排序
 2GET /soulboy_shop_v1/_search
 3{
 4  "size": 10,
 5  "from": 0,
 6  "sort": [
 7    {
 8      "price": "asc"
 9    }
10  ],
11  "query": {
12    "match_all": {}
13  }
14}

布尔查询

• 通过组合多个查询条件，使用布尔逻辑（与、或、非）进行复杂的查询操作
• 语法格式
  • "must"关键字用于指定必须匹配的条件，即所有条件都必须满足
  • "must_not"关键字指定必须不匹配的条件，即所有条件都不能满足
  • "should"关键字指定可选的匹配条件，即至少满足一个条件
  • "filter"关键字用于指定一个过滤条件，可以是一个具体的过滤器，如 term、range 等，也可以是一个嵌套的 bool 过滤器

 1# 语法
 2{
 3  "query": {
 4    "bool": {
 5      "must": [
 6        // 必须匹配的条件
 7      ],
 8      "must_not": [
 9        // 必须不匹配的条件
10      ],
11      "should": [
12        // 可选匹配的条件
13      ],
14      "filter": [
15        // 过滤条件
16      ]
17    }
18  }
19}
20
21# 布尔查询（条件匹配+范围查询 同时满足）
22GET /soulboy_shop_v1/_search
23{
24  "query": {
25    "bool": {
26      "must": [
27        { "match": { "summary": "Cloud" }},
28        { "range": { "price": { "gte": 5 }}}
29      ]
30    }
31  }
32}

Filter（查询过滤）

• 来对搜索结果进行筛选和过滤，仅返回符合特定条件的文档，而不改变搜索评分
• Filter 查询对结果进行缓存，提高查询性能，用于数字范围、日期范围、布尔逻辑、存在性检查等各种过滤操作。
• 过滤条件通常用于对结果进行筛选，并且比查询条件更高效
• 而 bool 查询可以根据具体需求 组合多个条件、过滤器和查询子句

语法格式

• "filter"关键字用于指定一个过滤条件，可以是一个具体的过滤器，如term、range等，也可以是一个嵌套的bool过滤器

1{
2  "query": {
3    "bool": {
4      "filter": {
5        // 过滤条件
6      }
7    }
8  }
9}

准备数据

 1# 创建索引库
 2PUT /product
 3{
 4  "settings": {
 5    "number_of_shards": 2,
 6    "number_of_replicas": 0
 7  },
 8  "mappings": {
 9   "properties": {
10    "product_id": {
11      "type": "integer"
12    },
13    "product_name": {
14      "type": "text"
15    },
16    "category": {
17      "type": "keyword"
18    },
19    "price": {
20      "type": "float"
21    },
22    "availability": {
23      "type": "boolean"
24    }
25  } }  
26}
27
28# 导入数据
29* 通过一次 POST 请求实现批量插入
30* 每个文档都由两部分组成：index，指令用于指定文档的元数据，product_id 为文档的唯一标识符
31* 插入后查询 GET /product/_search
32POST /product/_bulk
33{ "index": { "_id": "1" } }
34{ "product_id": 1, "product_name": "Product 1", "category": "books", "price": 19.99, "availability": true }
35{ "index": { "_id": "2" } }
36{ "product_id": 2, "product_name": "Product 2", "category": "electronics", "price": 29.99, "availability": true }
37{ "index": { "_id": "3" } }
38{ "product_id": 3, "product_name": "Product 3", "category": "books", "price": 9.99, "availability": false }
39{ "index": { "_id": "4" } }
40{ "product_id": 4, "product_name": "Product 4", "category": "electronics", "price": 49.99, "availability": true }
41{ "index": { "_id": "5" } }
42{ "product_id": 5, "product_name": "Product 5", "category": "fashion", "price": 39.99, "availability": true }
43
44GET /product/_search

示例一 ：使用 term 过滤器查询 category 为 books 的产品：

 1GET /product/_search
 2{
 3  "query": {
 4    "bool": {
 5      "filter": {
 6        "term": {
 7          "category": "books"
 8        }
 9      }
10    }
11  }
12}

示例二：使用 range 过滤器查询价格 price 在 30 到 50 之间的产品

 1GET /product/_search
 2{
 3  "query": {
 4    "bool": {
 5      "filter": {
 6        "range": {
 7          "price": {
 8            "gte": 30,
 9            "lte": 50
10          }
11        }
12      }
13    }
14  }
15}

多字段匹配、短语搜索

match 高级用法，业务查询，需要在多个字段上进行文本搜索，用 multi_match

数据环境准备

 1# 创建索引库
 2PUT /product_v2
 3{
 4  "settings": {
 5    "number_of_shards": 2,
 6    "number_of_replicas": 0
 7  },
 8  "mappings": {
 9    "properties": {
10      "product_name": {
11        "type": "text"
12      },
13      "description": {
14        "type": "text"
15      },
16      "category": {
17        "type": "keyword"
18      }
19    }
20  }
21}
22
23# 批量插入数据
24POST /product_v2/_bulk
25{ "index": { "_index": "product_v2", "_id": "1" } }
26{ "product_name": "iPhone 12", "description": "The latest iPhone model from Apple", "category": "electronics" }
27{ "index": { "_index": "product_v2", "_id": "2" } }
28{ "product_name": "Samsung Galaxy S21", "description": "High-performance Android smartphone", "category": "electronics" }
29{ "index": { "_index": "product_v2", "_id": "3" } }
30{ "product_name": "MacBook Pro", "description": "Powerful laptop for professionals", "category": "electronics" }
31{ "index": { "_index": "product_v2", "_id": "4" } }
32{ "product_name": "Harry Potter and the Philosopher's Stone", "description": "Fantasy novel by J.K. Rowling", "category": "books" }
33{ "index": { "_index": "product_v2", "_id": "5" } }
34{ "product_name": "The Great Gatsby", "description": "Classic novel by F. Scott Fitzgerald", "category": "books" }

语法格式

 1# query：需要匹配的查询文本
 2# fields：一个包含需要进行匹配的字段列表的数组
 3
 4GET /index/_search
 5{
 6  "query": {
 7    "multi_match": {
 8      "query": "要搜索的文本",
 9      "fields": ["字段1", "字段2", ...]
10    }
11  }
12}

示例：多字段搜索

• 在 product_name 和 description 字段上执行了一个 multi_match 查询
• 将查询文本设置为 "iPhone"，对这两个字段进行搜索，并返回包含匹配到的文档，这个是 OR 的关系，会有最佳匹配

 1# 多字段搜索
 2GET /product_v2/_search
 3{
 4  "query": {
 5    "multi_match": {
 6      "query": "iPhone",
 7      "fields": ["product_name", "description"]
 8    }
 9  }
10}

示例：短语搜索案

• 使用 match_phrase 查询在 description 字段上执行了一个短语搜索将要搜索的短语设置为 "classic novel"。
• 使用 match_phrase 查询，Elasticsearch 将会返回包含 "classic novel" 短语的文档

 1# match_phrase短语搜索(命中1条document)
 2GET /product_v2/_search
 3{
 4  "query": {
 5    "match_phrase": {
 6      "description": "classic novel"
 7    }
 8  }
 9}
10
11# match搜索，会进行分词(命中2条document)
12GET /product_v2/_search
13{
14  "query": {
15    "match": {
16      "description": "classic novel"
17    }
18  }
19}

fuzzy 模糊查询（日常单词拼写错误）

• fuzzy 查询是 Elasticsearch 中提供的一种模糊匹配查询类型，用在搜索时容忍一些拼写错误或近似匹配
• 使用 fuzzy 查询，可以根据指定的**编辑距离（即词之间不同字符的数量）**来模糊匹配查询词

  1更改字符（box→fox)
  2删除字符（black→lack）
  3插入字符（sic→sick）
  4转置两个相邻字符（dgo→dog）
  

• fuzzy 模糊查询是拼写错误的简单解决方案，但具有很高的 CPU 开销和非常低的精准度
• 用法和 match 基本一致，Fuzzy query 的查询不分词

基本语法格式

 1GET /index/_search
 2{
 3  "query": {
 4    "fuzzy": {
 5      "field_name": {
 6        "value": "要搜索的词",
 7        "fuzziness": "模糊度"
 8      }
 9    }
10  }
11}

示例：模糊查询

 1# 指定模糊度2，更松散匹配 (this is a summary Spring Cloud video)(命中1条)
 2GET /soulboy_shop_v1/_search
 3{
 4  "query": {
 5    "fuzzy": {
 6      "summary": {
 7        "value": "clo",
 8        "fuzziness": "2"
 9      }
10    }
11  }
12}
13
14# 指定模糊度1，更严格匹配(查询不出来)
15GET /soulboy_shop_v1/_search
16{
17  "query": {
18    "fuzzy": {
19      "summary": {
20        "value": "clo",
21        "fuzziness": "1"
22      }
23    }
24  }
25}
26
27# 使用自动检查，1个单词拼写错误(this is a summary Spring Cloud video) (命中2条)
28GET /soulboy_shop_v1/_search
29{
30  "query": {
31    "fuzzy": {
32      "summary": {
33        "value": "Sprina",
34        "fuzziness": "auto"
35      }
36    }
37  }
38}

搜索高亮显示

日常搜索产品的时候，会有 关键词 显示不一样的颜色，方便用户直观看到区别

数据准备

 1#创建索引库
 2PUT /soulboy_high_light_test
 3{
 4  "mappings": {
 5    "properties": {
 6      "title": {
 7          "type": "text",
 8          "analyzer": "ik_max_word"
 9        },
10        "content": {
11          "type": "text",
12          "analyzer": "ik_max_word"
13        }
14     }
15  }, 
16  "settings": {
17    "number_of_shards": 2,
18    "number_of_replicas": 0
19  }
20}
21
22
23#插入数据
24PUT /soulboy_high_light_test/_doc/1
25{
26  "title": "豆瓣电影2028年最新好看的电影推荐",
27  "content": "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《老王往事》精彩电影"
28}
29
30PUT /soulboy_high_light_test/_doc/2
31{
32  "title": "写下你认为好看的电影有哪些",
33  "content": "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和老王的故事》"
34}

Elastic Search 搜索引擎如何做到高亮显示

• 在 ES 中，高亮语法用于在搜索结果中 突出显示与查询匹配的关键词
• 高亮显示是通过标签包裹匹配的文本来实现的，通常是 <em> 或其他 HTML 标签
• 基本用法：在 highlight 里面填写要高亮显示的字段，可以填写多个

单条件查询高亮显示
  highlight里面填写需要高亮的字段

 1# 单条件查询高亮显示
 2GET /soulboy_high_light_test/_search 
 3{
 4  "query": {
 5    "match": {
 6      "content": "电影"
 7    }
 8  },
 9  "highlight": {
10    "fields": {
11      "content": {}
12    }
13  }
14}
15
16# 查询结果
17{
18  "took": 193,
19  "timed_out": false,
20  "_shards": {
21    "total": 2,
22    "successful": 2,
23    "skipped": 0,
24    "failed": 0
25  },
26  "hits": {
27    "total": {
28      "value": 2,
29      "relation": "eq"
30    },
31    "max_score": 0.17888658,
32    "hits": [
33      {
34        "_index": "soulboy_high_light_test",
35        "_id": "1",
36        "_score": 0.17888658,
37        "_source": {
38          "title": "豆瓣电影2028年最新好看的电影推荐",
39          "content": "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《老王往事》精彩电影"
40        },
41        "highlight": {
42          "content": [
43            "每年都有新<em>电影</em>上线，2028年最新好看的<em>电影</em>有不少，豆瓣<em>电影</em>上线了《釜山行》，《行尸走肉》，《老王往事》精彩<em>电影</em>"
44          ]
45        }
46      },
47      {
48        "_index": "soulboy_high_light_test",
49        "_id": "2",
50        "_score": 0.144106,
51        "_source": {
52          "title": "写下你认为好看的电影有哪些",
53          "content": "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和老王的故事》"
54        },
55        "highlight": {
56          "content": [
57            "每个人都看看很多<em>电影</em>，说下你近10年看过比较好的<em>电影</em>，比如《釜山行》，《行尸走肉》，《宙斯和老王的故事》"
58          ]
59        }
60      }
61    ]
62  }
63}

组合多条件查询
  highlight里面填写需要高亮的字段

 1# 组合多条件查询
 2GET /soulboy_high_light_test/_search
 3{
 4  "query": {
 5    "bool": {
 6      "should": [
 7        {
 8          "match": {
 9            "title": "电影"
10          }
11        },
12        {
13          "match": {
14            "content": "老王"
15          }
16        }
17      ]
18    }
19  },
20  "highlight": {
21    "fields": {
22      "title": {},
23      "content": {}
24    }
25  }
26}
27
28
29# 查询结果
30{
31  "took": 1,
32  "timed_out": false,
33  "_shards": {
34    "total": 2,
35    "successful": 2,
36    "skipped": 0,
37    "failed": 0
38  },
39  "hits": {
40    "total": {
41      "value": 2,
42      "relation": "eq"
43    },
44    "max_score": 0.43035197,
45    "hits": [
46      {
47        "_index": "soulboy_high_light_test",
48        "_id": "1",
49        "_score": 0.43035197,
50        "_source": {
51          "title": "豆瓣电影2028年最新好看的电影推荐",
52          "content": "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《老王往事》精彩电影"
53        },
54        "highlight": {
55          "title": [
56            "豆瓣<em>电影</em>2028年最新好看的<em>电影</em>推荐"
57          ],
58          "content": [
59            "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《<em>老王</em>往事》精彩电影"
60          ]
61        }
62      },
63      {
64        "_index": "soulboy_high_light_test",
65        "_id": "2",
66        "_score": 0.36774224,
67        "_source": {
68          "title": "写下你认为好看的电影有哪些",
69          "content": "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和老王的故事》"
70        },
71        "highlight": {
72          "title": [
73            "写下你认为好看的<em>电影</em>有哪些"
74          ],
75          "content": [
76            "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和<em>老王</em>的故事》"
77          ]
78        }
79      }
80    ]
81  }
82}

修改高亮样式
  使用highlight属性，可以增加属性，修改高亮样式

 1# 修改字体颜色为黄色
 2GET /soulboy_high_light_test/_search
 3{
 4  "query": {
 5    "bool": {
 6      "should": [
 7        {
 8          "match": {
 9            "title": "电影"
10          }
11        },
12        {
13          "match": {
14            "content": "老王"
15          }
16        }
17      ]
18    }
19  },
20  "highlight": {
21    "pre_tags": "<font color='yellow'>",
22    "post_tags": "</font>",
23    "fields": [{"title":{}},{"content":{}}]
24  } 
25}
26
27# 查询结果
28{
29  "took": 2,
30  "timed_out": false,
31  "_shards": {
32    "total": 2,
33    "successful": 2,
34    "skipped": 0,
35    "failed": 0
36  },
37  "hits": {
38    "total": {
39      "value": 2,
40      "relation": "eq"
41    },
42    "max_score": 0.43035197,
43    "hits": [
44      {
45        "_index": "soulboy_high_light_test",
46        "_id": "1",
47        "_score": 0.43035197,
48        "_source": {
49          "title": "豆瓣电影2028年最新好看的电影推荐",
50          "content": "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《老王往事》精彩电影"
51        },
52        "highlight": {
53          "title": [
54            "豆瓣<font color='yellow'>电影</font>2028年最新好看的<font color='yellow'>电影</font>推荐"
55          ],
56          "content": [
57            "每年都有新电影上线，2028年最新好看的电影有不少，豆瓣电影上线了《釜山行》，《行尸走肉》，《<font color='yellow'>老王</font>往事》精彩电影"
58          ]
59        }
60      },
61      {
62        "_index": "soulboy_high_light_test",
63        "_id": "2",
64        "_score": 0.36774224,
65        "_source": {
66          "title": "写下你认为好看的电影有哪些",
67          "content": "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和老王的故事》"
68        },
69        "highlight": {
70          "title": [
71            "写下你认为好看的<font color='yellow'>电影</font>有哪些"
72          ],
73          "content": [
74            "每个人都看看很多电影，说下你近10年看过比较好的电影，比如《釜山行》，《行尸走肉》，《宙斯和<font color='yellow'>老王</font>的故事》"
75          ]
76        }
77      }
78    ]
79  }
80}

聚合查询

  对大量数据聚合统计处理，类似 MySQL 数据库操作里面的 group by 分组、sum、avg、max 等函数处理。

  是 Elasticsearch 中强大的功能之一，根据数据进行分组、过滤、计算和统计，提取有关数据集信息，进行数据分析

数据可视化大屏里面的饼状图、柱状图、折线图、仪表盘数据等都是聚合查询的关键应用

常见聚合用途和应用场景案例

指标聚合 metric

  对数据集求最大、最小、和、平均值等指标的聚合

基本语法格式如下

 1GET /index/_search
 2{
 3  "size": 0,
 4  "aggs": {
 5    "aggregation_name": {
 6      "aggregation_type": {
 7        "aggregation_field": "field_name"
 8        // 可选参数
 9      }
10    }
11    // 可以添加更多的聚合
12  }
13}

桶聚合 bucketing

  对数据集进行分组 group by，然后在组上进行指标聚合，在 ES 中称为分桶，桶聚合 bucketing

基本语法格式如下

 1GET /index/_search
 2{
 3  "size": 0,
 4  "aggs": {
 5    "aggregation_name": {
 6      "bucket_type": {
 7        "bucket_options": {
 8          "bucket_option_name": "bucket_option_value",
 9          ...
10        },
11        "aggs": {
12          "sub_aggregation_name": {
13            "sub_aggregation_type": {
14              "sub_aggregation_options": {
15                "sub_aggregation_option_name": "sub_aggregation_option_value",
16                ...
17              }
18            }
19          }
20        }
21      }
22    }
23  }
24}

示例

数据环境准备

 1# 创建索引
 2PUT /sales
 3{
 4  "mappings": {
 5    "properties": {
 6      "product": {
 7        "type": "keyword"
 8      },
 9      "sales": {
10        "type": "integer"
11      }
12    }
13  }
14}
15
16# 批量插入数据
17POST /sales/_bulk
18{"index": {}}
19{"product": "iPhone", "sales": 4}
20{"index": {}}
21{"product": "Samsung", "sales": 60}
22{"index": {}}
23{"product": "iPhone", "sales": 100}
24{"index": {}}
25{"product": "Samsung", "sales": 80}
26{"index": {}}
27{"product": "soulboy手机", "sales": 50}
28{"index": {}}
29{"product": "soulboy手机", "sales": 5000}
30{"index": {}}
31{"product": "soulboy手机", "sales": 200}

聚合查询：分别按照商品名称 product 进行分组

  1# 分别按照商品名称（`product`）进行分组
  2GET /sales/_search
  3{
  4  "aggs":{//聚合操作
  5    "product_group":{//名称，随意起名
  6      "terms":{//分组
  7        "field":"product"//分组字段
  8      }
  9    }
 10  }
 11}
 12
 13# 查询结果
 14{
 15  "took": 3,
 16  "timed_out": false,
 17  "_shards": {
 18    "total": 1,
 19    "successful": 1,
 20    "skipped": 0,
 21    "failed": 0
 22  },
 23  "hits": {
 24    "total": {
 25      "value": 7,
 26      "relation": "eq"
 27    },
 28    "max_score": 1,
 29    "hits": [
 30      {
 31        "_index": "sales",
 32        "_id": "F1ryeZEBm34NyhWJFqUf",
 33        "_score": 1,
 34        "_source": {
 35          "product": "iPhone",
 36          "sales": 4
 37        }
 38      },
 39      {
 40        "_index": "sales",
 41        "_id": "GFryeZEBm34NyhWJFqUf",
 42        "_score": 1,
 43        "_source": {
 44          "product": "Samsung",
 45          "sales": 60
 46        }
 47      },
 48      {
 49        "_index": "sales",
 50        "_id": "GVryeZEBm34NyhWJFqUf",
 51        "_score": 1,
 52        "_source": {
 53          "product": "iPhone",
 54          "sales": 100
 55        }
 56      },
 57      {
 58        "_index": "sales",
 59        "_id": "GlryeZEBm34NyhWJFqUf",
 60        "_score": 1,
 61        "_source": {
 62          "product": "Samsung",
 63          "sales": 80
 64        }
 65      },
 66      {
 67        "_index": "sales",
 68        "_id": "G1ryeZEBm34NyhWJFqUf",
 69        "_score": 1,
 70        "_source": {
 71          "product": "soulboy手机",
 72          "sales": 50
 73        }
 74      },
 75      {
 76        "_index": "sales",
 77        "_id": "HFryeZEBm34NyhWJFqUf",
 78        "_score": 1,
 79        "_source": {
 80          "product": "soulboy手机",
 81          "sales": 5000
 82        }
 83      },
 84      {
 85        "_index": "sales",
 86        "_id": "HVryeZEBm34NyhWJFqUf",
 87        "_score": 1,
 88        "_source": {
 89          "product": "soulboy手机",
 90          "sales": 200
 91        }
 92      }
 93    ]
 94  },
 95  "aggregations": {
 96    "product_group": {
 97      "doc_count_error_upper_bound": 0,
 98      "sum_other_doc_count": 0,
 99      "buckets": [
100        {
101          "key": "soulboy手机",
102          "doc_count": 3
103        },
104        {
105          "key": "Samsung",
106          "doc_count": 2
107        },
108        {
109          "key": "iPhone",
110          "doc_count": 2
111        }
112      ]
113    }
114  }
115}

聚合查询：查询结果将返回每个产品的名称和销售总量
  计算每组的销售总量，使用了 terms 聚合和 sum 聚合来实现

 1# 计算每组的销售总量，使用了 `terms`聚合和`sum` 聚合来实现
 2GET /sales/_search
 3{
 4  "size": 0,
 5  "aggs": {
 6    "product_sales": {
 7      "terms": {
 8        "field": "product"
 9      },
10      "aggs": {
11        "total_sales": {
12          "sum": {
13            "field": "sales"
14          }
15        }
16      }
17    }
18  }
19}
20
21# 查询结果
22{
23  "took": 0,
24  "timed_out": false,
25  "_shards": {
26    "total": 1,
27    "successful": 1,
28    "skipped": 0,
29    "failed": 0
30  },
31  "hits": {
32    "total": {
33      "value": 7,
34      "relation": "eq"
35    },
36    "max_score": null,
37    "hits": []
38  },
39  "aggregations": {
40    "product_sales": {
41      "doc_count_error_upper_bound": 0,
42      "sum_other_doc_count": 0,
43      "buckets": [
44        {
45          "key": "soulboy手机",
46          "doc_count": 3,
47          "total_sales": {
48            "value": 5250
49          }
50        },
51        {
52          "key": "Samsung",
53          "doc_count": 2,
54          "total_sales": {
55            "value": 140
56          }
57        },
58        {
59          "key": "iPhone",
60          "doc_count": 2,
61          "total_sales": {
62            "value": 104
63          }
64        }
65      ]
66    }
67  }
68}

示例：指标聚合 metric

• 对数据集求最大、最小、和、平均值等指标的聚合，称为 指标聚合 metric
• 比如 max、min、avg、sum 等函数使用

示例：聚合查询 max

• 假设有一个电商网站的销售记录索引，包含商品名称和销售价格字段
• 使用 max 聚合查询来获取产品价格的最高值。

 1# 数据准备
 2POST /sales_v1/_doc
 3{ "product_name": "手机", "price": 1000 }
 4
 5POST /sales_v1/_doc
 6{ "product_name": "电视", "price": 1500 }
 7
 8POST /sales_v1/_doc
 9{ "product_name": "小滴课堂老王的黑丝", "price": 4500 }
10
11# 使用 max 聚合查询来获取产品价格的最高值。
12GET /sales_v1/_search
13{
14  "size": 0,
15  "aggs": {
16    "max_price": {
17      "max": {
18        "field": "price"
19      }
20    }
21  }
22}
23
24# 输出结果
25{
26  "took": 0,
27  "timed_out": false,
28  "_shards": {
29    "total": 1,
30    "successful": 1,
31    "skipped": 0,
32    "failed": 0
33  },
34  "hits": {
35    "total": {
36      "value": 6,
37      "relation": "eq"
38    },
39    "max_score": null,
40    "hits": []
41  },
42  "aggregations": {
43    "max_price": {
44      "value": 4500
45    }
46  }
47}

示例：聚合查询 min

• 一个学生考试成绩索引，包含学生姓名和考试分数字段。
• 使用 min 聚合查询来获取学生的最低考试分数。

 1# 数据准备
 2POST /exam_scores/_doc
 3{ "student_name": "小滴课堂-大钊", "score" : 80 }
 4POST /exam_scores/_doc
 5{ "student_name": "老王", "score" : 90 }
 6POST /exam_scores/_doc
 7{ "student_name": "小滴课堂-D哥", "score" : 40 }
 8
 9
10# 使用 min 聚合查询来获取学生的最低考试分数。
11GET /exam_scores/_search
12{
13  "size": 0,
14  "aggs": {
15    "min_score": {
16      "min": {
17        "field": "score"
18      }
19    }
20  }
21}
22
23# 输出结果
24{
25  "took": 0,
26  "timed_out": false,
27  "_shards": {
28    "total": 1,
29    "successful": 1,
30    "skipped": 0,
31    "failed": 0
32  },
33  "hits": {
34    "total": {
35      "value": 3,
36      "relation": "eq"
37    },
38    "max_score": null,
39    "hits": []
40  },
41  "aggregations": {
42    "min_score": {
43      "value": 40
44    }
45  }
46}