当前位置:   article > 正文

ELK基础_elk使用postgresql

elk使用postgresql

ELK基础

ELK是用于**数据抽取(Logstash)、搜索分析(Elasticsearch)、数据展现(Kibana)**的一整套解决方案,所以也称作ELK stack。

Elastic Stack简介

包含三大基础组件,分别是Elasticsearch、Logstash、Kibana。但实际上ELK不仅仅适用于日志分析,它还可以支持其它任何数据搜索、分析和收集的场景,日志分析和收集只是更具有代表性

组件介绍

Elasticsearch

Elasticsearch 是使用java开发,基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。它的特点有:分布式,零配置,自动发现,索引自动分片,索引副本机制,restful风格接口,多数据源,自动搜索负载等。

Logstash

Logstash 基于java开发,是一个数据抽取转化工具。一般工作方式为c/s架构,client端安装在需要收集信息的主机上,server端负责将收到的各节点日志进行过滤、修改等操作在一并发往elasticsearch或其他组件上去。

Kibana

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

Beats

Beats 平台集合了多种单一用途数据采集器。它们从成百上千或成千上万台机器和系统向 Logstash 或 Elasticsearch 发送数据。

Beats由如下组成:

Packetbeat:轻量型网络数据采集器,用于深挖网线上传输的数据,了解应用程序动态。Packetbeat 是一款轻量型网络数据包分析器,能够将数据发送至 Logstash 或 Elasticsearch。其支 持ICMP (v4 and v6)、DNS、HTTP、Mysql、PostgreSQL、Redis、MongoDB、Memcache等协议。

Filebeat:轻量型日志采集器。当您要面对成百上千、甚至成千上万的服务器、虚拟机和容器生成的日志时,请告别 SSH 吧。Filebeat 将为您提供一种轻量型方法,用于转发和汇总日志与文件,让简单的事情不再繁杂。

Metricbeat :轻量型指标采集器。Metricbeat 能够以一种轻量型的方式,输送各种系统和服务统计数据,从 CPU 到内存,从 Redis 到 Nginx,不一而足。可定期获取外部系统的监控指标信息,其可以监控、收集 Apache http、HAProxy、MongoDB、MySQL、Nginx、PostgreSQL、Redis、System、Zookeeper等服务。

Winlogbeat:轻量型 Windows 事件日志采集器。用于密切监控基于 Windows 的基础设施上发生的事件。Winlogbeat 能够以一种轻量型的方式,将 Windows 事件日志实时地流式传输至 Elasticsearch 和 Logstash。

Auditbeat:轻量型审计日志采集器。收集您 Linux 审计框架的数据,监控文件完整性。Auditbeat 实时采集这些事件,然后发送到 Elastic Stack 其他部分做进一步分析。

Heartbeat:面向运行状态监测的轻量型采集器。通过主动探测来监测服务的可用性。通过给定 URL 列表,Heartbeat 仅仅询问:网站运行正常吗?Heartbeat 会将此信息和响应时间发送至 Elastic 的其他部分,以进行进一步分析。

Functionbeat:面向云端数据的无服务器采集器。在作为一项功能部署在云服务提供商的功能即服务 (FaaS) 平台上后,Functionbeat 即能收集、传送并监测来自您的云服务的相关数据。

Elastic cloud

基于 Elasticsearch 的软件即服务(SaaS)解决方案。通过 Elastic 的官方合作伙伴使用托管的 Elasticsearch 服务。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PfwsB98P-1681790775731)(null)]****

#一、搜索是什么

概念:用户输入想要的关键词,返回含有该关键词的所有信息。

场景:

1互联网搜索:谷歌、百度、各种新闻首页

2 站内搜索(垂直搜索):企业OA查询订单、人员、部门,电商网站内部搜索商品(淘宝、京东)场景。

#二、数据库做搜索弊端

#1、站内搜索(垂直搜索):数据量小,简单搜索,可以使用数据库。

问题出现:

l 存储问题。电商网站商品上亿条时,涉及到单表数据过大必须拆分表,数据库磁盘占用过大必须分库(mycat)。

l 性能问题:解决上面问题后,查询“笔记本电脑”等关键词时,上亿条数据的商品名字段逐行扫描,性能跟不上。

l 不能分词。如搜索“笔记本电脑”,只能搜索完全和关键词一样的数据,那么数据量小时,搜索“笔记电脑”,“电脑”数据要不要给用户。

#2、互联网搜索,肯定不会使用数据库搜索。数据量太大。PB级。

三、全文检索、倒排索引和Lucene

#1、全文检索
倒排索引表:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UoQftQSp-1681790773230)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223210601630.png)]

如上:select * from product_term like ‘’%哪吒%‘’:

查含有哪吒的字的数据时会产生下面一个分词表(倒排索引表):

查哪吒会将有哪吒字段记入表中的分词term,含有哪吒的对应数据的id计入表中的id。如上上面四个都有,那么九江他们的content,id计入分词表对应的term和id:

分词term:哪吒,ids:1

此时查到还有其他的数据也拥有哪吒字段:哪吒海报,哪吒公仔,哪吒玩偶,对应的id2,3,4,全部计入分词表中:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMxRiBXs-1681790773231)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223212213100.png)]

记入的id1,2,3,4对应的除了哪吒外,还有电影,海报,公仔,玩偶,于是将它们记入term:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bd5ngMJt-1681790773231)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223210656825.png)]

最后形成的表为倒排索引表,里面的term,id是倒排索引,进行全文检索:

select * from product_term where term = ‘哪吒’

查询等于哪吒的数据时,从分词表中知道对应的id1,2,3,4都符合,查出来返回给母表。母表根据id拿到所有与哪吒相关的数据。

这样解决了数据磁盘占用过大(将一个数据特别大的表,通过倒排索引拆分成一个精简的表,通过匹配度高的词进行全文检索),性能损耗过大,效率低的问题以及不能分词:用户搜索如搜索“笔记电脑”,“电脑”的数据也会给用户。

2 . Lucene:

就是一个jar包,里面封装了全文检索的引擎、搜索的算法代码。开发时,引入lucene的jar包,通过api开发搜索相关业务。底层会在磁盘建立索引库。

第一章 Elasticsearch(Es)是什么

简介

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pG7rB9WO-1681790776508)(null)]

官网:https://www.elastic.co/cn/products/elasticsearch

1 . 为什么使用Es?没有Es存在的问题:

数据如何分布?

已知我们单个服务器(lucene实列)只能存1t数据,java客户端连接后拿到服务器lucene的jar包后执行相关业务。如果我们此时有2t数据,那么就需要两台服务器来存储,那么数据如何分布到两台服务器呢?平分取模?可如果后续一直增加数据,那么还是这么操作吗?况且lucene也不支持这种操作,这种操作只能让java客户端来操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o21X9QP4-1681790773231)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223213751440.png)]

数据如何交互?

就算成功平分数据,那么用户搜索数据在第一个服务器没找到,那么去第二个服务器找到数据了,怎么反馈呢?

数据如何备份?

数据量大时,数据如何备份?再起一个服务器(lucene实列)来进行数据保存,怎么进行数据的实时保存?

上述的三种问题,Es都可解决:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oTGq3TbT-1681790773232)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223215249599.png)]

Es数据分布进行分片机制来解决。将所有的数据进行分片到很多个实列(shard)当中。

Es使用平行节点解决数据交互问题:客户端访问数据时,都可以平行交互到其他实列服务器的数据(访问一个服务器相当于同时访问了所有的服务器实列)。

Es使用副本机制来进行数据的保存,备份。

Es还拥有高级搜索功能(比如:分组,聚合)。

2 . Elasticsearch的功能

  • 分布式的搜索引擎和数据分析引擎

搜索:互联网搜索、电商网站站内搜索、OA系统查询

数据分析:电商网站查询近一周哪些品类的图书销售前十;新闻网站,最近3天阅读量最高的十个关键词,舆情分析。

  • 全文检索,结构化检索,数据分析

全文检索:搜索商品名称包含java的图书select * from books where book_name like “%java%”。

结构化检索:搜索商品分类为spring的图书都有哪些,select * from books where category_id=‘spring’

数据分析:分析每一个分类下有多少种图书,select category_id,count(*) from books group by category_id

  • 对海量数据进行近实时的处理

分布式:ES自动可以将海量数据分散到多台服务器上去存储和检索,经行并行查询,提高搜索效率。相对的,Lucene是单机应用。

近实时:数据库上亿条数据查询,搜索一次耗时几个小时,是批处理(batch-processing)。而es只需秒级即可查询海量数据,所以叫近实时。秒级

3 . Es核心概念:

(1)NRT(Near Realtime):近实时

两方面:

  • 写入数据时,过1秒才会被搜索到,因为内部在分词、录入索引。
  • es搜索时:搜索和分析数据需要秒级出结果。
#(2)Cluster:集群

包含一个或多个启动着es实例的机器群。通常一台机器起一个es实例。同一网络下,集群名一样的多个es实例自动组成集群,自动均衡分片等行为。默认集群名为“elasticsearch”。

#(3)Node:节点

每个es实例称为一个节点。节点名自动分配,也可以手动配置。一个节点有多个主分片和副本

#(4)Index:索引

包含一堆有相似结构的文档数据。

索引创建规则:

  • 仅限小写字母
  • 不能包含\、/、 *、?、"、<、>、|、#以及空格符等特殊符号
  • 从7.0版本开始不再包含冒号
  • 不能以-、_或+开头
  • 不能超过255个字节(注意它是字节,因此多字节字符将计入255个限制)
#(5)Document:文档

es中的最小数据单元。一个document就像数据库中的一条记录。通常以json格式显示。多个document存储于一个索引(Index)中。

book document

{
  "book_id": "1",
  "book_name": "java编程思想",
  "book_desc": "从Java的基础语法到最高级特性(深入的[面向对象](https://baike.baidu.com/item/面向对象)概念、多线程、自动项目构建、单元测试和调试等),本书都能逐步指导你轻松掌握。",
  "category_id": "2",
  "category_name": "java"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
#(6)Field:字段

就像数据库中的列(Columns),定义每个document应该有的字段。

#(7)Type:类型

每个索引里都可以有一个或多个type,type是index中的一个逻辑数据分类,一个type下的document,都有相同的field。

注意:6.0之前的版本有type(类型)概念,type相当于关系数据库的表,ES官方将在ES9.0版本中彻底删除type。本教程typy都为_doc。

#(8)shard:分片

index数据过大时,将index里面的数据,分为多个shard,分布式的存储在各个服务器上面。可以支持海量数据和高并发,提升性能和吞吐量,充分利用多台机器的cpu。

#(9)replica:副本

在分布式环境下,任何一台机器都会随时宕机,如果宕机,index的一个分片没有,导致此index不能搜索。所以,为了保证数据的安全,我们会将每个index的分片经行备份,存储在另外的机器上。保证少数机器宕机es集群仍可以搜索。

能正常提供查询和插入的分片我们叫做主分片(primary shard),其余的我们就管他们叫做备份的分片(replica shard)。

es6默认新建索引时,5分片,2副本,也就是一主一备,共10个分片。所以,es集群最小规模为两台

4 .Es的优点:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OGnBxiVy-1681790773232)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221223224309040.png)]

假设我们有个叫book的索引,该索引有3t的数据量。每个主分片对应有一个副本R0,1,2。

(1)我们的es集群每个实列服务器只能存1t数据。所有会分片成p0,p1,p2三个shard来存储数据。这样减轻了单个node(节点:es实列)的压力.

(2)因为每个机器的的吞吐量为1000/s,那么有三个机器,当有客户端要往里面存数据时,同时往3个里存,那么总速度就达到了3000/s,充分利用机器的性能。

(3)当数据量越来越大,那么其中的索引就会越来越多,就会分片更多的服务器实列分担压力。新增的分片会将得到其他的机器存的数据和索引信息。这样分担存储数据减轻压力,而分担索引信息更是提高了集群扩展。

(4)大数据高并发的情况下,提供副本机制提供容错(副本和主分片的数据是完全一致的)。

(5)高可用:当其中一个node宕机后,它的副本会立刻接替该node,并和其他的node建立新的索引联系。

(6)能正常提供查询和插入的分片我们叫做主分片(primary shard),其余的我们就管他们叫做备份的分片(副本)。只进行查询数据不进行增删改的情况下,那么也可以去副本查拿到结果,那么三台机器三个副本,也就意味着查询的效率达到6000/s,更加提高了吞吐量。

5 . elasticsearch核心概念 vs. 数据库核心概念

关系型数据库(比如Mysql)非关系型数据库(Elasticsearch)
数据库Database索引Index
表Table索引Index(原为Type)
数据行Row文档Document
数据列Column字段Field
约束 Schema映射Mapping

6 . es相关配置:

安装es前,安装设置jdk1.8以上版本,随后在config下的elstaticsearch.yml进行配置:(es中默认端口为9200)

node.name: node-1  
cluster.initial_master_nodes: ["node-1"]  
xpack.ml.enabled: false 
http.cors.enabled: true
http.cors.allow-origin: /.*/
  • 1
  • 2
  • 3
  • 4
  • 5

在jvm.options内设置:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q5dBpH89-1681790773232)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224130627627.png)]

随后bin下双击elstaticsearch.bat运行,运行成功后,es中默认端口为9200,浏览器输入localhost:9200

http://localhost:9200/?pretty 查看状态:

显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VbexjtAi-1681790773232)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224130752327.png)]

http://localhost:9200/_cluster/health 查询集群状态:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJazEiXu-1681790773233)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224133737195.png)]

Status:集群状态。Green 所有分片可用。Yellow所有主分片可用。Red主分片不可用,集群不可用。

7 . Kibana相关配置:

在Kibana.yml配置 修改为支持中文:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VYpTn8af-1681790773233)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224135356368.png)]

随后在bin下启动Kibana.bat(Kibana的默认端口为5601)

浏览器访问http://localhost:5601 进入Dev Tools界面:

5、发送get请求,查看集群状态GET _cluster/health。相当于浏览器访问。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KpLEGx7J-1681790776931)(null)]

总览

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cyrQOL2n-1681790777109)(null)]

Dev Tools界面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PHe30wRK-1681790777203)(null)]

监控集群界面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c4wo3wC8-1681790777378)(null)]

集群状态(搜索速率、索引速率等

8 .Elstaticsearch-head插件安装:

安装后,在该文件目录下打开黑窗口,运行npm run start 显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R0xBijh4-1681790773234)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224174344211.png)]

在浏览器输入请求:http://localhost:9100显示出Elstaticsearch-head插件页面:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kk8LB1gU-1681790773234)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224175100296.png)]

已知我们启动了Es,Es-head插件它自动连接到Es默认iphttp://localhost:9200,我们点击连接http://localhost:9200后显示出了Es的内容:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CaELpz5j-1681790773234)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224175113861.png)]

第二章 Es 快速入门

1 . 文档的数据格式:

(1)应用系统的数据结构都是面向对象的,具有复杂的数据结构

(2)对象存储到数据库,需要将关联的复杂对象属性插到另一张表,查询时再拼接起来。

(3)es面向文档,文档中存储的数据结构,与对象一致。所以一个对象可以直接存成一个文档。

(4)es的document用json数据格式来表达。

例如我们在java中一个使用类来对一个目标封装,比如班级类对应学生,姓名,年龄等属性,es通过json字符串形式来进行存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qsKXTGwo-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224180207849.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CEfBq6uV-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224180219819.png)]

2 . 简单的集群管理:

(1)快速检查集群的健康状况

打开kibana,开发工具:查看es健康状况

输入:GET /_cat/health?v (加个?v表示把每个数据对应属于哪个表的那哪个列的信息也显示打印出来)

随后在右侧显示出对应状况的数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qck8QG2W-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224181804246.png)]

如果只是::GET /_cat/health

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UN0nxjRS-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224182604537.png)]

如何快速了解集群的健康状况?green、yellow、red?

green:每个索引的primary shard(主分片)和replica shard(副本)都是active状态的

yellow:每个索引的primary shard(主分片)都是active状态的,但是部分replica shard(副本)不是active状态,处于不可用的状态

red:不是所有索引的primary shard都是active状态的,部分索引有数据丢失

(2)快速查看集群中的索引:

GET /_cat/indices?v

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S0dM9BsX-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224182530888.png)]

(3)简单的索引操作:

注意:创建索引时,不同数据放到不同索引中:

如下图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-899WJfsc-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224194239857.png)]

如果把user和order索引都全放到下面三个分片中,把数据混杂起来,业务人员要对订单order索引进行分析,有的分片内既存有order的索引,还存有user的索引,那么势必会对搜索分析过程造成干扰。

如果在某些时候突然order数据暴增,order的读写非常繁忙,而user和order的放在一块的话,势必会影响导致user的读写操作变慢,同时user本身速度也会因为user的读写变慢。

创建索引:

PUT /demo_index?pretty (pretty表示用json格式)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vT6GqCqg-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224182846151.png)]

acknowledged为true:表示主分片接收到了创建索引的请求

shards_acknowledged为true:表示副本接收到了创建索引的请求

最后成功创建索引,名字叫demo_index的索引

删除索引:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FzsnLBND-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224183127020.png)]

acknowledged为true:表示主分片接收到了删除索引的请求,成功删除了叫demo_index的索引

3 . 商品的CRUD操作

先创建一个图书的索引:

PUT /book

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJ57kr4W-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224183534907.png)]

(1)插入数据:语法:PUT /index/type/id

往book索引里插入一条数据:该数据id为1,文本类型

PUT /book/_doc/1

PUT /book/_doc/1
{
"name": "Bootstrap开发",
"description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
"studymodel": "201002",
"price":38.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "bootstrap", "dev"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

运行显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RSYRYWAN-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224183852906.png)]

同理插入id为2,3的图书信息:

PUT /book/_doc/2
{
"name": "java编程思想",
"description": "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
"studymodel": "201001",
"price":68.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "java", "dev"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
PUT /book/_doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行,java程序员都在用。",
"studymodel": "201001",
"price":88.6,
"timestamp":"2019-08-24 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "spring", "java"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
(2)查询数据:语法:GET /index/type/id

查询图书,检索文档:

查询book中id为1,类型为文本_doc的信息

GET /book_doc/1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-coRqRiRH-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224184245115.png)]

我们可以打开kibana的discovery,快速索引,将book输入,它就会自动检索到我们创建book索引,拿到book索引的所有数据显示出来:方便我们查看整个book的数据,如果只想查看到id,价格,书名等信息,点击左边的对应可用字段即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FChl1wcV-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224184819683.png)]

如只看id和索引:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8j70pJj9-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224185138580.png)]

(3)修改:全局替换操作
PUT /book/_doc/1
{
    "name": "Bootstrap开发教程1",
    "description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
    "studymodel": "201002",
    "price":38.6,
    "timestamp":"2019-08-25 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
    "tags": [ "bootstrap", "开发"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

可以看到,运行后对result显示了更新内容:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OF4ii6OY-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224190612748.png)]

但是这个是全局替换,需要带上所有的信息才能替换

(4)修改:局部替换:
语法:POST /{index}/type /{id}/_update

我们要修改文档中,且只修改name这一个属性的内容:

POST /book/_doc/1/_update

因为_doc马上要被系统删除不用了,所以使用下面的格式:

POST /book/_doc/1/_update
{
  "doc": {
   "name": " Bootstrap开发教程高级666"
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ywGSgys4-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224191308982.png)]

查询时发现确实修改成功:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A70a5clL-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224191453783.png)]

(5)删除:

删除id为1的文档数据

DELETE /book/_doc/1
  • 1

4 . 生成文档id:

(1)手动生成id

场景:数据从其他系统导入时,本身有唯一主键。如数据库中的图书、员工信息等。

用法:put /index/_doc/id

PUT /test_index/_doc/1
{
  "test_field": "test"
}
  • 1
  • 2
  • 3
  • 4
(2)自动生成id(id自动递增):

用法:POST /index/_doc

POST /test_index/_doc
{
  "test_field": "test1"
}
  • 1
  • 2
  • 3
  • 4

如下,es自动生成了id的串儿:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dFkULEfw-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224194814838.png)]

5 . _source 字段:

含义:插入数据时的所有字段和值。在get获取数据时,在_source字段中原样返回。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BnEy4tRw-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224200333053.png)]

(1)定制指定返回字段:

source_includes:表示要拿指定的字段的信息

只查看价格和名字:

GET /book/_doc/1?_source_includes=price,name

source只显示了介个和name的信息:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h9PM8eML-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224200805770.png)]

