分布式搜索引擎01
– elasticsearch基础
0.学习目标
1.初识elasticsearch
说明:随着业务的发展我们的数据量越来越庞大,传统的这种mysql数据库就渐渐的难以满足我们复杂的业务需求了,所以在微服务架构下一般都会用到一种分布式搜索的技术,今天就开始学习分布式搜索当中最为流行的一种elasticsearch。
1.1.了解ES
1.1.1.elasticsearch的作用
elasticsearch是一款非常强大的开源搜索引擎,具备非常多强大功能,可以帮助我们从海量数据中快速找到需要的内容
例如:
-
在GitHub搜索代码
-
在电商网站搜索商品
-
在百度搜索答案
-
在打车软件搜索附近的车
1.1.2.ELK技术栈
elasticsearch结合kibana、Logstash、Beats,也就是elastic stack(ELK)。被广泛应用在日志数据分析、实时监控等领域:
- 日志数据分析:项目运行过程中产生的海量日志信息,方便定位系统所出现的问题。线上运行你不可能Debug测试。elasticsearch会以可视化的形式展示出来。
- 实时监控:项目运行过程中的运行状态,比如cpu、内存、访问频率等等,将来以可视化的形式展示出来。
而elasticsearch是elastic stack的核心,负责存储、搜索、分析数据。
- Kibana:组件可以被替换
- elasticsearch:核心组件不可被替换
- Logstash:组件可以被替换
- Beats:组件可以被替换
1.1.3.elasticsearch和lucene
elasticsearch底层是基于lucene来实现的。
Lucene是一个Java语言的搜索引擎类库,是Apache公司的顶级项目,由DougCutting于1999年研发。官网地址:https://lucene.apache.org/
。
- 类库:jar包。
优点:
- 易扩展:可以基于它做二次的开发和定制,实现更高一级的功能,这个类库只实现了搜索引擎的核心api,剩下的你可以去拓展。
- 高性能(基于倒排索引):这种数据结构查询起来性能非常好。
缺点:
- 只限于Java语言开发:它是java语言的类库
- 学习曲线陡峭:api设计比较复杂
- 不支持水平扩展:lucene这套类库只考虑了如何实现搜索,没有高并发也不支持集群扩展场景,想要实现这些功能必须要做一些二次的开发。而elasticsearch正是基于lucene做的二次开发。
elasticsearch的发展历史:
- 2004年Shay Banon基于Lucene开发了Compass
- 2010年Shay Banon 重写了Compass,取名为Elasticsearch。
https://www.elastic.co/cn/
- Restful接口和语言无关
1.1.4.为什么不是其他搜索技术?
目前比较知名的搜索引擎技术排名:
搜索引擎技术排名:
- Elasticsearch:开源的分布式搜索引擎
- Splunk:商业项目 , 收费
- Solr:Apache的开源搜索引擎
虽然在早期,Apache Solr是最主要的搜索引擎技术,但随着发展elasticsearch已经渐渐超越了Solr,独占鳌头:
1.1.5.总结
什么是elasticsearch?
- 一个开源的分布式搜索引擎,可以用来实现搜索、日志统计、分析、系统监控等功能
什么是elastic stack(ELK)?
- 是以elasticsearch为核心的技术栈,包括beats、Logstash、kibana、elasticsearch
什么是Lucene?
- 是Apache的开源搜索引擎类库,提供了搜索引擎的核心API
1.2.倒排索引
倒排索引的概念是基于MySQL这样的正向索引而言的。
1.2.1.正向索引
那么什么是正向索引呢?例如给下表(tb_goods)中的id创建索引:
如果是根据id查询,那么直接走索引,查询速度非常快。
但如果是基于title做模糊查询(模糊查询即便建立了索引也会导致索引失效,走全表扫描),只能是逐行扫描数据,流程如下:
1)用户搜索数据,条件是title符合"%手机%"
2)逐行获取数据,比如id为1的数据
3)判断数据中的title是否符合用户搜索条件
4)如果符合则放入结果集,不符合则丢弃。回到步骤1
逐行扫描,也就是全表扫描,随着数据量增加,其查询效率也会越来越低。当数据量达到数百万时,就是一场灾难。
1.2.2.倒排索引
倒排索引中有两个非常重要的概念:
- 文档(
Document
):用来搜索的数据,其中的每一条数据就是一个文档。例如一个网页、一个商品信息 - 词条(
Term
):对文档数据或用户搜索数据,利用某种算法分词,得到的具备含义的词语就是词条。例如:我是中国人,就可以分为:我、是、中国人、中国、国人这样的几个词条(中英文都可以,)
创建倒排索引是对正向索引的一种特殊处理,流程如下:
- 倒排索引在创建的时候会形成一张新的表。表中包含2个字段(词条、文档id)。
- 将每一个文档的数据利用算法分词,得到一个个词条
- 创建表,每行数据包括词条、词条所在文档id、位置等信息
- 解释:新建的表中存入词条以及文档id,词条不能重复记录,当重复时在重复的词条后记录对应数据的di即可。
- 因为词条唯一性,可以给词条创建索引,例如hash表结构索引
如图:
倒排索引的搜索流程如下(以搜索"华为手机"为例):
1)用户输入条件"华为手机"
进行搜索。
2)对用户输入内容分词,得到词条:华为
、手机
。
3)拿着词条在倒排索引中查找,可以得到包含词条的文档id:1、2、3。
4)拿着文档id到正向索引中查找具体文档。
如图:
虽然要先查询倒排索引,再查询倒排索引,但是无论是词条、还是文档id都建立了索引,查询速度非常快!无需全表扫描。
1.2.3.正向和倒排
那么为什么一个叫做正向索引,一个叫做倒排索引呢?
-
正向索引是最传统的,根据id索引的方式。但根据词条查询时,必须先逐条获取每个文档,然后判断文档中是否包含所需要的词条,是根据文档找词条的过程。
-
而倒排索引则相反,是先找到用户要搜索的词条,根据词条得到保护词条的文档的id,然后根据id获取文档。是根据词条找文档的过程。
是不是恰好反过来了?
那么两者方式的优缺点是什么呢?
正向索引:
- 优点:
- 可以给多个字段创建索引
- 根据索引字段搜索、排序速度非常快
- 缺点:
- 根据非索引字段,或者索引字段中的部分词条查找时,只能全表扫描。
倒排索引:
- 优点:
- 根据词条搜索、模糊搜索时,速度非常快
- 缺点:
- 只能给词条创建索引,而不是字段
- 无法根据字段做排序
1.3.es的一些概念
elasticsearch中有很多独有的概念,与mysql中略有差别,但也有相似之处。
1.3.1.文档和字段
elasticsearch是面向 文档(Document) 存储的,可以是数据库中的一条商品数据,一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中:
而Json文档中往往包含很多的字段(Field),类似于数据库中的列。
1.3.2.索引和映射
索引(Index):就是相同类型的文档的集合。
例如:
- 所有用户文档,就可以组织在一起,称为用户的索引;
- 所有商品的文档,可以组织在一起,称为商品的索引;
- 所有订单的文档,可以组织在一起,称为订单的索引;
因此,我们可以把索引当做是数据库中的表,不同类型放到不同的索引库。
映射(mapping):索引中文档的字段约束信息,类似表的结构约束
数据库的表会有约束信息,用来定义表的结构、字段的名称、类型等信息。因此,索引库中就有映射(mapping),是索引中文档的字段约束信息,类似表的结构约束。
1.3.3.mysql与elasticsearch
我们统一的把mysql与elasticsearch的概念做一下对比:
MySQL | Elasticsearch | 说明 |
---|---|---|
Table | Index | 索引(index),就是文档的集合,类似数据库的表(table) |
Row :行数据 | Document | 文档(Document),就是一条条的数据,类似数据库中的行(Row),文档都是JSON格式 |
Column :列数据 | Field | 字段(Field),就是JSON文档中的字段,类似数据库中的列(Column) |
Schema:约束 | Mapping | Mapping(映射)是索引中文档的约束,例如字段类型约束。类似数据库的表结构(Schema) |
SQL | DSL | DSL是elasticsearch提供的JSON风格的请求语句,用来操作elasticsearch,实现CRUD |
说明:
- mysql:将来在mysql中sql写好了,通过connection把它发给mysql去处理。
- elasticsearch:DSL 写好了是通过http请求发送的,因为es里面对外暴露的是restful接口,这种接口和语言无关,也就是说任何语言只要你能发送http请求你都可以把你的DSL发给我去处理。
是不是说,我们学习了elasticsearch就不再需要mysql了呢?
并不是如此,两者各自有自己的擅长支出:互补关系
-
Mysql:擅长事务类型操作,可以确保数据的安全和一致性
- 因为有a c i d 原子行…
-
Elasticsearch:擅长海量数据的搜索、分析、计算
- 没有事务的特性,无法保证数据的安全和一致性
因此在企业中,往往是两者结合使用:
- 对安全性要求较高的写操作,使用mysql实现
- 对查询性能要求较高的搜索需求,使用elasticsearch实现
- 两者再基于某种方式,实现数据的同步,保证一致性
举例:
- 用户发送一个请求到服务器,之后在服务器中进行判断,如果是增删改的写操作 就把它写到我们的mysql中,这样数据就比较安全了。
- 如果是查询读操作则建议到elasticsearch中去搜索,因为es的性能更好。
- 也就意味着两边都需要有数据,因为crud你要操作的是同一张表的数据,你不能增删改操作mysql中的订单表,查询elasticsearch中的表不是订单表了。
- 如何确保数据同步2边都有数据呢???
- 一般是写在mysql中的,然后mysql在基于某种方式将数据同步给我们的es,从而实现数据的双写。
1.4.安装es、kibana
为什么还要安装kibana????
因为kibana里面提供了一个DevTool工具,可以让我们非常方便的去编写es中的dsl语句从而去操作es(发送请求到es)。
1.4.1.安装
参考课前资料:https://blog.csdn.net/aa35434/article/details/138261790
1.4.2.分词器
es在创建倒排索引时需要对文档分词;在搜索时,需要对用户输入内容分词。但默认的分词规则对中文处理并不友好。
我们在kibana的DevTools中测试的请求代码:
POST /_analyze
{
"analyzer": "standard",
"text": "黑马程序员学习java太棒了!"
}
语法说明:
- POST:请求方式
- /_analyze:请求路径,这里省略了http://192.168.150.101:9200,由kibana帮我们补充
- 请求参数,json风格:
- analyzer:分词器类型,这里是默认的standard分词器
- text:要分词的内容
测试:使用默认的分词器,没有安装IK分词器之前的测试
效果:中文都是按字进行拆分,他没有办法理解中文含义安内容来分,比如:手机分为手和机
2个词,这样在搜索手机
的时候包含手
和机
的词都出来了,手表、大手、小手这些词和你搜的手机都没有关系,显然不合适。
解决:处理中文分词,一般会使用IK分词器。
IK分词器官网:https://github.com/medcl/elasticsearch-analysis-ik
安装IK分词器,参考课前资料《安装elasticsearch.md》:https://blog.csdn.net/aa35434/article/details/138261790
1.4.3.总结
分词器的作用是什么?
- 创建倒排索引时对文档分词
- 用户搜索时,对输入的内容分词
IK分词器有几种模式?
- ik_smart:智能切分,粗粒度
- ik_max_word:最细切分,细粒度
IK分词器如何拓展词条?如何停用词条?
- 利用config目录的IkAnalyzer.cfg.xml文件添加拓展词典和停用词典
- 在词典中添加拓展词条或者停用词条
2.索引库操作----表、约束
索引库就类似数据库表,mapping映射(约束)就类似表的结构。
我们要向es中存储数据,必须先创建“库”和“表”。
2.1.mapping映射属性(约束)
mapping是对索引库中文档的约束,常见的mapping属性包括:
- type:字段数据类型,常见的简单类型有:
- 字符串:text(可分词的文本,可以进行拆分)、keyword(精确值,不可以拆分,例如:品牌、国家、ip地址)
- 数值:long、integer、short、byte、double、float、
- 布尔:boolean
- 日期:date
- 对象:object
- index:是否创建倒排索引,默认为true,所有的字段都会创建倒排索引,都会参与搜索。
- 实际开发过程中不是所有的字段都需要创建索引去搜索(邮箱、图片),因此在创建字段映射的时候需要判断一下这个字段是否参与搜索,也可以根据你的业务需求去判断。
- analyzer:使用哪种分词器
- 用到的比较少,只有text类型才需要分词,一般analyzer结合text一起使用。
- properties:该字段的子字段
- 比如指定下面name的子属性,firstName和lastName。
例如下面的json文档:
{
"age": 21,
"weight": 52.1,
"isMarried": false,
"info": "黑马程序员Java讲师",
"email": "zy@itcast.cn",
"score": [99.1, 99.5, 98.9],
"name": {
"firstName": "云",
"lastName": "赵"
}
}
对应的每个字段映射(mapping):
- age:类型为 integer;参与搜索,因此需要index为true;无需分词器
- weight:类型为float;参与搜索,因此需要index为true;无需分词器
- isMarried:类型为boolean;参与搜索,因此需要index为true;无需分词器
- info:类型为字符串,需要分词,因此是text;参与搜索,因此需要index为true;分词器可以用ik_smart
- email:类型为字符串,但是不需要分词,因此是keyword;不参与搜索,因此需要index为false;无需分词器
- score:虽然是数组,但是我们只看元素的类型,类型为float;参与搜索,因此需要index为true;无需分词器
- name:类型为object,需要定义多个子属性
- name.firstName;类型为字符串,但是不需要分词,因此是keyword;参与搜索,因此需要index为true;无需分词器
- name.lastName;类型为字符串,但是不需要分词,因此是keyword;参与搜索,因此需要index为true;无需分词器
2.2.索引库的CRUD
这里我们统一使用Kibana编写DSL的方式来演示。
2.2.1.创建索引库和映射----插入(put)
即:创建表并指定约束
基本语法:
- 请求方式:PUT
- 请求路径:/索引库名,可以自定义
- 请求参数:mapping映射
格式:
PUT /索引库名称
{
"mappings": { #映射(字段约束、表结构)
"properties": {#字段
"字段名":{#指定具体的字段,每个字段有主机的信息
"type": "text", #字段数据类型
"analyzer": "ik_smart" #分词器
},
"字段名2":{
"type": "keyword",
"index": "false" #不创建索引
},
"字段名3":{
"properties": {#代表子字段,对象嵌套的方式
"子字段": {
"type": "keyword"
}
}
},
// ...略
}
}
}
示例:
PUT /heima
{
"mappings": {
"properties": {
"info":{ #用户信息:多个字段组成的字符串,需要分词,默认index为true建立索引
"type": "text", #text类型可分词
"analyzer": "ik_smart" #使用text属性必须指定分词器,不然默认的分词器对中文不友好
},
"email":{ #邮箱:不需要分词所以不需要指定分词器,不建立索引参与搜索
"type": "keyword",#不需要分词设置为精确值类型
"index": false #不建立索引,不需要参与搜索
},
"name":{ #对象字段
"type": "object", #对象类型
"properties": { #子字段
"firstName": { #具体的子字段
"type": "keyword" #子字段的类型为字符串精确值,不能分词,参与搜索创建索引为true(默认的index)
},
"lastName": { #具体的子字段
"type": "keyword" #子字段的类型为字符串精确值,不能分词
}
}
}
// ... 略
}
}
}
去掉注释:
PUT /heima
{
"mappings": {
"properties": {
"info":{
"type": "text",
"analyzer": "ik_smart"
},
"email":{
"type": "keyword",
"index": "false"
},
"name":{
"type": "object",
"properties": {
"firstName": {
"type": "keyword"
},
"lastName": {
"type": "keyword"
}
}
}
}
}
}
2.2.2.查询索引库----查询
基本语法:
-
请求方式:GET
-
请求路径:/索引库名
-
请求参数:无
格式:
GET /索引库名
示例:
2.2.3.修改索引库----修改(put)
倒排索引结构虽然不复杂,但是一旦数据结构改变(比如改变了分词器),就需要重新创建倒排索引,这简直是灾难。因此索引库一旦创建,无法修改mapping。
虽然无法修改mapping中已有的字段,但是却允许添加新的字段到mapping中,因为不会对倒排索引产生影响。
总结:
- 在es中索引库是不允许修改的
- 但它允许你修改索引库的过程中添加新字段
语法说明:
PUT /索引库名/_mapping #代表改的是索引库的映射
{
"properties": {
"新字段名":{ #新字段名不能和已存在的字段名相同,否则它就认为你改的是已存在的字段,报错
"type": "integer"
}
}
}
示例:
PUT /heima/_mapping
{
"properties": {
"age":{
"type": "integer"
}
}
}
2.2.4.删除索引库----删除
语法:
-
请求方式:DELETE
-
请求路径:/索引库名
-
请求参数:无
格式:
DELETE /索引库名
在kibana中测试:
2.2.5.总结
索引库操作有哪些?
- 创建索引库:PUT /索引库名
- 查询索引库:GET /索引库名
- 删除索引库:DELETE /索引库名
- 添加字段:PUT /索引库名/_mapping
3.文档操作----一操作表中的数据
上面是对表的crud,现在是对表中一行行的数据的crud。
3.1.新增文档
新增文档的DSL语法如下:
- _doc:固定写法
- 文档id:不写会默认随机生成一个,显然不合适(我们要知道具体的文档id),所以需要自己指定
- 下面就是一个json格式的数据
POST /索引库名/_doc/文档id #告诉kibana,新增的文档到那个库里面去
{
"字段1": "值1",
"字段2": "值2",
"字段3": {
"子属性1": "值3",
"子属性2": "值4"
},
// ...
}
示例:
POST /heima/_doc/1
{
"info": "黑马程序员Java讲师",
"email": "zy@itcast.cn",
"name": {
"firstName": "云",
"lastName": "赵"
}
}
响应:created代表成功
3.2.查询文档
根据rest风格,新增是post,查询应该是get,不过查询一般都需要条件,这里我们把文档id带上。
语法:
GET /{索引库名称}/_doc/{id}
通过kibana查看数据:
GET /heima/_doc/1
查看结果:
- _version:版本控制,每做一次版本修改都会加1。
- _source:代表插入的原始文档
3.3.删除文档
删除使用DELETE请求,同样,需要根据id进行删除:
语法:
DELETE /{索引库名}/_doc/id值
示例:
# 根据id删除数据
DELETE /heima/_doc/1
结果:
3.4.修改文档
修改有两种方式:
- 全量修改:直接覆盖原来的文档
- 增量修改:修改文档中的部分字段
3.4.1.全量修改
全量修改是覆盖原来的文档,其本质是:
- 根据指定的id删除文档
- 新增一个相同id的文档
注意:如果根据id删除时,id不存在,第二步的新增也会执行,也就从修改变成了新增操作了。
总结:全量修改既可以做修改也可以做新增,如果id存在是修改,如果文档id不存在是新增。
语法: 和新增相比POST 变为PUT了,其它的没有变化。
PUT /{索引库名}/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
// ... 略
}
示例:
PUT /heima/_doc/1
{
"info": "黑马程序员高级Java讲师",
"email": "zy@itcast.cn",
"name": {
"firstName": "云",
"lastName": "赵"
}
}
再次查询文档,发现成功修改
如果修改的id不存在就变为新增了
3.4.2.增量(局部)修改
增量修改是只修改指定id匹配的文档中的部分字段。
语法:
POST /{索引库名}/_update/文档id
{
"doc": {
"字段名": "新的值",
}
}
示例:
POST /heima/_update/1
{
"doc": {
"email": "ZhaoYun@itcast.cn"
}
}
查看文档,成功修改
3.5.总结
文档操作有哪些?
- 创建文档:POST /{索引库名}/_doc/文档id { json文档 }
- 查询文档:GET /{索引库名}/_doc/文档id
- 删除文档:DELETE /{索引库名}/_doc/文档id
- 修改文档:
- 全量修改:PUT /{索引库名}/_doc/文档id { json文档 }
- 增量修改:POST /{索引库名}/_update/文档id { “doc”: {字段}}
4.RestAPI
说明:就像数据库一样,前面我们用的是dsl语句操作es,我们作为java程序员最终一定是以java代码的方式操作es的。
ES官方提供了各种不同语言的客户端,用来操作ES。这些客户端的本质就是组装DSL语句,通过http请求发送给ES。官方文档地址:https://www.elastic.co/guide/en/elasticsearch/client/index.html
其中的Java Rest Client(操作java的
)又包括两种:
- Java Low Level Rest Client:最早出现的
- Java High Level Rest Client:基于Low Level进一步的封装,用起来更方便。
我们学习的是Java HighLevel Rest Client客户端API
4.0.导入Demo工程
4.0.1.导入数据
首先导入课前资料提供的数据库数据:
数据结构如下:
CREATE TABLE `tb_hotel` (
`id` bigint(20) NOT NULL COMMENT '酒店id',
`name` varchar(255) NOT NULL COMMENT '酒店名称;例:7天酒店',
`address` varchar(255) NOT NULL COMMENT '酒店地址;例:航头路',
`price` int(10) NOT NULL COMMENT '酒店价格;例:329',
`score` int(2) NOT NULL COMMENT '酒店评分;例:45,就是4.5分',
`brand` varchar(32) NOT NULL COMMENT '酒店品牌;例:如家',
`city` varchar(32) NOT NULL COMMENT '所在城市;例:上海',
`star_name` varchar(16) DEFAULT NULL COMMENT '酒店星级,从低到高分别是:1星到5星,1钻到5钻',
`business` varchar(255) DEFAULT NULL COMMENT '商圈;例:虹桥',
`latitude` varchar(32) NOT NULL COMMENT '纬度;例:31.2497',
`longitude` varchar(32) NOT NULL COMMENT '经度;例:120.3925',
`pic` varchar(255) DEFAULT NULL COMMENT '酒店图片;例:/img/1.jpg',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
4.0.2.导入项目
然后导入课前资料提供的项目:
项目结构如图:修改为自己本地的信息,数据库密码、mysql修改为本地localhost的ip
4.0.3.mapping映射分析
创建索引库,最关键的是mapping映射,而mapping映射要考虑的信息包括:
- 字段名
- 字段数据类型
- 是否参与搜索
- 是否需要分词
- 如果分词,分词器是什么?
其中:
- 字段名、字段数据类型,可以参考数据表结构的名称和类型
- 把数据库表中的类型转化为es中对应的类型
- 是否参与搜索要分析业务来判断,例如图片地址,就无需参与搜索
- 是否分词呢要看内容,内容如果是一个整体就无需分词,反之则要分词
- 分词器,我们可以统一使用ik_max_word
数据库表中的数据结构:
转化为酒店数据的索引库结构:
PUT /hotel
{
"mappings": {
"properties": {
"id": {#bigint对应的是long类型,但是id类型特殊只能使用字符串类型,不分词是keyword类型
#id肯定参与到crud,所以index使用默认的true建立索引,参与搜索
"type": "keyword"
},
"name":{ #参与搜索,默认inxex为true
"type": "text", #字符串类型,需要分词
"analyzer": "ik_max_word", #细粒度的分词器
"copy_to": "all"
},
"address":{#地址:来到一个新地方一般是搜索附近的酒店,而不是直接输入具体的酒店地址来搜索。
"type": "keyword",#不需要搜索所以没必要分词,字符串的keyword类型,也不需要分词器
"index": false #不搜索所以不建立索引
},
"price":{#价格:
"type": "integer"#整数类型,参与搜索index为true建立索引,分词器针对的是字符串的text类型
},
"score":{#评分:整数类型,参与搜索index为true建立索引,不需要分词器
"type": "integer"
},
"brand":{#酒店品牌:字符串类型
"type": "keyword",#不需要分词,参与搜索index为true建立索引,不需要分词器
"copy_to": "all"
},
"city":{#城市
"type": "keyword",#不需要分词,参与搜索index为true建立索引,不需要分词器
"copy_to": "all"
},
"starName":{#酒店星级:
"type": "keyword"#不需要分词,参与搜索index为true建立索引,不需要分词器
},
"business":{#商圈:
"type": "keyword"#不需要分词,参与搜索index为true建立索引,不需要分词器
},
"location":{#经纬度:酒店坐标,地理坐标比较特殊(对应表的2个字段 latitude、longitude)
"type": "geo_point"#酒店在地球上比较小,所以代表一个点(既包含经度又包含纬度)
},
"pic":{#酒店图片:url地址,既不分词又不搜索
"type": "keyword", #不分词
"index": false #不搜索
},
#name字段、brand字段、business字段这些字段将来都要参与搜索,也就意味着用户可能输入多个关键字去搜索,
# 即查询的条件不止一个,类似于数据库es也是1个字段搜索效率高,但是现在就像根据多个字段搜索又想要性能好,
# 该如何解决呢???
# 字段拷贝可以使用copy_to属性将当前字段拷贝到指定字段,这样all字段就具有所有你拷贝进去的字段值,
# 也就是说能够在一个字段里搜到多个字段的内容了,这种拷贝还做了优化并不是真的把文档拷贝进去了,而只是
# 基于它创建倒排索引,所以将来你去查的时候看不到这个字段,但是能够根据它来搜。
"all":{ #这个字段名all随意
"type": "text", #字符串类型 可以分词
"analyzer": "ik_max_word" #细粒度的ik分词器
}
}
}
}
无注释:
PUT /hotel
{
"mappings": {
"properties": {
"id": {
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_max_word",
"copy_to": "all"
},
"address":{
"type": "keyword",
"index": false
},
"price":{
"type": "integer"
},
"score":{
"type": "integer"
},
"brand":{
"type": "keyword",
"copy_to": "all"
},
"city":{
"type": "keyword",
"copy_to": "all"
},
"starName":{
"type": "keyword"
},
"business":{
"type": "keyword"
},
"location":{
"type": "geo_point"
},
"pic":{
"type": "keyword",
"index": false
},
"all":{
"type": "text",
"analyzer": "ik_max_word"
}
}
}
}
几个特殊字段说明:
- location:地理坐标,里面包含精度、纬度
- all:一个组合字段,其目的是将多字段的值 利用copy_to合并,提供给用户搜索
地理坐标说明:
copy_to说明:
4.0.4.初始化RestClient
在elasticsearch提供的API中,与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中,必须先完成这个对象的初始化,建立与elasticsearch的连接。
分为三步:
1)引入es的RestHighLevelClient依赖:
<!--es-->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<!--这种方式不能修改es有关的所有版本,所以用插件的方式-->
<!--<version>7.12.1</version>-->
</dependency>
2)因为SpringBoot默认的ES版本是7.6.2,所以我们需要覆盖默认的ES版本:
注意:要和服务端的版本保持一致
<properties>
<java.version>1.8</java.version>
<!--指定es版本-->
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
3)初始化RestHighLevelClient:
初始化的代码如下:
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200")
));
这里为了单元测试方便,我们创建一个测试类HotelIndexTest,然后将初始化的代码编写在@BeforeEach方法中:
package cn.itcast.hotel;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
public class HotelIndexTest {
private RestHighLevelClient client;//定义在外面方便复用
@BeforeEach//单元测试方法之前执行
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
//指定es地址,如果是集群可以写多个
HttpHost.create("http://192.168.10.161:9200")
));
}
@Test
void testInit(){
System.out.println(client);
}
@AfterEach//单元测试方法之后执行
void tearDown() throws IOException {
this.client.close();//销毁释放资源
}
}
4.1.创建索引库
4.1.1.代码解读
创建索引库的API如下:
代码分为三步:
- 1)创建Request对象。因为是创建索引库的操作,因此Request是CreateIndexRequest。
- 2)添加请求参数,其实就是DSL的JSON参数部分。因为json字符串很长,这里是定义了静态字符串常量MAPPING_TEMPLATE,让代码看起来更加优雅。
- 3)发送请求,client.indices()方法的返回值是IndicesClient类型,封装了所有与索引库操作有关的方法。
4.1.2.完整示例
在hotel-demo的cn.itcast.hotel.constants包下,创建一个类,定义mapping映射的JSON字符串常量:
操作步骤:
- 首先:创建一个类编写一个常量,后面要加上""。
- 之后复制之前编写的dsl语句(put这一行不复制)
- 直接复制到这个""里面,会自动生成下面的格式,加上分号(
;
)
package cn.itcast.hotel.constants;
public class HotelConstants {
public static final String MAPPING_TEMPLATE = "{\n" +
" \"mappings\": {\n" +
" \"properties\": {\n" +
" \"id\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"name\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_max_word\",\n" +
" \"copy_to\": \"all\"\n" +
" },\n" +
" \"address\":{\n" +
" \"type\": \"keyword\",\n" +
" \"index\": false\n" +
" },\n" +
" \"price\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"score\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"brand\":{\n" +
" \"type\": \"keyword\",\n" +
" \"copy_to\": \"all\"\n" +
" },\n" +
" \"city\":{\n" +
" \"type\": \"keyword\",\n" +
" \"copy_to\": \"all\"\n" +
" },\n" +
" \"starName\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"business\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"location\":{\n" +
" \"type\": \"geo_point\"\n" +
" },\n" +
" \"pic\":{\n" +
" \"type\": \"keyword\",\n" +
" \"index\": false\n" +
" },\n" +
" \"all\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_max_word\"\n" +
" }\n" +
" }\n" +
" }\n" +
"}";
}
在hotel-demo中的HotelIndexTest测试类中,编写单元测试,实现创建索引:
package cn.itcast.hotel;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import static cn.itcast.hotel.constants.HotelConstants.MAPPING_TEMPLATE;
public class HotelIndexTest {
private RestHighLevelClient client;//定义在外面方便复用
@BeforeEach
//单元测试方法之前执行
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
//指定es地址,如果是集群可以写多个
HttpHost.create("http://192.168.10.161:9200")
));
}
@Test
void testInit(){
System.out.println(client);
}
//创建索引库
@Test
void createHotelIndex() throws IOException {
// 1.创建Request对象(CreateIndexRequest是创建的对象):参数 索引库的名称
CreateIndexRequest request = new CreateIndexRequest("hotelssss");
// 2.准备请求的参数:DSL语句,语句的类型
// DSL语句太长没有直接传,所以定义为常量方式
request.source(MAPPING_TEMPLATE, XContentType.JSON);
// 3.发送请求
//client.indices():获取操作索引库的对象 IndicesClient,这个对象包含所有与索引库操作有关的方法
// create(xx,xx):创建索引库,参数1为request对象 参数2为请求的一些参数,控制请求头的一些信息,一般不用控制使用默认即可
// create需要抛出异常
client.indices().create(request, RequestOptions.DEFAULT);
}
@AfterEach
//单元测试方法之后执行
void tearDown() throws IOException {
this.client.close();//销毁释放资源
}
}
访问测试:
4.2.删除索引库
删除索引库的DSL语句非常简单:
DELETE /hotel
与创建索引库相比:
- 请求方式从PUT变为DELTE
- 请求路径不变
- 无请求参数
所以代码的差异,注意体现在Request对象上。依然是三步走:
- 1)创建Request对象。这次是DeleteIndexRequest对象
- 2)准备参数。这里是无参
- 3)发送请求。改用delete方法
在hotel-demo中的HotelIndexTest测试类中,编写单元测试,实现删除索引:
//删除
@Test
void testDeleteHotelIndex() throws IOException {
// 1.创建Request对象
DeleteIndexRequest request = new DeleteIndexRequest("hotelssss");
// 2.发送请求:不同的请求方法对应不同的request对象
client.indices().delete(request, RequestOptions.DEFAULT);
}
4.3.判断索引库是否存在
判断索引库是否存在,本质就是查询,对应的DSL是:
GET /hotel
因此与删除的Java代码流程是类似的。依然是三步走:
- 1)创建Request对象。这次是GetIndexRequest对象
- 2)准备参数。这里是无参
- 3)发送请求。改用exists方法
- 4)只不过判断是否存在有返回值,要输出它。
//判断索引库是否存在
@Test
void testExistsHotelIndex() throws IOException {
// 1.创建Request对象
GetIndexRequest request = new GetIndexRequest("hotelssss");
// 2.发送请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.输出
System.out.println(exists); //true
System.err.println(exists ? "索引库已经存在!" : "索引库不存在!");//索引库已经存在! err:打印出来的是红色,更加显眼
}
测试删除:
-
执行删除方法,在执行判断方法:不存在
-
之后在执行创建方法,在执行判断方法:存在
4.4.单元测试总代码:
package cn.itcast.hotel;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import static cn.itcast.hotel.constants.HotelConstants.MAPPING_TEMPLATE;
public class HotelIndexTest {
private RestHighLevelClient client;//定义在外面方便复用
//创建RestClient对象:java代码的方式操作es的api对象
@BeforeEach
//单元测试方法之前执行
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
//指定es地址,如果是集群可以写多个
HttpHost.create("http://192.168.10.161:9200")
));
}
@Test
void testInit(){
System.out.println(client);
}
//创建索引库
@Test
void createHotelIndex() throws IOException {
// 1.创建Request对象(CreateIndexRequest是创建的对象):参数 索引库的名称
CreateIndexRequest request = new CreateIndexRequest("hotelssss");
// 2.准备请求的参数:DSL语句,语句的类型
// DSL语句太长没有直接传,所以定义为常量方式
request.source(MAPPING_TEMPLATE, XContentType.JSON);
// 3.发送请求
//client.indices():获取操作索引库的对象 IndicesClient,这个对象包含所有与索引库操作有关的方法
// create(xx,xx):创建索引库,参数1为request对象 参数2为请求的一些参数,控制请求头的一些信息,一般不用控制使用默认即可
// create需要抛出异常
client.indices().create(request, RequestOptions.DEFAULT);
}
//删除
@Test
void testDeleteHotelIndex() throws IOException {
// 1.创建Request对象
DeleteIndexRequest request = new DeleteIndexRequest("hotelssss");
// 2.发送请求:不同的请求方法对应不同的request对象
client.indices().delete(request, RequestOptions.DEFAULT);
}
//判断索引库是否存在
@Test
void testExistsHotelIndex() throws IOException {
// 1.创建Request对象
GetIndexRequest request = new GetIndexRequest("hotelssss");
// 2.发送请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.输出
System.out.println(exists); //true
System.err.println(exists ? "索引库已经存在!" : "索引库不存在!");//索引库已经存在! err:打印出来的是红色,更加显眼
}
@AfterEach
//单元测试方法之后执行
void tearDown() throws IOException {
this.client.close();//销毁释放资源
}
}
4.5.总结
JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。
索引库操作的基本步骤:
- 初始化RestHighLevelClient
- 创建XxxIndexRequest。XXX是Create、Get、Delete
- 准备DSL( Create时需要,其它是无参)
- 发送请求。调用RestHighLevelClient#indices().xxx()方法,xxx是create、exists、delete
5.RestClient操作文档
5.0 案例需求:利用JavaRestClient实现文档的CRUD
去数据库查询酒店数据,导入到hotel索引库,实现酒店数据的CRUD
基本步骤如下:
- 初始化JavaRestClient:上节课已做过
- 利用JavaRestClient新增酒店数据到索引库:从数据库里去查酒店数据,把它转化为索引库所需要的格式,然后写到索引库里去。
- 利用JavaRestClient根据id查询酒店数据
- 利用JavaRestClient删除酒店数据
- 利用JavaRestClient修改酒店数据
为了与索引库操作分离,我们再次参加一个测试类,做两件事情:
- 初始化RestHighLevelClient
- 我们的酒店数据在数据库,需要利用IHotelService去查询,所以注入这个接口
package cn.itcast.hotel;
import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.service.IHotelService;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.List;
@SpringBootTest
public class HotelDocumentTest {
@Autowired
private IHotelService hotelService;
private RestHighLevelClient client;
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200")
));
}
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
5.1.新增文档
我们要将数据库的酒店数据查询出来,写入elasticsearch中。
新增文档的流程:新增的数据来自于数据库,所以需要先把对应的酒店数据查出来,然后再插入到elasticsearch索引库中。
5.1.1.索引库实体类
-
数据库中表的数据:可以封装为java中的一个实体类
-
es索引库中的索引是由一个个文档json类型的数据组成的:也可以封装为java类型的一个实体类
-
总结:该业务新增的流程,数据库中的表转化为对应的实体类,实体类在转化为json存入到es中,只不过es需要的实体类格式不同需要先进行实体类的转化。
数据库查询后的结果是一个Hotel(酒店)类型的对象。结构如下:
@Data
@TableName("tb_hotel")
public class Hotel {
@TableId(type = IdType.INPUT)
private Long id;
private String name;
private String address;
private Integer price;
private Integer score;
private String brand;
private String city;
private String starName;
private String business;
private String longitude;
private String latitude;
private String pic;
}
与我们的索引库结构存在差异:
- longitude和latitude需要合并为location:索引库的地理位置坐标特殊,它是把经纬度合成一个字符串,拼接在一起
因此,我们需要定义一个新的类型,与索引库结构吻合:
package cn.itcast.hotel.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class HotelDoc {
private Long id;
private String name;
private String address;
private Integer price;
private Integer score;
private String brand;
private String city;
private String starName;
private String business;
private String location;
private String pic;
public HotelDoc(Hotel hotel) {
this.id = hotel.getId();
this.name = hotel.getName();
this.address = hotel.getAddress();
this.price = hotel.getPrice();
this.score = hotel.getScore();
this.brand = hotel.getBrand();
this.city = hotel.getCity();
this.starName = hotel.getStarName();
this.business = hotel.getBusiness();
this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
this.pic = hotel.getPic();
}
}
5.1.2.语法说明
新增文档的DSL语句如下:
POST /{索引库名}/_doc/1
{
"name": "Jack",
"age": 21
}
对应的java代码如图:
可以看到与创建索引库类似,同样是三步走:
- 1)创建Request对象
- 2)准备请求参数,也就是DSL中的JSON文档
- 3)发送请求
变化的地方在于,这里直接使用client.xxx()的API,不再需要client.indices()了。
5.1.3.完整代码
我们导入酒店数据,基本流程一致,但是需要考虑几点变化:
- 酒店数据来自于数据库,我们需要先查询出来,得到hotel对象
- hotel对象需要转为HotelDoc对象
- HotelDoc需要序列化为json格式
因此,代码整体步骤如下:
- 1)根据id查询酒店数据Hotel
- 2)将Hotel封装为HotelDoc
- 3)将HotelDoc序列化为JSON
- 4)创建IndexRequest,指定索引库名和id
- 5)准备请求参数,也就是JSON文档
- 6)发送请求
在hotel-demo的HotelDocumentTest测试类中,编写单元测试:
package cn.itcast.hotel;
import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.pojo.HotelDoc;
import cn.itcast.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import static cn.itcast.hotel.constants.HotelConstants.MAPPING_TEMPLATE;
@SpringBootTest
public class HotelDocumentTest {
@Autowired
IHotelService hotelService; //myPlus方式:注入了业务层实现类,该类的父接口实现了IService<Hotel>
private RestHighLevelClient client;//定义在外面方便复用
//创建RestClient对象:java代码的方式操作es的api对象
@BeforeEach
//单元测试方法之前执行
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
//指定es地址,如果是集群可以写多个
HttpHost.create("http://192.168.10.161:9200")
));
}
@Test
void testInit(){
System.out.println(client);
}
//文档新增
@Test
void testAddDocument() throws IOException {
// 1.根据id查询酒店数据 61083L用的是数据库酒店表的一张真实id
Hotel hotel = hotelService.getById(61083L);
// 2.转换为文档类型
HotelDoc hotelDoc = new HotelDoc(hotel);
// 3.将HotelDoc对象转json: fastjson提供的api
String json = JSON.toJSONString(hotelDoc);
// 1.准备Request对象 :索引库名 ,文档id(来自己数据库的酒店数据)
// bigint对应的是long类型,但是id类型特殊只能使用字符串类型,不分词是keyword类型
IndexRequest request = new IndexRequest("hotelssss").id(hotelDoc.getId().toString());
// 2.准备Json文档:新增的json文档(来自己数据库的酒店数据),类型
request.source(json, XContentType.JSON);
// 3.发送请求 index:操作文档,给文档创建倒排索引
// request对象 依然是默认类型
client.index(request, RequestOptions.DEFAULT);
}
@AfterEach
//单元测试方法之后执行
void tearDown() throws IOException {
this.client.close();//销毁释放资源
}
}
运行单元测试类,然后访问测试:可以正确查询到这条插入的文档数据
用到的mybatis-plus
用到的数据库表中对应的数据:
5.2.查询文档
5.2.1.语法说明
查询的DSL语句如下:
GET /hotel/_doc/{id}
非常简单,因此代码大概分两步:
- 准备Request对象
- 发送请求
不过查询的目的是得到结果,解析为HotelDoc,因此难点是结果的解析。完整代码如下:
可以看到,结果是一个JSON,其中文档放在一个_source(封装的是原始文档信息)
属性中,因此解析就是拿到_source
,反序列化为Java对象即可。
与之前类似,也是三步走:
- 1)准备Request对象。这次是查询,所以是GetRequest
- 2)发送请求,得到结果。因为是查询,这里调用client.get()方法
- 3)解析结果,就是对JSON做反序列化
5.2.2.完整代码
在hotel-demo的HotelDocumentTest测试类中,编写单元测试:
//查询
@Test
void testGetDocumentById() throws IOException {
// 1.准备Request :索引库,文档id
GetRequest request = new GetRequest("hotelssss", "61083");
// 2.发送请求,得到响应:request对象,默认类型
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析响应结果:_source封装的是原始文档信息,所以想要拿到查询结果只需要解析source即可
String json = response.getSourceAsString();//返回值是个json字符串
//我们最终肯定得到的是个对象:将json字符串转化为对象(fastjson实现反序列化)
// 反序列化的值,需要转化的类型
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println(hotelDoc);
}
运行测试类:
5.3.删除文档
删除的DSL为是这样的:
DELETE /hotel/_doc/{id}
与查询相比,仅仅是请求方式从DELETE变成GET,可以想象Java代码应该依然是三步走:
- 1)准备Request对象,因为是删除,这次是DeleteRequest对象。要指定索引库名和id
- 2)准备参数,无参
- 3)发送请求。因为是删除,所以是client.delete()方法
在hotel-demo的HotelDocumentTest测试类中,编写单元测试:
//删除
@Test
void testDeleteDocument() throws IOException {
// 1.准备Request
DeleteRequest request = new DeleteRequest("hotelssss", "61083");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}
先执行删除,在执行查询:结果为null
5.4.修改文档
5.4.1.语法说明
修改我们讲过两种方式:
- 全量修改:本质是先根据id删除,再新增
- 增量修改:修改文档中的指定字段值
在RestClient的API中,全量修改与新增的API完全一致,判断依据是ID:
- 如果新增时,ID已经存在,则修改
- 如果新增时,ID不存在,则新增
这里不再赘述,我们主要关注增量修改。
代码示例如图:
与之前类似,也是三步走:
- 1)准备Request对象。这次是修改,所以是UpdateRequest
- 2)准备参数。也就是JSON文档,里面包含要修改的字段
- 3)更新文档。这里调用client.update()方法
5.4.2.完整代码
在hotel-demo的HotelDocumentTest测试类中,编写单元测试:
// 增量修改:修改局部
@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("hotelssss", "61083");
// 2.准备请求参数:需要更新的字段
request.doc(
"price", "952",
"starName", "四钻"
);
// 3.发送请求,更新文档
client.update(request, RequestOptions.DEFAULT);
}
执行修改的单元测试,在执行查询的单元测试:可以看到字段更新成功
5.5.批量导入文档
说明:上面学习的新增是一次新增一条数据,那么如果你将来的数据库里有数千上万的数据,一次新增一个太麻烦了。
案例需求:利用BulkRequest批量将数据库数据导入到索引库中。
步骤如下:
-
利用mybatis-plus查询酒店数据
-
将查询到的酒店数据(Hotel)转换为文档类型数据(HotelDoc)
-
利用JavaRestClient中的BulkRequest批处理,实现批量新增文档
5.5.1.语法说明
批量处理BulkRequest,其本质就是将多个普通的CRUD请求组合在一起发送。
其中提供了一个add方法,用来添加其他请求:
可以看到,能添加的请求包括:
- IndexRequest,也就是新增
- UpdateRequest,也就是修改
- DeleteRequest,也就是删除
因此Bulk中添加了多个IndexRequest,就是批量新增功能了。示例:
其实还是三步走:
- 1)创建Request对象。这里是BulkRequest
- 2)准备参数。批处理的参数,就是其它Request对象,这里就是多个IndexRequest
- 3)发起请求。这里是批处理,调用的方法为client.bulk()方法
我们在导入酒店数据时,将上述代码改造成for循环处理即可。
5.5.2.完整代码
在hotel-demo的HotelDocumentTest测试类中,编写单元测试:
//批量新增
@Test
void testBulkRequest() throws IOException {
// 批量查询酒店数据 MP方式
List<Hotel> hotels = hotelService.list();//查询所有酒店数据
// 1.创建Request:不需要传递参数,它只是一个封装,把别的请求捆绑到一起
BulkRequest request = new BulkRequest();
// 2.准备参数,添加多个新增的Request:根据传递请求类型的不同,可以批量修改、批量删除、批量新增
for (Hotel hotel : hotels) {
// 2.1.转换为文档类型HotelDoc :遍历hotes一个个的转化
HotelDoc hotelDoc = new HotelDoc(hotel);
// 2.2.创建新增文档的Request对象 :批量新增使用IndexRequest对象
// 索引库名称 文档id 新增的json文档数据
// 链式加载
request.add(new IndexRequest("hotelssss")
.id(hotelDoc.getId().toString())
.source(JSON.toJSONString(hotelDoc), XContentType.JSON));
}
// 3.发送请求
// bulk:批量处理, 参数1 参数2 和以前一样
client.bulk(request, RequestOptions.DEFAULT);
}
执行单元测试,然后批量查询文档数据
5.6.文档单元测试总代码
package cn.itcast.hotel;
import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.pojo.HotelDoc;
import cn.itcast.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.List;
import static cn.itcast.hotel.constants.HotelConstants.MAPPING_TEMPLATE;
@SpringBootTest
public class HotelDocumentTest {
@Autowired
IHotelService hotelService; //myPlus方式:注入了业务层实现类,该类的父接口实现了IService<Hotel>
private RestHighLevelClient client;//定义在外面方便复用
//创建RestClient对象:java代码的方式操作es的api对象
@BeforeEach
//单元测试方法之前执行
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
//指定es地址,如果是集群可以写多个
HttpHost.create("http://192.168.10.161:9200")
));
}
@Test
void testInit(){
System.out.println(client);
}
//文档新增
@Test
void testAddDocument() throws IOException {
// 1.根据id查询酒店数据 61083L用的是数据库酒店表的一张真实id
Hotel hotel = hotelService.getById(61083L);
// 2.转换为文档类型
HotelDoc hotelDoc = new HotelDoc(hotel);
// 3.将HotelDoc对象转json: fastjson提供的api
String json = JSON.toJSONString(hotelDoc);
// 1.准备Request对象 :索引库名 ,文档id(来自己数据库的酒店数据)
// bigint对应的是long类型,但是id类型特殊只能使用字符串类型,不分词是keyword类型
IndexRequest request = new IndexRequest("hotelssss").id(hotelDoc.getId().toString());
// 2.准备Json文档:新增的json文档(来自己数据库的酒店数据),类型
request.source(json, XContentType.JSON);
// 3.发送请求 index:操作文档,给文档创建倒排索引
// request对象 依然是默认类型
client.index(request, RequestOptions.DEFAULT);
}
//批量新增
@Test
void testBulkRequest() throws IOException {
// 批量查询酒店数据 MP方式
List<Hotel> hotels = hotelService.list();//查询所有酒店数据
// 1.创建Request:不需要传递参数,它只是一个封装,把别的请求捆绑到一起
BulkRequest request = new BulkRequest();
// 2.准备参数,添加多个新增的Request:根据传递请求类型的不同,可以批量修改、批量删除、批量新增
for (Hotel hotel : hotels) {
// 2.1.转换为文档类型HotelDoc :遍历hotes一个个的转化
HotelDoc hotelDoc = new HotelDoc(hotel);
// 2.2.创建新增文档的Request对象 :批量新增使用IndexRequest对象
// 索引库名称 文档id 新增的json文档数据
// 链式加载
request.add(new IndexRequest("hotelssss")
.id(hotelDoc.getId().toString())
.source(JSON.toJSONString(hotelDoc), XContentType.JSON));
}
// 3.发送请求
// bulk:批量处理, 参数1 参数2 和以前一样
client.bulk(request, RequestOptions.DEFAULT);
}
//查询
@Test
void testGetDocumentById() throws IOException {
// 1.准备Request :索引库,文档id
GetRequest request = new GetRequest("hotelssss", "61083");
// 2.发送请求,得到响应:request对象,默认类型
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析响应结果:_source封装的是原始文档信息,所以想要拿到查询结果只需要解析source即可
String json = response.getSourceAsString();//返回值是个json字符串
//我们最终肯定得到的是个对象:将json字符串转化为对象(fastjson实现反序列化)
// 反序列化的值,需要转化的类型
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println(hotelDoc);
}
// 增量修改:修改局部
@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("hotelssss", "61083");
// 2.准备请求参数:需要更新的字段
request.doc(
"price", "952",
"starName", "四钻"
);
// 3.发送请求,更新文档
client.update(request, RequestOptions.DEFAULT);
}
//删除
@Test
void testDeleteDocument() throws IOException {
// 1.准备Request
DeleteRequest request = new DeleteRequest("hotelssss", "61083");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}
@AfterEach
//单元测试方法之后执行
void tearDown() throws IOException {
this.client.close();//销毁释放资源
}
}
5.7.小结
文档操作的基本步骤:
- 初始化RestHighLevelClient
- 创建XxxRequest。XXX是Index、Get、Update、Delete、Bulk
- 准备参数(Index、Update、Bulk时需要)
- 发送请求。调用RestHighLevelClient#.xxx()方法,xxx是index、get、update、delete、bulk
- 解析结果(Get时需要)