ElasticSearch -v7.9.3
以下学习笔记均来自视频资料https://www.bilibili.com/video/BV17a4y1x7zq
lucene 是一套信息检索工具包!jar包! 不包含 搜索引擎系统!
包含的: 索引结构! 读写索引的工具! 排序,搜索规则...工具类!
Lucene 和 ElasticSearch关系
ElasticSearch是基于Lucene 做了一些封装和增强
ElasticSearch的概述
ElasticSearch,简称为es,es是一个开源的高扩展的分布式全文检索引擎,它可以近乎实时的存储、检索数据;本身扩展性很好,可以扩展到上百台服务器,处理PB级别(大数据时代)的数据.es也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能,但是他的目的是通过简单的RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单.
据国际权威的数据库产品评测机构DB Engines的统计,在2016年1月,ElasticSearch已超过Solr等,成为排名第一的搜索引擎类应用.
ElasticSearch和solr的差别
ElasticSearch简介
ElasticSearch 是一个实时分布式搜索和分析引擎.他让你以前所未有的速度处理大数据成为可能.
他用于全文检索、结构化搜索、分析以及将这三者混合使用：
维基百科使用ElasticSearch提供全文搜索并高亮关键字，以及输入实时搜索（search-asyou-type和搜索纠错(did-you-mean)等搜索建议功能.
英国卫报使用ElasticSearch结合用户日志和社交网络数据提供他们的编辑以实时的反馈,以便了解公众对新发表的文章的回应.
StackOverflow结合全文搜索和地理位置查询,以及more-like-this功能来找到相关的问题和答案.
Github 使用ElasticSearch检索1300亿行的代码.
但是ElasticSearch不仅用于大型企业,它还让像DataDag以及Klout这样的创业公司将最初的想法变成可扩展的解决方案.
ElasticSearch可以在你的笔记本上运行,也可以在数以百计的服务器上处理PB级的数据.
ElasticSearch是一个基于Apache Lucene(TM) 的开源还是专有领域,Lucene可以被任务时迄今为止最先进、性能最好的、功能最全的搜索引擎库。
但是Lucene只是一个库。想要使用它，你必须使用java来作为开发语言并将其直接继承到你的应用中，更糟糕的是Lucene非常法扎，你需要深入了解检索的相关知识来理解他是如何工作的。
ElasticSearch也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是他的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。
Solr简介
Solr是Apache下的一个顶级开源项目，采用Java开发，他是基于Lucene的全文搜索服务器。solr提供了比Lucene更为丰富的查询语言，同时实现了可配置、可扩展,并对索引、搜索性能进行了优化。solr可以独立运行，运行在jetty、tomcat等这些Servlet容器中，Solr索引的实现方法很简单，用POST方法向服务器发送一个描述Field及其内容的XML文档，Solr根据xml文档添加、删除、更新索引。Solr搜索只需要发送HTP GET请求，然后对Solr返回xml、json等格式的查询结果进行解析，组织页面布局。Solr不提供构建UI的功能，Solr提供了一个管理界面，通过管理界面可以查询Solr的配置和运行情况。
solr是基于lucene开发企业级搜索服务器，实际上就是封装了lucene。
solr是一个独立的企业级搜索应用服务器，他对外提供类似于web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的文件，生成索引；也可以通过提出查找请求，并得到返回结果。
Lucene简介
Lucene是apache软件基金会4 jakarta项目组的一个子项目,是一个开放源代码的全文检索引擎工具包,但他不是一个完整的全文检索引擎,而是一个全文检索引擎的架构,提供了完整的查询引擎和索引引擎,部分文本分析引擎,Lucene的目的是为软件开发人员提供了一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎.Lucene是一套用于全文检索和搜寻的开源程式库,由Apache软件基金会支持和提供.Lucene提供了一个简单却强大的应用程式接口,能够做全文索引和搜寻.在java开发环境里Lucene是一个成熟的免费开源工具.就其本身而言,Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库.人们经常提到信息检索程序库,虽然与搜索引擎有关,但不应该将信息检索程序库与搜索引擎相混淆.
Lucene是一个全文检索引擎的架构. 那什么是全文搜索引擎?
全文搜索引擎是名副其实的搜索引擎,国外具代表性的有Google、Fast/AllTheWeb、AltaVisata、Inktomi、Teoma、WiseNut等，国内著名的有百度。他们都是通过互联网上提取各个网站的信息
（以网页文字为主）而建立的数据库中，检索与用户查询条件匹配的相关记录，然后按一定的排列顺序将结果返回给用户，因此他们是真正的搜索引擎。
从搜索结果来源的角度，全文搜索引擎又可细分为两种，一种是拥有自己的检索程序（indexer）俗称“蜘蛛”（Spider）程序或“机器人”（Robot）程序，并自检网页数据库，搜索结果直接从自身的数据库中调用，如上面提到的7家引擎；另一种则是租用其他引擎的数据库，并按自定的格式拍你搜索结果，如Lycos引擎。
ElasticSearch和Solr 比较
1.当单纯的对已有数据进行搜索时，solr更快；
2.当实时建立索引是，solr会产生io阻塞，查询性能较差，ElasticSearch具有明显的优势。
3.随着数据量的增加，solr的搜索效率会变得更低，而ElasticSearch却没有明显的变化。
转变我们的搜索基础设施后solr ElasticSearch，可以看到1~50倍的差距；
ElasticSearch vs solr总结
1.es基本是开箱即用，非常简单。Solr安装略微复杂！
2.solr利用Zookeeper进行分布式管理，而ElasticSearch自身带有分布式协调管理功能。
3.solr支持更多格式的数据，比如json、xml、csv，而ElasticSearch仅支持json格式。
4.solr官方提供的功能更多，而ElasticSearch本身更注重于核心功能，高级功能多有第三方插件提供，例如图形化界面徐涛kibana友好支撑。
5.solr查询快，但更新索引时慢（即插入删除慢），用于电商等查询多的应用；
- ElasticSearch 建立索引快（即查询快），即实时性查询快，用于facebook新浪等搜索
- solr 是传统搜索应用的有力解决方案，但ElasticSearch更实用与新兴的实时搜索应用
6.solr比较成熟，有一个更大，更成熟的用户、开发和贡献者社区，而ElasticSearch相对开发维护者较少，更新太快，学习使用成本较高。
ElasticSearch 安装
下载
华为云镜像(视频粉丝提供)
ElasticSearch: https://mirrors.huaweicloud.com/elasticsearch/?C=N&O=D
logstash: https://mirrors.huaweicloud.com/logstash/?C=N&O=D
kibana: https://mirro
es
-
安装 解压即可
-
目录熟悉
bin 启动文件
config 配置文件
log4j2 日志配置文件
jvm.option java 虚拟机相关配置
elasticsearch.yml elasticsearch配置文件 集群 默认9200端口! 跨域
lib 相关jar包
logs 日志
modules 功能模块
plugins 插件
- 启动 如果报错 可以尝试在
config/elasticsearch.yml添加一条配置：
xpack.ml.enabled: false
- 测试 127.0.0.1:9200
安装可视化界面es head插件
-
下载地址:
-
启动
npm install
npm run start
- 如果 有跨域问题 配置es
http.cors.enabled: true
http.cors.allow-origin: "*"
安装kibana
Kibana是一个针对Elasticsearch的开源分析及可视化平台,用来搜索、查看交互存储在Elasticsearch索引中的数据。使用Kibana，可以通过各种图表进行高级数据分析及展示。Kibana让海量数据更容易理解。它操作简单，基于浏览器的用户界面可以快速创建仪表板（dashbord）实时显示Elasticsearch查询动态。设置Kibana非常简单。无需编码或者额外的基础架构，几分钟内就可以完成安装并启动Elasticsearch索引监测。
官网：https://www.elastic.co/cn/kibanakibana的版本与es要一致!!
安装kibana
1.解压
2.使用bin目录下的bat启动
3.测试http://localhost:5601
4.开发工具! (post.google浏览器插件,curl,head测试)
5.汉化!
//在配置文件中修改
i18n.locale: "zh-CN"
ES核心概念
ElasticSearch 是面向文档,关系行数据库 和ElasticSearch 的客观的对比
| Relational DB | ElasticSearch |
|---|---|
| 数据库(database) | 索引(indices) |
| 表(tables) | types |
| 行(rows) | documents |
| 字段(columns) | fields |
ElasticSearch (集群)中可以包含多个索引(数据库),每个索引中可以包含多个文档(行),每个文档中又包含多个字段(列).
一个进程就是一个集群!物理设计:
ElasticSearch 在后台把每个索引划分成多个切片,每分分片可以在集群中的不同服务器间迁移
逻辑设计:
一个索引类型中,包含多个文档,比如说文档1,文档2.当我们索引一片文档时,可以通过这样的一个顺序找到它:索引>类型>文档id,通过这个组合我们就能索引到某个具体的文档.注意:id不必是整数,实际上他是个字符串.> 文档
就是一条条数据!
ElasticSearch 面向文档,意味着索引和搜索数据的最小单位是文档,ElasticSearch 中,文档有几个重要属性:- 自我包含,一篇文档同时包含字段和对应的值,也就是同时包含key:value
-
可以是层次型的,一个文档中包含自文档,复杂的逻辑实体就是这么来的.
-
灵活的结构,文档不依赖预先定义的模式,我们知道关系型数据库中,要提前定义字段才能使用,在ElasticSearch 中,对于字段是非常灵活的,有时候,我们可以忽略该字段,或者动态的添加一个新的字段.
尽管我们可以随意的新增或者忽略某个字段,凡是,每个字段的类型非常重要,比如一个年龄字段类型,可以是字符串也可以是整形.因为ElasticSearch 会保存字段和类型之间的映射及其他的设置.这种具体到每个映射的每种类型,这也是为什么在ElasticSearch 中,类型有时候也称为映射类型.
类型
字段的类型!
类型是文档的逻辑容器,就像关系型数据库一样,表格是行的容器.类型中对于字段的定义成为映射,比如name映射为字符串类型.我们说文档是无模式的,他们不需要拥有映射中所定义的所有字段,比如新增一个字段,那么ElasticSearch 是怎么做的呢?ElasticSearch 会自动的将新字段加入映射,但是这个字段的不确定它是什么类型,ElasticSearch 就开始猜,如果这个值是18,那么ElasticSearch 会任务他是整形.但ElasticSearch 也可能猜不对.所以最安全的方式就是提前定义好所需要的映射,这点跟关系型数据库殊途同归了,先定义好字段,然后再使用,别整什么幺蛾子.
索引
就是数据库!
索引是映射类型的容器,ElasticSearch 中的索引是一个非常大的文档集合.索引存储了映射类型的字段和其他设置.然后他们被存储到了各个分片上了,
物理设计:节点和分片 如何工作
一个集群至少有一个节点,而一个节点就是一个ElasticSearch 进程,节点可以有多个索引默认的,如果你创建索引,那么索引将会有个5个分片(primary shard,又称主分片)构成的,每个主分片会有一个副本(replica shard ,又称复制分片)
集群
↓
---------------------------------------------------------------------------------------------------
↓ ↓ ↓
节点1 节点2 节点3
-------------------- --------------------------- ------------------------
↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
p0 p3 r4 p2 r0 r1 r3 p1 p4 r2
上图是一个有三个节点的集群,可以看到主分片和对应的复制分片都不会在同一个节点,这样有利于某个节点挂掉了,数据也不至于丢失.实际上,一个分片是一个Lucene索引,一个包含倒排索引的文件目录,倒排索引的结构使得ElasticSearch 在不扫描全部文档的情况,就能告诉你哪些文档包括特定的关键字.
倒排索引
ElasticSearch 使用的是一种称为倒排索引的结构,采用lucene倒序排序作为底层.这种结构适用于快速的全文搜索,一个索引由文档中所有不重复的列表构成,对于每个词,都有一个包含他的文档列表.例如,现在有一个文档,每个文档包含如下内容:
Study every day,good good up to forerver # 文档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 | √ | × |
| forever | √ | √ |
| total | 2 | 1 |
两个文档都匹配,但是第一个文档比第二个匹配更高.
ElasticSearch 的索引和Lucene的索引对比
在ElasticSearch 中,索引(库)这个词被频繁使用,这就是术语的使用.在ElasticSearch 中索引被分为多个分片,每个分片是一个lucene的索引.所以一个ElasticSearch 索引是由多个Lucene索引组成的
IK分词器插件(也必须要版本一致)
什么是ik分词器
分词:即把一段中文或者别的划分成一个个关键字,我们在搜索时候会把自己的信息进行分词,会把数据库中或者索引库中的数据进行分词,然后进行一个匹配的操作,默认的中文分词是将每个字看成一个词,比如"我爱你"会被分为"我","爱","你",这显然是不符合要求的,所以我们需要安装中文分词器ik来解决这个问题.
如果要使用中文,,建议使用ik分词器!!!
ik提供了两个分词算法:ik_smart和ik_max_word,其中ik_smart为最少切分,ik_max_word为最细粒度划分!
下载
- https://github.com/medcl/elasticsearch-analysis-ik/releases
- 解压到ElasticSearch 的plugins 中
- 然后重启测试
- elasticsearch-plugins list 查看加载进来的插件
- 使用kibana测试
查看不同的分词器效果
ik_smart为最少切分
GET _analyze
{
"analyzer":"ik_smart",
"text": "张三李四王五"
}
//结果
{
"tokens" : [
{
"token" : "张三李四",
"start_offset" : 0,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "王",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 1
}
]
}
ik_max_word为最细粒度划分
GET _analyze
{
"analyzer": "ik_max_word",
"text": "张三李四王五"
}
//结果
{
"tokens" : [
{
"token" : "张三李四",
"start_offset" : 0,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "王",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 1
},
{
"token" : "李四",
"start_offset" : 2,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 3
},
{
"token" : "四",
"start_offset" : 3,
"end_offset" : 4,
"type" :
{
"token" : "王",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 5
},
{
"token" : "五",
"start_offset" : 5,
"end_offset" : 6,
"type" : "TYPE_CNUM",
"position" : 2
}
]
}
问题
输入我们自己创建的词 ik并不认 怎么办
{
"tokens" : [
{
"token" : "原",
"start_offset" : 0,
"end_offset" : 1,
"type" : "CN_CHAR",
"position" : 0
},
{
"token" : "神",
"start_offset" : 1,
"end_offset" : 2,
"type" : "CN_CHAR",
"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" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 4
}
]
}
ik 分词器config 添加自己的词库
- 新建自己的dic(字典文件)
- 在IKAnalyzer.cfg.xml 中引用
{
"tokens" : [
{
"token" : "原神",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "怎么了",
"start_offset" : 2,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "怎么",
"start_offset" : 2,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 2
},{
"token" : "了",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 3
}
]
}
Rest风格说明
一种软件架构风格,而不是标准,只是提供了一组设计原则和约束.它主要用于客户端和服务器交互类的软件.基于这个风格设计的软件可以简洁,更有层次,更易于实现缓存等机制.
基本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 | 查询所有数据 |
关于索引的基本操作
基础测试
字段指定类型:常用的
-
字符串类型
text、keyword
-
数值类型
long、integer、short、byte、double、float、half float、scaled float
-
日期类型
date
-
布尔值类型
boolean
-
二进制类型
binary
1.创建一个索引
PUT /test1/type1/1
{
"name": "张三",
"age": 88
}
//结果
#! 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}
PUT /索引名/~类型名~/文档id
{请求体}
2.创建规则(类似建库,你可以这样理解)
PUT /test2
{
"mappings": {
"properties": {
"name" : {
"type": "text"
},
"age": {
"type": "long"
},
"birthday": {
"type": "date"
}
}
}
}
//结果
{
"acknowledged" : true,
"shards_acknowledged" : true,
"index" : "test2"
}
3.获取规则（通过get获取）
GET test2
//结果
{
"test2" : {
"aliases" : { },
"mappings" : {
"properties" : {
"age" : {
"type" : "long"
},
"birthday" : {
"type" : "date"
},
"name" : {
"type" : "text"
}
}
},
"settings" : {
"index" : {
"creation_date" : "1617862533333",
"number_of_shards" : "1",
"number_of_replicas" : "1",
"uuid" : "OwhbqEMXRLGaTXz4i5vIng",
"version" :{
"created" : "7090399"
},
"provided_name" : "test2"
}
}
}
}
4.查看默认的信息
//在8以后可能type就没了 默认就是一个_doc
PUT /test3/_doc/1
{
"name": "张三",
"age": 88,
"birthday": "2020-01-01"
}
GET test3
//get结果
{
"test3" : {
"aliases" : { },
"mappings" : {
"properties" : {
"age" : {
"type" : "long"
},
"birthday" : {
"type" : "date"
},
"name" : {
"type" : "text",
"fields" : {
"keyword" : {
"type" : "keyword",
"ignore_above" : 256
}
}
}
}
},
"settings" : {
"index" : {
"creation_date" : "1617862955031",
"number_of_shards" : "1",
"number_of_replicas" : "1",
"uuid" : "b2BqvC1CRxuq6uekyFwoig",
"version" : {
"created" : "7090399"
},
"provided_name" : "test3"
}
}
}
}
如果没有指定文档字段类型,es会默认配置字段类型,但是不一定 会准确匹配
扩展
通过 get _cat可以获得更多的信息!!!
修改 提交还是使用PUT即可! 然后覆盖
-
直接覆盖
PUT /test3/_doc/1 { "name": "张三1", "age": 88, "birthday": "2020-01-01" } //结果 { "_index" : "test3", "_type" : "_doc", "_id" : "1", "_version" : 2, "result" : "updated", "_shards" : { "total" : 2, "successful" : 1, "failed" : 0 }, "_seq_no" : 1, "_primary_term" : 1 } -
现在_update
POST /test3/_doc/1/_update { "doc":{ "name": "法外狂徒张三" } } //结果 #! Deprecation: [types removal] Specifying types in document update requests is deprecated, use the endpoint /{index}/_update/{id} instead. { "_index" : "test3", "_type" : "_doc", "_id" : "1", "_version" : 3, "result" : "updated", "_shards" : { "total" : 2, "successful" : 1, "failed" : 0 }, "_seq_no" : 2, "_primary_term" : 1 }
删除索引
DELETE test1
//结果
{
"acknowledged" : true
}
关于文档的基本操作
基本操作
1.新增数据
PUT /test3/user/1
{
"name": "lhx",
"age": 88,
"desc": "渣男",
"tags":["渣男","袜子控"]
}
2.查询数据
GET test3/user/1
3.修改数据
直接覆盖 不建议
PUT /test3/user/1
{
"name": "lhx",
"age": 88,
"desc": "渣男",
"tags":["渣男","袜子控"]
}
4.更新数据 (更加灵活)
POST test3/user/3
{
"doc":{
"age":18
}
}
5.搜索
简单的搜索
GET test3/user/1
简单的条件查询
GET test3/user/_search?q=name:lxp
_score 代表匹配度 权重
hit:
索引和文档的信息
查询的结果总数
然后就是查询出来的具体的文档
数据中的东西都可以遍历出来了
分数:我们可以通过来判断谁更加符合结果
复杂操作
GET test3/user/_search
{
"query":{
"match":{
"name":"lhx"
}
}
}
_source字段过滤(输出部分字段)
GET test3/user/_search
{
"query":{
"match":{
"name":"lhx"
}
},
"_source":["name","desc"]
}
排序 sort
GET test3/user/_search
{
"query":{
"match":{
"name":"lhx"
}
},
"sort": [
{
"age": {
"order": "desc"
}
}
]
}
分页 查询 from从第几条开始 size每页多少条 类似(limit 的两个参数)
GET test3/user/_search
{
"query":{
"match":{
"name":"lhx"
}
},
"sort": [
{
"age": {
"order": "desc"
}
}
],
"from": 0,
"size": 1
}
数据下标还是从0开始的.
布尔值
must (相当于and) 所有的条件都得符合
多条件查询
GET test3/user/_search
{
"query":{
"bool":{
"must":[
{
"match":{
"name": "zll"
}
},
{
"match": {
"age": 88
}
}
]
}
}
}
should 好比 (or)
GET test3/user/_search
{
"query":{
"bool":{
"should":[
{
"match":{
"name": "zll"
}
},
{
"match": {
"age": 88
}
}
]
}
}
}
must_not (not)
GET test3/user/_search
{
"query":{
"bool":{
"must_not":[
{
"match": {
"name": "lxp"
}
}
]
}
}
}
过滤器
GET test3/user/_search
{
"query":{
"bool":{
"must": [
],
"filter":{
"range":{
"age": {
"gt": 10
}
}
}
}
}
}
多个条件使用空格隔开 只要满足其中一个结果就可以通过分值基本的判断
GET test3/user/_search
{
"query":{
"match":{
"name": "lxp zll"
}
}
}
精确查询
term查询是直接通过倒排索引指定的词条进程精确查找
关于分词:
- term 直接查询精确的值
- match 会使用分词器解析!(先分析文档,然后在通过分析的文档进行查询)
两个类型 text keyword
keyword 不会被分词器拆分
text 会被拆分
多个值匹配精确查询
GET testdb/_doc/_search
{
"query": {
"bool": {
"should": [
{
"term": {
"t1": "44"
}
},
{
"term": {
"t1": "55"
}
}
]
}
}
}
高亮查询
自定义搜索高亮 pre_tags 前缀 post_tags 后缀
GET testdb/_doc/_search
{
"query":{
"match":{
"name": "张三"
}
},
"highlight":{
"pre_tags":"<p class='key' style='color:red'>",
"post_tags":"</p>",
"fields":{
"name":{}
}
}
}
- 匹配
- 按条件匹配
- 精确匹配
- 区间范围匹配
- 匹配字段过滤
- 多条件查询
- 高亮查询
集成SpringBoot
看文档
1.找到原生的依赖
2.找对象
3.分析类中的方法
配置项目
问题:一定要保证导入的依赖和es 的版本一致
具体的api测试
1.创建索引
2.判断索引是否存在
3.删除索引
4.操作文档
5.crud文档
package com.zhonglao.zhonglaoes;
import com.alibaba.fastjson.JSON;
import com.zhonglao.zhonglaoes.pojo.User;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
@RunWith(SpringRunner.class)
@SpringBootTest
class ZhonglaoEsApplicationTests {
@Resource
private RestHighLevelClient client;
/*----------------------------------------------索引操作-----------------------------------*/
//测试索引的创建 Request
@Test
void testCreateIndex() throws IOException {
//创建索引请求
CreateIndexRequest request = new CreateIndexRequest("zhonglao_index");
//执行创建请求
CreateIndexResponse createIndexResponse =
client.indices().create(request, RequestOptions.DEFAULT);
System.out.println(createIndexResponse);
}
//测试索引是否存在 Request
@Test
void testEXitsIndex() throws IOException {
//创建索引请求
GetIndexRequest request = new GetIndexRequest("zhonglao_index");
//执行创建请求
boolean exists = client.indices().exists(request,RequestOptions.DEFAULT);
System.out.println(exists);
}
//测试删除索引 Request
@Test
void testDeleteIndex() throws IOException {
//创建索引请求
DeleteIndexRequest request = new DeleteIndexRequest("zhonglao_index");
//执行创建请求
AcknowledgedResponse delete = client.indices().delete(request,RequestOptions.DEFAULT);
System.out.println(delete.isAcknowledged());
}
/*----------------------------------------------文档操作-----------------------------------*/
//测试添加文档
@Test
void testAddDocument() throws IOException {
//创建对象
User user = new User("张三",3);
//创建请求
IndexRequest request = new IndexRequest("zhonglao_index");
//规则
request.id(String.valueOf(1));
request.timeout(TimeValue.timeValueSeconds(1));
//数据放入请求 json
request.source(JSON.toJSONString(user), XContentType.JSON);
IndexResponse index = client.index(request, RequestOptions.DEFAULT);
System.out.println(index.status());//命令返回的状态
System.out.println(index.toString());
}
//获取文档,判断文档是否存在
@Test
void testExistsDocument() throws IOException {
GetRequest getRequest = new GetRequest("zhonglao_index","1");
//不获取返回的_source 的上下文了
// getRequest.fetchSourceContext(new FetchSourceContext(false));
// getRequest.storedFields("_none_");
boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
System.out.println(exists);
}
//获取文档的信息
@Test
void testGetDocument() throws IOException {
GetRequest getRequest = new GetRequest("zhonglao_index","1");
//不获取返回的_source 的上下文了
// getRequest.fetchSourceContext(new FetchSourceContext(false));
// getRequest.storedFields("_none_");
GetResponse get = client.get(getRequest, RequestOptions.DEFAULT);
System.out.println(get.getSourceAsString());//打印文档内容
System.out.println(get);
}
//更新文档记录
@Test
void testUpdateDocument() throws IOException {
UpdateRequest updateRequest = new UpdateRequest("zhonglao_index","1");
updateRequest.timeout("1s");
User user = new User("李四", 20);
updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
System.out.println(update);
}
//删除文档记录
@Test
void testDeleteDocument() throws IOException {
DeleteRequest deleteRequest = new DeleteRequest("zhonglao_index","1");
deleteRequest.timeout("1s");
DeleteResponse delete = client.delete(deleteRequest, RequestOptions.DEFAULT);
System.out.println(delete.status());
}
//批量操作
@Test
void testBulkRequest() throws IOException {
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout("10s");
ArrayList<User> users = new ArrayList<>();
users.add(new User("刘一",1));
users.add(new User("陈二",2));
users.add(new User("张三",1));
users.add(new User("李四",1));
users.add(new User("王五",1));
users.add(new User("赵六",1));
users.add(new User("孙七",1));
users.add(new User("周八",1));
users.add(new User("吴九",1));
users.add(new User("郑十",1));
for (int i = 0; i < users.size(); i++) {
//批量更新和删除 也就是切换不同的request
bulkRequest.add(new IndexRequest("zhonglao_index").id(""+i).source(JSON.toJSONString(users.get(i)),XContentType.JSON));
}
BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
System.out.println(bulk.hasFailures());//是否成功 false为成功
}
//查询
@Test
void testSearch() throws IOException {
SearchRequest searchRequest = new SearchRequest("zhonglao_index");
//构建搜索条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//查询条件,可以使用QueryBuilders工具来实现
//QueryBuilders.termQuery 精确
//QueryBuilders.matchAllQuery 匹配所有
// MatchAllQueryBuilder termQueryBuilder = QueryBuilders.matchAllQuery();
//不使用keyword 中文会失效
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword","张三");
searchSourceBuilder.query(termQueryBuilder);
searchSourceBuilder.from(0);
searchSourceBuilder.size(10);
//设置时间
searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
//将查询条件放入查询请求
searchRequest.source(searchSourceBuilder);
//使用客户端请求 返回结果
SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(JSON.toJSONString(search.getHits()));
System.out.println("=========================================");
for (SearchHit hit : search.getHits().getHits()) {
System.out.println(hit.getSourceAsMap());
}
}
}