6 . 文档的替换和删除:

(1)全量替换:
PUT /test_index/_doc/1
{
  "test_field": "test"
}
  • 1
  • 2
  • 3
  • 4

执行语句新增数据后,会后一个version为1,再执行该语句,version为2,执行两次,返回结果中版本号(_version)在不断上升。此过程为全量替换。先前的数据为一个待删除的数据,实质:旧文档的内容不会立即删除,只是标记为deleted。适当的时机,集群会将这些文档删除。

(2)强制创建:

为防止覆盖原有数据,我们在新增时,设置为强制创建,不会覆盖原有文档。

语法:PUT /index/ _doc/id/__create

新增id为4的数据:

PUT /book/_doc/4/_create
{
    "name": "Bootstrap开发教程1",
    "description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
    "studymodel": "201002",
    "price":38.6,
    "timestamp":"2019-08-25 19:11:35",
    "pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
    "tags": [ "bootstrap", "开发"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

执行后,我们再执行该语句报错说该数据已经存在,不能覆盖,不能重复。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpsPhZJj-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224203430384.png)]

(3)删除:(延迟删除)

DELETE /book/id

DELETE /book/_doc/id

DELETE  /book/_doc/1/
  • 1

实质:旧文档的内容不会立即删除,只是标记为deleted。适当的时机,集群会将这些文档删除。

7 . 局部更新(局部替换):

使用 PUT /index/type/id 为文档全量替换,需要将文档所有数据提交。

partial update局部替换则只修改变动字段。

用法:

post /index/type/id/_update 
{
   "doc": {
      "field""value"
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

内部与全量替换是一样的,旧文档标记为删除,新建一个文档。

优点:

  • 大大减少网络传输次数和流量,提升性能
  • 减少并发冲突发生的概率。

7 . 批量增删改:

批量增语法:POST /_bulk

其他的以此类推。

POST /_bulk
{"action": {"metadata"}}
{"data"}

  • 1
  • 2
  • 3
  • 4

8 . 使用脚本更新:

es可以内置脚本执行复杂操作

(1)内置脚本:

修改文档6的num字段,+1。

插入数据

PUT /test_index/_doc/6
{
  "num": 0,
}
  • 1
  • 2
  • 3
  • 4

执行脚本操作(ctx:上下文,_source:文档6的source中的内容num+1)

POST /test_index/_doc/6/_update
{
   "script" : "ctx._source.num+=1"
}
  • 1
  • 2
  • 3
  • 4

搜索所有文档,将num字段乘以2输出

插入数据

PUT /test_index/_doc/7
{
  "num": 5
}
  • 1
  • 2
  • 3
  • 4

查询

GET /test_index/_search
{
  "script_fields": {
    "my_doubled_field": {
      "script": {
       "lang": "expression",
        "source": "doc['num'] * multiplier",
        "params": {
          "multiplier": 2
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

返回

{
        "_index" : "test_index",
        "_type" : "_doc",
        "_id" : "7",
        "_score" : 1.0,
        "fields" : {
          "my_doubled_field" : [
            10.0
          ]
        }
      }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

9 . 图解es的并发问题

如同商品秒杀,多线程情况下,es同样会出现并发冲突问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i1lUNFI7-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224213124651.png)]

10 . 图解悲观锁与乐观锁机制

解决es并发问题:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9tcyq1AC-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224221026145.png)]

11 . java 客户端 获取es简单数据

我们启动es,kebana后

(1)高层api:

导入以来:

<dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>7.3.0</version>
        <exclusions>
            <exclusion>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>7.3.0</version>
    </dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

java代码:

public class TestDemo {
    public static void main(String[] args) throws IOException {
        //连接es的步骤:
        //1.获取连接的客户端
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("localhost",9200,"http")));

        //2.构建请求,查询索引book的id为1的数据
        GetRequest getRequest = new GetRequest("book","1");

        //3.执行,这里请求参数使用默认
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        //4.拿到响应后解析,查询到数据后获取结果打印输出显示
        System.out.println(getResponse.getId());
        System.out.println(getResponse.getVersion());
        System.out.println(getResponse.getSource());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

输出显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rlFqfFvw-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225102214406.png)]

12 . 结合springboot获取es数据查询操作:

  • 当今趋势
  • 方便开发
  • 创建连接交由spring容器,避免每次请求的网络开销。

引入依赖:

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <version>2.0.6.RELEASE</version>
        </dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

配置springboot配置文件:

spring:
  application:
    name: service-search
heima:
  elasticsearch:
    hostlist: 127.0.0.1:9200 #多个结点中间用逗号分隔
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bpkjONyg-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225102727072.png)]

设置主启动类:

@SpringBootApplication
public class SearchApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SearchApplication.class, args);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bsiWRagO-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225102949502.png)]

springboot搭建完成后,我们只需要将我们前面的高级es获取数据的类注入springboot容器内,我们的springboot就可以拿来使用了:

已知我们在kibana插入了这个数据:

PUT /test_post/_doc/1
{
  "user":"tom",
  "postDate":"2019-07-18",
  "message":"trying out es"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JyOTcqgy-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225111035398.png)]

我们先配置springboot配置类:

@Configuration
public class ElestaticSearchConfig {

    @Value("${heima.elasticsearch.hostlist}")
    private String hostlist;
    @Bean(destroyMethod = "close")// RestClient用完后需要关闭,close是RestClient自带的关闭方法
    public RestHighLevelClient getRestHighLevelClient(){
        //按照逗号分割,因为可能会写有多个ip,拿出每个ip
        String[] split = hostlist.split(",");
        //定义一个数组将split存入该数组操作
        HttpHost[] httpHostArray = new HttpHost[split.length];
        for (int i = 0; i < split.length; i++) {
            String item = split[i];
            //将拿到的ip,端口分隔开存入httpArray数组
            httpHostArray[i] = new HttpHost(item.split(":")[0],
                    Integer.parseInt(item.split(":")[1]),"http");
        }
        //将数组传入实现对es的连接
        return new RestHighLevelClient(RestClient.builder(httpHostArray));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZMdJG3EZ-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225112911258.png)]

随后测试类测试查询test_post中的id为1的几个数据:

@SpringBootTest(classes =SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestDocument {
    @Autowired
    RestHighLevelClient client;
    @Test
    public void test1() throws IOException {
        //1.连接请求
        GetRequest getRequest = new GetRequest("test_post","1");
        //执行
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(getResponse.getId());
        System.out.println(getResponse.getVersion());
        System.out.println(getResponse.getSource());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

运行后:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6rHtH1TV-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225113047952.png)]

(1)输出可选参数:

在构建请求时,设置请求我们想要的参数

@SpringBootTest(classes =SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestDocument {
    @Autowired
    RestHighLevelClient client;
    @Test
    public void test1() throws IOException {
        //1.连接请求
        GetRequest getRequest = new GetRequest("test_post","1");
        //设置不想要的字段为user,message字段的,
        String[] includes =Strings.EMPTY_ARRAY;
        String[] excludes =  new String[]{"user","message"};
        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
        GetRequest getRequest1 = getRequest.fetchSourceContext(fetchSourceContext);

        //执行
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(getResponse.getId());
        System.out.println(getResponse.getVersion());
        System.out.println(getResponse.getSource());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

运行后,source中只打印输出了postDate字段的数据:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CVjMWbCl-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225120911370.png)]

上述的操作都是同步查询:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ahgoDkW8-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225121750622.png)]

(2)异步查询:
@SpringBootTest(classes =SearchApplication.class)
@RunWith(SpringRunner.class)
public class TestDocument {
    @Autowired
    RestHighLevelClient client;
    @Test
    public void test1() throws IOException {
        //1.连接请求
        GetRequest getRequest = new GetRequest("test_post","1");
        String[] includes =Strings.EMPTY_ARRAY;
        String[] excludes =  new String[]{"user","message"};
        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
        GetRequest getRequest1 = getRequest.fetchSourceContext(fetchSourceContext);

        //执行
        //同步查询
//        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        //异步查询:
        //创建一个监听器:监听发送异步请求查询是否能成功
        ActionListener<GetResponse> listener = new ActionListener<GetResponse>() {
           //请求成功时执行
            @Override
            public void onResponse(GetResponse getResponse) {
                System.out.println(getResponse.getId());
                System.out.println(getResponse.getVersion());
                System.out.println(getResponse.getSource());
            }

            //失败时执行:
            @Override
            public void onFailure(Exception e) {
                e.printStackTrace();
            }
        };
        client.getAsync(getRequest,RequestOptions.DEFAULT,listener);
        //由于我们在注解上设置客户端在发送请求后会立刻关闭client:@Bean(destroyMethod = "close")/
        //所以我们需要让主线程睡一会儿,防止测试时无法访问
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

运行后:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-65Sw5U2k-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225132245022.png)]

我们可以获取结果时以 好几种方式来拿到结果,按照需求来给定结果:

 // 获取结果
        if (getResponse.isExists()) {
            long version = getResponse.getVersion();

            String sourceAsString = getResponse.getSourceAsString();//检索文档(String形式)
            System.out.println(sourceAsString);
            byte[] sourceAsBytes = getResponse.getSourceAsBytes();//以字节接受
            Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
            System.out.println(sourceAsMap);

        }else {

        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

13 . springboot进行文档新增数据操作

	@Autowired
    RestHighLevelClient client;
@Test
    public void testAdd() throws IOException {
        //1.构建请求
//        PUT /test_post/_doc/2
        //构建请求头:
        IndexRequest request = new IndexRequest("test_post");
        request.id("3");
        //构建请求体:四种方法
        //方法一:
        String  jsonString = "{\n" +
                "  \"user\":\"tom\",\n" +
                "  \"postDate\":\"2019-07-18\",\n" +
                "  \"message\":\"trying out es\"\n" +
                "}\n";
        request.source(jsonString, XContentType.JSON);//插入的字符串是json
//        //方法二:
//        Map<String, Object> jsonMap = new HashMap<>();
//        jsonMap.put("user","tom");
//        jsonMap.put("postDate","2019-07-18");
//        jsonMap.put("message","trying out es");
//        request.source(jsonMap);
//        //方法三:
//        XContentBuilder builder = XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.field("user","tom");
//            builder.field("postDate","2019-07-18");
//            builder.field("message","trying out es");
//        }
//        builder.endObject();
//        request.source(builder);
//        //方法四:
//        request.source("user","tom",
//                "postDate","2019-07-18",
//                "message","trying out es");

        //可选参数:
        //设置超时时间1s,下面两种都一样:
        request.timeout("1s");
        request.timeout(TimeValue.timeValueSeconds(1));
        //手动维护版本号:
        request.version(2);
        request.versionType(VersionType.EXTERNAL);

        //2.执行
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

        //3.获取结果
        System.out.println(indexResponse.getIndex());
        System.out.println(indexResponse.getId());
        System.out.println(indexResponse.getResult());
        //test_post
        //3
        //CREATED
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

我们查询时可以同步,异步操作,同理新增数据也会有这些操作,同步操作:上述操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pCpxNxQL-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225141326642.png)]

异步操作:

//创建一个监听器:监听发送异步请求查询是否能成功
ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() {

    @Override
    public void onResponse(IndexResponse indexResponse) {
        System.out.println(indexResponse.getIndex());
        System.out.println(indexResponse.getId());
        System.out.println(indexResponse.getResult());
    }

    @Override
    public void onFailure(Exception e) {
        e.printStackTrace();
    }
};

//3.获取结果
client.indexAsync(request,RequestOptions.DEFAULT,listener);
//test_post
//3
//CREATED
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

我们这里使用同步操作,获取结果后进行一些判断:

System.out.println(indexResponse.getIndex());
System.out.println(indexResponse.getId());
System.out.println(indexResponse.getResult());
//如果这个操作是插入新增操作,就打印出来
if(indexResponse.getResult() == DocWriteResponse.Result.CREATED){
    DocWriteResponse.Result result = indexResponse.getResult();
    System.out.println("CREATE---"+result.toString());
    //同理
}else if(indexResponse.getResult() == DocWriteResponse.Result.UPDATED){
    DocWriteResponse.Result result = indexResponse.getResult();
    System.out.println("update---" + result.toString());
}else{

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

运行后报错版本问题:

因为我们对数据进行了修改,数据的版本应该变化,我们设置的手动维护版本号:所以修改版本号+1:

//手动维护版本号:
request.version(3);
request.versionType(VersionType.EXTERNAL);
  • 1
  • 2
  • 3

我们对该索引下id为3的数据的name进行修改:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LS2Q9b34-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225150217398.png)]

显示出修改成功。

我们在java上拿到分片的信息,进行对分片的判断:

//对分片的操作:
ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
//判断成功的分片如果不等于总的主分片数
if(shardInfo.getTotal() != shardInfo.getSuccessful()){
    System.out.println("处理成功的分片数少于总分片");
}
//失败的分片的失败原因:将每个失败分片的错误原因打印出来
if(shardInfo.getFailed()> 0){
    for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()){
        String reason = failure.reason();
        System.out.println(reason);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vm3EiFoF-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225151113612.png)]

14 结合springboot对es数据的修改

主要使用局部更新

对id为3的数据的doc内容的user修改:

POST /test_post/_doc/3/_update 
{
   "doc": {
      "user": "tomas Jj"
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

我们通过java来实现上述操作:

@Test
public void updateTest() throws IOException {
    //POST /test_post/_doc/3/_update
    //创建请求头:
    UpdateRequest request = new UpdateRequest("test_post", "3");
    //设置请求体(这里使用map的方式)
    Map<String, Object> jsonMap = new HashMap<>();
    jsonMap.put("user","tom jj");
    request.doc(jsonMap);
    //设置可选参数
    request.timeout("3s");
    //重试3次数据都不更新,就不操作了
    request.retryOnConflict(3);

    //执行:这里使用同步方式,也可用异步,相同的操作
    UpdateResponse updateResponse = client.update(request, RequestOptions.DEFAULT);
    //获取结果
    updateResponse.getId();
    updateResponse.getIndex();
    //判断结果:
    if(updateResponse.getResult() == DocWriteResponse.Result.CREATED){
        DocWriteResponse.Result result = updateResponse.getResult();
        System.out.println(result);
    } else if (updateResponse.getResult() == DocWriteResponse.Result.UPDATED) {
        DocWriteResponse.Result result = updateResponse.getResult();
        System.out.println(result);
    }else if(updateResponse.getResult() == DocWriteResponse.Result.NOOP)//noop表示这次操作没有对数据修改,相当于没有操作
    {
        DocWriteResponse.Result result = updateResponse.getResult();
        System.out.println(result);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

运行后显示:值被修改:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3bA0SJp-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225153806388.png)]

且是修改操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7mTffJcD-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225153829349.png)]

15 . 结合springboot对es数据的删除操作:

DELETE /test_posts/_doc/3
  • 1
@Test
public void testDelete() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("test_post", "3");
    //同理有同步也有异步,这里使用同步操作
    DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
    //获取结果
    deleteResponse.getId();
    deleteResponse.getResult();
    DocWriteResponse.Result result = deleteResponse.getResult();
    System.out.println(result);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

16 . 结合springboot对es数据的批量增删改操作:

  @Test
    public void testBulk() throws IOException {
//        1创建请求
        BulkRequest request = new BulkRequest();
        //增删改操作:对book索引中id=1的数据,新增suorce中的field字段,且id为1
        request.add(new IndexRequest("book").id("1").source(XContentType.JSON, "field", "1"));
        //对book索引中id=1的数据,新增suorce中的field字段,且id为2
        request.add(new IndexRequest("book").id("2").source(XContentType.JSON, "field", "2"));

        //2.执行
        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

        //获取结果
        for (BulkItemResponse itemResponse : bulkResponse) {
            DocWriteResponse itemResponseResponse = itemResponse.getResponse();

            switch (itemResponse.getOpType()) {
                case INDEX:
                case CREATE:
                    IndexResponse indexResponse = (IndexResponse) itemResponseResponse;
                    indexResponse.getId();
                    System.out.println(indexResponse.getResult());
                    break;
                case UPDATE:
                    UpdateResponse updateResponse = (UpdateResponse) itemResponseResponse;
                    updateResponse.getIndex();
                    System.out.println(updateResponse.getResult());
                    break;
                case DELETE:
                    DeleteResponse deleteResponse = (DeleteResponse) itemResponseResponse;
                    System.out.println(deleteResponse.getResult());
                    break;
            }
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

运行后出现了新增两个数据的信息:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2CrDyy8n-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225163418596.png)]

我们注掉新增的代码,添加修改代码:

  @Test
    public void testBulk() throws IOException {
		//1创建请求
        BulkRequest request = new BulkRequest();
		//对book索引中id=2的数据,将suorce中的doc中的id改为3
		request.add(new UpdateRequest("book","2").doc(XContentType.JSON, "field", "3"));
        //删除book索引中id为1的数据
        request.add(new DeleteRequest("book").id("1"));
        
         //2.执行
        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

        //获取结果
        for (BulkItemResponse itemResponse : bulkResponse) {
            DocWriteResponse itemResponseResponse = itemResponse.getResponse();

            switch (itemResponse.getOpType()) {
                case INDEX:
                case CREATE:
                    IndexResponse indexResponse = (IndexResponse) itemResponseResponse;
                    indexResponse.getId();
                    System.out.println(indexResponse.getResult());
                    break;
                case UPDATE:
                    UpdateResponse updateResponse = (UpdateResponse) itemResponseResponse;
                    updateResponse.getIndex();
                    System.out.println(updateResponse.getResult());
                    break;
                case DELETE:
                    DeleteResponse deleteResponse = (DeleteResponse) itemResponseResponse;
                    System.out.println(deleteResponse.getResult());
                    break;
            }
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

运行后:1被删除,2被修改

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z77iz5kH-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225163609969.png)]

第三章: 图解es内部机制

一、图解es分布式基础

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3wL0A5R5-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225174911244.png)]

#1、es对复杂分布式机制的透明隐藏特性
  • 分布式机制:分布式数据存储及共享。
  • 分片机制:数据存储到哪个分片,副本数据写入。
  • 集群发现机制:cluster discovery。新启动es实例,自动加入集群。
  • shard负载均衡:大量数据写入及查询,es会将数据平均分配。
  • shard副本:新增副本数,分片重分配。
#2、Elasticsearch的垂直扩容与水平扩容

垂直扩容:使用更加强大的服务器替代老服务器。但单机存储及运算能力有上线。且成本直线上升。如10t服务器1万。单个10T服务器可能20万。

水平扩容:采购更多服务器,加入集群。大数据。

#3、增减或减少节点时的数据rebalance

新增或减少es实例时,es集群会将数据重新分配。

#4、master节点

功能:

  • 创建删除节点
  • 创建删除索引
#5、节点对等的分布式架构
  • 节点对等,每个节点都能接收所有的请求
  • 自动请求路由
  • 响应收集

#二、图解分片shard、副本replica机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yerF0NXq-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225182848741.png)]

#1、shard&replica机制

(1)每个index包含一个或多个shard

(2)每个shard都是一个最小工作单元,承载部分数据,lucene实例,完整的建立索引和处理请求的能力

(3)增减节点时,shard会自动在nodes中负载均衡

(4)primary shard和replica shard,每个document肯定只存在于某一个primary shard以及其对应的replica shard中,不可能存在于多个primary shard

(5)replica shard是primary shard的副本,负责容错,以及承担读请求负载

(6)primary shard的数量在创建索引的时候就固定了,replica shard的数量可以随时修改

(7)primary shard的默认数量是1,replica默认是1,默认共有2个shard,1个primary shard,1个replica shard

注意:es7以前primary shard的默认数量是5,replica默认是1,默认有10个shard,5个primary shard,5个replica shard

(8)primary shard不能和自己的replica shard放在同一个节点上(否则节点宕机,primary shard和副本都丢失,起不到容错的作用),但是可以和其他primary shard的replica shard放在同一个节点上

#2、图解单node环境下创建index是什么样子的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0MWJuemb-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225183333933.png)]

(1)单node环境下,创建一个index,有3个primary shard,3个replica shard (2)集群status是yellow (3)这个时候,只会将3个primary shard分配到仅有的一个node上去,另外3个replica shard是无法分配的 (4)集群可以正常工作,但是一旦出现节点宕机,数据全部丢失,而且集群不可用,无法承接任何请求

