目录
1.前言
ElasticSearch是一个实时分布式搜索和分析引擎。它让你以前所未有的速度处理大数据成为可能。它用于全文搜索、结构化搜索、分析以及将这三者混合使用:
总之,可以对搜索关键字高亮显示,可以对搜索结果纠错,提供建议。并且ELK是大数据必会的技术。
2.聊聊Doug Cutting
1998年9月4日,Google公司在美国硅谷城里,正如大家所知,它是一家做搜索引擎起家的公司。
一个名叫Doug Cutting 的美国工程师,迷上了搜索引擎。他做了一个用于文本搜索的函数库,命名为Lucene. Lucene。
Lucene是一套信息检索工具包,并不包含搜索引擎系统,它包含了索引结构、读写索引工具、相关性工具、排序等功能。因此在使用Lucenen时仍需关注搜索引擎系统,例如数据获取、解析、分词等方面的东西。
Lucene. Lucene是用java写的,目标是为各种中小型应用软件加入全文搜索功能。
该项目早期被发布在Doug Cutting的个人网站,后来成为了Apache软件基金会jakarta项目的一个子项目。
2004年,在Lucene的基础上和apache开源伙伴Mike Cafarella合作,开发了一款可以代替当时的主流搜索的开源搜索引擎,命名为Nutch.
Nutch 是一个建立在Lucene核心之上的网页搜索应用程序,它在Lucene的基础上加了爬虫和一些网页相关的功能,目的就是从一个简单的站内检索推广到全球网络上的搜索上。
随着时间的推移,作为互联网搜索引擎,都面临对象“体积”不断增大的问题。需要存储大量的网页,并不断优化自己的搜索算法,提升搜索效率。
2003年,Google发表的一篇技术论文,公开介绍了谷歌文件系统GFS(Google File Systeam)这时Google成为了存储海量搜索数据而设计的专用文件系统。
2004年,Doug Cutting基于Google的GFS论文,实现了分布式文件存储系统,并命名为NDFS(Nutch Distributed File System)
还是2004年,Google又发飙了一篇论文,介绍自己的MapReduce编程模型,这个编程模型,用于大规模数据集(1TB)的并行分析运算。
2005年,Doug Cutting又基于MapReduce,在Nutch搜索引擎实现了该功能。
2006年,Yahoo(雅虎)公司,招安了Doug Cutting
加盟Yahoo之后,Doug Cutting将NDFS和MapReduce进行了升级改造,并命名为Hadoop (NDFS也改名为HDFS,Hadoop Distributed File System)。
这就是大名鼎鼎的大数据框架系统–Hadoop的由来,而Doug Cutting则被人称为Hadoop之父
Hadoop这个名字其实是Doug Cutting他儿子的黄色玩具大象的名字,所以Hadoop就是一只奔跑的黄色大象
2026年,Google又发表了论文,这次,他们介绍了自己的BigTable ,这是一种分布式数据存储系统,一种用来处理海量数据的非关系型数据库。
Doug Cutting当然没有放过,在自己的hadoop系统里面,引入了BigTable,并命名为HBase。
所以Hadoop的核心部分,基本都有Google的影子
2008年1月,Hadoop成功尚未,正式成为Apache基金会的竞技项目。
同年2月,Yahoo宣布建成了一个拥有1万个内核的Hadoop集群,并将自己的搜索引擎产品部署在上面。
7月,Hadoop打破世界纪录,称为最快排序1TB数据的系统,用时209秒。
Lucene和ElasticSearche的关系
ElasticSearche是基于Lucene做了一些封装和增强
3.ElasticSearche概述
ElasticSearch,简称es,es是一个开源的高拓展的分布式全文检索引擎,它可以近乎实时的存储、检索数据;本身扩展性很好,可以扩展到上百台服务器,处理PB级别的数据。es也使用java开发并使用Lucene 作为其核心来实现所有索引和搜索的功能,但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单。
在2016年1月,ElasticSearche已经超越了Solr,成为了排名第一的搜索引擎类应用。
历史
多年前,一个叫做Shay Banon的刚结婚不久的失业开发者,由于妻子要去伦敦学习厨师,他遍跟着去了。他在找工作的过程中,为了给妻子构造一个食谱的搜索引擎,他开始构建一个早期版本的Lucehe。
直接基于Lucehe工作会比较困难,所以Shay开始抽象Lucene代码以便java程序员可以在应用中添加搜索功能,,他发布了她第一个开源项目,叫做Copass。
后来Shay找到一份工作,这份工作处在高性能和内存数据网格的分布式环境中,因此高性能、实时的、分布式的搜索引擎也是理所当然需要的,然后他决定重写Compass库,使其成为一个独立的服务叫做Elasticearch。
第一个公开版本出现在2010年2月,在哪之后Elasticsearch已经称为Github上最欢迎的项目之一,代码贡献者超过300人,一家主营Elasticsearch的公司就此成立,他们一边提供商业支持一边开发新功能,不过Elasticsearch将永远开源且对所有人可使用
谁在使用:
- 维基百科,类似百度百科,全文检索,高亮,搜索推荐
- 国外新闻网站,类似搜狐新闻,用户行为日志(点击,浏览,收藏,评论)+社交网络数据,数据分析。。。
- Stack Overflow国外的程序异常讨论论坛
- GitHub(开源代码管理),搜索上千亿行代码
- 电商网站,检索商品
- 日志数据分析,logstash采集日志,ES进行复杂的数据分析,ELK技术(elasticsearch+logstash+kibana)
- 商品价格监控网站
- 商业智能系统
- 站内搜索
4.es与solr的差别
ElasticSearch简介
ElasticSearch是一个实施分布式搜索和分析引擎。它让你以前所未有的速度处理大数据成为可能。它用于全文搜索、结构化搜索、分析以及将这三者混合使用:
维基百科使用es提供全文搜索并高亮关键字,以及输入实施搜索和搜索纠错等搜索建议功能;
英国公报使用es结合用户日志和社交网络数据提供给他们的编辑以实施的反馈,以便了解龚总对新发表的文章的回应。
es是一个基于Apache Lucene(TM)的开源搜索引擎。无论在开源还是专有领域,Lucene可以被认为是迄今为止最先进、性能最好、功能最全的搜索引擎库。
但是, Lucene只是以个库。 想要使用它,你必须使用Java来作为开发语言并将其直接集成到你的应用中, 更糟糕的是, Lucene非常复杂,你需要深入了解检索的相关知识来理解它是如何工作的。
Elasticsearch也使用ava开发并使用Lucene作为其核心来实现所有索引和搜索的功能,但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单。
solr简介
Solr是Apache下的一个顶级开源项目,采用java开发,是基于Lucene的全文搜索服务器。Solr提供了比Lucene更为丰富的查询语言,同时实现了可配置、可扩展、并对索引、搜索性能进行了优化。
Solr可以独立运行,运行在Jetty、Tomcat等这些Servlet容器中 , Solr索弓|的实现方法很简单,用POST方法向Solr服务器发送一个描述Field及其内容的XML文档, Solr根据xml文档添加、删除、更新索引。Solr 搜索只需要发送HTTP GET请求,然后对Solr返回Xml、json等格式的查询结果进行解析,组织页面布局。Solr不提供构建UI的功能, Solr提供了一个管理界面,通过管理界面可以查询SoIr的配置和运行情况。
solr是基于lucene开发企业级搜索服务器,实际上就是封装了lucene.
它可以独立运行,是一个独立的企业及搜索应用服务器,它对外提供类似于web-service的API接口。用户可以通过http请求,像搜索引擎服务器提交一定格式的文件,生成索引;也可以通过提出查找请求,并得到返回结果。
Lucene简介
Lucene是apache软件基金会4 jakarta项目组的一个子项目, 是-个开放源代码的全 文检索引擎工具包,但它不是一 -个完整的全文检索引擎,而是一个全文检索弓|擎的架构,提供了完整的查询引擎和索引引擎,部分文本分析引擎(英文与德文两种西方语言)。
Lucene的目的是为软件开发人员提供一一个简单 易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索弓|擎。Lucene是一 套用于全文检索和搜寻的开源程式库,由Apache软件基金会支持和提供。Lucene提供 了一个简单却强大的应用程式接口,能够做全文索引和搜寻。在Java开发环境里Lucene是一 个成熟的免费开源工具。 就其本身而言,Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库。工人们经常提到信息检索程序库,虽然与搜索引擎有关,但不应该将信息检索程序库与搜索引|擎相混淆。
Lucene是一个全文检索引|擎的架构。那什么是全文搜索弓|擎?
全文搜索引擎是名副其实的搜索引|擎,国外具代表性的有Google、Fast/AlITheWeb. AltaVista、 Inktomi、 Teoma、 WiseNut等 ,国内著名的有百度( Baidu)。它们都是通过从互联网上提取的各个网站的信息(以网页文字为主)而建立的数据库中,检索与用户查询条件匹配的相关记录,然后按一定的排列顺序将结果返回给用户,因此他们是真正的搜索引擎。
从搜索结果来源的角度,全文搜索引|擎又可细分为两种, - -种是拥有自己的检索程序( Indexer) , 俗称"蜘蛛”( Spider )程序或"机器人”( Robot )程序,并自建网页数据库,搜索结果直接从自身的数据库中调用,如上面提到的7家引擎;另-种则是租用其他引擎的数据库,并按自定的格式排列搜索结果,如Lycos引擎。
两者比较
- 当单纯的对已有数据进行搜索时,Solr更快
- 当实时建立索引时,Solr会产生io阻塞,查询性能较差,ElasticSearch具有明显的优势
- 随着数据量的增加,Solr的搜索效率会变得更低,而Elasticsearch却没有明显的变化
总结
- es基本是开箱即用,非常简单。而solr会有点复杂。
- Solr利用Zookeeper进行分布式管理,而elasticsearch自身带有分布式协调管理功能
- solr支持更多格式的数据,比如json xml csv。而es只支持json文件格式
- solr官方提供的功能更多,而elasticsearch更注重核心功能,高级功能由第三方插件提供
- solr查询快,但更新索引时慢(插入删除慢),用于电商等查询多的应用
- es建立索引快,即实时性查询快,用于facebook新浪等搜索
- solr较成熟,有一个更大,更成熟的用户、开发和贡献者社区,而elasticsearch相对开发维护者较少,更新太快,学习使用成本较高
5.Elasticsearch安装
1.elasticsearch以及head的安装与使用
elasticsearch官网:https://www.elastic.co/cn/elasticsearch/
elasticsearch下载:https://mirrors.huaweicloud.com/elasticsearch/?C=N&O=D
注:安装ElasticSearch之前必须保证JDK1.8+安装完毕,并正确的配置好JDK环境变量,否则启动ElasticSearch失败。
windows下载
- 1.下载windows7.6.1版本,解压压缩包,打开,看到如下目录:
- 2.打开config文件夹:
- 3.双击bin目录下的elasticsearch.bat启动
- 4.打开浏览器访问localhost:9200
安装可视化界面 head插件
注意:这里需要nodejs基础,如果没有学过,就去前面先把狂神的vue学习一下
下载地址:https://gitcode.net/mirrors/mobz/elasticsearch-head?utm_source=csdn_github_accelerator
解压后安装依赖,一定要跳转到该解压文件夹下打开cmd输入该命令:
解决跨域问题
由于ES进程和客户端进程端口号不同,存在跨域问题,所以需要在ES的配置文件中配置下解决跨域问题:
在底行添加:
http.cors.enabled: true
http.cors.allow-origin: "*"
启动es,使用head工具进行连接测试:
操作read
- 1.查看elasticsearch信息
- 2.新建索引,初学的话这里的索引就相当于数据库
- 3.数据库的一些数据
这里的head就只做一个可视化工具,具体的elasticearch操作在kibana操作
2.了解ELK
ELK是Elasticsearch、Logstash、 Kibana三大开源框架首字母大写简称。 市面上也被成为Elastic Stack。其中Elasticsearch是一 个基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。 像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用Elasticsearch作为底层支持框架,可见Elasticsearch提供的搜索能力确实强大,市面上很多时候我们简称Elasticsearch为es。
Logstash是ELK的中央数据流引擎,用于从不同目标(文件/数据存储/MQ )收集的不同格式数据,经过过滤后支持输出到不同目的地(文件/MQ/redis/elasticsearch/kafka等)。Kibana可以将elasticsearch的数据通过友 好的页面展示出来,提供实时分析的功能。
市面上很多开发只要提到ELK能够一致说出它是一个日志分析架构技术栈总称,但实际上ELK不仅仅适用于日志分析,它还可以支持其它任何数据分析和收集的场景,日志分析和收集只是更具有代表性。并非唯一性。
3.安装kibana
Kibana是一个针对ElasticSearch的开源分析及可视化平台,用来搜索、查看交互存储在ElasticSearch索引中的数据。使用Kibana,可以通过各种如表进行高级数据分析及展示。Kibana让海量数据更容易理解。它操作简单,基于浏览器的用户界面可以快速创建仪表板实时显示Elasticsearch查询动态。设置Kibana非常简单。无需编码或者额外的基础构架,几分钟内就可以完成Kibana安装并启动Elasricsearch索引检测。
kibana要和es版本一致
下载:https://mirrors.huaweicloud.com/kibana/?C=N&O=D
- 1.下载然后解压,这里解压会比较久
- 2.启动,打开bin目录下的kibana ,这里必须要先开启ElasticSearch
- 3.复制kibana的网站然后打开
4.汉化,点开config的kibana.yml最后一行修改为zh-cn,然后重启kibana
6.ES核心概念
ElasticSearch是面向文档型的数据库,一条数据在这里就是一个文档。
Relational DB(关系型数据库) | ElasticSearch |
---|---|
数据库(database) | 索引(indices) |
表(tables) | types |
行(rows) | documents |
字段(columns) | fields |
es中可以包含多个索引(数据库),每个索引中可以包含多个类型(表),每个类型下又包含多个文档(行),每个文档又包含多个字段(列)。
elasticsearch是面向文档,关系型数据库和elasticsearch客观的对比!一切都是json
物理设计:
es在后台把每个索引划分成多个分片,每个分片可以在集群中的不同服务器中转移。一个人就是一个集群,默认的集群名字就是elasticsearch
一个索引类型,包含多个文档,当我们索引一篇文档时,可以通过这样的顺序找到他: 索引-》类型-》文档id(该id实际是个字符串),通过这个组合我们就能索引到某个具体的文档。
文档(行)
es是面向文档的,意味着索引和搜索数据的最小单位是文档,es中,文档有几个重要的属性:
- 自我包含,一篇文档同时包含字段和对应的值,也就是同时包含key:value
- 可以是层次性的,一个文档中包含自文档,复杂的逻辑实体就是这么来的。
- 灵活的结构,文档不依赖预先定义的模式,我们知道关系型数据库中,要提前定义字段才能使用,在es中,对于字段是非常灵活的。有时候,我们可以忽略字段,或者动态的添加一个新的字段
尽管我们可以随意的添加或忽略某个字段,但是,每个字段的类型非常重要。因为es会保存字段和类型之间的映射以及其他的设置。这种映射具体到每个映射的每种类型,这也是为什么在es中,类型有时候也称为映射类型。
类型(表)
类型是文档的逻辑容器,就像关系型数据库一样,表格是行的容器。类型中对于字段的定义称为映射,比如name映射为string类型.我们说文档是无模式的,他们不需要拥有映射中所定义的所有字段,当新增加一个字段时,es会自动的将新字段加入映射,但是这个字段不确定他是什么类型,所以最安全的方式是提前定义好所需要的映射。
索引(数据库)
就是数据库!
索引是映射类型的容器, elasticsearch中的索引是一个非常大的文档集合。索引存储了映射类型的字段和其他设置。然后它们被存储到了各个分片上了。我们来研究下分片是如何工作的。
物理设计:分片
节点和分片如何工作
一个集群至少有一 个节点,而一个节点就是一个elasricsearch进程 ,节点可以有多个索引默认的,如果你创建索引,那么索引将会有个5个分片( primary shard ,又称主分片)构成的,每一个主分片会有-一个副本( replica shard ,又称复制分片)
上图是一个有3个节点的集群,可以看到主分片和对应的复制分片都不会在同一个节点内,这样有利于某个节点挂掉了,数据也不至于丢失。实际上, 一个分片是一个Lucene索引, 一个包含倒排索引的文件目录,倒排索引的结构使得elasticsearch在不扫描全部文档的情况下,就能告诉你哪些文档包含特定的关键字。不过,等等,倒排索引是什么鬼?
倒排索引
elasticsearch使用的是一种称为倒排索引的结构,采用Lucene倒排索作为底层。这种结构适用于快速的全文搜索,一个索引由文档中所有不重复的列表构成,对于每一个词,都有一个包含它的文档列表。 例如,现在有两个文档,每个文档包含如下内容:
Study every day, good good up to forever # 文档1包含的内容
To forever, study every day,good good up # 文档2包含的内容
为创建倒排索引,我们首先要将每个文档拆分成独立的词(或称为词条或者tokens) ,然后创建一一个包含所有不重 复的词条的排序列表,然后列出每个词条出现在哪个文档:
term | doc_1 | doc_2 |
---|---|---|
Study | √ | × |
To | × | × |
every | √ | √ |
forever | √ | √ |
day | √ | √ |
study | × | √ |
good | √ | √ |
every | √ | √ |
to | √ | × |
up | √ | √ |
现在,我们试图搜索 to forever,只需要查看包含每个词条的文档
term | doc_1 | doc_2 |
---|---|---|
to | √ | x |
forever | √ | √ |
total | 2 | 1 |
两个文档都匹配,但是第一个文档比第二个匹配程度更高。如果没有别的条件,现在,这两个包含关键字的文档都将返回。
再来看一个示例,比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构:
博客文章(原始数据) | 索引列表(倒排索引) | ||
博客文章ID | 标签 | 标签 | 博客文章ID |
1 | python | python | 1,2,3 |
2 | python | linux | 3,4 |
3 | linux,python | ||
4 | linux |
如果要搜索含有python标签的文章,那相对于查找所有原始数据而言,查找倒排索引后的数据将会快的多。只需要查看标签这一栏,然后获取相关的文章ID即可。完全过滤掉无关的所有数据,提高效率!
elasticsearch的索引和Lucene的索引对比:
在elasticsearch中,索引(库)这个词被频繁使用,这就是术语的使用。在elasticsearch中 ,索引被分为多个分片,每份分片是-个Lucene的索引。所以一个elasticsearch索引是由多 个Lucene索引组成的。别问为什么,谁让elasticsearch使用Lucene作为底层呢!如无特指,说起索引都是指elasticsearch的索引。
接下来的一切操作都在kibana中Dev Tools下的Console里完成。基础操作!
7.ik中文分词器插件
什么是IK分词器 ?
分词:即把一-段中文或者别的划分成一个个的关键字,我们在搜索时候会把自己的信息进行分词,会把数据库中或者索引库中的数据进行分词,然后进行一个匹配操作,默认的中文分词是将每个字看成一个词,比如“我爱狂神”会被分为"我",“爱”,“狂”,“神” ,这显然是不符合要求的,所以我们需要安装中文分词器ik来解决这个问题。
如果要使用中文,建议使用ik分词器!
IK提供了两个分词算法: ik_ smart和ik_ max_ word ,其中ik_ smart为最少切分, ik_ max_ _word为最细粒度划分!一会我们测试!
什么是IK分词器:
把一句话分词
如果使用中文:推荐IK分词器
两个分词算法:ik_smart(最少切分),ik_max_word(最细粒度划分)
安装ik分词器插件
下载地址:https://github.com/medcl/elasticsearch-analysis-ik/releases?after=v7.8.0
-
1.GitHub下载,找到对应版本,然后点开标题进入下载
-
2.解压放入到es对应的plugins下即可,注意这里目录名字不能带空格,不能嵌套文件夹,版本要一致
- 3.重启观察ES,发现ik插件被加载了
- 4.可以通过elasticsearch-plugin list来查看加载的插件
使用ik分词器
- 1.打开kibana的控制台
- 2.ik_smart(最少切分)测试:
请求:
GET _analyze
{
"analyzer": "ik_smart",
"text": "家和万事兴"
}
结果:
{
"tokens" : [
{
"token" : "家和万事兴",
"start_offset" : 0,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 0
}
]
}
- 3.ik_max_word(最细粒度划分)测试:
会把多种词组划分更细
请求:
GET _analyze
{
"analyzer": "ik_max_word",
"text": "家和万事兴"
}
结果:
{
"tokens" : [
{
"token" : "家和万事兴",
"start_offset" : 0,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "家和",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "万事兴",
"start_offset" : 2,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 2
},
{
"token" : "万事",
"start_offset" : 2,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 3
},
{
"token" : "万",
"start_offset" : 2,
"end_offset" : 3,
"type" : "TYPE_CNUM",
"position" : 4
},
{
"token" : "事",
"start_offset" : 3,
"end_offset" : 4,
"type" : "CN_CHAR",
"position" : 5
},
{
"token" : "兴",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 6
}
]
}
向ik分词器增加自己的词库字典
发现一个问题,狂神说竟然不是一个词,那这种需要的词就要加入到词库里面
新建自定义字典文档:
然后更改配置文件
保存然后重启es和kibana
打开之后,狂神说变成了一个词了
8.Rest风格关于索引操作
一种软件架构风格 ,而不是标准,只是提供了一组设计原则和约束条件。 它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。
method | url地址 | 描述 |
---|---|---|
PUT | localhost:9200/索引名称/类型名称/文档id | 创建文档(指定文档id) |
POST | localhost:9200/索引名称/类型名称 | 创建文档(随机文档id) |
POST | localhost:9200/索引名称/类型名称/文档id/_update | 修改文档 |
DELETE | localhost:9200/索引名称/类型名称/文档id | 删除文档 |
GET | localhost:9200/索引名称/类型名称/文档id | 通过文档id查询文档 |
POST | localhost:9200/索引名称/类型名称/_search | 查询所有的数据 |
创建索引
- 1.启动elasticsearch-7.6.1、elasticsearch-head-master(npm run start)、kibana-7.6.1-windows-x86_64
- 2.打开kibana控制台,创建一个索引
PUT /索引名/类型名/文档id
{请求体}
请求:
PUT /test1/type1/1
{
"name":"sm",
"age":18
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
"_index" : "test1",
"_type" : "type1",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
指定数据类型
那么name这个字段用不用指定类型呢。毕竟我们关系型数据库是需要指定类型的啊!
- 字符串类型 text、 keyword
- 数值类型 long, integer, short, byte, double, float, half float, scaled float
- 日期类型 date
- 布尔值类型 boolean
- 二进制类型 binary
请求:
PUT /test2
{
"mappings": {
"properties": {
"name":{
"type": "text"
},
"age":{
"type": "long"
},
"birthday":{
"type": "date"
}
}
}
}
结果:
{
"acknowledged" : true,
"shards_acknowledged" : true,
"index" : "test2"
}
获取索引信息
通过get请求获取表信息
请求:
GET test2
结果:
{
"test2" : {
"aliases" : { },
"mappings" : {
"properties" : {
"age" : {
"type" : "long"
},
"birthday" : {
"type" : "date"
},
"name" : {
"type" : "text"
}
}
},
"settings" : {
"index" : {
"creation_date" : "1630478449755",
"number_of_shards" : "1",
"number_of_replicas" : "1",
"uuid" : "q5CNUyBBT0mqzV611KOG4w",
"version" : {
"created" : "7060199"
},
"provided_name" : "test2"
}
}
}
}
查看默认的规则
7以后的版本可以不指定类型,可以用doc表示默认类型
请求:
PUT /test/_doc/1
{
"name":"雙馬",
"age":18,
"birth":"2020-02-29"
}
结果:
{
"_index" : "test",
"_type" : "_doc",
"_id" : "1",
"_version" : 2,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 1
}
使用GET获取一下
请求:
get test
结果:
{
"test" : {
"aliases" : { },
"mappings" : {
"properties" : {
"age" : {
"type" : "long"
},
"birth" : {
"type" : "date"
},
"name" : {
"type" : "text",
"fields" : {
"keyword" : {
"type" : "keyword",
"ignore_above" : 256
}
}
}
}
},
"settings" : {
"index" : {
"creation_date" : "1677035557124",
"number_of_shards" : "1",
"number_of_replicas" : "1",
"uuid" : "nSGKUaXlQzu_EKKGFP_8ow",
"version" : {
"created" : "7060199"
},
"provided_name" : "test"
}
}
}
}
发现es自动帮我们定义了类型
扩展:
可以查看索引信息
修改操作
- 1.put覆盖,会覆盖原来的内容并且版本号+1
请求:
PUT /test/_doc/1
{
"name":"雙馬123",
"age":18,
"birth":"2020-02-29"
}
结果:
{
"_index" : "test",
"_type" : "_doc",
"_id" : "1",
"_version" : 4,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 6,
"_primary_term" : 2
}
- 2.使用post_update
请求:
POST /test/_doc/1_update
{
"doc":{
"name":"法外狂徒"
}
}
结果:
{
"_index" : "test",
"_type" : "_doc",
"_id" : "1_update",
"_version" : 4,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 7,
"_primary_term" : 2
}
删除操作
请求:
DELETE test
结果:
{
"acknowledged" : true
}
9.关于文档的基本操作
添加数据 PUT
请求:
PUT /test/user/1
{
"name":"张三",
"age": 23,
"desc":"个性张扬,敢闯敢拼",
"tags":["正直","乐观","易怒"]
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
"_index" : "test",
"_type" : "user",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
继续添加
请求:
PUT /test/user/2
{
"name":"李四",
"age": 18,
"desc":"个性张扬,敢闯敢拼",
"tags":["正直","悲观","易怒"]
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
"_index" : "test",
"_type" : "user",
"_id" : "2",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 2
}
获取数据
请求:
GET /test/user/2
结果:
#! Deprecation: [types removal] Specifying types in document get requests is deprecated, use the /{index}/_doc/{id} endpoint instead.
{
"_index" : "test",
"_type" : "user",
"_id" : "2",
"_version" : 1,
"_seq_no" : 1,
"_primary_term" : 2,
"found" : true,
"_source" : {
"name" : "李四",
"age" : 18,
"desc" : "个性张扬,敢闯敢拼",
"tags" : [
"正直",
"悲观",
"易怒"
]
}
}
修改数据
- 1.put方式
请求:
PUT /test/user/2
{
"name":"李四666",
"age": 18,
"desc":"个性张扬,敢闯敢拼",
"tags":["正直","悲观","易怒"]
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
"_index" : "test",
"_type" : "user",
"_id" : "2",
"_version" : 2,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 2,
"_primary_term" : 2
}
- 2.post方式
不加_update
请求:
POST /test/user/2
{
"doc":{
"name":"李四"
}
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
"_index" : "test",
"_type" : "user",
"_id" : "2",
"_version" : 3,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 3,
"_primary_term" : 2
}
加_update
先进行put的覆盖一下变成
然后进行加_update的操作
请求:
POST /test/user/2/_update
{
"doc":{
"name":"李四"
}
}
结果:
#! Deprecation: [types removal] Specifying types in document update requests is deprecated, use the endpoint /{index}/_update/{id} instead.
{
"_index" : "test",
"_type" : "user",
"_id" : "2",
"_version" : 9,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 11,
"_primary_term" : 2
}
修改文档数据建议使用post 的_uptate 方式
简单的搜索
GET /test/user/2
简单的条件查询
请求:
GET /test/user/_search?q=name:张三
结果:
#! Deprecation: [types removal] Specifying types in search requests is deprecated.
{
"took" : 18,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 1,
"relation" : "eq"
},
"max_score" : 1.3862942,
"hits" : [
{
"_index" : "test",
"_type" : "user",
"_id" : "1",
"_score" : 1.3862942,
"_source" : {
"name" : "张三",
"age" : 23,
"desc" : "个性张扬,敢闯敢拼",
"tags" : [
"正直",
"乐观",
"易怒"
]
}
}
]
}
}
复杂的查询
精确匹配
请求:
GET test/user/_search
{
"query":{
"match":{
"name":"张"
}
}
}
结果:
#! Deprecation: [types removal] Specifying types in search requests is deprecated.
{
"took" : 3,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 1,
"relation" : "eq"
},
"max_score" : 0.6931471,
"hits" : [
{
"_index" : "test",
"_type" : "user",
"_id" : "1",
"_score" : 0.6931471,
"_source" : {
"name" : "张三",
"age" : 23,
"desc" : "个性张扬,敢闯敢拼",
"tags" : [
"正直",
"乐观",
"易怒"
]
}
}
]
}
}
这里在添加一个数据然后再查询
PUT /test/user/3
{
"name":"张三不是我",
"age": 6,
"desc":"个性张扬,敢闯敢拼,不畏风险",
"tags":["正直","悲观","易怒"]
}
查询
GET test/user/_search
{
"query":{
"match":{
"name":"张"
}
}
}
结果:
#! Deprecation: [types removal] Specifying types in search requests is deprecated.
{
"took" : 0,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 2,
"relation" : "eq"
},
"max_score" : 0.5442147,
"hits" : [
{
"_index" : "test",
"_type" : "user",
"_id" : "1",
"_score" : 0.5442147,
"_source" : {
"name" : "张三",
"age" : 23,
"desc" : "个性张扬,敢闯敢拼",
"tags" : [
"正直",
"乐观",
"易怒"
]
}
},
{
"_index" : "test",
"_type" : "user",
"_id" : "3",
"_score" : 0.36928856,
"_source" : {
"name" : "张三不是我",
"age" : 6,
"desc" : "个性张扬,敢闯敢拼,不畏风险",
"tags" : [
"正直",
"悲观",
"易怒"
]
}
}
]
}
}
hit : 索引和文档的信息
查询的结果总数
然后就是查询出来的具体的文档
数据中的东西都可以遍历出来了
分数:我们可以通过来判断谁更加更加符合结果
结果过滤
请求:
GET test/user/_search
{
"query":{
"match":{
"name":"张"
}
}, "_source": ["name","desc"]
}
结果:
#! Deprecation: [types removal] Specifying types in search requests is deprecated.
{
"took" : 1,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 2,
"relation" : "eq"
},
"max_score" : 0.5442147,
"hits" : [
{
"_index" : "test",
"_type" : "user",
"_id" : "1",
"_score" : 0.5442147,
"_source" : {
"name" : "张三",
"desc" : "个性张扬,敢闯敢拼"
}
},
{
"_index" : "test",
"_type" : "user",
"_id" : "3",
"_score" : 0.36928856,
"_source" : {
"name" : "张三不是我",
"desc" : "个性张扬,敢闯敢拼,不畏风险"
}
}
]
}
}
排序
请求:
GET test/user/_search
{
"query":{
"match":{
"name":"张"
}
},
"sort": [
{
"age": {
"order": "desc"
}
}
]
}
年龄降序:
年龄升序:
分页查询
from:从第几个数据开始
size:返回多少条数据(单页面的数据)
请求:
GET test/user/_search
{
"query":{
"match":{
"name":"张"
}
},
"sort": [
{
"age": {
"order": "asc"
}
}
],
"from": 0
, "size": 1
}
结果:
布尔值查询(与、或、非)
must:所有的条件都要符合,对应于数据库中的and
should:多个条件,只要满足一个条件即可查出,相当于or操作
must_not:不符合条件的才能查出来,相当于逻辑非
must请求:
GET test/user/_search
{
"query":{
"bool": {
"must": [
{
"match": {
"name": "张"
}
},
{
"match": {
"age": "6"
}
}
]
}
}
}
should请求:
must_not:
过滤查询
请求:
GET test/user/_search
{
"query":{
"bool": {
"must": [
{
"match": {
"name": "张"
}
}
],
"filter": {
"range": {
"age": {
"gte": 10,
"lte": 25
}
}
}
}
}
}
结果:
- gt:>
- gte:>=
- ite:<=
- it:<
多个条件查询
请求:
GET test/user/_search
{
"query":{
"match": {
"tags": "直 乐"
}
}
}
精确查询
term查询是直接通过倒排索引|指定的词条进程精确查找的!
关于分词:
term:直接精确查询(使用倒排索引,效率高)
match:会使用分词器解析(先分析文档,然后通过分析的文档进行查询)
term会进行精确解析,解析会遇到两种类型,一种keyword,一种text。keyword不会进行分词,text会进行分词
- 1.创建一个索引库的初始化
PUT testdb
{
"mappings": {
"properties": {
"name":{
"type": "text"
},
"desc":{
"type": "keyword"
}
}
}
}
- 2.添加两个数据
PUT testdb/_doc/1
{
"name":"雙馬聊java name",
"desc":"雙馬聊java desc"
}
- 3.进行ik分词查询
查询keyword内容
GET _analyze
{
"analyzer": "keyword",
"text": ["雙馬聊java name"]
}
查询标准内容
GET _analyze
{
"analyzer": "standard",
"text": ["雙馬聊java name"]
}
- 4.使用精确查询
text类型
GET testdb/_search
{
"query": {
"term": {
"name":"雙"
}
}
}
keyword类型
GET testdb/_search
{
"query": {
"term": {
"desc":"雙馬聊java desc"
}
}
}
keyword字段类型不会被分词器解析
精确查询多个值
- 1.添加文档
PUT testdb/_doc/3
{
"t1":"22",
"t2":"2020-4-6"
}
PUT testdb/_doc/4
{
"t1":"33",
"t2":"2020-4-7"
}
2.精确查询多个值
GET testdb/_search
{
"query": {
"bool": {
"should": [
{
"term": {
"t1":"22"
}
},
{
"term": {
"t1": "33"
}
}
]
}
}
}
高亮查询
GET test/user/_search
{
"query":{
"match": {
"name":"张"
}
},
"highlight": {
"fields": {
"name":{}
}
}
}
自定义高亮条件
GET test/user/_search
{
"query":{
"match": {
"name":"张"
}
},
"highlight": {
"pre_tags": "<p class='key' style='color:red'>",
"post_tags": "</p>",
"fields": {
"name":{}
}
}
}
10.Springboot集成ES
1.环境搭建
- 1.创建一个空项目,并将项目结构修改好
- 2.添加一个springboot模块,并添加好一些基础依赖
- 2.版本依赖问题,这里高版本的springboot的es版本肯定于自己使用的版本不一致的,这里需要自己调整
修改pom文件
<properties>
<java.version>1.8</java.version>
<!--自定义版本和本地版本一致-->
<elaticsearch.version>7.6.1</elaticsearch.version>
</properties>
- 3.定义配置类
@Configuration
public class ElasticSearchConfig {
@Bean
public RestHighLevelClient restHighLevelClient() {
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("127.0.0.1", 9200, "http")
)
);
return client;
}
}
2.springboot操作es索引
创建索引
- 1.操作es之前,先在测试类,引入配置类
@Autowired
private RestHighLevelClient restHighLevelClient;
- 2.创建索引
@Test
void testCreateIndex() throws IOException {
//所有的创建都是请求,所以要先创建请求
CreateIndexRequest request = new CreateIndexRequest("test4");
//客户端(client)执行请求,并获得响应(response)
CreateIndexResponse response = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
System.out.println(response);
}
- 3.打开elasticsearch-head查看
判断索引是否存在
//判断索引是否存在
@Test
void testExistIndex() throws IOException {
//创建请求
GetIndexRequest request = new GetIndexRequest("test4");
//在客户端执行
boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
System.out.println(exists);
}
删除索引
//删除索引
@Test
void testDeleteIndex() throws IOException{
DeleteIndexRequest request = new DeleteIndexRequest("test4");
AcknowledgedResponse delete = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
System.out.println(delete.isAcknowledged());
}
3.springboot操作es文档
创建实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
private String name;
private Integer age;
}
这里需要json依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.23</version>
</dependency>
添加文档
//添加文档(相当于插入数据)
@Test
void testAddDocument() throws Exception{
//创建对象
User user = new User("张三",18);
//创建请求
IndexRequest request = new IndexRequest("test4");
//设置请求规则(之前用命令的格式是:pub/test4/_doc/1
//设置id
request.id("1");
//设置超时时间为1秒
request.timeout(TimeValue.timeValueSeconds(1));
request.timeout("1s");
//将数据放入请求(需要json数据,所以需要把对象转json,使用阿里巴巴的fastjson依赖即可
request.source(JSON.toJSONString(user), XContentType.JSON);
//客户端发送请求,获取相应结果
IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);
System.out.println(indexResponse.toString());
//打印状态 创建的时候是CREATED,更新的时候是UPDATE
System.out.println(indexResponse.status());//CREATED
}
判断文档是否存在
//判断文档是否存在(查询文档之前需要做判断)
@Test
void testIsExists() throws IOException {
GetRequest request = new GetRequest("test4", "1");
//不获取返回的 _resource 的上下文,效率更高,正式使用视情况而定
request.fetchSourceContext(new FetchSourceContext(false));
request.storedFields("_none_");
boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);
System.out.println(exists);
}
获取文档信息
//获取文档信息
@Test
void testGetDocumentInfo() throws IOException {
GetRequest request = new GetRequest("test4", "1");
GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
System.out.println(response.getSourceAsString());//{"age":18,"name":"张三"}
System.out.println(response);
}
更新文档信息
//更新文档信息
@Test
void testUpdateDocumentInfo() throws IOException {
//更新操作就把请求改为更新就行
UpdateRequest updateRequest = new UpdateRequest("test4", "1");
updateRequest.timeout("1s");
User user = new User("李四",23);
updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
System.out.println(update.status());
}
删除文档信息
// 删除文档
@Test
void testDeleteDocument() throws IOException {
DeleteRequest request = new DeleteRequest("test4", "1");
request.timeout("1s");
DeleteResponse deleteResponse = restHighLevelClient.delete(request, RequestOptions.DEFAULT);
System.out.println(deleteResponse);
}
批量操作数据
// 批量插入数据(修改,删除类似操作)
@Test
void testBulkRequest() throws IOException {
BulkRequest request = new BulkRequest();
request.timeout("10s");
ArrayList<User> users = new ArrayList<>();
users.add(new User("张三", 21));
users.add(new User("李四", 22));
users.add(new User("王五", 23));
users.add(new User("赵六", 18));
users.add(new User("小刘", 19));
// 批处理请求, 修改,删除,只要在这里修改相应的请求就可以
for (int i = 0; i < users.size(); i++) {
request.add(new IndexRequest("test4")
.id(String.valueOf(i + 1))
.source(JSON.toJSONString(users.get(i)), XContentType.JSON));
}
BulkResponse bulkResponse = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
//是否失败,返回false表示成功
System.out.println(bulkResponse.hasFailures());
}
查询文档(复杂查询)
// 查询文档
//SearchRequest 搜索请求
//SearchSourceBuilder 条件构造
//Highl ightBuilder 构建高亮
//TermQueryBuilder 精确查询
//MatchAl LQueryBuilder|
@Test
void testSearch() throws IOException {
SearchRequest searchRequest = new SearchRequest("test4");
// 构建搜索条件
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
// 查询条件, 可以使用QueryBuilders工具类实现
// QueryBuilders.termQuery 精确
// QueryBuilders.matchLLQuery() 匹配所有
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword", "张三");
// MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
sourceBuilder.query(termQueryBuilder);
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
searchRequest.source(sourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(JSON.toJSON(searchResponse.getHits()));
System.out.println("======================================");
for (SearchHit documentFields : searchResponse.getHits().getHits()) {
System.out.println(documentFields.getSourceAsMap());
}
}