赞
踩
ELK是用于**数据抽取(Logstash)、搜索分析(Elasticsearch)、数据展现(Kibana)**的一整套解决方案,所以也称作ELK 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查询订单、人员、部门,电商网站内部搜索商品(淘宝、京东)场景。
问题出现:
l 存储问题。电商网站商品上亿条时,涉及到单表数据过大必须拆分表,数据库磁盘占用过大必须分库(mycat)。
l 性能问题:解决上面问题后,查询“笔记本电脑”等关键词时,上亿条数据的商品名字段逐行扫描,性能跟不上。
l 不能分词。如搜索“笔记本电脑”,只能搜索完全和关键词一样的数据,那么数据量小时,搜索“笔记电脑”,“电脑”数据要不要给用户。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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拿到所有与哪吒相关的数据。
这样解决了数据磁盘占用过大(将一个数据特别大的表,通过倒排索引拆分成一个精简的表,通过匹配度高的词进行全文检索),性能损耗过大,效率低的问题以及不能分词:用户搜索如搜索“笔记电脑”,“电脑”的数据也会给用户。
就是一个jar包,里面封装了全文检索的引擎、搜索的算法代码。开发时,引入lucene的jar包,通过api开发搜索相关业务。底层会在磁盘建立索引库。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pG7rB9WO-1681790776508)(null)]
官网:https://www.elastic.co/cn/products/elasticsearch
已知我们单个服务器(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还拥有高级搜索功能(比如:分组,聚合)。
搜索:互联网搜索、电商网站站内搜索、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只需秒级即可查询海量数据,所以叫近实时。秒级
两方面:
包含一个或多个启动着es实例的机器群。通常一台机器起一个es实例。同一网络下,集群名一样的多个es实例自动组成集群,自动均衡分片等行为。默认集群名为“elasticsearch”。
每个es实例称为一个节点。节点名自动分配,也可以手动配置。一个节点有多个主分片和副本
包含一堆有相似结构的文档数据。
索引创建规则:
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"
}
就像数据库中的列(Columns),定义每个document应该有的字段。
每个索引里都可以有一个或多个type,type是index中的一个逻辑数据分类,一个type下的document,都有相同的field。
注意:6.0之前的版本有type(类型)概念,type相当于关系数据库的表,ES官方将在ES9.0版本中彻底删除type。本教程typy都为_doc。
index数据过大时,将index里面的数据,分为多个shard,分布式的存储在各个服务器上面。可以支持海量数据和高并发,提升性能和吞吐量,充分利用多台机器的cpu。
在分布式环境下,任何一台机器都会随时宕机,如果宕机,index的一个分片没有,导致此index不能搜索。所以,为了保证数据的安全,我们会将每个index的分片经行备份,存储在另外的机器上。保证少数机器宕机es集群仍可以搜索。
能正常提供查询和插入的分片我们叫做主分片(primary shard),其余的我们就管他们叫做备份的分片(replica shard)。
es6默认新建索引时,5分片,2副本,也就是一主一备,共10个分片。所以,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,更加提高了吞吐量。
关系型数据库(比如Mysql) | 非关系型数据库(Elasticsearch) |
---|---|
数据库Database | 索引Index |
表Table | 索引Index(原为Type) |
数据行Row | 文档Document |
数据列Column | 字段Field |
约束 Schema | 映射Mapping |
安装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: /.*/
在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主分片不可用,集群不可用。
在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)]
集群状态(搜索速率、索引速率等
安装后,在该文件目录下打开黑窗口,运行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)]
(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)]
打开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状态的,部分索引有数据丢失
GET /_cat/indices?v
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S0dM9BsX-1681790773235)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224182530888.png)]
如下图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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的索引
先创建一个图书的索引:
PUT /book
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJ57kr4W-1681790773236)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224183534907.png)]
往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"]
}
运行显示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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"]
}
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"]
}
查询图书,检索文档:
查询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)]
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", "开发"]
}
可以看到,运行后对result显示了更新内容:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OF4ii6OY-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224190612748.png)]
但是这个是全局替换,需要带上所有的信息才能替换
我们要修改文档中,且只修改name这一个属性的内容:
POST /book/_doc/1/_update
因为_doc马上要被系统删除不用了,所以使用下面的格式:
POST /book/_doc/1/_update
{
"doc": {
"name": " Bootstrap开发教程高级666"
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)]
删除id为1的文档数据
DELETE /book/_doc/1
场景:数据从其他系统导入时,本身有唯一主键。如数据库中的图书、员工信息等。
用法:put /index/_doc/id
PUT /test_index/_doc/1
{
"test_field": "test"
}
用法:POST /index/_doc
POST /test_index/_doc
{
"test_field": "test1"
}
如下,es自动生成了id的串儿:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dFkULEfw-1681790773237)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224194814838.png)]
含义:插入数据时的所有字段和值。在get获取数据时,在_source字段中原样返回。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BnEy4tRw-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224200333053.png)]
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)]
PUT /test_index/_doc/1
{
"test_field": "test"
}
执行语句新增数据后,会后一个version为1,再执行该语句,version为2,执行两次,返回结果中版本号(_version)在不断上升。此过程为全量替换。先前的数据为一个待删除的数据,实质:旧文档的内容不会立即删除,只是标记为deleted。适当的时机,集群会将这些文档删除。
为防止覆盖原有数据,我们在新增时,设置为强制创建,不会覆盖原有文档。
语法: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", "开发"]
}
执行后,我们再执行该语句报错说该数据已经存在,不能覆盖,不能重复。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpsPhZJj-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224203430384.png)]
DELETE /book/id
DELETE /book/_doc/id
DELETE /book/_doc/1/
实质:旧文档的内容不会立即删除,只是标记为deleted。适当的时机,集群会将这些文档删除。
使用 PUT /index/type/id 为文档全量替换,需要将文档所有数据提交。
partial update局部替换则只修改变动字段。
用法:
post /index/type/id/_update
{
"doc": {
"field":"value"
}
}
内部与全量替换是一样的,旧文档标记为删除,新建一个文档。
优点:
批量增语法:POST /_bulk
其他的以此类推。
POST /_bulk
{"action": {"metadata"}}
{"data"}
es可以内置脚本执行复杂操作
修改文档6的num字段,+1。
插入数据
PUT /test_index/_doc/6
{
"num": 0,
}
执行脚本操作(ctx:上下文,_source:文档6的source中的内容num+1)
POST /test_index/_doc/6/_update
{
"script" : "ctx._source.num+=1"
}
搜索所有文档,将num字段乘以2输出
插入数据
PUT /test_index/_doc/7
{
"num": 5
}
查询
GET /test_index/_search
{
"script_fields": {
"my_doubled_field": {
"script": {
"lang": "expression",
"source": "doc['num'] * multiplier",
"params": {
"multiplier": 2
}
}
}
}
}
返回
{
"_index" : "test_index",
"_type" : "_doc",
"_id" : "7",
"_score" : 1.0,
"fields" : {
"my_doubled_field" : [
10.0
]
}
}
如同商品秒杀,多线程情况下,es同样会出现并发冲突问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i1lUNFI7-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224213124651.png)]
解决es并发问题:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9tcyq1AC-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221224221026145.png)]
我们启动es,kebana后
导入以来:
<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>
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()); } }
输出显示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rlFqfFvw-1681790773238)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225102214406.png)]
引入依赖:
<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>
配置springboot配置文件:
spring:
application:
name: service-search
heima:
elasticsearch:
hostlist: 127.0.0.1:9200 #多个结点中间用逗号分隔
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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"
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)); } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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()); } }
运行后:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6rHtH1TV-1681790773239)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225113047952.png)]
在构建请求时,设置请求我们想要的参数
@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()); } }
运行后,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)]
@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); } } }
运行后:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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 {
}
@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 }
我们查询时可以同步,异步操作,同理新增数据也会有这些操作,同步操作:上述操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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
我们这里使用同步操作,获取结果后进行一些判断:
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:
//手动维护版本号:
request.version(3);
request.versionType(VersionType.EXTERNAL);
我们对该索引下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);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vm3EiFoF-1681790773240)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225151113612.png)]
主要使用局部更新
对id为3的数据的doc内容的user修改:
POST /test_post/_doc/3/_update
{
"doc": {
"user": "tomas Jj"
}
}
我们通过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); } }
运行后显示:值被修改:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)]
DELETE /test_posts/_doc/3
@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);
}
@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; } } }
运行后出现了新增两个数据的信息:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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被修改
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z77iz5kH-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225163609969.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3wL0A5R5-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225174911244.png)]
垂直扩容:使用更加强大的服务器替代老服务器。但单机存储及运算能力有上线。且成本直线上升。如10t服务器1万。单个10T服务器可能20万。
水平扩容:采购更多服务器,加入集群。大数据。
新增或减少es实例时,es集群会将数据重新分配。
功能:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yerF0NXq-1681790773241)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225182848741.png)]
(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放在同一个节点上
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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分片都可以读,且速度有提升
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ogGuKKw-1681790773242)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221225190206179.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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节点为例介绍。
一个文档,最终会落在主分片的一个分片上,到底应该在哪一个分片?这就是数据路由。
shard = hash(routing) % number_of_primary_shards
如下图分片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。
routing的key值设定为num
PUT /test_index/_doc/15?routing=num
{
"num": 0,
"tags": []
}
场景:在程序中,架构师可以手动指定已有数据的一个属性为路由值,好处是可以定制一类文档数据存储到一个分片中。缺点是设计不好,会造成数据倾斜,造成数据分布不均匀。
所以,不同文档尽量放到不同的索引中。剩下的事情交给es集群自己处理。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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就都有了
.
概念:自动或手动为index中的_doc建立的一种数据结构和相关配置,简称为mapping映射。
就是相当于数据库建表时对各个字段的类型确定。
动态映射:dynamic mapping,自动为我们建立index,以及对应的mapping,mapping中包含了每个field对应的数据类型,以及如何分词等设置。
重点:我们当然,后面会讲解,也可以手动在创建数据之前,先创建index,以及对应的mapping
查询mapping:
GET /website/_mapping/
显示出:
{ "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 } } } } } } }
插入三个数据:
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 }
查询:
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 条结果
2019-01-01,exact value,搜索的时候,必须输入2019-01-01,才能搜索出来
如果你输入一个01,是搜索不出来的
select * from book where name= ‘java’
搜“笔记电脑”,笔记本电脑词条会不会出现。
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,自然语义处理
作用:切分词语,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 停用词: 了 的 呢。
一个分词器,很重要,将一段文本进行各种处理,最后处理好的结果才会拿去建立倒排索引。
例句: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必须以和index建立时相同的analyzer进行分词
query string对exact value和full text的区别对待
如: date:exact value 精确匹配
text: full text 全文检索
GET /_analyze
{
"analyzer": "standard",
"text": "Text to analyze 80"
}
返回值:
{ "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 } ] }
token 实际存储的term 关键字
position 在此词条在原文本中的位置
start_offset/end_offset字符在原始字符串中的位置
(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进行设置,包括数据类型,包括索引行为,包括分词器,等
GET /_mapping
查看索引website的映射信息:将各个字段的信息展示
GET /website/_mapping/
创建索引后,应该立即手动创建映射
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)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中已经有一份原始文档了。
目前已经取代了"index": false。上边介绍的text文本字段在映射时要设置分词器,keyword字段为关键字字段,通常搜索keyword是按照整体搜索,所以创建keyword字段的索引时是不进行分词的,比如:邮政编码、手机号码、身份证等。keyword字段通常用于过虑、排序、聚合等
设置pic为不可分词
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnbh05KK-1681790773243)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226135055702.png)]
日期类型不用设置分词器。
通常日期类型的字段用于排序。
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
},
由于比例因子为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
}
只能创建index时手动建立mapping,或者新增field mapping,但是不能update field mapping。
因为已有数据按照映射早已分词存储好。如果修改,那这些存量数据怎么办。
新增一个字段mapping
PUT /book/_mapping/
{
"properties" : {
"new_field" : {
"type" : "text",
"index": "false"
}
}
}
如果修改mapping,会报错
PUT /book/_mapping/
{
"properties" : {
"studymodel" : {
"type" : "keyword"
}
}
}
返回:
{
"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
}
通过删除索引来删除映射。
{ “tags”: [ “tag1”, “tag2” ]},内部的值跟数组一样必须是同一类型。
建立索引时与string是一样的,数据类型不能混
null,[],[null]
PUT /company/_doc/1
{
"address": {
"country": "china",
"province": "guangdong",
"city": "guangzhou"
},
"name": "jack",
"age": 27,
"join_date": "2019-01-01"
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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 } } } } } } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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"
}
底层存储格式
{
"name": [jack],
"age": [27],
"join_date": [2017-01-01],
"address.country": [china],
"address.province": [guangdong],
"address.city": [guangzhou]
}
对象数组:
{
"authors": [
{ "age": 26, "name": "Jack White"},
{ "age": 55, "name": "Tom Jones"},
{ "age": 39, "name": "Kitty Smith"}
]
}
存储格式:
{
"authors.age": [26, 55, 39],
"authors.name": [jack, white, tom, jones, kitty, smith]
}
直接put数据 PUT index/_doc/1,es会自动生成索引,并建立动态映射dynamic mapping。
在生产上,我们需要自己手动建立索引和映射,为了更好地管理索引。就像数据库的建表语句一样。
创建索引的语法
PUT /index
{
//放置索引的分片数
"settings": { ... any settings ... },
//映射
"mappings": {
"properties" : {
"field1" : { "type" : "text" }
}
},
//别名
"aliases": {
"default_index": {}
}
}
举例:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)]
GET /my_index/_mapping
GET /my_index/_setting
修改副本数
PUT /my_index/_settings
{
"index" : {
"number_of_replicas" : 2
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)]
DELETE /my_index
DELETE /index_one,index_two
DELETE /index_*
DELETE /_all
为了安全起见,防止恶意删除索引,删除时必须指定索引名:
elasticsearch.yml
action.destructive_requires_name: true
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_" } } } } }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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"
}
显示出 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"
}
运行后,分词器只分了句子的关键词,连接词那些都忽略掉
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9y7YW9jw-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226161737205.png)]
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"] } } } } }
测试:
GET /my_index/_analyze
{
"analyzer": "my_analyzer",
"text": "tom&jerry are a friend in the house, <a>, HAHA!!"
}
运行后显示:语句都按照策略被修改,显示出
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ocMaRkdQ-1681790773245)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226162631482.png)]
type,是一个index中用来区分类似的数据的,类似的数据,但是可能有不同的fields,而且有不同的属性来控制索引建立、分词器. field的value,在底层的lucene中建立索引的时候,全部是opaque bytes类型,不区分类型的。 lucene是没有type的概念的,在document中,实际上将type作为一个document的field来存储,即_type,es通过_type来进行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" } } } } } }
PUT /goods/electronic_goods/1
{
"name": "小米空调",
"price": 1999.0,
"service_period": "one year"
}
PUT /goods/fresh_goods/1
{
"name": "澳洲龙虾",
"price": 199.0,
"eat_period": "one week"
}
es文档在底层的存储是这样子的
{ "goods": { "mappings": { "_type": { "type": "string", "index": "false" }, "name": { "type": "string" } "price": { "type": "double" } "service_period": { "type": "string" }, "eat_period": { "type": "string" } } } }
底层数据存储格式
{
"_type": "electronic_goods",
"name": "小米空调",
"price": 1999.0,
"service_period": "one year",
"eat_period": ""
}
{
"_type": "fresh_goods",
"name": "澳洲龙虾",
"price": 199.0,
"service_period": "",
"eat_period": "one week"
}
同一索引下,不同type的数据存储其他type的field 大量空值,造成资源浪费。
所以,不同类型数据,要放到不同的索引中。
es9中,将会彻底删除type。
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 } } } }
测试:
我们插入一条数据:
PUT /my_index/_doc/1
{
"title": "my article",
"content": "this is my article",
"address": {
"province": "guangdong",
"city": "guangzhou"
}
}
随后我们查询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" } } } }
插入数据,
PUT /my_index/_doc/1
{
"title": "my article",
"content": "this is my article",
"address": {
"province": "guangdong",
"city": "guangzhou"
}
}
因为有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
}
默认会按照一定格式识别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" } } } }
测试:
PUT /my_index/_doc/1
{
"title": "my article",
"content": "this is my article",
"address": {
"province": "guangdong",
"city": "guangzhou"
},
"post_date":"2019-09-10"
}
查看映射显示:
GET /my_index/_mapping
发现并没有将时间转换为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"]
}
}
插入数据
PUT my_index/_doc/1
{
"create_date": "09/25/2019"
}
查看显示:自动映射为日期类型了
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IKXdVpxR-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226175412495.png)]
虽然json支持本机浮点和整数数据类型,但某些应用程序或语言有时可能将数字呈现为字符串。通常正确的解决方案是显式地映射这些字段,但是可以启用数字检测(默认情况下禁用)来自动完成这些操作。
PUT my_index
{
"mappings": {
"numeric_detection": true
}
}
插入数据
PUT my_index/_doc/1
{
"my_float": "1.0",
"my_integer": "1"
}
查看映射显示:将字段的数据都自动转为为对应类型,而不是text类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wAsJLFMC-1681790773246)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221226175717444.png)]
PUT /my_index { "mappings": { "dynamic_templates": [ { "en": { //匹配en结尾的字段 "match": "*_en", //匹配到后这个属性是string后就映射下面的mapping "match_mapping_type": "string", "mapping": { "type": "text", "analyzer": "english" } } } ] } }
插入数据
PUT /my_index/_doc/1
{
"title": "this is my first article"
}
运行后查看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"
}
运行后查看两个数据都能查到显示出:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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 } } } } } ] } }
模板参数
"match": "long_*",
"unmatch": "*_text",
"match_mapping_type": "string",
"path_match": "name.*",
"path_unmatch": "*.middle",
"match_pattern": "regex",
"match": "^profit_\d+$"
1结构化搜索
默认情况下,elasticsearch将字符串字段映射为带有子关键字字段的文本字段。但是,如果只对结构化内容进行索引,而对全文搜索不感兴趣,则可以仅将“字段”映射为“关键字”。请注意,这意味着为了搜索这些字段,必须搜索索引所用的完全相同的值。
如下。匹配的类型如果刚好为string,那么字段就会变成keyword类型,keyword类型作为关键字不会分词
该字段不会全文索引,但是关键字可以被查到
{
"strings_as_keywords": {
"match_mapping_type": "string",
"mapping": {
"type": "keyword"
}
}
}
2仅搜索,与上述情况相反:
与前面的示例相反,如果您只关心字符串字段的全文搜索,并且不打算对字符串字段运行聚合、排序或精确搜索,您可以告诉弹性搜索将其仅映射为文本字段(这是5之前的默认行为)
{
"strings_as_text": {
"match_mapping_type": "string",
"mapping": {
"type": "text"
}
}
}
3norms 不关心评分
norms是指标时间的评分因素,比如匹配度高的有限匹配这种。如果您不关心评分,例如,如果您从不按评分对文档进行排序,则可以在索引中禁用这些评分因子的存储并节省一些空间。
{ "strings_as_keywords": { "match_mapping_type": "string", "mapping": { "type": "text", //norms设置为false就不会计算评分, "norms": false, "fields": { "keyword": { "type": "keyword", "ignore_above": 256 } } } } }
我们创建的一个索引后,如果该索引的数据类型不符合要求,就需要修改索引,那么就只能新建一个索引。然后哦把旧数据放到新索引中,之后客户端查询数据都会去新索引查询。但是再操作的这个过程中需要停机(客户端不去读旧索引,读新索引的这段空档)
演示:第一天和第二天插入数据
PUT /my_index/_doc/1
{
"title": "2019-09-10"
}
PUT /my_index/_doc/2
{
"title": "2019-09-11"
}
此时我们在第三天的数据插入时进行修改时报错不能修改:因为如果一个字段为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"
}
}
}
此时,唯一的办法,就是进行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
新建一个index,调整其title的类型为string
PUT /my_index_new
{
"mappings": {
"properties": {
"title": {
"type": "text"
}
}
}
}
使用scroll api将数据批量查询出来
GET /my_index/_search?scroll=1m
{
"query": {
"match_all": {}
},
"size": 1
}
返回
{ "_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 ] } ] } }
采用bulk api将scoll查出来的一批数据,批量写入新索引(这里将id为1的数据写入新索引)
POST /_bulk
{ "index": { "_index": "my_index_new", "_id": "1" }}
{ "title": "2019-09-10" }
反复循环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" }}
]
}
直接通过prod_index别名来查询,是否ok
查询id为1的能查到
GET /prod_index/1
PUT /my_index_v1/_alias/my_index
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" }}
]
}
ik_max_word: 会将文本做最细粒度的拆分,比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民大会堂,人民大会,大会堂”,会穷尽各种可能的组合;
ik_smart: 会做最粗粒度的拆分,比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国,人民大会堂”。
存储时,使用ik_max_word(将一些词存入,直接从存储的词拿到),搜索时,使用ik_smart(按照分词方式分开存入倒排索引进行搜索,将匹配度高的选用)
PUT /my_index
{
"mappings": {
"properties": {
"text": {
"type": "text",
//分词策略
"analyzer": "ik_max_word",
//搜索时分词策略
"search_analyzer": "ik_smart"
}
}
}
}
搜索
GET /my_index/_search?q=中华人民共和国人民大会堂
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
PUT /my_index { "settings": { "number_of_shards": 1, "number_of_replicas": 1 }, "mappings": { "properties": { "field1":{ "type": "text" }, "field2":{ "type": "text" } } }, "aliases": { "default_index": {} } }
@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); }
上面是同步方式,同理也可以异步操作:
//异步新增索引 @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(); } }
//删除索引库
@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);
}
@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(); } }
@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);
}
索引还存在,类似作为一个备份,只是搜索时不会去使用这个索引:
@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);
}
我们能查询到该数据,但是给这个数据插入数据时报错,说索引关闭错误。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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);
}
get请求一般没有请求体,参数直接带上的
post有请求体,参数放到请求体内
已知插入三条数据:
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"] }
无条件搜索所有
GET /book/_search
{ "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" ] } } ] } }
解释
took:耗费了几毫秒
timed_out:是否超时,这里是没有
_shards:到几个分片搜索,成功几个,跳过几个,失败几个。
hits.total:查询结果的数量,3个document
hits.max_score:score的含义,就是document对于一个search的相关度的匹配分数,越相关,就越匹配,分数也高
hits.hits:包含了匹配搜索的document的所有详细数据
与http请求传参类似
查询价格并且按照降序显示:
GET /book/_search?q=name:java&sort=price:desc&timeout=10ms
类比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 ] } ] } }
GET /book/_search?timeout=10ms
全局设置:配置文件中设置 search.default_search_timeout:100ms。默认不超时。
告诉你如何一次性搜索多个index和多个type下的数据
/_search:所有索引下的所有数据都搜索出来
/index1/_search:指定一个index,搜索其下所有的数据
/index1,index2/_search:同时搜索两个index下的数据
/index*/_search:按照通配符去匹配多个索引
应用场景:生产环境log索引可以按照日期分开。
log_to_es_*
log_to_es_20190910
log_to_es_20190911
log_to_es_20180910
搜索原理初步图解
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gal2Thxc-1681790773247)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221228114933831.png)]
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
根据相关度评分倒排序,所以分页过深,协调节点会将大量数据聚合分析。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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)]
1消耗网络带宽,因为所搜过深的话,各 shard 要把数据传递给 coordinate node,这个过程是有大量数据传递的,消耗网络。
2消耗内存,各 shard 要把数据传送给 coordinate node,这个传递回来的数据,是被 coordinate node 保存在内存中的,这样会大量消耗内存。
3消耗cup,coordinate node 要把传回来的数据进行排序,这个排序过程很消耗cpu。 所以:鉴于deep paging的性能问题,所有应尽量减少使用
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的语法,还有一个是掌握+和-的含义
GET /book/_search?q=java
直接可以搜索所有的field,任意一个field包含指定的关键字就可以搜索出来。我们在进行中搜索的时候,难道是对document中的每一个field都进行一次搜索吗?不是的。
es中_all元数据。建立索引的时候,插入一条docunment,es会将所有的field值经行全量分词,把这些分词,放到_all field中。在搜索的时候,没有指定field,就在_all搜索。
举例
{
name:jack
email:123@qq.com
address:beijing
}
_all : jack,123@qq.com,beijing
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": {} }
}
排序 GET /book/_search?sort=price:desc
GET /book/_search
{
"query" : {
"match" : {
"name" : " java"
}
},
"sort": [
{ "price": "desc" }
]
}
分页查询 GET /book/_search?size=10&from=0
GET /book/_search
{
"query": { "match_all": {} },
"from": 0,
"size": 10
}
指定返回字段 GET /book/ _search? _source=name,studymodel
GET /book/_search
{
"query": { "match_all": {} },
"_source": ["name", "studymodel"]
}
通过组合以上各种类型查询,实现复杂查询。
{
QUERY_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}
{
QUERY_NAME: {
FIELD_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}
}
GET /test_index/_search
{
"query": {
"match": {
"test_field": "test"
}
}
}
搜索需求: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 }
搜索:
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 } } ] } } }
返回:
{ "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 } } ] } }
更复杂的搜索需求:
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 } } }
重新创建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 } } } }
插入数据
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"] }
搜索decription有java程序员的数据
GET /book/_search
{
"query" : {
"match" : {
"description" : "java程序员"
}
}
}
{ "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、建立索引时, description字段 term倒排索引
java 2,3
程序员 3
2、搜索时,直接找description中含有java的文档 2,3,并且3号文档含有两个java字段,一个程序员,所以得分高,排在前面。2号文档含有一个java,排在后面
拿到所有数据:
GET /book/_search
{
"query": {
"match_all": {}
}
}
GET /book/_search
{
"query": {
"match": {
"description": "java程序员"
}
}
}
多条件查询java程序员,在name和description字段中有的都查出来:
select * from book like “%java%” or like “%程序员%” or like “%java程序员%”
GET /book/_search
{
"query": {
"multi_match": {
"query": "java程序员",
"fields": ["name", "description"]
}
}
}
查询价格大于80小于90的数据:
GET /book/_search
{
"query": {
"range": {
"price": {
"gte": 80,
"lte": 90
}
}
}
}
字段为keyword时,存储和搜索都不分词
GET /book/_search
{
"query": {
//表示查询description中就有一个单个的分词为:java程序员
"term": {
"description": "java程序员"
}
}
}
查询在tag字段下,只要有search,full_next,nosql的分词的都要显示出来。
GET /book/_search
{
"query": { "terms": { "tag": [ "search", "full_text", "nosql" ] }}
}
查询有join_date字段的
GET /book/_search
{
"query": {
"exists": {
"field": "join_date"
}
}
}
返回包含与搜索词类似的词的文档,该词由Levenshtein编辑距离度量。
包括以下几种情况:
如下:已知book有java字样的数据,查询时输错了也可以检索到:
GET /book/_search
{
"query": {
"fuzzy": {
"description": {
"value": "jave"
}
}
}
}
查book索引中id为1,4,100的文档数据
GET /book/_search
{
"query": {
"ids" : {
"values" : ["1", "4", "100"]
}
}
}
在倒排索引内前缀有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"
}
}
}
}
GET /book/_search
{
"query": {
"regexp": {
//查询时查倒排索引表内description中j开头a结尾的数据
"description": {
"value": "j.*a"
}
}
}
}
需求:用户查询description中有"java程序员",并且价格大于80小于90的数据。
GET /book/_search { "query": { "bool": { "must": [ { "match": { "description": "java程序员" } }, { "range": { "price": { "gte": 80, "lte": 90 } } } ] } } }
使用filter:
GET /book/_search { "query": { "bool": { "must": [ { "match": { "description": "java程序员" } } ], "filter": { "range": { "price": { "gte": 80, "lte": 90 } } } } } }
filter,仅仅只是按照搜索条件查询的结果过滤出需要的数据而已,不计算任何相关度分数,对相关度没有任何影响。
query,会去计算每个document相对于搜索条件的相关度,并按照相关度进行排序。
应用场景:
一般来说,如果你是在进行搜索,需要将最匹配搜索条件的数据先返回,那么用query 如果你只是要根据一些条件筛选出一部分数据,不关注其排序,那么用filter
filter,不需要计算相关度分数,不需要按照相关度分数进行排序,同时还有内置的自动cache最常使用filter的数据
query,相反,要计算相关度分数,按照分数进行排序,而且无法cache结果
验证错误语句:查看写的dsl是否成功
GET /book/_validate/query?explain
{
"query": {
"mach": {
"description": "java程序员"
}
}
}
返回:
{
"valid" : false,
"error" : "org.elasticsearch.common.ParsingException: no [query] registered for [mach]"
}
正确
GET /book/_validate/query?explain
{
"query": {
"match": {
"description": "java程序员"
}
}
}
返回
{
"_shards" : {
"total" : 1,
"successful" : 1,
"failed" : 0
},
"valid" : true,
"explanations" : [
{
"index" : "book",
"valid" : true,
"explanation" : "description:java description:程序员"
}
]
}
一般用在那种特别复杂庞大的搜索下,比如你一下子写了上百行的搜索,这个时候可以先用validate api去验证一下,搜索是否合法。
合法以后,explain就像mysql的执行计划,可以看到搜索的目标等信息
默认情况下,是按照_score降序排序的
然而,某些情况下,可能没有有用的_score,比如说filter
GET book/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"description": "java程序员"
}
}
]
}
}
}
当然,也可以是constant_score
相当于sql中order by ?sort=sprice:desc
GET /book/_search { "query": { "constant_score": { "filter" : { "term" : { "studymodel" : "201001" } } } }, "sort": [ { "price": { "order": "desc" } } ] }
如果对一个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)]
场景:下载某一个索引中1亿条数据,放到文件或是数据库。
不能一下全查出来,系统内存溢出。所以使用scoll滚动搜索技术,一批一批查询。
scoll搜索会在第一次搜索的时候,保存一个当时的视图快照,之后只会基于该旧的视图快照提供数据搜索,如果这个期间数据变更,是不会让用户看到的
每次发送scroll请求,我们还需要指定一个scoll参数,指定一个时间窗口,每次搜索请求只要在这个时间窗口内能完成就可以了。
搜索
1m:一分钟,
//指定一分钟内将book所以的数据查出
//分批,一次查3条数据
GET /book/_search?scroll=1m
{
"query": {
"match_all": {}
},
"size": 3
}
返回
{ "_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" : [ ] } }
获得的结果会有一个scoll_id,下一次再发送scoll请求的时候,必须带上这个scoll_id
GET /_search/scroll
{
"scroll": "1m",
"scroll_id" : "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAMOkWTURBNDUtcjZTVUdKMFp5cXloVElOQQ=="
}
与分页区别:
分页给用户看的 deep paging
scroll是用户系统内部操作,如下载批量数据,数据转移。零停机改变索引映射,然后再使用scroll分批查询。
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("=========================="); } } }
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”}
GET /book/_search?explain=true
{
"query": {
"match": {
"description": "java程序员"
}
}
}
返回
{ "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" : [ ] } ] } ] } ] } ] } } ] } }
GET /book/_explain/3
{
"query": {
"match": {
"description": "java程序员"
}
}
}
搜索的时候,要依靠倒排索引;排序的时候,需要依靠正排索引,看到每个document的每个field,然后进行排序,所谓的正排索引,其实就是doc values
在建立索引的时候,一方面会建立倒排索引,以供搜索用;一方面会建立正排索引,也就是doc values,以供排序,聚合,过滤等操作使用
doc values是被保存在磁盘上的,此时如果内存足够,os会自动将其缓存在内存中,性能还是会很高;如果内存不足够,os会将其写入磁盘上
倒排索引
doc1: hello world you and me
doc2: hi, world, how are you
term | doc1 | doc2 |
---|---|---|
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 }
document | name | age |
---|---|---|
doc1 | jack | 27 |
doc2 | tom | 30 |
(1)搜索请求发送到某一个coordinate node,构构建一个priority queue,长度以paging操作from和size为准,默认为10
(2)coordinate node将请求转发到所有shard,每个shard本地搜索,并构建一个本地的priority queue
(3)各个shard将自己的priority queue返回给coordinate node,并构建一个全局的priority queue
一次请求要打到所有shard的一个replica/primary上去,如果每个shard都有多个replica,那么同时并发过来的搜索请求可以同时打到其他的replica上去
(1)coordinate node构建完priority queue之后,就发送mget请求去所有shard上获取对应的document
(2)各个shard将document返回给coordinate node
(3)coordinate node将合并后的document结果返回给client客户端
决定了哪些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了
已经讲解过原理了,主要就是限定在一定时间内,将部分获取到的数据直接返回,避免查询耗时过长
document文档路由,_id路由,routing=user_id,这样的话可以让同一个user对应的数据到一个shard上去
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"] }
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" }
}
}
}
运行后:如果报错:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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
}
}
}
最后再聚合查询studymodel的数量,由下可知:studymodel有2001001有两个,2001002有一个
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Q54tRv5-1681790773250)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229182304070.png)]
跟上述情况相同,设置字段"fielddata": true
PUT /book/_mapping/
{
"properties": {
"tags": {
"type": "text",
"fielddata": true
}
}
}
查询
GET /book/_search
{
"size": 0,
"query": {
"match_all": {}
},
"aggs": {
"group_by_tags": {
"terms": { "field": "tags" }
}
}
}
运行后:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6TbNPUC-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229182534915.png)]
将description为java程序员的数据聚合统计tags字段内的数据
GET /book/_search
{
"size": 0,
"query": {
"match": {
"description": "java程序员"
}
},
"aggs": {
"group_by_tags": {
"terms": { "field": "tags" }
}
}
}
运行后显示出:tags字段内各个key的数量进行统计:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QOXY0bgP-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229183715184.png)]
GET /book/_search { "size": 0, "aggs" : { "group_by_tags" : { "terms" : { "field" : "tags" }, #再次聚合 "aggs" : { "avg_price" : { "avg" : { "field" : "price" } } } } } }
运行后:算出tags的key各个数据拥有的数量,且算出各个数据的平均价格
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55OB16Or-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229185406838.png)]
GET /book/_search { "size": 0, "aggs" : { "group_by_tags" : { "terms" : { "field" : "tags", //在group by分组后按照价格降序排序 "order": { "avg_price": "desc" } }, "aggs" : { "avg_price" : { "avg" : { "field" : "price" } } } } } }
运行后:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCp2jbwD-1681790773251)(C:\Users\陈刚\AppData\Roaming\Typora\typora-user-images\image-20221229195625813.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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" } } } } } } } }
city name 北京 张三 北京 李四 天津 王五 天津 赵六
天津 王麻子
划分出来两个bucket,一个是北京bucket,一个是天津bucket 北京bucket:包含了2个人,张三,李四 上海bucket:包含了3个人,王五,赵六,王麻子
metric,就是对一个bucket执行的某种聚合分析的操作,比如说求平均值,求最大值,求最小值
select count(*) from book group studymodel
bucket:group by studymodel --> 那些studymodel相同的数据,就会被划分到一个bucket中 metric:count(*),对每个user_id bucket中所有的数据,计算一个数量。还有avg(),sum(),max(),min()
创建索引及映射
PUT /tvs PUT /tvs/_mapping { "properties": { "price": { "type": "long" }, "color": { "type": "keyword" }, "brand": { "type": "keyword" }, "sold_date": { "type": "date" } } }
批量插入数据:
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" }
查询条件解析
size:只获取聚合结果,而不要执行聚合的原始数据
aggs:固定语法,要对一份数据执行分组聚合操作
popular_colors:就是对每个aggs,都要起一个名字,
terms:根据字段的值进行分组
field:根据指定的字段的值进行分组
GET /tvs/_search
{
"size": 0,
"aggs": {
"popular_color": {
"terms": {
"field": "color"
}
}
}
}
运行后显示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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降序排序
GET /tvs/_search { "size" : 0, "aggs": { "colors": { "terms": { "field": "color" }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } } }
在一个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
每个颜色下平均价格及每个颜色下每个平抛的平均价格:
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" } } } } } } }
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" } } } } } }
求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" } } } } } }
histogram:类似于terms,也是进行bucket分组操作,接收一个field,按照这个field的值的各个范围区间,进行bucket分组操作
"histogram":{
"field": "price",
"interval": 2000
}
interval:2000,划分范围,02000,20004000,40006000,60008000,8000~10000,buckets
bucket有了之后,一样的,去对每个bucket执行avg,count,sum,max,min,等各种metric操作,聚合分析
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" } } } } }
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" } } } } } }
搜索与聚合可以结合起来。
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" } } }
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" } } } } } }
搜索+聚合
过滤+聚合
GET /tvs/_search { "size": 0, "query": { "constant_score": { "filter": { "range": { "price": { "gte": 1200 } } } } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } }
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" } } } } } }
aggs.filter,针对的是聚合去做的
如果放query里面的filter,是全局的,会对所有的数据都有影响
但是,如果,比如说,你要统计,长虹电视,最近1个月的平均值; 最近3个月的平均值; 最近6个月的平均值
bucket filter:对不同的bucket下的aggs,进行filter
GET /tvs/_search { "size": 0, "aggs": { "group_by_color": { "terms": { "field": "color", "order": { "avg_price": "asc" } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } } }
相当于sql子表数据字段可以立刻使用。
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" } } } } } } } }
简单聚合,多种聚合,详见代码。
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("===================="); } } }
format:显示方式的形式
POST /_sql?format=txt
{
"query": "SELECT * FROM tvs "
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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、代码
translate:es底层如何将该sql转换成dsl的解释出来:
POST /_sql/translate
{
"query": "SELECT * FROM tvs "
}
返回:
{ "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" } } ] }
POST /_sql?format=txt
{
"query": "SELECT * FROM tvs",
"filter": {
"range": {
"price": {
"gte" : 1200,
"lte" : 2000
}
}
}
}
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>
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); } } }
大型企业可以购买白金版,增加Machine Learning、高级安全性x-pack。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b8vkI9v0-1681790782023)(null)]
logstash是一个数据抽取工具,将数据从一个地方转移到另一个地方。如hadoop生态圈的sqoop等。下载地址:https://www.elastic.co/cn/downloads/logstash
logstash之所以功能强大和流行,还与其丰富的过滤器插件是分不开的,过滤器提供的并不单单是过滤的功能,还可以对进入过滤器的原始数据进行复杂的逻辑处理,甚至添加独特的事件到后续流程中。 Logstash配置文件有如下三部分组成,其中input、output部分是必须配置,filter部分是可选配置,而filter就是过滤器插件,可以在这部分实现各种日志过滤功能。
input {
#输入插件
}
filter {
#过滤匹配插件
}
output {
#输出插件
}
-e数据从哪儿来,到哪儿去
input:数据从哪里来
stdin:从控制台来
output:数据到哪里去
stdout:从控制台输出
logstash.bat -e "input{stdin{}} output{stdout{}}"
为了好维护,将配置写入文件test1.coinf,启动
logstash.bat -f ../config/test1.conf
https://www.elastic.co/guide/en/logstash/current/input-plugins.html
我们再test1.conf内写入配置规定输入输出:
input{
stdin{
}
}
output {
stdout{
codec=>rubydebug
}
}
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
}
}
默认情况下,logstash会从文件的结束位置开始读取数据,也就是说logstash进程会以类似tail -f命令的形式逐行获取数据。
input { tcp { port => "1234" } } filter { grok { match => { "message" => "%{SYSLOGLINE}" } } } output { stdout{ codec=>rubydebug } }
https://www.elastic.co/guide/en/logstash/current/filter-plugins.html
grok是一个十分强大的logstash filter插件,他可以通过正则解析任意文本,将非结构化日志数据弄成结构化和方便查询的结构。他是目前logstash 中解析非结构化日志数据最好的方式。
Grok 的语法规则是:
%{语法: 语义}
例如输入的内容为:
172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
%{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}
通过上面这个组合匹配模式,我们将输入的内容分成了五个部分,即五个字段,将输入内容分割为不同的数据字段,这对于日后解析和查询日志数据非常有用,这正是使用grok的目的。
例子:
input{
stdin{}
}
filter{
grok{
match => ["message","%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}"]
}
}
output{
stdout{
codec => "rubydebug"
}
}
输入内容:
172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
date插件是对于排序事件和回填旧数据尤其重要,它可以用来转换日志记录中的时间字段,变成LogStash::Timestamp对象,然后转存到@timestamp字段里,这在之前已经做过简单的介绍。 下面是date插件的一个配置示例(这里仅仅列出filter部分):
filter {
grok {
match => ["message", "%{HTTPDATE:timestamp}"]
}
date {
match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
}
}
gsub可以通过正则表达式替换字段中匹配到的值,只对字符串字段有效,下面是一个关于mutate插件中gsub的示例(仅列出filter部分):
filter {
mutate {
gsub => ["filed_name_1", "/" , "_"]
}
}
这个示例表示将filed_name_1字段中所有"/“字符替换为”_"。
split可以通过指定的分隔符分割字段中的字符串为数组,下面是一个关于mutate插件中split的示例(仅列出filter部分):
filter {
mutate {
split => ["filed_name_2", "|"]
}
}
这个示例表示将filed_name_2字段以"|"为区间分隔为数组。
rename可以实现重命名某个字段的功能,下面是一个关于mutate插件中rename的示例(仅列出filter部分):
filter {
mutate {
rename => { "old_field" => "new_field" }
}
}
这个示例表示将字段old_field重命名为new_field。
remove_field可以实现删除某个字段的功能,下面是一个关于mutate插件中remove_field的示例(仅列出filter部分):
filter {
mutate {
remove_field => ["timestamp"]
}
}
这个示例表示将字段timestamp删除。
filter {
geoip {
source => "ip_field"
}
}
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" }
https://www.elastic.co/guide/en/logstash/current/output-plugins.html
output是Logstash的最后阶段,一个事件可以经过多个输出,而一旦所有输出处理完成,整个事件就执行完成。 一些常用的输出包括:
1、输出到标准输出(stdout)
output {
stdout {
codec => rubydebug
}
}
2、保存为文件(file)
output {
file {
path => "/data/log/%{+yyyy-MM-dd}/%{host}_%{+HH}.log"
}
}
3、输出到elasticsearch
output {
elasticsearch {
host => ["192.168.1.1:9200","172.16.213.77:9200"]
index => "logstash-%{+YYYY.MM.dd}"
}
}
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、是什么: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
我们再test1.conf内写入配置规定输入输出:
input{
stdin{
}
}
output {
stdout{
codec=>rubydebug
}
}
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
}
}
默认情况下,logstash会从文件的结束位置开始读取数据,也就是说logstash进程会以类似tail -f命令的形式逐行获取数据。
input { tcp { port => "1234" } } filter { grok { match => { "message" => "%{SYSLOGLINE}" } } } output { stdout{ codec=>rubydebug } }
https://www.elastic.co/guide/en/logstash/current/filter-plugins.html
grok是一个十分强大的logstash filter插件,他可以通过正则解析任意文本,将非结构化日志数据弄成结构化和方便查询的结构。他是目前logstash 中解析非结构化日志数据最好的方式。
Grok 的语法规则是:
%{语法: 语义}
例如输入的内容为:
172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
%{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}
通过上面这个组合匹配模式,我们将输入的内容分成了五个部分,即五个字段,将输入内容分割为不同的数据字段,这对于日后解析和查询日志数据非常有用,这正是使用grok的目的。
例子:
input{
stdin{}
}
filter{
grok{
match => ["message","%{IP:clientip}\ \[%{HTTPDATE:timestamp}\]\ %{QS:referrer}\ %{NUMBER:response}\ %{NUMBER:bytes}"]
}
}
output{
stdout{
codec => "rubydebug"
}
}
输入内容:
172.16.213.132 [07/Feb/2019:16:24:19 +0800] "GET / HTTP/1.1" 403 5039
date插件是对于排序事件和回填旧数据尤其重要,它可以用来转换日志记录中的时间字段,变成LogStash::Timestamp对象,然后转存到@timestamp字段里,这在之前已经做过简单的介绍。 下面是date插件的一个配置示例(这里仅仅列出filter部分):
filter {
grok {
match => ["message", "%{HTTPDATE:timestamp}"]
}
date {
match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
}
}
gsub可以通过正则表达式替换字段中匹配到的值,只对字符串字段有效,下面是一个关于mutate插件中gsub的示例(仅列出filter部分):
filter {
mutate {
gsub => ["filed_name_1", "/" , "_"]
}
}
这个示例表示将filed_name_1字段中所有"/“字符替换为”_"。
split可以通过指定的分隔符分割字段中的字符串为数组,下面是一个关于mutate插件中split的示例(仅列出filter部分):
filter {
mutate {
split => ["filed_name_2", "|"]
}
}
这个示例表示将filed_name_2字段以"|"为区间分隔为数组。
rename可以实现重命名某个字段的功能,下面是一个关于mutate插件中rename的示例(仅列出filter部分):
filter {
mutate {
rename => { "old_field" => "new_field" }
}
}
这个示例表示将字段old_field重命名为new_field。
remove_field可以实现删除某个字段的功能,下面是一个关于mutate插件中remove_field的示例(仅列出filter部分):
filter {
mutate {
remove_field => ["timestamp"]
}
}
这个示例表示将字段timestamp删除。
filter {
geoip {
source => "ip_field"
}
}
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" }
https://www.elastic.co/guide/en/logstash/current/output-plugins.html
output是Logstash的最后阶段,一个事件可以经过多个输出,而一旦所有输出处理完成,整个事件就执行完成。 一些常用的输出包括:
1、输出到标准输出(stdout)
output {
stdout {
codec => rubydebug
}
}
2、保存为文件(file)
output {
file {
path => "/data/log/%{+yyyy-MM-dd}/%{host}_%{+HH}.log"
}
}
3、输出到elasticsearch
output {
elasticsearch {
host => ["192.168.1.1:9200","172.16.213.77:9200"]
index => "logstash-%{+YYYY.MM.dd}"
}
}
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、是什么:elk中数据展现工具。
2、下载:https://www.elastic.co/cn/downloads/kibana
3、使用:建立索引模式,index partten
discover 中使用DSL搜索。
绘制图形
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
赞
踩
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。