PUT /test_index1
{
   "settings" : {
      "number_of_shards" : 3,
      "number_of_replicas" : 1
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
#3、图解2个node环境下replica shard是如何分配的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IWw8qKcr-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225184137126.png)]

(1)replica shard分配:3个primary shard,3个replica shard,1 node

(2)primary —> replica数据同步同步

(3)读请求:primary/replica分片都可以读,且速度有提升

#4、图解横向扩容

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ogGuKKw-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225190206179.png)]

  • 分片自动负载均衡,分片向空闲机器转移。
  • 每个节点存储更少分片,系统资源给与每个分片的资源更多,整体集群性能提高。
  • 扩容极限:节点数大于整体分片数,则必有空闲机器。
  • 超出扩容极限时,可以增加副本数,如设置副本数为2,总共3*3=9个分片。9台机器同时运行,存储和搜索性能更强。容错性更好。
  • 容错性:只要一个索引的所有主分片在,集群就就可以运行。
#5、 图解es容错机制 master选举,replica容错,数据恢复

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ElYI0jGa-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225190237677.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IYiFTYuT-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225190307374.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-laxkoGOP-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225190400710.png)]

以3分片,2副本数,3节点为例介绍。

  • master node宕机,自动master选举,集群为red
  • replica容错:新master将replica提升为primary shard,yellow
  • 重启宕机node,master copy replica到该node,使用原有的shard并同步宕机后的修改,green

#第九章 图解文档存储机制±

一、数据路由

#1、文档存储如何路由到相应分片

一个文档,最终会落在主分片的一个分片上,到底应该在哪一个分片?这就是数据路由。

#2、路由算法
shard = hash(routing) % number_of_primary_shards
  • 1

如下图分片id=1,主分片有3个:

hash(id=1)%3 = 1 ,数据路由发送给id=1的主分片。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hwfGYsUX-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225225824139.png)]

哈希值对主分片数取模。

举例:

对一个文档经行crud时,都会带一个路由值 routing number。默认为文档_id(可能是手动指定,也可能是自动生成)。

存储1号文档,经过哈希计算,哈希值为2,此索引有3个主分片,那么计算2%3=2,就算出此文档在P2分片上。

决定一个document在哪个shard上,最重要的一个值就是routing值,默认是_id,也可以手动指定,相同的routing值,每次过来,从hash函数中,产出的hash值一定是相同的

无论hash值是几,无论是什么数字,对number_of_primary_shards求余数,结果一定是在0~number_of_primary_shards-1之间这个范围内的。0,1,2。

#3、手动指定 routing number

routing的key值设定为num

PUT /test_index/_doc/15?routing=num
{
  "num": 0,
  "tags": []
}
  • 1
  • 2
  • 3
  • 4
  • 5

场景:在程序中,架构师可以手动指定已有数据的一个属性为路由值,好处是可以定制一类文档数据存储到一个分片中。缺点是设计不好,会造成数据倾斜,造成数据分布不均匀。

所以,不同文档尽量放到不同的索引中。剩下的事情交给es集群自己处理。

#4、主分片数量不可变

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-plETEIg1-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225230834506.png)]

涉及到以往数据的查询搜索,所以一旦建立索引,主分片数不可变。但是副本的分片数是可变的。

#二、 图解文档的增删改内部机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-laOmNDFd-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225224335250.png)]

增删改可以看做update,都是对数据的改动。一个改动请求发送到es集群,经历以下四个步骤:

(1)客户端选择一个node发送请求过去,这个node就是coordinating node(协调节点)

(2)coordinating node,对document进行路由,将请求转发给对应的node(有primary shard)

(3)实际的node上的primary shard处理请求,然后将数据同步到replica node。

(4)coordinating node,如果发现primary node和所有replica node都搞定之后,就返回响应结果给客户端。

#三、图解文档的查询内部机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5ET7W5FH-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226111857671.png)]

1、客户端发送请求到任意一个node,成为coordinate node

2、coordinate node对document进行路由,将请求转发到对应的node,此时会使用round-robin随机轮询算法,在primary shard以及其所有replica中随机选择一个,让读请求负载均衡

3、接收请求的node返回document给coordinate node

4、coordinate node返回document给客户端

5、特殊情况:document如果还在建立索引过程中,可能只有primary shard有,任何一个replica shard都没有,此时可能会导致无法读取到document,但是document完成索引建立之后,primary shard和replica shard就都有了

第十章 mapping映射入门

.

一、 什么是mapping映射

概念:自动或手动为index中的_doc建立的一种数据结构和相关配置,简称为mapping映射。

就是相当于数据库建表时对各个字段的类型确定。

动态映射:dynamic mapping,自动为我们建立index,以及对应的mapping,mapping中包含了每个field对应的数据类型,以及如何分词等设置。

重点:我们当然,后面会讲解,也可以手动在创建数据之前,先创建index,以及对应的mapping

查询mapping:

GET  /website/_mapping/
  • 1

显示出:

{
  "website" : {
    "mappings" : {
      "properties" : {
        "author_id" : {
          "type" : "long"
        },
        "content" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "post_date" : {
          "type" : "date"
        },
        "title" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

插入三个数据:

PUT /website/_doc/1
{
  "post_date": "2019-01-01",
  "title": "my first article",
  "content": "this is my first article in this website",
  "author_id": 11400
}

PUT /website/_doc/2
{
  "post_date": "2019-01-02",
  "title": "my second article",
  "content": "this is my second article in this website",
  "author_id": 11400
}
 
PUT /website/_doc/3
{
  "post_date": "2019-01-03",
  "title": "my third article",
  "content": "this is my third article in this website",
  "author_id": 11400
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

查询:

GET /website/_search?q=2019        0条结果             
GET /website/_search?q=2019-01-01           1条结果
GET /website/_search?q=post_date:2019-01-01     1条结果
GET /website/_search?q=post_date:2019          0 条结果
  • 1
  • 2
  • 3
  • 4

精确匹配与全文搜索的对比分析

#1、exact value 精确匹配

2019-01-01,exact value,搜索的时候,必须输入2019-01-01,才能搜索出来

如果你输入一个01,是搜索不出来的

select * from book where name= ‘java’

#2、full text 全文检索

搜“笔记电脑”,笔记本电脑词条会不会出现。

select * from book where name like ‘%java%’

(1)缩写 vs. 全称:cn vs. china

(2)格式转化:like liked likes

(3)大小写:Tom vs tom

(4)同义词:like vs love

2019-01-01,2019 01 01,搜索2019,或者01,都可以搜索出来

china,搜索cn,也可以将china搜索出来

likes,搜索like,也可以将likes搜索出来

Tom,搜索tom,也可以将Tom搜索出来

like,搜索love,同义词,也可以将like搜索出来

就不是说单纯的只是匹配完整的一个值,而是可以对值进行拆分词语后(分词)进行匹配,也可以通过缩写、时态、大小写、同义词等进行匹配。深入 NPL,自然语义处理

四、分词器 analyzer

#1、什么是分词器 analyzer

作用:切分词语,normalization(提升recall召回率)

给你一段句子,然后将这段句子拆分成一个一个的单个的单词,同时对每个单词进行normalization(时态转换,单复数转换)

recall,召回率:搜索的时候,增加能够搜索到的结果的数量

analyzer 组成部分:

1、character filter:在一段文本进行分词之前,先进行预处理,比如说最常见的就是,过滤html标签(<span>hello<span> --> hello),& --> and(I&you --> I and you)

2、tokenizer:分词,hello you and me --> hello, you, and, me

3、token filter:lowercase,stop word,synonymom,dogs --> dog,liked --> like,Tom --> tom,a/the/an --> 干掉,mother --> mom,small --> little

stop word 停用词: 了 的 呢。

一个分词器,很重要,将一段文本进行各种处理,最后处理好的结果才会拿去建立倒排索引。

#2、内置分词器的介绍

例句:Set the shape to semi-transparent by calling set_trans(5)

standard analyzer标准分词器:set, the, shape, to, semi, transparent, by, calling, set_trans, 5(默认的是standard)

simple analyzer简单分词器:set, the, shape, to, semi, transparent, by, calling, set, trans

whitespace analyzer:Set, the, shape, to, semi-transparent, by, calling, set_trans(5)

language analyzer(特定的语言的分词器,比如说,english,英语分词器):set, shape, semi, transpar, call, set_tran, 5

官方文档:

https://www.elastic.co/guide/en/elasticsearch/reference/7.4/analysis-analyzers.html

query string根据字段分词策略

#1、query string分词

query string必须以和index建立时相同的analyzer进行分词

query string对exact value和full text的区别对待

如: date:exact value 精确匹配

text: full text 全文检索

#2、测试分词器
GET /_analyze
{
  "analyzer": "standard",
  "text": "Text to analyze 80"
}
  • 1
  • 2
  • 3
  • 4
  • 5

返回值:

{
  "tokens" : [
    {
      "token" : "text",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "to",
      "start_offset" : 5,
      "end_offset" : 7,
      "type" : "<ALPHANUM>",
      "position" : 1
    },
    {
      "token" : "analyze",
      "start_offset" : 8,
      "end_offset" : 15,
      "type" : "<ALPHANUM>",
      "position" : 2
    },
    {
      "token" : "80",
      "start_offset" : 16,
      "end_offset" : 18,
      "type" : "<NUM>",
      "position" : 3
    }
  ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

token 实际存储的term 关键字

position 在此词条在原文本中的位置

start_offset/end_offset字符在原始字符串中的位置

#六、mapping回顾总结

(1)往es里面直接插入数据,es会自动建立索引,同时建立对应的mapping。(dynamic mapping)

(2)mapping中就自动定义了每个field的数据类型

(3)不同的数据类型(比如说text和date),可能有的是exact value,有的是full text

(4)exact value,在建立倒排索引的时候,分词的时候,是将整个值一起作为一个关键词建立到倒排索引中的;full text,会经历各种各样的处理,分词,normaliztion(时态转换,同义词转换,大小写转换),才会建立到倒排索引中。

(5)同时呢,exact value和full text类型的field就决定了,在一个搜索过来的时候,对exact value field或者是full text field进行搜索的行为也是不一样的,会跟建立倒排索引的行为保持一致;比如说exact value搜索的时候,就是直接按照整个值进行匹配,full text query string,也会进行分词和normalization再去倒排索引中去搜索

(6)可以用es的dynamic mapping,让其自动建立mapping,包括自动设置数据类型;也可以提前手动创建index和tmapping,自己对各个field进行设置,包括数据类型,包括索引行为,包括分词器,等

八、手动管理mapping(对mapping的增删查改)

#1、查询所有索引的映射

GET /_mapping

查看索引website的映射信息:将各个字段的信息展示

GET /website/_mapping/

#2、创建映射 !!重点

创建索引后,应该立即手动创建映射

PUT book/_mapping
{
	"properties": {
           "name": {
                  "type": "text"
            },
           "description": {
              "type": "text",
              //存储description时使用英文分词的分词器
              "analyzer":"english",
              //搜索description的关键词用英文分词去寻找
              "search_analyzer":"english"
           },
           "pic":{
             "type":"text",
             //默认为index=true,即要进行索引,只有进行索引才可以从索引库搜索到。
             //我们不可能搜索书搜索图片来检索,所以图片的索引不设置。
             "index":false
           },
           "studymodel":{
             "type":"text"
           }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
Text 文本类型

1)analyzer

通过analyzer属性指定分词器。

上边指定了analyzer是指在索引和搜索都使用english,如果单独想定义搜索时使用的分词器则可以通过search_analyzer属性。

2)index

index属性指定是否索引。

默认为index=true,即要进行索引,只有进行索引才可以从索引库搜索到。

但是也有一些内容不需要索引,比如:商品图片地址只被用来展示图片,不进行搜索图片,此时可以将index设置为false。

删除索引,重新创建映射,将pic的index设置为false,尝试根据pic去搜索,结果搜索不到数据。

3)store

是否在source之外存储,每个文档索引后会在 ES中保存一份原始文档,存放在"_source"中,一般情况下不需要设置store为true,因为在_source中已经有一份原始文档了。

keyword关键字字段

目前已经取代了"index": false。上边介绍的text文本字段在映射时要设置分词器,keyword字段为关键字字段,通常搜索keyword是按照整体搜索,所以创建keyword字段的索引时是不进行分词的,比如:邮政编码、手机号码、身份证等。keyword字段通常用于过虑、排序、聚合等

设置pic为不可分词

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnbh05KK-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226135055702.png)]

date日期类型

日期类型不用设置分词器。

通常日期类型的字段用于排序。

format

通过format设置日期格式

例子:

下边的设置允许date字段存储年月日时分秒、年月日及毫秒三种格式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dnoJsef2-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226135307127.png)]

{

“properties”: {

“timestamp”: {

“type”: “date”,

“format”: “yyyy-MM-dd HH:mm:ss||yyyy-MM-dd”

}

}

}

如:

插入文档:

Post book/doc/3

{

“name”: “spring开发基础”,

“description”: “spring 在java领域非常流行,java程序员都在用。”,

“studymodel”: “201001”,

“pic”:“group1/M00/00/01/wKhlQFqO4MmAOP53AAAcwDwm6SU490.jpg”,

“timestamp”:“2018-07-04 18:28:58”

}

数值类型

下边是ES支持的数值类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t6Qt4eXs-1681790779830)(null)]

1、尽量选择范围小的类型,提高搜索效率

2、对于浮点数尽量用比例因子,比如一个价格字段,单位为元,我们将比例因子设置为100这在ES中会按 分 存储,映射如下:

"price": {
        "type": "scaled_float",
        "scaling_factor": 100
  },
  • 1
  • 2
  • 3
  • 4

由于比例因子为100,如果我们输入的价格是23.45则ES中会将23.45乘以100存储在ES中。

如果输入的价格是23.456,ES会将23.456乘以100再取一个接近原始值的数,得出2346。

使用比例因子的好处是整型比浮点型更易压缩,节省磁盘空间。

如果比例因子不适合,则从下表选择范围小的去用:

更新已有映射,并插入文档:

PUT book/doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行,java程序员都在用。",
"studymodel": "201001",
 "pic":"group1/M00/00/01/wKhlQFqO4MmAOP53AAAcwDwm6SU490.jpg",
 "timestamp":"2018-07-04 18:28:58",
 "price":38.6
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
3、修改映射

只能创建index时手动建立mapping,或者新增field mapping,但是不能update field mapping。

因为已有数据按照映射早已分词存储好。如果修改,那这些存量数据怎么办。

新增一个字段mapping

PUT /book/_mapping/
{
  "properties" : {
    "new_field" : {
      "type" :    "text",
     "index":    "false"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

如果修改mapping,会报错

PUT /book/_mapping/
{
  "properties" : {
    "studymodel" : {
     "type" :    "keyword"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

返回:

{
  "error": {
    "root_cause": [
      {
        "type": "illegal_argument_exception",
        "reason": "mapper [studymodel] of different type, current_type [text], merged_type [keyword]"
      }
    ],
    "type": "illegal_argument_exception",
    "reason": "mapper [studymodel] of different type, current_type [text], merged_type [keyword]"
  },
  "status": 400
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
#4、删除映射

通过删除索引来删除映射。

九、 复杂数据类型

#1、multivalue field

{ “tags”: [ “tag1”, “tag2” ]},内部的值跟数组一样必须是同一类型。

建立索引时与string是一样的,数据类型不能混

#2、empty field

null,[],[null]

#3、object field
PUT /company/_doc/1
{
  "address": {
    "country": "china",
    "province": "guangdong",
    "city": "guangzhou"
  },
  "name": "jack",
  "age": 27,
  "join_date": "2019-01-01"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ICmUycb5-1681790773244)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226140343642.png)]

address:object类型

查询映射

GET /company/_mapping
{
  "company" : {
    "mappings" : {
      "properties" : {
        "address" : {
          "properties" : {
            "city" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "country" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "province" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        },
        "age" : {
          "type" : "long"
        },
        "join_date" : {
          "type" : "date"
        },
        "name" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I9wgua7m-1681790773244)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226140402414.png)]

object

{
  "address": {
    "country": "china",
    "province": "guangdong",
    "city": "guangzhou"
  },
  "name": "jack",
  "age": 27,
  "join_date": "2017-01-01"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

底层存储格式

{
    "name":            [jack],
    "age":          [27],
    "join_date":      [2017-01-01],
    "address.country":         [china],
    "address.province":   [guangdong],
    "address.city":  [guangzhou]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

对象数组:

{
    "authors": [
        { "age": 26, "name": "Jack White"},
        { "age": 55, "name": "Tom Jones"},
        { "age": 39, "name": "Kitty Smith"}
    ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

存储格式:

{
    "authors.age":    [26, 55, 39],
    "authors.name":   [jack, white, tom, jones, kitty, smith]
}
  • 1
  • 2
  • 3
  • 4

第十一章 索引Index入门

为什么我们要手动创建索引

直接put数据 PUT index/_doc/1,es会自动生成索引,并建立动态映射dynamic mapping。

在生产上,我们需要自己手动建立索引和映射,为了更好地管理索引。就像数据库的建表语句一样。

#一、索引管理

1 . 创建索引

创建索引的语法

PUT /index
{
//放置索引的分片数
    "settings": { ... any settings ... },
    //映射
    "mappings": {
       "properties" : {
            "field1" : { "type" : "text" }
        }
    },
    //别名
    "aliases": {
    	"default_index": {}
  } 
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

举例:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HYhXFD0N-1681790773244)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226144005874.png)]

给properties属性赋值:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GGWyv7pd-1681790773244)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226144203556.png)]

2 . 查询索引

GET /my_index/_mapping

GET /my_index/_setting

3 .修改索引

修改副本数

PUT /my_index/_settings
{
    "index" : {
        "number_of_replicas" : 2
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1JWN3Kqp-1681790773244)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226153450912.png)]

再次查询显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-swxTgAxc-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226153526105.png)]

4 . 删除索引:

DELETE /my_index

DELETE /index_one,index_two

DELETE /index_*

DELETE /_all

为了安全起见,防止恶意删除索引,删除时必须指定索引名:

elasticsearch.yml

action.destructive_requires_name: true

二、定制分词器

#1、默认的分词器

standard

分词三个组件,character filter,tokenizer,token filter

standard tokenizer:以单词边界进行切分

standard token filter:什么都不做

lowercase token filter:将所有字母转换为小写

stop token filer(默认被禁用):移除停用词,比如a the it等等

修改分词器的设置

启用english停用词token filter

PUT /my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "es_std": {
        //设置标准的默认分词器
          "type": "standard",
          //停用词:
          停用词类似助词,连接词,敏感词汇,避免搜索时因为这些词降低效率,加入_english_,就是英文句子只去找这个句子的关键词
          "stopwords": "_english_"
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nHtkAjzQ-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226161349294.png)]

测试:我们使用标准分词器

GET /my_index/_analyze
{
  "analyzer": "standard", 
  "text": "a dog is in the house"
}
  • 1
  • 2
  • 3
  • 4
  • 5

显示出 a dog is in the house

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R9FkNnLt-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226161509968.png)]

测试:我们使用我们自己设置的停用词分词器:

GET /my_index/_analyze
{
  "analyzer": "es_std", 
  "text": "a dog is in the house"
}
  • 1
  • 2
  • 3
  • 4
  • 5

运行后,分词器只分了句子的关键词,连接词那些都忽略掉

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9y7YW9jw-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226161737205.png)]

