以下学习笔记均来自视频资料https://www.bilibili.com/video/BV17a4y1x7zq
lucene 是一套信息检索工具包!jar包! 不包含 搜索引擎系统!
包含的: 索引结构! 读写索引的工具! 排序,搜索规则...工具类!
Lucene 和 ElasticSearch关系
ElasticSearch是基于Lucene 做了一些封装和增强
ElasticSearch,简称为es,es是一个开源的高扩展的分布式全文检索引擎,它可以近乎实时的存储、检索数据;本身扩展性很好,可以扩展到上百台服务器,处理PB级别(大数据时代)的数据.es也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能,但是他的目的是通过简单的RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单.
据国际权威的数据库产品评测机构DB Engines的统计,在2016年1月,ElasticSearch已超过Solr等,成为排名第一的搜索引擎类应用.
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是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是apache软件基金会4 jakarta项目组的一个子项目,是一个开放源代码的全文检索引擎工具包,但他不是一个完整的全文检索引擎,而是一个全文检索引擎的架构,提供了完整的查询引擎和索引引擎,部分文本分析引擎,Lucene的目的是为软件开发人员提供了一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎.Lucene是一套用于全文检索和搜寻的开源程式库,由Apache软件基金会支持和提供.Lucene提供了一个简单却强大的应用程式接口,能够做全文索引和搜寻.在java开发环境里Lucene是一个成熟的免费开源工具.就其本身而言,Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库.人们经常提到信息检索程序库,虽然与搜索引擎有关,但不应该将信息检索程序库与搜索引擎相混淆.
Lucene是一个全文检索引擎的架构. 那什么是全文搜索引擎?
全文搜索引擎是名副其实的搜索引擎,国外具代表性的有Google、Fast/AllTheWeb、AltaVisata、Inktomi、Teoma、WiseNut等,国内著名的有百度。他们都是通过互联网上提取各个网站的信息
(以网页文字为主)而建立的数据库中,检索与用户查询条件匹配的相关记录,然后按一定的排列顺序将结果返回给用户,因此他们是真正的搜索引擎。
从搜索结果来源的角度,全文搜索引擎又可细分为两种,一种是拥有自己的检索程序(indexer)俗称“蜘蛛”(Spider)程序或“机器人”(Robot)程序,并自检网页数据库,搜索结果直接从自身的数据库中调用,如上面提到的7家引擎;另一种则是租用其他引擎的数据库,并按自定的格式拍你搜索结果,如Lycos引擎。
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查询快,但更新索引时慢(即插入删除慢),用于电商等查询多的应用;
6.solr比较成熟,有一个更大,更成熟的用户、开发和贡献者社区,而ElasticSearch相对开发维护者较少,更新太快,学习使用成本较高。
下载
官网:https://www.elastic.co/
华为云镜像(视频粉丝提供)
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
添加一条配置:
测试 127.0.0.1:9200
安装可视化界面es head插件
下载地址:
启动
npm install npm run start
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"
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_smart和ik_max_word,其中ik_smart为最少切分,ik_max_word为最细粒度划分!
下载
查看不同的分词器效果
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 添加自己的词库
{ "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命令说明:
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查询是直接通过倒排索引指定的词条进程精确查找
关于分词:
两个类型 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":{} } } }
看文档
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()); } } }