#3、定制化自己的分词器
PUT /my_index
{
  "settings": {
    "analysis": {
      "char_filter": {
      //设置一个映射关系,&都会自动转化为and
        "&_to_and": {
          "type": "mapping",
          "mappings": ["&=> and"]
        }
      },
      //设置停用词,the,a 都会被干掉忽略
      "filter": {
        "my_stopwords": {
          "type": "stop",
          "stopwords": ["the", "a"]
        }
      },
      "analyzer": {
        "my_analyzer": {
          "type": "custom",
          //把html文档的标签去掉,并将&都会自动转化为and
          "char_filter": ["html_strip", "&_to_and"],
          //分词使用标准默认分词器
          "tokenizer": "standard",
          //对词的标准化大小变小写,在使用我们设置的停用词来操作
          "filter": ["lowercase", "my_stopwords"]
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

测试:

GET /my_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": "tom&jerry are a friend in the house, <a>, HAHA!!"
}
  • 1
  • 2
  • 3
  • 4
  • 5

运行后显示:语句都按照策略被修改,显示出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ocMaRkdQ-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226162631482.png)]

三、type底层结构及弃用原因

#1、type是什么

type,是一个index中用来区分类似的数据的,类似的数据,但是可能有不同的fields,而且有不同的属性来控制索引建立、分词器. field的value,在底层的lucene中建立索引的时候,全部是opaque bytes类型,不区分类型的。 lucene是没有type的概念的,在document中,实际上将type作为一个document的field来存储,即_type,es通过_type来进行type的过滤和筛选。

#2、es中不同type存储机制

一个index中的多个type,实际上是放在一起存储的,因此一个index下,不能有多个type重名,而类型或者其他设置不同的,因为那样是无法处理的

{
   "goods": {
      "mappings": {
         "electronic_goods": {
            "properties": {
               "name": {
                  "type": "string",
               },
               "price": {
                  "type": "double"
               },
               "service_period": {
                  "type": "string"
                   }			
                }
         },
         "fresh_goods": {
            "properties": {
               "name": {
                  "type": "string",
               },
               "price": {
                  "type": "double"
               },
               "eat_period": {
              		"type": "string"
               }
                }
         }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
PUT /goods/electronic_goods/1
{
  "name": "小米空调",
  "price": 1999.0,
  "service_period": "one year"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
PUT /goods/fresh_goods/1
{
  "name": "澳洲龙虾",
  "price": 199.0,
  "eat_period": "one week"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

es文档在底层的存储是这样子的

{
   "goods": {
      "mappings": {
        "_type": {
          "type": "string",
          "index": "false"
        },
        "name": {
          "type": "string"
        }
        "price": {
          "type": "double"
        }
        "service_period": {
          "type": "string"
        },
        "eat_period": {
          "type": "string"
        }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

底层数据存储格式

{
  "_type": "electronic_goods",
  "name": "小米空调",
  "price": 1999.0,
  "service_period": "one year",
  "eat_period": ""
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
{
  "_type": "fresh_goods",
  "name": "澳洲龙虾",
  "price": 199.0,
  "service_period": "",
  "eat_period": "one week"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
#3、type弃用

同一索引下,不同type的数据存储其他type的field 大量空值,造成资源浪费。

所以,不同类型数据,要放到不同的索引中。

es9中,将会彻底删除type。

四、定制dynamic mapping

#1、定制dynamic策略

true:遇到陌生字段,就进行dynamic mapping

false:新检测到的字段将被忽略。这些字段将不会被索引,因此将无法搜索,但仍将出现在返回点击的源字段中。这些字段不会添加到映射中,必须显式添加新字段。

strict:遇到陌生字段,就报错

创建mapping

PUT /my_index
{
    "mappings": {
    //dynamic默认true,表示进行动态映射properties属性,
    如果没有属性,自动推测进行动态映射
      "dynamic": true,
       "properties": {
        "title": {
          "type": "text"
        },
        "address": {
          "type": "object",
          //因为address存的object不确定的,
          //我们dynamic进行动态映射
          "dynamic": true
        }
	    }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

测试:

我们插入一条数据:

PUT /my_index/_doc/1
{
  "title": "my article",
  "content": "this is my article",
  "address": {
    "province": "guangdong",
    "city": "guangzhou"
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

随后我们查询article的信息:

GET my_index/_search?q=content:article

x显示出能查到。

可如果我们将其修改为false:表示仍然进行动态映射properties属性,但是不存在倒排索引表中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-glOTlJ5d-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226172115654.png)]

随后我们再查询article的信息:

GET my_index/_search?q=content:article

我们并没有查到该数据信息:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gjdvfZUC-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226172203230.png)]

这是因为dynamic设置为false后,它的映射的属性全部放在原始文档中,并没有放在倒排索引表中,这样就查不到了。

创建mapping

PUT /my_index
{
    "mappings": {
    //strict:遇到陌生字段,就报错
      "dynamic": "strict",
       "properties": {
        "title": {
          "type": "text"
        },
        "address": {
          "type": "object",
          "dynamic": "true"
        }
	    }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

插入数据,

PUT /my_index/_doc/1
{
  "title": "my article",
  "content": "this is my article",
  "address": {
    "province": "guangdong",
    "city": "guangzhou"
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

因为有properties没有的content字段,strict会报错

{
  "error": {
    "root_cause": [
      {
        "type": "strict_dynamic_mapping_exception",
        "reason": "mapping set to strict, dynamic introduction of [content] within [_doc] is not allowed"
      }
    ],
    "type": "strict_dynamic_mapping_exception",
    "reason": "mapping set to strict, dynamic introduction of [content] within [_doc] is not allowed"
  },
  "status": 400
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
date_detection 日期探测

默认会按照一定格式识别date,比如yyyy-MM-dd。但是如果某个field先过来一个2017-01-01的值,就会被自动dynamic mapping成date,后面如果再来一个"hello world"之类的值,就会报错。可以手动关闭某个type的date_detection,如果有需要,自己手动指定某个field为date类型。

PUT /my_index
{
    "mappings": {
    //把它关闭,就不会将某些转换为时间类型
      "date_detection": false,
       "properties": {
        "title": {
          "type": "text"
        },
        "address": {
          "type": "object",
          "dynamic": "true"
        }
	    }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

测试:

PUT /my_index/_doc/1
{
  "title": "my article",
  "content": "this is my article",
  "address": {
    "province": "guangdong",
    "city": "guangzhou"
  },
  "post_date":"2019-09-10"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

查看映射显示:

GET /my_index/_mapping
  • 1

发现并没有将时间转换为Date类型,还是text文本类型:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IPdKGJqu-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226175125451.png)]

自定义日期格式
PUT my_index
{
  "mappings": {
    "dynamic_date_formats": ["MM/dd/yyyy"]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

插入数据

PUT my_index/_doc/1
{
  "create_date": "09/25/2019"
}
  • 1
  • 2
  • 3
  • 4

查看显示:自动映射为日期类型了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IKXdVpxR-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226175412495.png)]

numeric_detection 数字探测

虽然json支持本机浮点和整数数据类型,但某些应用程序或语言有时可能将数字呈现为字符串。通常正确的解决方案是显式地映射这些字段,但是可以启用数字检测(默认情况下禁用)来自动完成这些操作。

PUT my_index
{
  "mappings": {
    "numeric_detection": true
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

插入数据

PUT my_index/_doc/1
{
  "my_float":   "1.0", 
  "my_integer": "1" 
}
  • 1
  • 2
  • 3
  • 4
  • 5

查看映射显示:将字段的数据都自动转为为对应类型,而不是text类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wAsJLFMC-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226175717444.png)]

3、定制自己的dynamic mapping template(动态映射模板)
PUT /my_index
{
    "mappings": {
            "dynamic_templates": [
                { 
                  "en": {
                  //匹配en结尾的字段
                      "match":              "*_en", 
                      //匹配到后这个属性是string后就映射下面的mapping
                      "match_mapping_type": "string",
                      "mapping": {
                          "type":           "text",
                          "analyzer":       "english"
                      }
                }                  
            }
        ]
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

插入数据

PUT /my_index/_doc/1
{
  "title": "this is my first article"
}
  • 1
  • 2
  • 3
  • 4

运行后查看mapping能查到:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oy6TZvvN-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226180910375.png)]

插入数据:

PUT /my_index/_doc/2
{
  "title_en": "this is my first article"
}
  • 1
  • 2
  • 3
  • 4

运行后查看两个数据都能查到显示出:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1qXodFgl-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226181054274.png)]

如果我们换成查is:

GET my_index/_search?q=is

数据1能查到,2却查不到,这是数据2的字段匹配到了模板中en结尾的映射,且还是string类型,匹配到里面的映射,通过分词器将is这种非关键词去掉了。所以查不到了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zak3oCr3-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226181135655.png)]

PUT my_index
{
  "mappings": {
    "dynamic_templates": [
      {
        "integers": {
          "match_mapping_type": "long",
          "mapping": {
            "type": "integer"
          }
        }
      },
      {
        "strings": {
          "match_mapping_type": "string",
          "mapping": {
            "type": "text",
            "fields": {
              "raw": {
                "type":  "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

模板参数

"match":   "long_*",
"unmatch": "*_text",
"match_mapping_type": "string",
"path_match":   "name.*",
"path_unmatch": "*.middle",
  • 1
  • 2
  • 3
  • 4
  • 5
"match_pattern": "regex",
"match": "^profit_\d+$"
  • 1
  • 2
场景

1结构化搜索

默认情况下,elasticsearch将字符串字段映射为带有子关键字字段的文本字段。但是,如果只对结构化内容进行索引,而对全文搜索不感兴趣,则可以仅将“字段”映射为“关键字”。请注意,这意味着为了搜索这些字段,必须搜索索引所用的完全相同的值。

如下。匹配的类型如果刚好为string,那么字段就会变成keyword类型,keyword类型作为关键字不会分词

该字段不会全文索引,但是关键字可以被查到

	{
        "strings_as_keywords": {
          "match_mapping_type": "string",
          "mapping": {
            "type": "keyword"
          }
        }
      }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

2仅搜索,与上述情况相反:

与前面的示例相反,如果您只关心字符串字段的全文搜索,并且不打算对字符串字段运行聚合、排序或精确搜索,您可以告诉弹性搜索将其仅映射为文本字段(这是5之前的默认行为)

	{
        "strings_as_text": {
          "match_mapping_type": "string",
          "mapping": {
            "type": "text"
          }
        }
      }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

3norms 不关心评分

norms是指标时间的评分因素,比如匹配度高的有限匹配这种。如果您不关心评分,例如,如果您从不按评分对文档进行排序,则可以在索引中禁用这些评分因子的存储并节省一些空间。

{
        "strings_as_keywords": {
          "match_mapping_type": "string",
          "mapping": {
            "type": "text",
            //norms设置为false就不会计算评分,
            "norms": false,
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

五、零停机重建索引

#1、零停机重建索引

我们创建的一个索引后,如果该索引的数据类型不符合要求,就需要修改索引,那么就只能新建一个索引。然后哦把旧数据放到新索引中,之后客户端查询数据都会去新索引查询。但是再操作的这个过程中需要停机(客户端不去读旧索引,读新索引的这段空档)

演示:第一天和第二天插入数据

PUT /my_index/_doc/1
{
  "title": "2019-09-10"
}

PUT /my_index/_doc/2
{
  "title": "2019-09-11"
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

此时我们在第三天的数据插入时进行修改时报错不能修改:因为如果一个字段为keyword类型,如果改为text,那么搜索时就会进行分词操作,如果数据量过大进行分词操作就会对es的负载压力过大导致崩溃。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i2PTSvfi-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221227101125334.png)]

如果此时想修改title的类型,是不可能的

PUT /my_index/_mapping
{
  "properties": {
    "title": {
      "type": "text"
   	}
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

此时,唯一的办法,就是进行reindex,也就是说,重新建立一个索引,将旧索引的数据查询出来,再导入新索引。

如果说旧索引的名字,是old_index,新索引的名字是new_index,终端java应用,已经在使用old_index在操作了,难道还要去停止java应用,修改使用的index为new_index,才重新启动java应用吗?这个过程中,就会导致java应用停机,可用性降低。

所以说,给java应用一个别名,这个别名是指向旧索引的,java应用先用着,java应用先用prod_index alias来操作,此时实际指向的是旧的my_index/0

PUT /my_index/_alias/prod_index
  • 1

新建一个index,调整其title的类型为string

PUT /my_index_new
{
  "mappings": {
    "properties": {
		"title": {
         "type": "text"
        }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

使用scroll api将数据批量查询出来

GET /my_index/_search?scroll=1m
{
    "query": {
        "match_all": {}
    },    
    "size":  1
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

返回

{
  "_scroll_id": "DnF1ZXJ5VGhlbkZldGNoBQAAAAAAADpAFjRvbnNUWVZaVGpHdklqOV9zcFd6MncAAAAAAAA6QRY0b25zVFlWWlRqR3ZJajlfc3BXejJ3AAAAAAAAOkIWNG9uc1RZVlpUakd2SWo5X3NwV3oydwAAAAAAADpDFjRvbnNUWVZaVGpHdklqOV9zcFd6MncAAAAAAAA6RBY0b25zVFlWWlRqR3ZJajlfc3BXejJ3",
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 3,
    "max_score": null,
    "hits": [
      {
        "_index": "my_index",
        "_type": "my_type",
        "_id": "1",
        "_score": null,
        "_source": {
          "title": "2019-01-02"
        },
        "sort": [
          0
        ]
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

采用bulk api将scoll查出来的一批数据,批量写入新索引(这里将id为1的数据写入新索引)

POST /_bulk
{ "index":  { "_index": "my_index_new", "_id": "1" }}
{ "title":    "2019-09-10" }
  • 1
  • 2
  • 3

反复循环8~9,查询一批又一批的数据出来,采取bulk api将每一批数据批量写入新索引

将prod_index alias切换到my_index_new上去,java应用会直接通过index别名使用新的索引中的数据,java应用程序不需要停机,零提交,高可用

POST /_aliases
{
    "actions": [
    //将旧index的别名删除
        { "remove": { "index": "my_index", "alias": "prod_index" }},
        //给新index加上旧index的别名,这样客户端就会去新index去查数据了
        { "add":    { "index": "my_index_new", "alias": "prod_index" }}
    ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

直接通过prod_index别名来查询,是否ok

查询id为1的能查到

GET /prod_index/1
  • 1
2、生产实践:基于alias对client透明切换index
PUT /my_index_v1/_alias/my_index
  • 1

client对my_index进行操作

reindex操作,完成之后,切换v1到v2

POST /_aliases
{
    "actions": [
        { "remove": { "index": "my_index_v1", "alias": "my_index" }},
        { "add":    { "index": "my_index_v2", "alias": "my_index" }}
    ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

第十二章 中文分词器 IK分词器

3、ik分词器基础知识

ik_max_word: 会将文本做最细粒度的拆分,比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民大会堂,人民大会,大会堂”,会穷尽各种可能的组合;

ik_smart: 会做最粗粒度的拆分,比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国,人民大会堂”。

#4、ik分词器的使用

存储时,使用ik_max_word(将一些词存入,直接从存储的词拿到),搜索时,使用ik_smart(按照分词方式分开存入倒排索引进行搜索,将匹配度高的选用)

PUT /my_index 
{
  "mappings": {
      "properties": {
        "text": {
          "type": "text",
          //分词策略
          "analyzer": "ik_max_word",
          //搜索时分词策略
          "search_analyzer": "ik_smart"
        }
      }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

搜索

GET /my_index/_search?q=中华人民共和国人民大会堂
  • 1

二、 ik配置文件

#1、 ik配置文件

ik配置文件地址:es/plugins/ik/config目录

IKAnalyzer.cfg.xml:用来配置自定义词库

main.dic:ik原生内置的中文词库,总共有27万多条,只要是这些单词,都会被分在一起

preposition.dic: 介词

quantifier.dic:放了一些单位相关的词,量词

suffix.dic:放了一些后缀

surname.dic:中国的姓氏

stopword.dic:英文停用词

ik原生最重要的两个配置文件

main.dic:包含了原生的中文词语,会按照这个里面的词语去分词

stopword.dic:包含了英文的停用词

停用词,stopword

a the and at but

一般,像停用词,会在分词的时候,直接被干掉,不会建立在倒排索引中

自定义词库

(1)自己建立词库:每年都会涌现一些特殊的流行词,网红,蓝瘦香菇,喊麦,鬼畜,一般不会在ik的原生词典里

自己补充自己的最新的词语,到ik的词库里面

IKAnalyzer.cfg.xml:ext_dict,创建mydict.dic。

补充自己的词语,然后需要重启es,才能生效

(2)自己建立停用词库:比如了,的,啥,么,我们可能并不想去建立索引,让人家搜索

custom/ext_stopword.dic,已经有了常用的中文停用词,可以补充自己的停用词,然后重启es

第十三章 java api 实现索引管理(java对索引的增删改查)

PUT /my_index
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "field1":{
        "type": "text"
      },
      "field2":{
        "type": "text"
      }
    }
  },
  "aliases": {
    "default_index": {}
  } 
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
创建索引:
  @Test
    public void testCreateIndex() throws IOException {
        //创建索引对象
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("ydlclass_book");
        //设置参数
        createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "0"));
        //指定映射1
        createIndexRequest.mapping(" {\n" +
                " \t\"properties\": {\n" +
                "            \"name\":{\n" +
                "             \"type\":\"keyword\"\n" +
                "           },\n" +
                "           \"description\": {\n" +
                "              \"type\": \"text\"\n" +
                "           },\n" +
                "            \"price\":{\n" +
                "             \"type\":\"long\"\n" +
                "           },\n" +
                "           \"pic\":{\n" +
                "             \"type\":\"text\",\n" +
                "             \"index\":false\n" +
                "           }\n" +
                " \t}\n" +
                "}", XContentType.JSON);

        //指定映射2


//        Map<String, Object> message = new HashMap<>();
//        message.put("type", "text");
//        Map<String, Object> properties = new HashMap<>();
//        properties.put("message", message);
//        Map<String, Object> mapping = new HashMap<>();
//        mapping.put("properties", properties);
//        createIndexRequest.mapping(mapping);


        //指定映射3


//        XContentBuilder builder = XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.startObject("properties");
//            {
//                builder.startObject("message");
//                {
//                    builder.field("type", "text");
//                }
//                builder.endObject();
//            }
//            builder.endObject();
//        }
//        builder.endObject();
//        createIndexRequest.mapping(builder);

        //设置别名
        createIndexRequest.alias(new Alias("ydlclass_index_new"));

        // 额外参数
        //设置超时时间
        createIndexRequest.setTimeout(TimeValue.timeValueMinutes(2));
        //设置主节点超时时间
        createIndexRequest.setMasterTimeout(TimeValue.timeValueMinutes(1));
        //在创建索引API返回响应之前等待的活动分片副本的数量,以int形式表示
        //简单说就是,你创建一个3分片的索引,必须等待es告诉你,2个分片都建好了,才算这个索引创建完成了。然后才往下运行创建第三个分片。
        createIndexRequest.waitForActiveShards(ActiveShardCount.from(2));
        createIndexRequest.waitForActiveShards(ActiveShardCount.DEFAULT);

        //操作索引的客户端
        IndicesClient indices = client.indices();
        //执行创建索引库
        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);

        //得到响应(全部)
        boolean acknowledged = createIndexResponse.isAcknowledged();
        //得到响应 指示是否在超时前为索引中的每个分片启动了所需数量的碎片副本
        boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();

        System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!" + acknowledged);
        System.out.println(shardsAcknowledged);

    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83

上面是同步方式,同理也可以异步操作:

//异步新增索引
//异步新增索引
@Test
public void testCreateIndexAsync() throws IOException {
    //创建索引对象
    CreateIndexRequest createIndexRequest = new CreateIndexRequest("ydlclass_book2");
    //设置参数
    createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "0"));
    //指定映射1
    createIndexRequest.mapping(" {\n" +
            " \t\"properties\": {\n" +
            "            \"name\":{\n" +
            "             \"type\":\"keyword\"\n" +
            "           },\n" +
            "           \"description\": {\n" +
            "              \"type\": \"text\"\n" +
            "           },\n" +
            "            \"price\":{\n" +
            "             \"type\":\"long\"\n" +
            "           },\n" +
            "           \"pic\":{\n" +
            "             \"type\":\"text\",\n" +
            "             \"index\":false\n" +
            "           }\n" +
            " \t}\n" +
            "}", XContentType.JSON);

    //监听方法
    ActionListener<CreateIndexResponse> listener =
            new ActionListener<CreateIndexResponse>() {

                @Override
                public void onResponse(CreateIndexResponse createIndexResponse) {
                    System.out.println("!!!!!!!!创建索引成功");
                    System.out.println(createIndexResponse.toString());
                }

                @Override
                public void onFailure(Exception e) {
                    System.out.println("!!!!!!!!创建索引失败");
                    e.printStackTrace();
                }
            };

    //操作索引的客户端
    IndicesClient indices = client.indices();
    //执行创建索引库
    indices.createAsync(createIndexRequest, RequestOptions.DEFAULT, listener);

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
同步删除索引:
//删除索引库
@Test
public void testDeleteIndex() throws IOException {
    //删除索引对象
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("ydlclass_book2");
    //操作索引的客户端
    IndicesClient indices = client.indices();
    //执行删除索引
    AcknowledgedResponse delete = indices.delete(deleteIndexRequest, RequestOptions.DEFAULT);
    //得到响应
    boolean acknowledged = delete.isAcknowledged();
    System.out.println(acknowledged);

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
异步删除索引:
@Test
public void testDeleteIndexAsync() throws IOException {
    //删除索引对象
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("ydlclass_book2");
    //操作索引的客户端
    IndicesClient indices = client.indices();

    //监听方法
    ActionListener<AcknowledgedResponse> listener =
            new ActionListener<AcknowledgedResponse>() {
                @Override
                public void onResponse(AcknowledgedResponse deleteIndexResponse) {
                    System.out.println("!!!!!!!!删除索引成功");
                    System.out.println(deleteIndexResponse.toString());
                }

                @Override
                public void onFailure(Exception e) {
                    System.out.println("!!!!!!!!删除索引失败");
                    e.printStackTrace();
                }
            };
    //执行删除索引
    indices.deleteAsync(deleteIndexRequest, RequestOptions.DEFAULT, listener);

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
查看索引是否存在:
@Test
public void testExistIndex() throws IOException {
    GetIndexRequest request = new GetIndexRequest("ydlclass_book");
    request.local(false);//从主节点返回本地信息或检索状态
    request.humanReadable(true);//以适合人类的格式返回结果
    request.includeDefaults(false);//是否返回每个索引的所有默认设置

    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println(exists);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
关闭索引,

索引还存在,类似作为一个备份,只是搜索时不会去使用这个索引:

@Test
public void testCloseIndex() throws IOException {
    CloseIndexRequest request = new CloseIndexRequest("index");
    AcknowledgedResponse closeIndexResponse = client.indices().close(request, RequestOptions.DEFAULT);
    boolean acknowledged = closeIndexResponse.isAcknowledged();
    System.out.println("!!!!!!!!!"+acknowledged);

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

我们能查询到该数据,但是给这个数据插入数据时报错,说索引关闭错误。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-USy3KfQG-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221227214327725.png)]

开启索引:
@Test
public void testOpenIndex() throws IOException {
    OpenIndexRequest request = new OpenIndexRequest("ydlclass_book");

    OpenIndexResponse openIndexResponse = client.indices().open(request, RequestOptions.DEFAULT);
    boolean acknowledged = openIndexResponse.isAcknowledged();
    System.out.println("!!!!!!!!!"+acknowledged);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

第十四章 search搜索入门

get请求一般没有请求体,参数直接带上的

post有请求体,参数放到请求体内

#一、搜索语法入门

#1、query string search
、query string search

已知插入三条数据:

PUT /book/_doc/1
{
"name": "Bootstrap开发",
"description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
"studymodel": "201002",
"price":38.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "bootstrap", "dev"]
}
PUT /book/_doc/2
{
"name": "java编程思想",
"description": "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
"studymodel": "201001",
"price":68.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "java", "dev"]
}
PUT /book/_doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行,java程序员都在用。",
"studymodel": "201001",
"price":88.6,
"timestamp":"2019-08-24 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "spring", "java"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

无条件搜索所有

GET /book/_search
  • 1
{
  "took" : 969,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "name" : "Bootstrap开发",
          "description" : "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
          "studymodel" : "201002",
          "price" : 38.6,
          "timestamp" : "2019-08-25 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "bootstrap",
            "dev"
          ]
        }
      },
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "name" : "java编程思想",
          "description" : "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
          "studymodel" : "201001",
          "price" : 68.6,
          "timestamp" : "2019-08-25 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "java",
            "dev"
          ]
        }
      },
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "name" : "spring开发基础",
          "description" : "spring 在java领域非常流行,java程序员都在用。",
          "studymodel" : "201001",
          "price" : 88.6,
          "timestamp" : "2019-08-24 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "spring",
            "java"
          ]
        }
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

解释

took:耗费了几毫秒

timed_out:是否超时,这里是没有

_shards:到几个分片搜索,成功几个,跳过几个,失败几个。

hits.total:查询结果的数量,3个document

hits.max_score:score的含义,就是document对于一个search的相关度的匹配分数,越相关,就越匹配,分数也高

hits.hits:包含了匹配搜索的document的所有详细数据

#2、传参

与http请求传参类似

查询价格并且按照降序显示:

GET /book/_search?q=name:java&sort=price:desc&timeout=10ms
  • 1

类比sql: select * from book where name like ’ %java%’ order by price desc

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : null,
        "_source" : {
          "name" : "java编程思想",
          "description" : "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
          "studymodel" : "201001",
          "price" : 68.6,
          "timestamp" : "2019-08-25 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "java",
            "dev"
          ]
        },
        "sort" : [
          68.6
        ]
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
#3、图解timeout

GET /book/_search?timeout=10ms

全局设置:配置文件中设置 search.default_search_timeout:100ms。默认不超时。

二、multi-index 多索引搜索

#1、multi-index搜索模式

告诉你如何一次性搜索多个index和多个type下的数据

/_search:所有索引下的所有数据都搜索出来
/index1/_search:指定一个index,搜索其下所有的数据
/index1,index2/_search:同时搜索两个index下的数据
/index*/_search:按照通配符去匹配多个索引
  • 1
  • 2
  • 3
  • 4

应用场景:生产环境log索引可以按照日期分开。

log_to_es_*

log_to_es_20190910

log_to_es_20190911

log_to_es_20180910

#2、初步图解一下简单的搜索原理

搜索原理初步图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gal2Thxc-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228114933831.png)]

三、分页搜索

#1、分页搜索的语法

sql: select * from book limit 1,5

size,from

//查询book中id为1到2的数据

GET /book/_search?size=2

//按照每页3条数据查询(id=1-3的数据)

GET /book/_search?size=3&from=0

//按照从id为4开始查后三条数据(查到id为5,6,7的数据)

GET /book/_search?size=3&from=4

GET /book_search?from=0&size=3

2、deep paging
#什么是deep paging

根据相关度评分倒排序,所以分页过深,协调节点会将大量数据聚合分析。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lelCW2JC-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228122029600.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tDd3Bn9n-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228121940339.png)]

deep paging 性能问题

1消耗网络带宽,因为所搜过深的话,各 shard 要把数据传递给 coordinate node,这个过程是有大量数据传递的,消耗网络。

2消耗内存,各 shard 要把数据传送给 coordinate node,这个传递回来的数据,是被 coordinate node 保存在内存中的,这样会大量消耗内存。

3消耗cup,coordinate node 要把传回来的数据进行排序,这个排序过程很消耗cpu。 所以:鉴于deep paging的性能问题,所有应尽量减少使用

四、 query string基础语法

#1、query string基础语法

GET /book/_search?q=name:java

//name中有java的检索出来

GET /book/_search?q=+name:java

//name中没有java的检索出来

GET /book/_search?q=-name:java

一个是掌握q=field:search content的语法,还有一个是掌握+和-的含义

#2、_all metadata的原理和作用
GET /book/_search?q=java
  • 1

直接可以搜索所有的field,任意一个field包含指定的关键字就可以搜索出来。我们在进行中搜索的时候,难道是对document中的每一个field都进行一次搜索吗?不是的。

es中_all元数据。建立索引的时候,插入一条docunment,es会将所有的field值经行全量分词,把这些分词,放到_all field中。在搜索的时候,没有指定field,就在_all搜索。

举例

{
    name:jack
    email:123@qq.com
    address:beijing
}
  • 1
  • 2
  • 3
  • 4
  • 5

_all : jack,123@qq.com,beijing

五、query DSL入门

#1、DSL

query string 后边的参数原来越多,搜索条件越来越复杂,不能满足需求。

GET /book/_search?q=name:java&size=10&from=0&sort=price:desc

DSL:Domain Specified Language,特定领域的语言

es特有的搜索语言,可在请求体中携带搜索条件,功能强大。

查询全部 GET /book/_search

GET /book/_search
{
  "query": { "match_all": {} }
}
  • 1
  • 2
  • 3
  • 4

排序 GET /book/_search?sort=price:desc

GET /book/_search 
{
    "query" : {
        "match" : {
            "name" : " java"
        }
    },
    "sort": [
        { "price": "desc" }
    ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

分页查询 GET /book/_search?size=10&from=0

GET  /book/_search 
{
  "query": { "match_all": {} },
  "from": 0,
  "size": 10
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

指定返回字段 GET /book/ _search? _source=name,studymodel

GET /book/_search 
{
  "query": { "match_all": {} },
  "_source": ["name", "studymodel"]
}
  • 1
  • 2
  • 3
  • 4
  • 5

通过组合以上各种类型查询,实现复杂查询。

#2、 Query DSL语法
{
    QUERY_NAME: {
        ARGUMENT: VALUE,
        ARGUMENT: VALUE,...
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
{
    QUERY_NAME: {
        FIELD_NAME: {
            ARGUMENT: VALUE,
            ARGUMENT: VALUE,...
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
GET /test_index/_search 
{
  "query": {
    "match": {
      "test_field": "test"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#3、组合多个搜索条件

搜索需求:title必须包含elasticsearch,content可以包含elasticsearch也可以不包含,author_id必须不为111

sql where and or !=

初始数据:

POST /website/_doc/1
{
          "title": "my hadoop article",
          "content": "hadoop is very bad",
          "author_id": 111
}

POST /website/_doc/2
{
          "title": "my elasticsearch  article",
          "content": "es is very bad",
          "author_id": 112
}
POST /website/_doc/3
{
          "title": "my elasticsearch article",
          "content": "es is very goods",
          "author_id": 111
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

搜索:

GET /website/_doc/_search
{
  "query": {
  //title必须包含elasticsearch,
    "bool": {
      "must": [
        {
          "match": {
            "title": "elasticsearch"
          }
        }
      ],
      //content可以包含elasticsearch也可以不包含
      "should": [
        {
          "match": {
            "content": "elasticsearch"
          }
        }
      ],
      //author_id必须不为111
      "must_not": [
        {
          "match": {
            "author_id": 111
          }
        }
      ]
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

返回:

{
  "took" : 488,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.47000363,
    "hits" : [
      {
        "_index" : "website",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.47000363,
        "_source" : {
          "title" : "my elasticsearch  article",
          "content" : "es is very bad",
          "author_id" : 112
        }
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

更复杂的搜索需求:

select * from test_index where name=‘tom’ or (hired =true and (personality =‘good’ and rude != true ))

GET /test_index/_search
{
    "query": {
            "bool": {
                "must": { "match":{ "name": "tom" }},
                "should": [
                    { "match":{ "hired": true }},
                    { "bool": {
                        "must":{ "match": { "personality": "good" }},
                        "must_not": { "match": { "rude": true }}
                    }}
                ],
                "minimum_should_match": 1
            }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

六、full-text search 全文检索

#1、全文检索

重新创建book索引

PUT /book/
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0
  },
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_max_word",
        "search_analyzer": "ik_smart"
      },
      "description":{
        "type": "text",
        "analyzer": "ik_max_word",
        "search_analyzer": "ik_smart"
      },
      "studymodel":{
        "type": "keyword"
      },
      "price":{
        "type": "double"
      },
      "timestamp": {
         "type": "date",
         "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
      },
      "pic":{
        "type":"text",
        "index":false
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

插入数据

PUT /book/_doc/1
{
"name": "Bootstrap开发",
"description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
"studymodel": "201002",
"price":38.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "bootstrap", "dev"]
}

PUT /book/_doc/2
{
"name": "java编程思想",
"description": "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
"studymodel": "201001",
"price":68.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "java", "dev"]
}

PUT /book/_doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行,java程序员都在用。",
"studymodel": "201001",
"price":88.6,
"timestamp":"2019-08-24 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "spring", "java"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

搜索decription有java程序员的数据

GET  /book/_search 
{
    "query" : {
        "match" : {
            "description" : "java程序员"
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#2、_score初探
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 2.137549,
    "hits" : [
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 2.137549,
        "_source" : {
          "name" : "spring开发基础",
          "description" : "spring 在java领域非常流行,java程序员都在用。",
          "studymodel" : "201001",
          "price" : 88.6,
          "timestamp" : "2019-08-24 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "spring",
            "java"
          ]
        }
      },
      {
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.57961315,
        "_source" : {
          "name" : "java编程思想",
          "description" : "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
          "studymodel" : "201001",
          "price" : 68.6,
          "timestamp" : "2019-08-25 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "java",
            "dev"
          ]
        }
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

结果分析

1、建立索引时, description字段 term倒排索引

java 2,3

程序员 3

2、搜索时,直接找description中含有java的文档 2,3,并且3号文档含有两个java字段,一个程序员,所以得分高,排在前面。2号文档含有一个java,排在后面

七、DSL 语法练习

#1、match_all

拿到所有数据:

GET /book/_search
{
    "query": {
        "match_all": {}
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
#2、match
GET /book/_search
{
	"query": { 
		"match": { 
			"description": "java程序员"
		}
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#3、multi_match

多条件查询java程序员,在name和description字段中有的都查出来:

select * from book like “%java%” or like “%程序员%” or like “%java程序员%”

GET /book/_search
{
  "query": {
    "multi_match": {
      "query": "java程序员",
      "fields": ["name", "description"]
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
#4、range query 范围查询

查询价格大于80小于90的数据:

GET /book/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 80,
		"lte": 90
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
#5、term query

字段为keyword时,存储和搜索都不分词

GET /book/_search
{
  "query": {
  //表示查询description中就有一个单个的分词为:java程序员
    "term": {
      "description": "java程序员"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
#6、terms query

查询在tag字段下,只要有search,full_next,nosql的分词的都要显示出来。

GET /book/_search
{
    "query": { "terms": { "tag": [ "search", "full_text", "nosql" ] }}
}
  • 1
  • 2
  • 3
  • 4
#7、exist query 查询有某些字段值的文档

查询有join_date字段的

GET /book/_search
{
    "query": {
        "exists": {
            "field": "join_date"
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#8、Fuzzy query

返回包含与搜索词类似的词的文档,该词由Levenshtein编辑距离度量。

包括以下几种情况:

  • 更改角色(box→fox)不小心写错了
  • 删除字符(aple→apple)写漏了
  • 插入字符(sick→sic)写多了
  • 调换两个相邻字符(ACT→CAT)写反了

如下:已知book有java字样的数据,查询时输错了也可以检索到:

GET /book/_search
{
    "query": {
        "fuzzy": {
            "description": {
                "value": "jave"
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
#9、IDs

查book索引中id为1,4,100的文档数据

GET /book/_search
{
    "query": {
        "ids" : {
            "values" : ["1", "4", "100"]
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#10、prefix 前缀查询

在倒排索引内前缀有spring的数据

如:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KPH69KNW-1681790773248)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228152609919.png)]

查询时查倒排索引表内description以spring开头的数据
GET /book/_search
{
    "query": {
        "prefix": {
            "description": {
                "value": "spring"
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
#11、regexp query 正则查询
GET /book/_search
{

    "query": {
        "regexp": {
        //查询时查倒排索引表内description中j开头a结尾的数据
            "description": {
                "value": "j.*a"
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

八、 Filter

#1、 filter与query示例

需求:用户查询description中有"java程序员",并且价格大于80小于90的数据。

GET /book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "description": "java程序员"
          }
        },
        {
          "range": {
            "price": {
              "gte": 80,
		      "lte": 90
            }
          }
        }
      ]
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

使用filter:

GET /book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "description": "java程序员"
          }
        }
      ],
      "filter": {
        "range": {
          "price": {
            "gte": 80,
		     "lte": 90
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
#2、filter与query对比

filter,仅仅只是按照搜索条件查询的结果过滤出需要的数据而已,不计算任何相关度分数,对相关度没有任何影响。

query,会去计算每个document相对于搜索条件的相关度,并按照相关度进行排序。

应用场景:

一般来说,如果你是在进行搜索,需要将最匹配搜索条件的数据先返回,那么用query 如果你只是要根据一些条件筛选出一部分数据,不关注其排序,那么用filter

3、filter与query性能

filter,不需要计算相关度分数,不需要按照相关度分数进行排序,同时还有内置的自动cache最常使用filter的数据

query,相反,要计算相关度分数,按照分数进行排序,而且无法cache结果

#九、定位错误语法

验证错误语句:查看写的dsl是否成功

GET /book/_validate/query?explain
{
  "query": {
    "mach": {
      "description": "java程序员"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

返回:

{
  "valid" : false,
  "error" : "org.elasticsearch.common.ParsingException: no [query] registered for [mach]"
}
  • 1
  • 2
  • 3
  • 4

正确

GET /book/_validate/query?explain
{
  "query": {
    "match": {
      "description": "java程序员"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

返回

{
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "failed" : 0
  },
  "valid" : true,
  "explanations" : [
    {
      "index" : "book",
      "valid" : true,
      "explanation" : "description:java description:程序员"
    }
  ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

一般用在那种特别复杂庞大的搜索下,比如你一下子写了上百行的搜索,这个时候可以先用validate api去验证一下,搜索是否合法。

合法以后,explain就像mysql的执行计划,可以看到搜索的目标等信息

十、定制排序规则

#1、默认排序规则

默认情况下,是按照_score降序排序的

然而,某些情况下,可能没有有用的_score,比如说filter

GET book/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "description": "java程序员"
          }
        }
      ]
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

当然,也可以是constant_score

#2、定制排序规则

相当于sql中order by ?sort=sprice:desc

GET /book/_search 
{
  "query": {
    "constant_score": {
      "filter" : {
            "term" : {
                "studymodel" : "201001"
            }
        }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

十一、 Text字段排序问题

如果对一个text field进行排序,结果往往不准确,因为分词后是多个单词,再排序就不是我们想要的结果了。

例子:下面三条数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xFwW17mj-1681790773248)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228184329925.png)]

方案一:

设置给title属性加上:fielddate:true,那么就可以按照这个属性的第一个分词进行字典排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JAMxRlei-1681790773248)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228184300722.png)]

按照title进行排序:是按照title分词后的第一个单词来进行排序的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GAfkSc8g-1681790773248)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228184545928.png)]

可是这样有问题,如果有好几个前面时third后面的词不是相同的article二是各自不同的单词,那么就无法正确排序了。

方案二:把目标属性所有的词不分词都按照keyword来进行排序

通常解决方案是,将一个text field建立两次索引,text一个分词,用来进行搜索;field一个不分词,用来进行排序。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jmjmfst5-1681790773248)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228190740458.png)]

插入三条数据:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V3QBXtuo-1681790773249)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228184329925.png)]

按照title的keyword来正序排序查询:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dfFc8AGg-1681790773249)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228190922053.png)]

十二、Scroll分批查询

场景:下载某一个索引中1亿条数据,放到文件或是数据库。

不能一下全查出来,系统内存溢出。所以使用scoll滚动搜索技术,一批一批查询。

scoll搜索会在第一次搜索的时候,保存一个当时的视图快照,之后只会基于该旧的视图快照提供数据搜索,如果这个期间数据变更,是不会让用户看到的

每次发送scroll请求,我们还需要指定一个scoll参数,指定一个时间窗口,每次搜索请求只要在这个时间窗口内能完成就可以了。

搜索

1m:一分钟,

//指定一分钟内将book所以的数据查出
//分批,一次查3条数据
GET /book/_search?scroll=1m
{
  "query": {
    "match_all": {}
  },
  "size": 3
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

返回

{
  "_scroll_id" : "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAMOkWTURBNDUtcjZTVUdKMFp5cXloVElOQQ==",
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
     
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

获得的结果会有一个scoll_id,下一次再发送scoll请求的时候,必须带上这个scoll_id

GET /_search/scroll
{
    "scroll": "1m", 
    "scroll_id" : "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAMOkWTURBNDUtcjZTVUdKMFp5cXloVElOQQ=="
}
  • 1
  • 2
  • 3
  • 4
  • 5

与分页区别:

分页给用户看的 deep paging

scroll是用户系统内部操作,如下载批量数据,数据转移。零停机改变索引映射,然后再使用scroll分批查询。

第十五章 java api实现搜索

package com.itheima.es;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.Map;

/**
 * creste by itheima.itcast
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class TestSearch {
    @Autowired
    RestHighLevelClient client;

  //搜索全部记录
    @Test
    public void testSearchAll() throws IOException {
        //GET /book/_search
        //{
        //  "query": { "match_all": {} }
        //}
        //1.构建搜索请求:
        //请求头:
        SearchRequest searchRequest = new SearchRequest("book");
        //请求体:
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        searchRequest.source(searchSourceBuilder);

        //2.执行搜索:
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        //3.获取结果
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for ( SearchHit hit : searchHits ){
            //id
            String id = hit.getId();
            //相关度评分
            float score = hit.getScore();
            //拿到source的内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String)sourceAsMap.get("name");
            System.out.println("id : -----"+id);
            System.out.println("score:-----"+score);
            System.out.println("name: ----"+name);
            System.out.println("========================");

        }

    }


    //搜索分页
    @Test
    public void testSearchPage() throws IOException {
//    GET book/_search
//    {
//        "query": {
//          "match_all": {}
//       },
//        "from": 0,
//        "size": 2
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());


        //第几页
        int page=1;
        //每页几个
        int size=2;
        //下标计算
        int from=(page-1)*size;


        searchSourceBuilder.from(from);
        searchSourceBuilder.size(size);


        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");
        }
    }



    //ids搜索
    @Test
    public void testSearchIds() throws IOException {
//    GET /book/_search
//    {
//        "query": {
//           "ids" : {
//             "values" : ["1", "4", "100"]
//          }
//     }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.idsQuery().addIds("1","4","100"));




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }


    //match搜索
    @Test
    public void testSearchMatch() throws IOException {
//
//    GET /book/_search
//    {
//        "query": {
//           "match": {
//            "description": "java程序员"
//        }
//      }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("description", "java程序员"));




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }

    //term 搜索
    @Test
    public void testSearchTerm() throws IOException {
//
//    GET /book/_search
//    {
//        "query": {
//           "term": {
//            "description": "java程序员"
//        }
//      }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("description", "java程序员"));




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }


    //multi_match搜索
    @Test
    public void testSearchMultiMatch() throws IOException {
//    GET /book/_search
//    {
//        "query": {
//          "multi_match": {
//            "query": "java程序员",
//            "fields": ["name", "description"]
//        }
//      }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.multiMatchQuery("java程序员","name","description"));




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }
//    GET /book/_search
//    {
//        "query": {
//        "bool": {
//            "must": [
//            {
//                "multi_match": {
//                "query": "java程序员",
//                        "fields": ["name","description"]
//            }
//            }
//      ],
//            "should": [
//            {
//                "match": {
//                "studymodel": "201001"
//            }
//            }
//      ]
//        }
//    }
//    }

    //bool搜索
    @Test
    public void testSearchBool() throws IOException {
//    GET /book/_search
//    {
//        "query": {
//          "bool": {
//            "must": [
//            {
//                "multi_match": {
//                  "query": "java程序员",
//                  "fields": ["name","description"]
//            }
//            }
//      ],
//            "should": [
//            {
//                "match": {
//                "studymodel": "201001"
//            }
//            }
//      ]
//        }
//    }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //构建multiMatch请求
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("java程序员", "name", "description");
        //构建match请求
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("studymodel", "201001");

        BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.should(matchQueryBuilder);

        searchSourceBuilder.query(boolQueryBuilder);




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }

//    GET /book/_search
//    {
//        "query": {
//          "bool": {
//            "must": [
//            {
//                "multi_match": {
//                "query": "java程序员",
//                        "fields": ["name","description"]
//            }
//            }
//      ],
//            "should": [
//            {
//                "match": {
//                "studymodel": "201001"
//            }
//            }
//      ],
//            "filter": {
//                "range": {
//                    "price": {
//                        "gte": 50,
//                                "lte": 90
//                    }
//                }
//
//            }
//        }
//    }
//    }

    //filter搜索
    @Test
    public void testSearchFilter() throws IOException {
//    GET /book/_search
//    {
//        "query": {
//          "bool": {
//            "must": [
//            {
//                "multi_match": {
//                "query": "java程序员",
//                        "fields": ["name","description"]
//            }
//            }
//      ],
//            "should": [
//            {
//                "match": {
//                "studymodel": "201001"
//            }
//            }
//          ],
//            "filter": {
//                "range": {
//                    "price": {
//                        "gte": 50,
//                         "lte": 90
//                    }
//                }
//
//            }
//        }
//    }
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //构建multiMatch请求
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("java程序员", "name", "description");
        //构建match请求
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("studymodel", "201001");

        BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.should(matchQueryBuilder);

        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(50).lte(90));

        searchSourceBuilder.query(boolQueryBuilder);


        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");

        }
    }




    //sort搜索
    @Test
    public void testSearchSort() throws IOException {
//    GET /book/_search
//    {
//        "query": {
//        "bool": {
//            "must": [
//            {
//                "multi_match": {
//                "query": "java程序员",
//                "fields": ["name","description"]
//            }
//            }
//      ],
//            "should": [
//            {
//                "match": {
//                "studymodel": "201001"
//            }
//            }
//      ],
//            "filter": {
//                "range": {
//                    "price": {
//                        "gte": 50,
//                                "lte": 90
//                    }
//                }
//
//            }
//        }
//    },
//        "sort": [
//        {
//            "price": {
//            "order": "asc"
//        }
//        }
//  ]
//    }
        //1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //构建multiMatch请求
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("java程序员", "name", "description");
        //构建match请求
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("studymodel", "201001");

        BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.should(matchQueryBuilder);

        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(50).lte(90));

        searchSourceBuilder.query(boolQueryBuilder);

        //按照价格升序
        searchSourceBuilder.sort("price", SortOrder.ASC);


        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

        //数据数据
        SearchHit[] searchHits = hits.getHits();
        System.out.println("--------------------------");
        for (SearchHit hit : searchHits) {
            String id = hit.getId();
            float score = hit.getScore();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String description = (String) sourceAsMap.get("description");
            Double price = (Double) sourceAsMap.get("price");
            System.out.println("id:" + id);
            System.out.println("name:" + name);
            System.out.println("description:" + description);
            System.out.println("price:" + price);
            System.out.println("==========================");
        }
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447
  • 448
  • 449
  • 450
  • 451
  • 452
  • 453
  • 454
  • 455
  • 456
  • 457
  • 458
  • 459
  • 460
  • 461
  • 462
  • 463
  • 464
  • 465
  • 466
  • 467
  • 468
  • 469
  • 470
  • 471
  • 472
  • 473
  • 474
  • 475
  • 476
  • 477
  • 478
  • 479
  • 480
  • 481
  • 482
  • 483
  • 484
  • 485
  • 486
  • 487
  • 488
  • 489
  • 490
  • 491
  • 492
  • 493
  • 494
  • 495
  • 496
  • 497
  • 498
  • 499
  • 500
  • 501
  • 502
  • 503
  • 504
  • 505
  • 506
  • 507
  • 508
  • 509
  • 510
  • 511
  • 512
  • 513
  • 514
  • 515
  • 516
  • 517
  • 518
  • 519
  • 520
  • 521
  • 522
  • 523
  • 524
  • 525
  • 526
  • 527
  • 528
  • 529
  • 530
  • 531
  • 532
  • 533
  • 534
  • 535
  • 536
  • 537
  • 538
  • 539
  • 540
  • 541
  • 542
  • 543
  • 544
  • 545
  • 546
  • 547
  • 548
  • 549
  • 550
  • 551
  • 552
  • 553
  • 554
  • 555
  • 556
  • 557
  • 558
  • 559
  • 560
  • 561
  • 562
  • 563
  • 564
  • 565
  • 566
  • 567
  • 568
  • 569
  • 570
  • 571
  • 572
  • 573
  • 574
  • 575
  • 576
  • 577
  • 578
  • 579
  • 580
  • 581
  • 582
  • 583
  • 584
  • 585
  • 586
  • 587
  • 588
  • 589
  • 590
  • 591
  • 592
  • 593
  • 594
  • 595
  • 596
  • 597
  • 598
  • 599
  • 600
  • 601
  • 602
  • 603
  • 604
  • 605
  • 606
  • 607
  • 608
  • 609
  • 610
  • 611
  • 612
  • 613
  • 614
  • 615
  • 616

第十六章 评分机制详解

#一、评分机制 TF\IDF

#1、算法介绍

relevance score算法,简单来说,就是计算出,一个索引中的文本,与搜索文本,他们之间的关联匹配程度。

Elasticsearch使用的是 term frequency/inverse document frequency算法,简称为TF/IDF算法。TF词频(Term Frequency),IDF逆向文件频率(Inverse Document Frequency)

Term frequency:搜索文本中的各个词条在field文本中出现了多少次,出现次数越多,就越相关。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lf48SCRY-1681790781151)(null)]

举例:搜索请求:hello world

doc1 : hello you and me,and world is very good.

doc2 : hello,how are you

Inverse document frequency:搜索文本中的各个词条在整个索引的所有文档中出现了多少次,出现的次数越多,就越不相关.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Mr3HTgX-1681790781316)(null)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6f2LdVcN-1681790781469)(null)]

举例:搜索请求:hello world

doc1 : hello ,today is very good

doc2 : hi world ,how are you

整个index中1亿条数据。hello的document 1000个,有world的document 有100个。

doc2 更相关

Field-length norm:field长度,field越长,相关度越弱

举例:搜索请求:hello world

doc1 : {“title”:“hello article”,"content ":“balabalabal 1万个”}

doc2 : {“title”:“my article”,"content ":“balabalabal 1万个,world”}

#2、_score是如何被计算出来的
GET /book/_search?explain=true
{
  "query": {
    "match": {
      "description": "java程序员"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

返回

{
  "took" : 5,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 2.137549,
    "hits" : [
      {
        "_shard" : "[book][0]",
        "_node" : "MDA45-r6SUGJ0ZyqyhTINA",
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 2.137549,
        "_source" : {
          "name" : "spring开发基础",
          "description" : "spring 在java领域非常流行,java程序员都在用。",
          "studymodel" : "201001",
          "price" : 88.6,
          "timestamp" : "2019-08-24 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "spring",
            "java"
          ]
        },
        "_explanation" : {
          "value" : 2.137549,
          "description" : "sum of:",
          "details" : [
            {
              "value" : 0.7936629,
              "description" : "weight(description:java in 0) [PerFieldSimilarity], result of:",
              "details" : [
                {
                  "value" : 0.7936629,
                  "description" : "score(freq=2.0), product of:",
                  "details" : [
                    {
                      "value" : 2.2,
                      "description" : "boost",
                      "details" : [ ]
                    },
                    {
                      "value" : 0.47000363,
                      "description" : "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5)) from:",
                      "details" : [
                        {
                          "value" : 2,
                          "description" : "n, number of documents containing term",
                          "details" : [ ]
                        },
                        {
                          "value" : 3,
                          "description" : "N, total number of documents with field",
                          "details" : [ ]
                        }
                      ]
                    },
                    {
                      "value" : 0.7675597,
                      "description" : "tf, computed as freq / (freq + k1 * (1 - b + b * dl / avgdl)) from:",
                      "details" : [
                        {
                          "value" : 2.0,
                          "description" : "freq, occurrences of term within document",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.2,
                          "description" : "k1, term saturation parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 0.75,
                          "description" : "b, length normalization parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 12.0,
                          "description" : "dl, length of field",
                          "details" : [ ]
                        },
                        {
                          "value" : 35.333332,
                          "description" : "avgdl, average length of field",
                          "details" : [ ]
                        }
                      ]
                    }
                  ]
                }
              ]
            },
            {
              "value" : 1.3438859,
              "description" : "weight(description:程序员 in 0) [PerFieldSimilarity], result of:",
              "details" : [
                {
                  "value" : 1.3438859,
                  "description" : "score(freq=1.0), product of:",
                  "details" : [
                    {
                      "value" : 2.2,
                      "description" : "boost",
                      "details" : [ ]
                    },
                    {
                      "value" : 0.98082924,
                      "description" : "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5)) from:",
                      "details" : [
                        {
                          "value" : 1,
                          "description" : "n, number of documents containing term",
                          "details" : [ ]
                        },
                        {
                          "value" : 3,
                          "description" : "N, total number of documents with field",
                          "details" : [ ]
                        }
                      ]
                    },
                    {
                      "value" : 0.6227967,
                      "description" : "tf, computed as freq / (freq + k1 * (1 - b + b * dl / avgdl)) from:",
                      "details" : [
                        {
                          "value" : 1.0,
                          "description" : "freq, occurrences of term within document",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.2,
                          "description" : "k1, term saturation parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 0.75,
                          "description" : "b, length normalization parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 12.0,
                          "description" : "dl, length of field",
                          "details" : [ ]
                        },
                        {
                          "value" : 35.333332,
                          "description" : "avgdl, average length of field",
                          "details" : [ ]
                        }
                      ]
                    }
                  ]
                }
              ]
            }
          ]
        }
      },
      {
        "_shard" : "[book][0]",
        "_node" : "MDA45-r6SUGJ0ZyqyhTINA",
        "_index" : "book",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.57961315,
        "_source" : {
          "name" : "java编程思想",
          "description" : "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
          "studymodel" : "201001",
          "price" : 68.6,
          "timestamp" : "2019-08-25 19:11:35",
          "pic" : "group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
          "tags" : [
            "java",
            "dev"
          ]
        },
        "_explanation" : {
          "value" : 0.57961315,
          "description" : "sum of:",
          "details" : [
            {
              "value" : 0.57961315,
              "description" : "weight(description:java in 0) [PerFieldSimilarity], result of:",
              "details" : [
                {
                  "value" : 0.57961315,
                  "description" : "score(freq=1.0), product of:",
                  "details" : [
                    {
                      "value" : 2.2,
                      "description" : "boost",
                      "details" : [ ]
                    },
                    {
                      "value" : 0.47000363,
                      "description" : "idf, computed as log(1 + (N - n + 0.5) / (n + 0.5)) from:",
                      "details" : [
                        {
                          "value" : 2,
                          "description" : "n, number of documents containing term",
                          "details" : [ ]
                        },
                        {
                          "value" : 3,
                          "description" : "N, total number of documents with field",
                          "details" : [ ]
                        }
                      ]
                    },
                    {
                      "value" : 0.56055,
                      "description" : "tf, computed as freq / (freq + k1 * (1 - b + b * dl / avgdl)) from:",
                      "details" : [
                        {
                          "value" : 1.0,
                          "description" : "freq, occurrences of term within document",
                          "details" : [ ]
                        },
                        {
                          "value" : 1.2,
                          "description" : "k1, term saturation parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 0.75,
                          "description" : "b, length normalization parameter",
                          "details" : [ ]
                        },
                        {
                          "value" : 19.0,
                          "description" : "dl, length of field",
                          "details" : [ ]
                        },
                        {
                          "value" : 35.333332,
                          "description" : "avgdl, average length of field",
                          "details" : [ ]
                        }
                      ]
                    }
                  ]
                }
              ]
            }
          ]
        }
      }
    ]
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
#3、分析一个document是如何被匹配上的
GET /book/_explain/3
{
  "query": {
    "match": {
      "description": "java程序员"
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

#二、Doc value

搜索的时候,要依靠倒排索引;排序的时候,需要依靠正排索引,看到每个document的每个field,然后进行排序,所谓的正排索引,其实就是doc values

在建立索引的时候,一方面会建立倒排索引,以供搜索用;一方面会建立正排索引,也就是doc values,以供排序,聚合,过滤等操作使用

doc values是被保存在磁盘上的,此时如果内存足够,os会自动将其缓存在内存中,性能还是会很高;如果内存不足够,os会将其写入磁盘上

倒排索引

doc1: hello world you and me

doc2: hi, world, how are you

termdoc1doc2
hello*
world**
you**
and*
me*
hi*
how*
are*

搜索时:

hello you --> hello, you

hello --> doc1

you --> doc1,doc2

doc1: hello world you and me

doc2: hi, world, how are you

sort by 出现问题

正排索引

doc1: { “name”: “jack”, “age”: 27 }

doc2: { “name”: “tom”, “age”: 30 }

documentnameage
doc1jack27
doc2tom30

#三、query phase

#1、query phase

(1)搜索请求发送到某一个coordinate node,构构建一个priority queue,长度以paging操作from和size为准,默认为10

(2)coordinate node将请求转发到所有shard,每个shard本地搜索,并构建一个本地的priority queue

(3)各个shard将自己的priority queue返回给coordinate node,并构建一个全局的priority queue

#2、replica shard如何提升搜索吞吐量

一次请求要打到所有shard的一个replica/primary上去,如果每个shard都有多个replica,那么同时并发过来的搜索请求可以同时打到其他的replica上去

#四、 fetch phase

#1、fetch phbase工作流程

(1)coordinate node构建完priority queue之后,就发送mget请求去所有shard上获取对应的document

(2)各个shard将document返回给coordinate node

(3)coordinate node将合并后的document结果返回给client客户端

#2、一般搜索,如果不加from和size,就默认搜索前10条,按照_score排序

#五、搜索参数小总结

#1、preference

决定了哪些shard会被用来执行搜索操作

_primary, _primary_first, _local, _only_node:xyz, _prefer_node:xyz, _shards:2,3

bouncing results问题,两个document排序,field值相同;不同的shard上,可能排序不同;每次请求轮询打到不同的replica shard上;每次页面上看到的搜索结果的排序都不一样。这就是bouncing result,也就是跳跃的结果。

搜索的时候,是轮询将搜索请求发送到每一个replica shard(primary shard),但是在不同的shard上,可能document的排序不同

解决方案就是将preference设置为一个字符串,比如说user_id,让每个user每次搜索的时候,都使用同一个replica shard去执行,就不会看到bouncing results了

#2、timeout

已经讲解过原理了,主要就是限定在一定时间内,将部分获取到的数据直接返回,避免查询耗时过长

#3、routing

document文档路由,_id路由,routing=user_id,这样的话可以让同一个user对应的数据到一个shard上去

#4、search_type

default:query_then_fetch

dfs_query_then_fetch,可以提升revelance sort精准度

#第十七章 聚合入门

一、聚合示例

已知插入三条数据:

PUT /book/_doc/1
{
"name": "Bootstrap开发",
"description": "Bootstrap是由Twitter推出的一个前台页面开发css框架,是一个非常流行的开发框架,此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码,可以帮助开发者(尤其是不擅长css页面开发的程序人员)轻松的实现一个css,不受浏览器限制的精美界面css效果。",
"studymodel": "201002",
"price":38.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "bootstrap", "dev"]
}
PUT /book/_doc/2
{
"name": "java编程思想",
"description": "java语言是世界第一编程语言,在软件开发领域使用人数最多。",
"studymodel": "201001",
"price":68.6,
"timestamp":"2019-08-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "java", "dev"]
}
PUT /book/_doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行,java程序员都在用。",
"studymodel": "201001",
"price":88.6,
"timestamp":"2019-08-24 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg",
"tags": [ "spring", "java"]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
#1、需求:计算每个studymodel下的商品数量

sql语句: select studymodel,count(*) from book group by studymodel

GET /book/_search
{
  #size=0,表示我们查询只显示聚合的数据,不显示所有的数据
  "size": 0, 
  "query": {
    "match_all": {}
  }, 
  "aggs": {
    "group_by_model": {
      "terms": { "field": "studymodel" }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

运行后:如果报错:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olBsIc5n-1681790773250)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229181843922.png)]

我们需要对fielddata设置为false:

先查看sudymodel字段的映射相关信息,看看是什么类型:

GET book/_mapping

随后确认text类型后,设置:

PUT /book/_mapping/
{
  "properties": {
    "studymodel": {
      "type": "text",
      "fielddata": true
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

最后再聚合查询studymodel的数量,由下可知:studymodel有2001001有两个,2001002有一个

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Q54tRv5-1681790773250)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229182304070.png)]

2、需求:计算每个tags下的商品数量

跟上述情况相同,设置字段"fielddata": true

PUT /book/_mapping/
{
  "properties": {
    "tags": {
      "type": "text",
      "fielddata": true
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

查询

GET /book/_search
{
  "size": 0, 
  "query": {
    "match_all": {}
  }, 
  "aggs": {
    "group_by_tags": {
      "terms": { "field": "tags" }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行后:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6TbNPUC-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229182534915.png)]

3、需求:加上搜索条件,计算每个tags下的商品数量

将description为java程序员的数据聚合统计tags字段内的数据

GET /book/_search
{
  "size": 0, 
  "query": {
    "match": {
      "description": "java程序员"
    }
  }, 
  "aggs": {
    "group_by_tags": {
      "terms": { "field": "tags" }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

运行后显示出:tags字段内各个key的数量进行统计:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QOXY0bgP-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229183715184.png)]

4、需求:先分组,再算每组的平均值,计算每个tag下的商品的平均价格
GET /book/_search
{
    "size": 0,
    "aggs" : {
        "group_by_tags" : {
            "terms" : { 
              "field" : "tags" 
            },
            #再次聚合
            "aggs" : {
                "avg_price" : {
                    "avg" : { "field" : "price" }
                }
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

运行后:算出tags的key各个数据拥有的数量,且算出各个数据的平均价格

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55OB16Or-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229185406838.png)]

#5、需求:计算每个tag下的商品的平均价格,并且按照平均价格降序排序
GET /book/_search
{
    "size": 0,
    "aggs" : {
        "group_by_tags" : {
            "terms" : { 
              "field" : "tags",
              //在group by分组后按照价格降序排序
              "order": {
                "avg_price": "desc"
              }
            },
            "aggs" : {
                "avg_price" : {
                    "avg" : { "field" : "price" }
                }
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

运行后:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCp2jbwD-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229195625813.png)]

6、需求:按照指定的价格范围区间进行分组,然后在每组内再按照tag进行分组,最后再计算每组的平均价格降序排序:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zxtXNqom-1681790773252)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229195809662.png)]

GET /book/_search
{
  "size": 0,
  "aggs": {
    "range_by_price": {
      "range": {
        "field": "price",
        "ranges": [
          {
            "from": 0,
            "to": 40
          },
          {
            "from": 40,
            "to": 60
          },
          {
            "from": 60,
            "to": 80
          }
        ]
      },
      "aggs": {
        "group_by_tags": {
          "terms": {
            "field": "tags",
            "order":{
            "avg_price":"desc"
            }
          },
          "aggs": {
            "average_price": {
              "avg": {
                "field": "price"
              }
            }
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

二、两个核心概念:bucket和metric

#1、bucket:一个数据分组

city name 北京 张三 北京 李四 天津 王五 天津 赵六

天津 王麻子

划分出来两个bucket,一个是北京bucket,一个是天津bucket 北京bucket:包含了2个人,张三,李四 上海bucket:包含了3个人,王五,赵六,王麻子

2、metric:对一个数据分组执行的统计

metric,就是对一个bucket执行的某种聚合分析的操作,比如说求平均值,求最大值,求最小值

select count(*) from book group studymodel

bucket:group by studymodel --> 那些studymodel相同的数据,就会被划分到一个bucket中 metric:count(*),对每个user_id bucket中所有的数据,计算一个数量。还有avg(),sum(),max(),min()

#3、电视案例

创建索引及映射

PUT /tvs
PUT /tvs/_mapping
{			
			"properties": {
				"price": {
					"type": "long"
				},
				"color": {
					"type": "keyword"
				},
				"brand": {
					"type": "keyword"
				},
				"sold_date": {
					"type": "date"
				}
			}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

批量插入数据:

POST /tvs/_bulk
{ "index": {}}
{ "price" : 1000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-10-28" }
{ "index": {}}
{ "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-11-05" }
{ "index": {}}
{ "price" : 3000, "color" : "绿色", "brand" : "小米", "sold_date" : "2019-05-18" }
{ "index": {}}
{ "price" : 1500, "color" : "蓝色", "brand" : "TCL", "sold_date" : "2019-07-02" }
{ "index": {}}
{ "price" : 1200, "color" : "绿色", "brand" : "TCL", "sold_date" : "2019-08-19" }
{ "index": {}}
{ "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-11-05" }
{ "index": {}}
{ "price" : 8000, "color" : "红色", "brand" : "三星", "sold_date" : "2020-01-01" }
{ "index": {}}
{ "price" : 2500, "color" : "蓝色", "brand" : "小米", "sold_date" : "2020-02-12" }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
需求1 统计哪种颜色的电视销量最高

查询条件解析

size:只获取聚合结果,而不要执行聚合的原始数据

aggs:固定语法,要对一份数据执行分组聚合操作

popular_colors:就是对每个aggs,都要起一个名字,

terms:根据字段的值进行分组

field:根据指定的字段的值进行分组

GET /tvs/_search
{
  "size": 0,
  "aggs": {
    "popular_color": {
      "terms": {
        "field": "color"
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行后显示:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jm4C3cNQ-1681790773252)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229220331435.png)]

返回结果解析

hits.hits:我们指定了size是0,所以hits.hits就是空的 aggregations:聚合结果 popular_color:我们指定的某个聚合的名称 buckets:根据我们指定的field划分出的buckets key:每个bucket对应的那个值 doc_count:这个bucket分组内,有多少个数据 数量,其实就是这种颜色的销量

每种颜色对应的bucket中的数据的默认的排序规则:按照doc_count降序排序

需求2 统计每种颜色电视平均价格
GET /tvs/_search
{
   "size" : 0,
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": { 
            "avg_price": { 
               "avg": {
                  "field": "price" 
               }
            }
         }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

在一个aggs执行的bucket操作(terms),平级的json结构下,再加一个aggs,这个第二个aggs内部,同样取个名字,执行一个metric操作,avg,对之前的每个bucket中的数据的指定的field,price field,求一个平均值

运行后:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1dv9Fp1-1681790773252)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229221010166.png)]

buckets,除了key和doc_count avg_price:我们自己取的metric aggs的名字 value:我们的metric计算的结果,每个bucket中的数据的price字段求平均值后的结果

相当于sql: select avg(price) from tvs group by color

#需求3 继续下钻分析

每个颜色下平均价格及每个颜色下每个平抛的平均价格:

GET /tvs/_search
{先按照颜色分组,在聚合算平均价格
  "size": 0,
  "aggs": {
    "group_by_color": {
      "terms": {
        "field": "color"
      },
      "aggs": {
        "color_avg_price": {
          "avg": {
            "field": "price"
          }
        },
        在按照品牌分组再聚合求平均价格
        "group_by_brand":{
          "terms": {
            "field": "brand"
          },
          "aggs": {
          "brand_avg_price": {
          "avg": {
            "field": "price"
          }
        }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
需求4:更多的metric

count:bucket,terms,自动就会有一个doc_count,就相当于是count avg:avg aggs,求平均值 max:求一个bucket内,指定field值最大的那个数据 min:求一个bucket内,指定field值最小的那个数据 sum:求一个bucket内,指定field值的总和

GET /tvs/_search
{
   "size" : 0,
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": {
            "avg_price": { "avg": { "field": "price" } },
            "min_price" : { "min": { "field": "price"} }, 
            "max_price" : { "max": { "field": "price"} },
            "sum_price" : { "sum": { "field": "price" } } 
         }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
需求5:划分范围 histogram

求0-2000,2000-4000,4000-6000,6000-8000的各个平均价格

GET /tvs/_search
{
   "size" : 0,
   "aggs":{
      "price":{
         "histogram":{ 
            "field": "price",
            //每次间隔2000
            "interval": 2000
         },
         "aggs":{
            "income": {
               "sum": { 
                 "field" : "price"
               }
             }
         }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

histogram:类似于terms,也是进行bucket分组操作,接收一个field,按照这个field的值的各个范围区间,进行bucket分组操作

"histogram":{ 
  "field": "price",
  "interval": 2000
}
  • 1
  • 2
  • 3
  • 4

interval:2000,划分范围,02000,20004000,40006000,60008000,8000~10000,buckets

bucket有了之后,一样的,去对每个bucket执行avg,count,sum,max,min,等各种metric操作,聚合分析

需求6:按照日期分组聚合

date_histogram,按照我们指定的某个date类型的日期field,以及日期interval,按照一定的日期间隔,去划分bucket

min_doc_count:即使某个日期interval,2017-01-01~2017-01-31中,一条数据都没有,那么这个区间也是要返回的,不然默认是会过滤掉这个区间的 extended_bounds,min,max:划分bucket的时候,会限定在这个起始日期,和截止日期内

求2019-1-1到2020-12-31每月的销售总额:

GET /tvs/_search
{
   "size" : 0,
   "aggs": {
      "sales": {
         "date_histogram": {
            "field": "sold_date",
            //按照一个月间隔
            "interval": "month", 
            "format": "yyyy-MM-dd",
            "min_doc_count" : 0, 
            //指定数据整体的时间范围
            "extended_bounds" : { 
                "min" : "2019-01-01",
                "max" : "2020-12-31"
            }
         }
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
需求7 统计每季度每个品牌的销售额
GET /tvs/_search 
{
  "size": 0,
  "aggs": {
    "group_by_sold_date": {
      "date_histogram": {
        "field": "sold_date",
        "interval": "quarter",
        "format": "yyyy-MM-dd",
        "min_doc_count": 0,
        "extended_bounds": {
          "min": "2019-01-01",
          "max": "2020-12-31"
        }
      },
      "aggs": {
        "group_by_brand": {
          "terms": {
            "field": "brand"
          },
          "aggs": {
            "sum_price": {
              "sum": {
                "field": "price"
              }
            }
          }
        },
        "total_sum_price": {
          "sum": {
            "field": "price"
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
需求8 :搜索与聚合结合,查询某个品牌按颜色销量

搜索与聚合可以结合起来。

sql select count(*)

from tvs

where brand like “%小米%”

group by color

es aggregation,scope,任何的聚合,都必须在搜索出来的结果数据中之行,搜索结果,就是聚合分析操作的scope

GET /tvs/_search 
{
  "size": 0,
  "query": {
    "term": {
      "brand": {
        "value": "小米"
      }
    }
  },
  "aggs": {
    "group_by_color": {
      "terms": {
        "field": "color"
      }
    }
  }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
需求9 global bucket:单个品牌与所有品牌销量对比

aggregation,scope,一个聚合操作,必须在query的搜索结果范围内执行

出来两个结果,一个结果,是基于query搜索结果来聚合的; 一个结果,是对所有数据执行聚合的

GET /tvs/_search 
{
  "size": 0, 
  "query": {
    "term": {
      "brand": {
        "value": "小米"
      }
    }
  },
  "aggs": {
    "single_brand_avg_price": {
      "avg": {
        "field": "price"
      }
    },
    "all": {
      "global": {},
      "aggs": {
        "all_brand_avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

#需求10:过滤+聚合:统计价格大于1200的电视平均价格

搜索+聚合

过滤+聚合

GET /tvs/_search 
{
  "size": 0,
  "query": {
    "constant_score": {
      "filter": {
        "range": {
          "price": {
            "gte": 1200
          }
        }
      }
    }
  },
  "aggs": {
    "avg_price": {
      "avg": {
        "field": "price"
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
#需求11 bucket filter:统计品牌最近一个月的平均价格
GET /tvs/_search 
{
  "size": 0,
  "query": {
    "term": {
      "brand": {
        "value": "小米"
      }
    }
  },
  "aggs": {
    "recent_150d": {
      "filter": {
        "range": {
          "sold_date": {
          //现在减150天
            "gte": "now-150d"
          }
        }
      },
      "aggs": {
        "recent_150d_avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    },
    "recent_140d": {
      "filter": {
        "range": {
          "sold_date": {
            "gte": "now-140d"
          }
        }
      },
      "aggs": {
        "recent_140d_avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    },
    "recent_130d": {
      "filter": {
        "range": {
          "sold_date": {
            "gte": "now-130d"
          }
        }
      },
      "aggs": {
        "recent_130d_avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

aggs.filter,针对的是聚合去做的

如果放query里面的filter,是全局的,会对所有的数据都有影响

但是,如果,比如说,你要统计,长虹电视,最近1个月的平均值; 最近3个月的平均值; 最近6个月的平均值

bucket filter:对不同的bucket下的aggs,进行filter

#需求12 排序:按每种颜色的平均销售额降序排序
GET /tvs/_search 
{
  "size": 0,
  "aggs": {
    "group_by_color": {
      "terms": {
        "field": "color",
        "order": {
          "avg_price": "asc"
        }
      },
      "aggs": {
        "avg_price": {
          "avg": {
            "field": "price"
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

相当于sql子表数据字段可以立刻使用。

#需求13 排序:按每种颜色的每种品牌平均销售额降序排序
GET /tvs/_search  
{
  "size": 0,
  "aggs": {
    "group_by_color": {
      "terms": {
        "field": "color"
      },
      "aggs": {
        "group_by_brand": {
          "terms": {
            "field": "brand",
            "order": {
              "avg_price": "desc"
            }
          },
          "aggs": {
            "avg_price": {
              "avg": {
                "field": "price"
              }
            }
          }
        }
      }
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

第十八章 java api实现聚合

简单聚合,多种聚合,详见代码。

package com.ydlclass.es;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.histogram.*;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.*;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.List;

/**
 * creste by ydlclass.ydl
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class TestAggs {
    @Autowired
    RestHighLevelClient client;

    //需求一:按照颜色分组,计算每个颜色卖出的个数
    @Test
    public void testAggs() throws IOException {
        // GET /tvs/_search
        // {
        //     "size": 0,
        //     "query": {"match_all": {}},
        //     "aggs": {
        //       "group_by_color": {
        //         "terms": {
        //             "field": "color"
        //         }
        //     }
        // }
        // }

        //1 构建请求
        SearchRequest searchRequest=new SearchRequest("tvs");

        //请求体
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        searchSourceBuilder.size(0);
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("group_by_color").field("color");
        searchSourceBuilder.aggregation(termsAggregationBuilder);

        //请求体放入请求头
        searchRequest.source(searchSourceBuilder);

        //2 执行
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3 获取结果
      //   "aggregations" : {
      //       "group_by_color" : {
      //           "doc_count_error_upper_bound" : 0,
      //           "sum_other_doc_count" : 0,
      //            "buckets" : [
      //           {
      //               "key" : "红色",
      //               "doc_count" : 4
      //           },
      //           {
      //               "key" : "绿色",
      //                   "doc_count" : 2
      //           },
      //           {
      //               "key" : "蓝色",
      //                   "doc_count" : 2
      //           }
      // ]
      //       }
        Aggregations aggregations = searchResponse.getAggregations();
        Terms group_by_color = aggregations.get("group_by_color");
        List<? extends Terms.Bucket> buckets = group_by_color.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            System.out.println("key:"+key);

            long docCount = bucket.getDocCount();
            System.out.println("docCount:"+docCount);

            System.out.println("=================================");
        }
    }

    // #需求二:按照颜色分组,计算每个颜色卖出的个数,每个颜色卖出的平均价格
    @Test
    public void testAggsAndAvg() throws IOException {
        // GET /tvs/_search
        // {
        //     "size": 0,
        //      "query": {"match_all": {}},
        //     "aggs": {
        //     "group_by_color": {
        //         "terms": {
        //             "field": "color"
        //         },
        //         "aggs": {
        //             "avg_price": {
        //                 "avg": {
        //                     "field": "price"
        //                 }
        //             }
        //         }
        //     }
        // }
        // }

        //1 构建请求
        SearchRequest searchRequest=new SearchRequest("tvs");

        //请求体
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        searchSourceBuilder.size(0);
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("group_by_color").field("color");

        //terms聚合下填充一个子聚合
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("avg_price").field("price");
        termsAggregationBuilder.subAggregation(avgAggregationBuilder);

        searchSourceBuilder.aggregation(termsAggregationBuilder);

        //请求体放入请求头
        searchRequest.source(searchSourceBuilder);

        //2 执行
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3 获取结果
        // {
        //     "key" : "红色",
        //      "doc_count" : 4,
        //      "avg_price" : {
        //        "value" : 3250.0
        //       }
        // }
        Aggregations aggregations = searchResponse.getAggregations();
        Terms group_by_color = aggregations.get("group_by_color");
        List<? extends Terms.Bucket> buckets = group_by_color.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            System.out.println("key:"+key);

            long docCount = bucket.getDocCount();
            System.out.println("docCount:"+docCount);

            Aggregations aggregations1 = bucket.getAggregations();
            Avg avg_price = aggregations1.get("avg_price");
            double value = avg_price.getValue();
            System.out.println("value:"+value);

            System.out.println("=================================");
        }
    }

    // #需求三:按照颜色分组,计算每个颜色卖出的个数,以及每个颜色卖出的平均值、最大值、最小值、总和。
    @Test
    public void testAggsAndMore() throws IOException {
        // GET /tvs/_search
        // {
        //     "size" : 0,
        //     "aggs": {
        //      "group_by_color": {
        //         "terms": {
        //             "field": "color"
        //         },
        //         "aggs": {
        //             "avg_price": { "avg": { "field": "price" } },
        //             "min_price" : { "min": { "field": "price"} },
        //             "max_price" : { "max": { "field": "price"} },
        //             "sum_price" : { "sum": { "field": "price" } }
        //         }
        //     }
        // }
        // }

        //1 构建请求
        SearchRequest searchRequest=new SearchRequest("tvs");

        //请求体
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        searchSourceBuilder.size(0);
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("group_by_color").field("color");


        //termsAggregationBuilder里放入多个子聚合
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("avg_price").field("price");
        MinAggregationBuilder minAggregationBuilder = AggregationBuilders.min("min_price").field("price");
        MaxAggregationBuilder maxAggregationBuilder = AggregationBuilders.max("max_price").field("price");
        SumAggregationBuilder sumAggregationBuilder = AggregationBuilders.sum("sum_price").field("price");

        termsAggregationBuilder.subAggregation(avgAggregationBuilder);
        termsAggregationBuilder.subAggregation(minAggregationBuilder);
        termsAggregationBuilder.subAggregation(maxAggregationBuilder);
        termsAggregationBuilder.subAggregation(sumAggregationBuilder);


        searchSourceBuilder.aggregation(termsAggregationBuilder);

        //请求体放入请求头
        searchRequest.source(searchSourceBuilder);

        //2 执行
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3 获取结果
        // {
        //     "key" : "红色",
        //     "doc_count" : 4,
        //     "max_price" : {
        //          "value" : 8000.0
        //     },
        //     "min_price" : {
        //          "value" : 1000.0
        // },
        //     "avg_price" : {
        //         "value" : 3250.0
        // },
        //     "sum_price" : {
        //         "value" : 13000.0
        // }
        // }
        Aggregations aggregations = searchResponse.getAggregations();
        Terms group_by_color = aggregations.get("group_by_color");
        List<? extends Terms.Bucket> buckets = group_by_color.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            System.out.println("key:"+key);

            long docCount = bucket.getDocCount();
            System.out.println("docCount:"+docCount);

            Aggregations aggregations1 = bucket.getAggregations();

            Max max_price = aggregations1.get("max_price");
            double maxPriceValue = max_price.getValue();
            System.out.println("maxPriceValue:"+maxPriceValue);

            Min min_price = aggregations1.get("min_price");
            double minPriceValue = min_price.getValue();
            System.out.println("minPriceValue:"+minPriceValue);

            Avg avg_price = aggregations1.get("avg_price");
            double avgPriceValue = avg_price.getValue();
            System.out.println("avgPriceValue:"+avgPriceValue);

            Sum sum_price = aggregations1.get("sum_price");
            double sumPriceValue = sum_price.getValue();
            System.out.println("sumPriceValue:"+sumPriceValue);

            System.out.println("=================================");
        }
    }

    // #需求四:按照售价每2000价格划分范围,算出每个区间的销售总额 histogram
    @Test
    public void testAggsAndHistogram() throws IOException {
        // GET /tvs/_search
        // {
        //     "size" : 0,
        //     "aggs":{
        //      "by_histogram":{
        //         "histogram":{
        //             "field": "price",
        //             "interval": 2000
        //         },
        //         "aggs":{
        //             "income": {
        //                 "sum": {
        //                     "field" : "price"
        //                 }
        //             }
        //         }
        //     }
        // }
        // }

        //1 构建请求
        SearchRequest searchRequest=new SearchRequest("tvs");

        //请求体
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        searchSourceBuilder.size(0);
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        HistogramAggregationBuilder histogramAggregationBuilder = AggregationBuilders.histogram("by_histogram").field("price").interval(2000);

        SumAggregationBuilder sumAggregationBuilder = AggregationBuilders.sum("income").field("price");
        histogramAggregationBuilder.subAggregation(sumAggregationBuilder);
        searchSourceBuilder.aggregation(histogramAggregationBuilder);

        //请求体放入请求头
        searchRequest.source(searchSourceBuilder);

        //2 执行
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3 获取结果
        // {
        //     "key" : 0.0,
        //     "doc_count" : 3,
        //      income" : {
        //          "value" : 3700.0
        //       }
        // }
        Aggregations aggregations = searchResponse.getAggregations();
        Histogram group_by_color = aggregations.get("by_histogram");
        List<? extends Histogram.Bucket> buckets = group_by_color.getBuckets();
        for (Histogram.Bucket bucket : buckets) {
            String keyAsString = bucket.getKeyAsString();
            System.out.println("keyAsString:"+keyAsString);
            long docCount = bucket.getDocCount();
            System.out.println("docCount:"+docCount);

            Aggregations aggregations1 = bucket.getAggregations();
            Sum income = aggregations1.get("income");
            double value = income.getValue();
            System.out.println("value:"+value);

            System.out.println("=================================");

        }
    }

    // #需求五:计算每个季度的销售总额
    @Test
    public void testAggsAndDateHistogram() throws IOException {
        // GET /tvs/_search
        // {
        //     "size" : 0,
        //     "aggs": {
        //     "sales": {
        //         "date_histogram": {
        //                      "field": "sold_date",
        //                     "interval": "quarter",
        //                     "format": "yyyy-MM-dd",
        //                     "min_doc_count" : 0,
        //                     "extended_bounds" : {
        //                         "min" : "2019-01-01",
        //                         "max" : "2020-12-31"
        //             }
        //         },
        //         "aggs": {
        //             "income": {
        //                 "sum": {
        //                     "field": "price"
        //                 }
        //             }
        //         }
        //     }
        // }
        // }

        //1 构建请求
        SearchRequest searchRequest=new SearchRequest("tvs");

        //请求体
        SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
        searchSourceBuilder.size(0);
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        DateHistogramAggregationBuilder dateHistogramAggregationBuilder = AggregationBuilders.dateHistogram("date_histogram").field("sold_date").calendarInterval(DateHistogramInterval.QUARTER)
                .format("yyyy-MM-dd").minDocCount(0).extendedBounds(new ExtendedBounds("2019-01-01", "2020-12-31"));
        SumAggregationBuilder sumAggregationBuilder = AggregationBuilders.sum("income").field("price");
        dateHistogramAggregationBuilder.subAggregation(sumAggregationBuilder);

        searchSourceBuilder.aggregation(dateHistogramAggregationBuilder);
        //请求体放入请求头
        searchRequest.source(searchSourceBuilder);

        //2 执行
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3 获取结果
        // {
        //     "key_as_string" : "2019-01-01",
        //      "key" : 1546300800000,
        //      "doc_count" : 0,
        //      "income" : {
        //         "value" : 0.0
        //      }
        // }
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedDateHistogram date_histogram = aggregations.get("date_histogram");
        List<? extends Histogram.Bucket> buckets = date_histogram.getBuckets();
        for (Histogram.Bucket bucket : buckets) {
            String keyAsString = bucket.getKeyAsString();
            System.out.println("keyAsString:"+keyAsString);
            long docCount = bucket.getDocCount();
            System.out.println("docCount:"+docCount);

            Aggregations aggregations1 = bucket.getAggregations();
            Sum income = aggregations1.get("income");
            double value = income.getValue();
            System.out.println("value:"+value);

            System.out.println("====================");
        }

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421

第十九章 es7 sql新特性

#一、快速入门

format:显示方式的形式

POST /_sql?format=txt
{
    "query": "SELECT * FROM tvs "
}
  • 1
  • 2
  • 3
  • 4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1O3iieth-1681790773252)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221231155212305.png)]

复杂sql也是这样写:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-32Qf0E6k-1681790773253)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221231155320422.png)]

#二、启动方式

1、http 请求

2、客户端:elasticsearch-sql-cli.bat

3、代码

四、sql 翻译

translate:es底层如何将该sql转换成dsl的解释出来:

POST /_sql/translate
{
    "query": "SELECT * FROM tvs "
}
  • 1
  • 2
  • 3
  • 4

返回:

{
  "size" : 1000,
  "_source" : false,
  "stored_fields" : "_none_",
  "docvalue_fields" : [
    {
      "field" : "brand"
    },
    {
      "field" : "color"
    },
    {
      "field" : "price"
    },
    {
      "field" : "sold_date",
      "format" : "epoch_millis"
    }
  ],
  "sort" : [
    {
      "_doc" : {
        "order" : "asc"
      }
    }
  ]
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

#五、与其他DSL结合

POST /_sql?format=txt
{
    "query": "SELECT * FROM tvs",
    "filter": {
        "range": {
            "price": {
                "gte" : 1200,
                "lte" : 2000
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

#六、 java 代码实现sql功能

1、前提 es拥有白金版功能

kibana中管理-》许可管理 开启白金版试用

2、导入依赖

    <dependency>
        <groupId>org.elasticsearch.plugin</groupId>
        <artifactId>x-pack-sql-jdbc</artifactId>
        <version>7.3.0</version>
    </dependency>
    
    <repositories>
        <repository>
            <id>elastic.co</id>
        <url>https://artifacts.elastic.co/maven</url>
        </repository>
    </repositories>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3、代码

public class TestEsSql {
    public static void main(String[] args) {
        //1.创建连接
        try {
            Connection connection = DriverManager.getConnection("jdbc:es://http://localhost:9200");
            //2.创建statement
            Statement statement = connection.createStatement();
            //3.执行sql
            ResultSet resultSet = statement.executeQuery("select * from tvs");
            //4.获取结果
            while(resultSet.next()){
                System.out.println(resultSet.getString(1));
                System.out.println(resultSet.getString(2));
                System.out.println(resultSet.getString(3));
                System.out.println(resultSet.getString(4));
                System.out.println("===================================");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

大型企业可以购买白金版,增加Machine Learning、高级安全性x-pack。

第二十章 Logstash学习

#一、Logstash基本语法组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b8vkI9v0-1681790782023)(null)]

#1、什么是Logstash

logstash是一个数据抽取工具,将数据从一个地方转移到另一个地方。如hadoop生态圈的sqoop等。下载地址:https://www.elastic.co/cn/downloads/logstash

logstash之所以功能强大和流行,还与其丰富的过滤器插件是分不开的,过滤器提供的并不单单是过滤的功能,还可以对进入过滤器的原始数据进行复杂的逻辑处理,甚至添加独特的事件到后续流程中。 Logstash配置文件有如下三部分组成,其中input、output部分是必须配置,filter部分是可选配置,而filter就是过滤器插件,可以在这部分实现各种日志过滤功能。

#2、配置文件:
input {
    #输入插件
}
filter {
    #过滤匹配插件
}
output {
    #输出插件
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
#3、启动操作:

-e数据从哪儿来,到哪儿去

input:数据从哪里来

stdin:从控制台来

output:数据到哪里去

stdout:从控制台输出

logstash.bat -e "input{stdin{}} output{stdout{}}"
  • 1

为了好维护,将配置写入文件test1.coinf,启动

logstash.bat -f ../config/test1.conf
  • 1

#二、Logstash输入插件(input)

https://www.elastic.co/guide/en/logstash/current/input-plugins.html

#1、标准输入(Stdin)

我们再test1.conf内写入配置规定输入输出:

input{
    stdin{
       
    }
}
output {
    stdout{
        codec=>rubydebug    
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
#2、读取文件(File)

logstash使用一个名为filewatch的ruby gem库来监听文件变化,并通过一个叫.sincedb的数据库文件来记录被监听的日志文件的读取进度(时间戳),这个sincedb数据文件的默认路径在 <path.data>/plugins/inputs/file下面,文件名类似于.sincedb_123456,而<path.data>表示logstash插件存储目录,默认是LOGSTASH_HOME/data。

input {
    file {
        path => ["/var/*/*"]
        start_position => "beginning"
    }
}
output {
    stdout{
        codec=>rubydebug    
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

默认情况下,logstash会从文件的结束位置开始读取数据,也就是说logstash进程会以类似tail -f命令的形式逐行获取数据。

#3、读取TCP网络数据
input {
  tcp {
    port => "1234"
  }
}

filter {
  grok {
    match => { "message" => "%{SYSLOGLINE}" }
  }
}

output {
    stdout{
        codec=>rubydebug
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

三、Logstash过滤器插件(Filter)

https://www.elastic.co/guide/en/logstash/current/filter-plugins.html

#1、Grok 正则捕获

grok是一个十分强大的logstash filter插件,他可以通过正则解析任意文本,将非结构化日志数据弄成结构化和方便查询的结构。他是目前logstash 中解析非结构化日志数据最好的方式。

Grok 的语法规则是:

%{语法: 语义}
  • 1

例如输入的内容为:

172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
  • 1

%{IP:clientip}匹配模式将获得的结果为:clientip: 172.16.213.132 %{HTTPDATE:timestamp}匹配模式将获得的结果为:timestamp: 07/Feb/2018:16:24:19 +0800 而%{QS:referrer}匹配模式将获得的结果为:referrer: “GET / HTTP/1.1”

下面是一个组合匹配模式,它可以获取上面输入的所有内容:

%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}
  • 1

通过上面这个组合匹配模式,我们将输入的内容分成了五个部分,即五个字段,将输入内容分割为不同的数据字段,这对于日后解析和查询日志数据非常有用,这正是使用grok的目的。

例子:

input{
    stdin{}
}
filter{
    grok{
        match => ["message","%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}"]
    }
}
output{
    stdout{
        codec => "rubydebug"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

输入内容:

172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
  • 1
#2、时间处理(Date)

date插件是对于排序事件和回填旧数据尤其重要,它可以用来转换日志记录中的时间字段,变成LogStash::Timestamp对象,然后转存到@timestamp字段里,这在之前已经做过简单的介绍。 下面是date插件的一个配置示例(这里仅仅列出filter部分):

filter {
    grok {
        match => ["message", "%{HTTPDATE:timestamp}"]
    }
    date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#3、数据修改(Mutate)
#(1)正则表达式替换匹配字段

gsub可以通过正则表达式替换字段中匹配到的值,只对字符串字段有效,下面是一个关于mutate插件中gsub的示例(仅列出filter部分):

filter {
    mutate {
        gsub => ["filed_name_1", "/" , "_"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将filed_name_1字段中所有"/“字符替换为”_"。

#(2)分隔符分割字符串为数组

split可以通过指定的分隔符分割字段中的字符串为数组,下面是一个关于mutate插件中split的示例(仅列出filter部分):

filter {
    mutate {
        split => ["filed_name_2", "|"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将filed_name_2字段以"|"为区间分隔为数组。

#(3)重命名字段

rename可以实现重命名某个字段的功能,下面是一个关于mutate插件中rename的示例(仅列出filter部分):

filter {
    mutate {
        rename => { "old_field" => "new_field" }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将字段old_field重命名为new_field。

#(4)删除字段

remove_field可以实现删除某个字段的功能,下面是一个关于mutate插件中remove_field的示例(仅列出filter部分):

filter {
    mutate {
        remove_field  =>  ["timestamp"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将字段timestamp删除。

#(5)GeoIP 地址查询归类
filter {
    geoip {
        source => "ip_field"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
#综合例子:
input {
    stdin {}
}
filter {
    grok {
        match => { "message" => "%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}" }
        remove_field => [ "message" ]
   }
date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
mutate {
          convert => [ "response","float" ]
           rename => { "response" => "response_new" }   
           gsub => ["referrer","\"",""]          
           split => ["clientip", "."]
        }
}
output {
    stdout {
        codec => "rubydebug"
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

#四、Logstash输出插件(output)

https://www.elastic.co/guide/en/logstash/current/output-plugins.html

output是Logstash的最后阶段,一个事件可以经过多个输出,而一旦所有输出处理完成,整个事件就执行完成。 一些常用的输出包括:

  • file: 表示将日志数据写入磁盘上的文件。
  • elasticsearch:表示将日志数据发送给Elasticsearch。Elasticsearch可以高效方便和易于查询的保存数据。

1、输出到标准输出(stdout)

output {
    stdout {
        codec => rubydebug
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

2、保存为文件(file)

output {
    file {
        path => "/data/log/%{+yyyy-MM-dd}/%{host}_%{+HH}.log"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

3、输出到elasticsearch

output {
    elasticsearch {
        host => ["192.168.1.1:9200","172.16.213.77:9200"]
        index => "logstash-%{+YYYY.MM.dd}"       
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • host:是一个数组类型的值,后面跟的值是elasticsearch节点的地址与端口,默认端口是9200。可添加多个地址。
  • index:写入elasticsearch的索引的名称,这里可以使用变量。Logstash提供了%{+YYYY.MM.dd}这种写法。在语法解析的时候,看到以+ 号开头的,就会自动认为后面是时间格式,尝试用时间格式来解析后续字符串。这种以天为单位分割的写法,可以很容易的删除老的数据或者搜索指定时间范围内的数据。此外,注意索引名中不能有大写字母。
  • manage_template:用来设置是否开启logstash自动管理模板功能,如果设置为false将关闭自动管理模板功能。如果我们自定义了模板,那么应该设置为false。
  • template_name:这个配置项用来设置在Elasticsearch中模板的名称。

#五、综合案例

input {
    file {
        path => ["D:/ES/logstash-7.3.0/nginx.log"]        
        start_position => "beginning"
    }
}

filter {
    grok {
        match => { "message" => "%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}" }
        remove_field => [ "message" ]
   }
	date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
	mutate {
           rename => { "response" => "response_new" }
           convert => [ "response","float" ]
           gsub => ["referrer","\"",""]
           remove_field => ["timestamp"]
           split => ["clientip", "."]
        }
}

output {
    stdout {
        codec => "rubydebug"
    }

elasticsearch {
    host => ["localhost:9200"]
    index => "logstash-%{+YYYY.MM.dd}"       
}

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

#第二十一章 kibana学习

#一、基本查询

1、是什么:elk中数据展现工具。

2、下载:https://www.elastic.co/cn/downloads/kibana

3、使用:建立索引模式,index partten

discover 中使用DSL搜索。

#二、可视化

绘制图形
/www.ydlclass.com/doc21xnv/distribute/elk/elk2.html#二、logstash输入插件-input)二、Logstash输入插件(input)

https://www.elastic.co/guide/en/logstash/current/input-plugins.html

#1、标准输入(Stdin)

我们再test1.conf内写入配置规定输入输出:

input{
    stdin{
       
    }
}
output {
    stdout{
        codec=>rubydebug    
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
#2、读取文件(File)

logstash使用一个名为filewatch的ruby gem库来监听文件变化,并通过一个叫.sincedb的数据库文件来记录被监听的日志文件的读取进度(时间戳),这个sincedb数据文件的默认路径在 <path.data>/plugins/inputs/file下面,文件名类似于.sincedb_123456,而<path.data>表示logstash插件存储目录,默认是LOGSTASH_HOME/data。

input {
    file {
        path => ["/var/*/*"]
        start_position => "beginning"
    }
}
output {
    stdout{
        codec=>rubydebug    
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

默认情况下,logstash会从文件的结束位置开始读取数据,也就是说logstash进程会以类似tail -f命令的形式逐行获取数据。

#3、读取TCP网络数据
input {
  tcp {
    port => "1234"
  }
}

filter {
  grok {
    match => { "message" => "%{SYSLOGLINE}" }
  }
}

output {
    stdout{
        codec=>rubydebug
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

三、Logstash过滤器插件(Filter)

https://www.elastic.co/guide/en/logstash/current/filter-plugins.html

#1、Grok 正则捕获

grok是一个十分强大的logstash filter插件,他可以通过正则解析任意文本,将非结构化日志数据弄成结构化和方便查询的结构。他是目前logstash 中解析非结构化日志数据最好的方式。

Grok 的语法规则是:

%{语法: 语义}
  • 1

例如输入的内容为:

172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
  • 1

%{IP:clientip}匹配模式将获得的结果为:clientip: 172.16.213.132 %{HTTPDATE:timestamp}匹配模式将获得的结果为:timestamp: 07/Feb/2018:16:24:19 +0800 而%{QS:referrer}匹配模式将获得的结果为:referrer: “GET / HTTP/1.1”

下面是一个组合匹配模式,它可以获取上面输入的所有内容:

%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}
  • 1

通过上面这个组合匹配模式,我们将输入的内容分成了五个部分,即五个字段,将输入内容分割为不同的数据字段,这对于日后解析和查询日志数据非常有用,这正是使用grok的目的。

例子:

input{
    stdin{}
}
filter{
    grok{
        match => ["message","%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}"]
    }
}
output{
    stdout{
        codec => "rubydebug"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

输入内容:

172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
  • 1
#2、时间处理(Date)

date插件是对于排序事件和回填旧数据尤其重要,它可以用来转换日志记录中的时间字段,变成LogStash::Timestamp对象,然后转存到@timestamp字段里,这在之前已经做过简单的介绍。 下面是date插件的一个配置示例(这里仅仅列出filter部分):

filter {
    grok {
        match => ["message", "%{HTTPDATE:timestamp}"]
    }
    date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#3、数据修改(Mutate)
#(1)正则表达式替换匹配字段

gsub可以通过正则表达式替换字段中匹配到的值,只对字符串字段有效,下面是一个关于mutate插件中gsub的示例(仅列出filter部分):

filter {
    mutate {
        gsub => ["filed_name_1", "/" , "_"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将filed_name_1字段中所有"/“字符替换为”_"。

#(2)分隔符分割字符串为数组

split可以通过指定的分隔符分割字段中的字符串为数组,下面是一个关于mutate插件中split的示例(仅列出filter部分):

filter {
    mutate {
        split => ["filed_name_2", "|"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将filed_name_2字段以"|"为区间分隔为数组。

#(3)重命名字段

rename可以实现重命名某个字段的功能,下面是一个关于mutate插件中rename的示例(仅列出filter部分):

filter {
    mutate {
        rename => { "old_field" => "new_field" }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将字段old_field重命名为new_field。

#(4)删除字段

remove_field可以实现删除某个字段的功能,下面是一个关于mutate插件中remove_field的示例(仅列出filter部分):

filter {
    mutate {
        remove_field  =>  ["timestamp"]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

这个示例表示将字段timestamp删除。

#(5)GeoIP 地址查询归类
filter {
    geoip {
        source => "ip_field"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
#综合例子:
input {
    stdin {}
}
filter {
    grok {
        match => { "message" => "%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}" }
        remove_field => [ "message" ]
   }
date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
mutate {
          convert => [ "response","float" ]
           rename => { "response" => "response_new" }   
           gsub => ["referrer","\"",""]          
           split => ["clientip", "."]
        }
}
output {
    stdout {
        codec => "rubydebug"
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

#四、Logstash输出插件(output)

https://www.elastic.co/guide/en/logstash/current/output-plugins.html

output是Logstash的最后阶段,一个事件可以经过多个输出,而一旦所有输出处理完成,整个事件就执行完成。 一些常用的输出包括:

  • file: 表示将日志数据写入磁盘上的文件。
  • elasticsearch:表示将日志数据发送给Elasticsearch。Elasticsearch可以高效方便和易于查询的保存数据。

1、输出到标准输出(stdout)

output {
    stdout {
        codec => rubydebug
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

2、保存为文件(file)

output {
    file {
        path => "/data/log/%{+yyyy-MM-dd}/%{host}_%{+HH}.log"
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5

3、输出到elasticsearch

output {
    elasticsearch {
        host => ["192.168.1.1:9200","172.16.213.77:9200"]
        index => "logstash-%{+YYYY.MM.dd}"       
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • host:是一个数组类型的值,后面跟的值是elasticsearch节点的地址与端口,默认端口是9200。可添加多个地址。
  • index:写入elasticsearch的索引的名称,这里可以使用变量。Logstash提供了%{+YYYY.MM.dd}这种写法。在语法解析的时候,看到以+ 号开头的,就会自动认为后面是时间格式,尝试用时间格式来解析后续字符串。这种以天为单位分割的写法,可以很容易的删除老的数据或者搜索指定时间范围内的数据。此外,注意索引名中不能有大写字母。
  • manage_template:用来设置是否开启logstash自动管理模板功能,如果设置为false将关闭自动管理模板功能。如果我们自定义了模板,那么应该设置为false。
  • template_name:这个配置项用来设置在Elasticsearch中模板的名称。

#五、综合案例

input {
    file {
        path => ["D:/ES/logstash-7.3.0/nginx.log"]        
        start_position => "beginning"
    }
}

filter {
    grok {
        match => { "message" => "%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}" }
        remove_field => [ "message" ]
   }
	date {
        match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
    }
	mutate {
           rename => { "response" => "response_new" }
           convert => [ "response","float" ]
           gsub => ["referrer","\"",""]
           remove_field => ["timestamp"]
           split => ["clientip", "."]
        }
}

output {
    stdout {
        codec => "rubydebug"
    }

elasticsearch {
    host => ["localhost:9200"]
    index => "logstash-%{+YYYY.MM.dd}"       
}

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

#第二十一章 kibana学习

#一、基本查询

1、是什么:elk中数据展现工具。

2、下载:https://www.elastic.co/cn/downloads/kibana

3、使用:建立索引模式,index partten

discover 中使用DSL搜索。

#二、可视化

绘制图形

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/blog/article/detail/45961
推荐阅读
相关标签
  

闽ICP备14008679号