07SpringCloud-Elasticsearch
1.初识Elasticsearch
什么是elasticsearch
elasticsearch是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容
elasticsearch结合kibana、Logstash、 Beats, 也就是elastic stack(ELK)。被广泛应用在日志数据分析、实时监控等领域。
elasticsearch可以将日志信息可视化展示出来，所以将来做日志分析时候非常方便。因此搜索引擎使用的场景非常广泛，ELK技术栈里面尽管有很多组件，核心就是elasticsearch，它复制数据的存储、计算、搜索分析。而Logstash,Beats主要负责数据抓取的， Kibana是一个数据可视化组件，用于数据展示，形成报表。但是可视化组件是否必须使用kibana?不一定，完全可以自己去实现。数据抓取也同理，完全可以自己去写java代码，抓取数据。所以，除了elasticsearch以外，都是可替代的。
elasticsearch的底层实现是一个名为Lucene的技术。
Lucene是- -个Java语言的搜索引擎类库,是Apache公司的顶级项目，由DougCutting于1999年研发
官网地址: https://lucene.apache.org/。
Lucene的优势：易扩展，高性能（基于倒排索引）
Lucene的缺点：只限于java语言开发，学习难，不支持水平扩展。不支持高并发场景，不支持集群扩展。所以要实现必须进行二次开发。
elasticsearch的发展
2004年Shay Banon基于Lucene开发了Compassp
2010年Shay Banon重写了Compass,取名为Elasticsearch。
官网地址: https://www.elastic.co/cn/
目前最新的版本是: 7.12.1
相比与lucene, elasticsearch具备下列优势:
- 支持分布式，可水平扩展.
- 提供Restful接口，可被任何语言调用
因此具备了处理海量数据和高并发场景的能力。
为什么学习elasticsearch？
搜索引擎技术排名:
-
Elasticsearch:开源的分布式搜索引擎
-
Splunk: 商业项目
-
Solr: Apache的开源搜索引擎
总结
什么是elasticsearch?
一个开源的分布式搜索引擎，可以用来实现搜索、日志统计、分析、系统监控等功能
什么是elastic stack (ELK) ?
是以elasticsearch为核心的技术栈 ，包括beats、Logstash.kibana、elasticsearch
什么是Lucene?
是Apache的开源搜索引擎类库, 提供了搜索引擎的核心API
2.倒排索引
倒排索引是与mysql等传统数据库的正向索引去对比得出的一个名称，因此与传统数据库的索引是有比较大的差异的。
这个差异我们通过一个案例来看一下。
正向索引和倒排索引
传统数据库( 如MySQL)采用正向索引，例如给下表(tb_ goods)中的id创建索引:
一般情况下，会基于id去创建索引形成一颗B+树，检索的速度就会非常快，这种方式的索引就是一种正向索引，但是如果我现在搜索的不是id，而是一个普通的title字段，title内容比较长，你不会去给他加索引，而且即便你有索引，如果是模糊查询，索引也不会生效，这种情况下没有索引我们数据库怎么去比较和查询呢？就会采用逐条扫描的方式，如果你的表数据非常大，性能差，这就是正向索引，它进行局部内容索引的时候，效率比较差。那倒排索引又是怎么来做的呢？
elasticsearch采用倒排索引:
文档(document) : 每条数据就是一个文档
词条(term) : 文档按照语义分成的词语
比如说，小米是一个词条，手机也是一个词条，等等…
所以倒排索引，它会先把文档中的内容分成词条去存，比方说我拿到第一条数据，那么我要对标题创建倒排索引，我就要把标题做个分词，分成，小米、手机两个词，并记录它的文档id，因为是第一条数据，即文档id为1，存第二条的时候，手机已经存在词条，再记录一个文档id即可。
将来你有更多的词条，继续往下记录即可，并且这些词条肯定有大量的重复，只记录唯一的一个词条。这样能保证倒排索引词条字段是绝对不会出现重复的。因为其唯一性，那么我们就可以给他创建索引了。数据较少的时候使用哈希法，也可以使用B+树，去给词条创建唯一索引。那么将来我们根据词条查询的速度，就非常快了。
现在比如说我搜索华为手机，elasticsearch会对用户输入的进行一段分词，分为华为、手机，拿着这两个词条去倒排索引中进行查询，这是非常快的，查到手机，1,2；查到华为2,3；两组文档ID。这个时候我就知道了包含华为手机的所有的文档了，其中2号文档的关联度更高一点，将来就可以排序，2号文档往前排，1和3往后一点。然后我拿着这三个id我就可以去查询文档了，查询id为1,2,3的正向索引，也会很快。
所以，我们其实经过了两次查询，但是两次查询都经过了索引，这个效率是比逐条查询效率高的。
倒排索引之所以叫倒排索引，因为我们在正向索引中，我们要找到包含手机的，我们得一行行的看，先看文档，再看是否包含词条。倒排索引是倒过来的，先去看词条，再去关联到文档。
倒排索引更擅长于基于文档的内容进行搜索，更复杂的搜索需求，这就是为什么我们的搜索引擎底层都是基于倒排索引的原因。
总结
什么是文档什么是词条？
-
每一条数据就是一 个文档
-
对文档中的内容分词，得到的词语就是词条
什么是正向索引？
- 基于文档id创建索引。查询词条时必须先找到文档，而后判断是否包含词条
什么是倒排索引？
- 对文档内容分词，对词条创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档id,而后获取到文档
3.ES与Mysql的概念对比
elasticsearch是面向文档存储的，可以是数据库中的一条商品数据，一个订单信息。
文档数据会被序列化为json格式后存储在elasticsearch中。
索引(Index)、映射(mapping)
索引(index) :相同类型的文档的集合
映射(mapping) :索引中文档的字段约束信息，类似表的结构约束
elasticsearch与mysql的概念对应关系
SQL和DSL在发送时的差别
在ES中，你写好了DSL以后，我们是基于HTTP请求发出去，因为ES对外暴露的restful接口，这种接口的好处的跟语言无关。任何的语言只要能发HTTP请求，你都可以把你的DSL发给我，我就能处理了。这样以来就彻底脱离了语言的束缚了。
是不是说有了ES以后，我们就能完全替代了我们的Mysql了呢？不是，他们两个擅长的事情是不一样的
Mysql:擅长事务类型操作，可以确保数据的安全和一-致性
Elasticsearch:擅长海量数据的搜索、分析、计算
ES没有事务的概念，它无法保证ACID，所有他们两个是各司其职的，如果说你现在做的是下单付款的业务，它对事务要求很高，数据的安全性、一致性要求很高，你就应该使用mysql去做数据的存储。但是你现在做的是商品的搜索或者页面的搜索，这个搜索比较复杂，你肯定得用ES去做。【是一种互补的关系】
将来我们的系统架构当中，两个都会存在。
比方说用户来一个商品查询的CRUD，它的请求访问到服务器以后，我们的服务器就可以作出一个判断，如果是增删写操作，就给到mysql，这样数据就比较安全了。如果你现在是查询的操作，就给到ES去做。
那么怎么确保ES和mysql都有数据呢？
mysql可以使用某种方式，将数据同步给ES，从而实现数据的双写。
总结
针对业务量比较大， 实现需求比较复杂的时候，才会考虑两个库里都去写。但一些简单的查询（根据ID查询）还是用数据库没问题的。
合适场景选择合适的技术
4.安装elasticsearch，kibana
4.1 部署单点ES
因为我们还需要部署kibana容器，因此需要让es和kibana容器互联。这里先创建一个网络：
docker network create es-net
网络名es-net可以任意取，在xshell输入，创建全新的网络。
输入结果：
[root@hadoop100 ~]# docker network create es-net
1394876ff1c3b5e2e0c7937daeb808324ed7be9ed8d09b781e0a8ef0bc689f31
这里我们采用elasticsearch的7.12.1版本的镜像，这个镜像体积非常大，接近1G。不建议大家自己pull。
课前资料提供了镜像的tar包：
大家将其上传到虚拟机中，然后运行命令加载即可：
# 导入数据
docker load -i es.tar
docker load -i kibana.tar
同理还有kibana的tar包也需要这样做。
加载情况
[root@hadoop100 software]# docker load -i es.tar
2653d992f4ef: Loading layer [==================================================>] 216.5MB/216.5MB
0ba8eff8aa04: Loading layer [==================================================>] 101.4MB/101.4MB
2a944434ad00: Loading layer [==================================================>] 314.9kB/314.9kB
ade95a7611c0: Loading layer [==================================================>] 543.9MB/543.9MB
09a575a6e776: Loading layer [==================================================>] 26.62kB/26.62kB
498ae65924d7: Loading layer [==================================================>] 7.68kB/7.68kB
36b3f8db7aaa: Loading layer [==================================================>] 490.5kB/490.5kB
Loaded image: elasticsearch:7.12.1
[root@hadoop100 software]# docker load -i kibana.tar
d797e87ed4ce: Loading layer [==================================================>] 112.9MB/112.9MB
80ce41fc1f8a: Loading layer [==================================================>] 26.62kB/26.62kB
3345a8ffd0ea: Loading layer [==================================================>] 3.584kB/3.584kB
d736a1702974: Loading layer [==================================================>] 20.34MB/20.34MB
570575469db2: Loading layer [==================================================>] 56.83kB/56.83kB
459d502a3562: Loading layer [==================================================>] 770.7MB/770.7MB
f22a9f0649d0: Loading layer [==================================================>] 2.048kB/2.048kB
4b66f24ba0de: Loading layer [==================================================>] 4.096kB/4.096kB
0a50faa06266: Loading layer [==================================================>] 15.36kB/15.36kB
8a310ff91413: Loading layer [==================================================>] 4.096kB/4.096kB
5997553ddc84: Loading layer [==================================================>] 479.2kB/479.2kB
f87dadd7c340: Loading layer [==================================================>] 309.8kB/309.8kB
Loaded image: kibana:7.12.1
运行docker命令，部署单点es：
docker run -d \
--name es \
-e "ES_JAVA_OPTS=-Xms1024m -Xmx1024m" \
-e "discovery.type=single-node" \
-v es-data:/usr/share/elasticsearch/data \
-v es-plugins:/usr/share/elasticsearch/plugins \
--privileged \
--network es-net \
-p 9200:9200 \
-p 9300:9300 \
elasticsearch:7.12.1
命令解释：
-e "cluster.name=es-docker-cluster"：设置集群名称-e "http.host=0.0.0.0"：监听的地址，可以外网访问-e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小-e "discovery.type=single-node"：非集群模式-v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录-v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录-v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录--privileged：授予逻辑卷访问权--network es-net：加入一个名为es-net的网络中-p 9200:9200：端口映射配置,(暴露的Http协议的端口，将来供用户访问的)-p 9300:9300：将来ES容器各个结点之间互联的端口。elasticsearch:7.12.1： 镜像名称
浏览器访问网站 http://192.168.10.100:9200/
ES安装就完成了！
安装Kibanna
kibana可以给我们提供一个elasticsearch的可视化界面，便于我们学习。
运行docker命令，部署kibana
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601 \
kibana:7.12.1
--network es-net：加入一个名为es-net的网络中，与elasticsearch在同一个网络中-e ELASTICSEARCH_HOSTS=http://es:9200"：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch-p 5601:5601：端口映射配置
kibana启动一般比较慢，需要多等待一会，可以通过命令：
docker logs -f kibana
查看运行日志，当查看到下面的日志，说明成功：
也就是这句话
{"type":"log","@timestamp":"2021-11-17T01:13:05+00:00","tags":["listening","info"],"pid":6,"message":"Server running at http://0.0.0.0:5601"}
此时，在浏览器输入地址访问：http://192.168.10.100:5601，即可看到结果
DevTools
kibana中提供了一个DevTools界面：
这个界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。
4.2 安装IK分词器
分词器
es在创建倒排索引时需要对文档分词;在搜索时，需要对用户输入内容分词。但默认的分词规则对中文处理并不友好。我们在kibana的DevTools中测试:
英语分词还是可以的，但是中文确是逐字分词。如果要分词中文就不能使用默认分词器。一般中文分词我们会采用IK分词器。https://github.com/medcl/elasticsearch-analysis-ik
在线安装ik插件（较慢）
# 进入容器内部
docker exec -it elasticsearch /bin/bash
# 在线下载并安装
./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
#退出
exit
#重启容器
docker restart elasticsearch
离线安装ik插件（推荐）
1）查看数据卷目录
安装插件需要知道elasticsearch的plugins目录位置，而我们用了数据卷挂载，因此需要查看elasticsearch的数据卷目录，通过下面命令查看:
docker volume inspect es-plugins
显示结果：
[
{
"CreatedAt": "2022-05-06T10:06:34+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
"Name": "es-plugins",
"Options": null,
"Scope": "local"
}
]
说明plugins目录被挂载到了：/var/lib/docker/volumes/es-plugins/_data这个目录中。
下面我们需要把课前资料中的ik分词器解压缩，重命名为ik
传到es容器的插件数据卷中
也就是/var/lib/docker/volumes/es-plugins/_data：
重启容器
# 4、重启容器
docker restart es
# 查看es日志
docker logs -f es
测试：
IK分词器包含两种模式：
ik_smart：最少切分 （ 粗粒度切分，从字数最多去到字数最少去看，比如说“程序员”是不会切分的）ik_max_word：最细切分（细粒度切分，比如说“程序员”会切分成，“程序员”，“程序”，“员”）
这两种带来的后果是什么？如果搜程序，按第一种是搜不到这篇文档的，搜索的概率就比较低，好处是分的词少占用的内存空间就少了。到时内存就能缓存更多的数据，效率更高一点。这就是smart模式优势。max_word占用内存空间会更多。
底层分词的原理是什么？
字典，字典里会有各种各样的词语罗列好了。IK分词器还有其他的中文分词器，都会依赖于一个字典去做分词。它这个字典中可能会包含我们不希望的分词（如 “的”，“了”，“哦”），也有我们希望有的新潮词汇（如“奥利给”，“白嫖”）等。我们应该如何扩展呢？
4.3 IK分词器 - 扩展词库
要拓展ik分词器的词库，只需要修改一个ik分词器 目录中的config目录中的IkAnalyzer.cfg.xml文件:
要禁用某些敏感词条，只需要修改一个ik分词器目录中的config目录中的IkAnalyzer.cfg.xml文件:
在ik分词器的config目录下修改以下3个文件
/var/lib/docker/volumes/es-plugins/_data/ik/config
其他更多的功能，参考官网文档
总结
5.索引库操作
mapping属性
mapping是对索引库中文档的约束，常见的mapping属性包括:
官方手册：https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html
常用：
| type | 字段数据类型 | |
| 字符串 | text (可分词的文本) keyword (精确值,例如:品牌、国家、ip地址) 如果字段不需要拆分，就用keyword |
|
| 数值 | long,integer,short,byte,double,float | |
| 布尔 | boolean | |
| 日期 | date | |
| 对象 | object | |
| index | 是否创建索引 | 默认为true，主要取决于某个字段是否参与搜索 |
| analyzer | 使用哪种分词器 | 使用的较少，因为只有text需要分词，其他类型都不需要分词。 它的值就是分词器的名称（ik_smart,ik_max_word) |
| properties | 该字段的子字段 | 处理"name":{ "firstName":"xx","lastName":"yy" }这种情况 |
总结：
创建索引库
DSL
PUT /heima
{
"mappings": {
"properties": {
"info":{
"type": "text",
"analyzer": "ik_smart"
},
"email":{
"type": "keyword",
"index": false
},
"name":{
"properties": {
"firstName":{
"type":"keyword"
},
"lastName":{
"type":"keyword"
}
}
}
}
}
}
结果
{
"acknowledged" : true,
"shards_acknowledged" : true,
"index" : "heima"
}
查询、删除索引库
修改索引库
事实上在ES中是不允许 修改的，因为索引库创建完成了以后，它的数据结构也就是mapping映射都已经定义好了，我们ES会基于这些mapping去创建倒排索引，那么如果说你要去修改一个字段，就会导致原有的倒排索引彻底失效。
【在ES里禁止修改索引库】
ES虽然禁止修改原有字段，但允许你添加新字段。
# 查询
GET /heima
# 修改索引库，添加新字段
PUT /heima/_mapping
{
"properties":{
"age":{
"type":"integer"
}
}
}
# 删除
DELETE /heima
总结：
6.文档的CRUD
添加文档
查看、删除文档
修改文档
所有DSL
# 插入文档
POST /heima/_doc/1
{
"info":"黑马程序员java讲师",
"email":"[email protected]",
"name":{
"firstName":"y",
"lastName":"z"
}
}
# 查询文档
GET /heima/_doc/1
# 删除文档
DELETE /heima/_doc/1
# 修改文档方式1，文档存在的情况：updated
PUT /heima/_doc/1
{
"info":"黑马程序员java讲师",
"email":"[email protected]",
"name":{
"firstName":"y",
"lastName":"z"
}
}
# 修改文档方式1，文档不存在的情况：created
PUT /heima/_doc/3
{
"info":"黑马程序员java讲师",
"email":"[email protected]",
"name":{
"firstName":"y",
"lastName":"z"
}
}
# 修改文档方式2-局部修改 updated
POST /heima/_update/1
{
"doc":{
"email":"[email protected]"
}
}
总结：
7.RestClient操作索引库
什么是RestClient
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址: https://www.elastic.co/guide/en/elasticsearch/client/index.html
案例
这个hotel-demo的application.yml默认的mysql地址 是 mysql:3306意味着连接的是虚拟机上docker的mysql，所以如果你是在windows机器上导入的sql文件，你应该改成localhost
分析数据结构
# 酒店的mapping
PUT /hotel
{
"mappings": {
"properties": {
"id":{
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_max_word"
},
"address":{
"type": "keyword",
"index": false
},
"price":{
"type":"integer"
},
"score":{
"type":"integer"
},
"brand":{
"type": "keyword"
},
"city":{
"type": "keyword"
},
"starName":{
"type": "keyword"
},
"business":{
"type": "keyword"
},
"location":{
"type":"geo_point"
},
"pic":{
"type": "keyword",
"index": false
}
}
}
}
我是根据多个字段搜索效率高，还是只根据一个字段搜索效率高？显然是一个字段效率高。我现在需求是用户搜名称、搜品牌、搜地址都能搜到，而且我还希望性能好怎么办？
字段拷贝可以使用copy_to属性将当前字段拷贝到指定字段。示例:
你可以在一个字段里搜到多个字段的内容了，而且这种拷贝还做了优化，并不是把文档拷贝进去了，而只是基于它创建倒排索引，所有你将来查询是查不到这个字段的，但搜却可以根据其搜。
即："copy_to": "all"
# 酒店的mapping
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"
},
"starName":{
"type": "keyword"
},
"business":{
"type": "keyword",
"copy_to": "all"
},
"location":{
"type":"geo_point"
},
"pic":{
"type": "keyword",
"index": false
},
"all":{
"type": "text",
"analyzer": "ik_max_word"
}
}
}
}
初始化RestClient
引入依赖：
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>elasticsearch-rest-high-level-clientartifactId>
<version>7.12.1version>
dependency>
为什么有些依赖是7.6.2版本？
因为依赖被Springboot管理，所以想要覆盖Springboot的版本定义，找到自己的pom文件，在properties标签下定义
<elasticsearch.version>7.12.1elasticsearch.version>
所以用springboot管理时，一定要去properties里指明版本。
那么这里的版本信息不写也行
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>elasticsearch-rest-high-level-clientartifactId>
dependency>
在test包下，创建测试类，以下是基本代码，包含了初始化与最终销毁的基本代码。（后面测试的代码都写在这个类中，并省略下面这段代码。）
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 java.io.IOException;
/**
* 酒店索引测试
* @author:whd
* @createTime: 2021/11/17
*/
public class HotelIndexTest {
private RestHighLevelClient client;
/**
* 在一开始就完成client的初始化
*/
@BeforeEach
void setUp() {
//如果是集群，这里的HttpHost.create("http://192.168.10.100:9200")可以用逗号分割
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.10.100:9200")
));
}
/**
* 用完后销毁
*/
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
测试初始化
@Test
void testInit() {
System.out.println("client = " + client);
}
创建索引库
这里将DSL语句定义在一个常量类里面
package cn.itcast.hotel.constants;
/**
* @author:whd
* @createTime: 2021/11/17
*/
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" +
" },\n" +
" \"starName\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"business\":{\n" +
" \"type\": \"keyword\",\n" +
" \"copy_to\": \"all\"\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" +
"}";
}
创建酒店索引
/**
* 创建酒店索引
*/
@Test
void createHotelIndex() throws IOException {
//1.创建Request对象
CreateIndexRequest request = new CreateIndexRequest("hotel");
//2.准备请求的参数，DSL语句
request.source(MAPPING_TEMPLATE, XContentType.JSON);
//3.发送请求
client.indices().create(request, RequestOptions.DEFAULT);
}
然后查询
GET /hotel
没问题，成功建立
删除、判断索引库是否存在
/**
* 删除索引
*/
@Test
void testDeleteHotelIndex() throws IOException {
DeleteIndexRequest request = new DeleteIndexRequest("hotel");
client.indices().delete(request,RequestOptions.DEFAULT);
System.out.println("删除成功！");
}
/**
* 是否存在索引
*/
@Test
void testExistsHotelIndex() throws IOException {
GetIndexRequest request = new GetIndexRequest("hotel");
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}
总结
索引库操作的基本步骤：
初始化RestHighLevelClient
创建XxxIndexRequest。XXX是Create、Get、Delete
准备DSL（ Create时需要）
发送请求。调用RestHighLevelClient.indices().xxx()方法，xxx是create、exists、delete
8.RestClient操作文档
添加
@SpringBootTest
public class HotelDocumentTest {
@Autowired
private IHotelService iHotelService;
private RestHighLevelClient client;
/**
* 添加文档
*/
@Test
void testAddDocument() throws IOException {
//根据ID查询酒店数据
Hotel hotel = iHotelService.getById(36934L);
//转换为文档类型（以处理location与经纬度不一致）
HotelDoc hotelDoc = new HotelDoc(hotel);
//1.准备request对象
IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
//2.准备JSON文档
request.source(JSON.toJSONString(hotelDoc),XContentType.JSON);
//3.发送请求
client.index(request,RequestOptions.DEFAULT);
}
/**
* 在一开始就完成client的初始化
*/
@BeforeEach
void setUp() {
//如果是集群，这里的HttpHost.create("http://192.168.10.100:9200")可以用逗号分割
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.10.100:9200")
));
}
/**
* 用完后销毁
*/
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
回到浏览器
发送GET /hotel/_doc/36934查询成功！
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "36934",
"_version" : 1,
"_seq_no" : 0,
"_primary_term" : 1,
"found" : true,
"_source" : {
"address" : "静安交通路40号",
"brand" : "7天酒店",
"business" : "四川北路商业区",
"city" : "上海",
"id" : 36934,
"location" : "31.251433, 121.47522",
"name" : "7天连锁酒店(上海宝山路地铁站店)",
"pic" : "https://m.tuniucdn.com/fb2/t1/G1/M00/3E/40/Cii9EVkyLrKIXo1vAAHgrxo_pUcAALcKQLD688AAeDH564_w200_h200_c1_t0.jpg",
"price" : 336,
"score" : 37,
"starName" : "二钻"
}
}
查询
/**
* 查询文档
*/
@Test
void testGetDocumentById() throws IOException {
//1.准备request对象
GetRequest request = new GetRequest("hotel","36934");
//2.发送请求得到响应
GetResponse response = client.get(request, RequestOptions.DEFAULT);
//3.解析响应结果
String json = response.getSourceAsString();
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println("hotelDoc = " + hotelDoc);
}
更新
/**
* 更新文档
*/
@Test
void testUpdateDocument() throws IOException {
//1.准备Request
UpdateRequest request = new UpdateRequest("hotel","36934");
//2.准备请求参数
request.doc(
"price","337",
"starName","五星"
);
//3.发送请求
client.update(request,RequestOptions.DEFAULT);
}
删除
/**
* 删除文档
*/
@Test
void testDeleteDocument() throws IOException {
//1.准备Request
DeleteRequest request = new DeleteRequest("hotel","36934");
//2.发送请求
client.delete(request,RequestOptions.DEFAULT);
}
总结
文档操作的基本步骤：
- 初始化RestHighLevelClient
- 创建XxxRequest。XXX是Index、Get、Update、Delete
- 准备参数（Index和Update时需要）
- 发送请求。调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete
- 解析结果（Get时需要）
批量处理文档
/**
* 批量导入数据到文档
*/
@Test
void testBulkRequest() throws IOException {
List<Hotel> hotelList = iHotelService.list();
BulkRequest request = new BulkRequest();
for (Hotel hotel : hotelList) {
HotelDoc hotelDoc = new HotelDoc(hotel);
//创建文档request对象
request.add(new IndexRequest("hotel")
.id(hotelDoc.getId().toString())
.source(JSON.toJSONString(hotelDoc),XContentType.JSON)
);
}
//发送请求
client.bulk(request,RequestOptions.DEFAULT);
}
在ES的DEVtools输入以下查询指令，即可得到结果
GET /hotel/_search
9.分布式搜索引擎
1.DSL查询语法
DSL Query的分类
Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：
-
查询所有：查询出所有数据，一般测试用。
例如：match_all
-
全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。
例如：
match_query
multi_match_query -
精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。
例如：
ids
range
term -
地理（geo）查询：根据经纬度查询。
例如：
geo_distance
geo_bounding_box -
复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。
例如：
bool
function_score
DSL Query - Match查询
默认只查询出来10条展示。
全文检索查询
# match查询
GET /hotel/_search
{
"query": {
"match": {
"all": "外滩"
}
}
}
# multi_match查询
# "brand","name","business"只要有一个满足就行
GET /hotel/_search
{
"query": {
"multi_match": {
"query": "外滩如家",
"fields": ["brand","name","business"]
}
}
}
搜索字段越多，查询的效率越低，因此要想办法把多个字段弄到一个字段里去查，比如说all字段
这个all字段实际上是我们索引库操作时"copy_to": "all"的结果
精确查询
# term查询
GET /hotel/_search
{
"query": {
"term": {
"city": {
"value": "上海"
}
}
}
}
# range查询
GET /hotel/_search
{
"query": {
"range": {
"price": {
"gte": 100,
"lte": 200
}
}
}
}
gte 大于等于，gt大于， lte同理
精确查询常见的有哪些？
- term查询：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段
- range查询：根据数值范围查询，可以是数值、日期的范围
地理查询
第一种
第二种
# distance 查询
GET /hotel/_search
{
"query": {
"geo_distance":{
"distance": "5km",
"location" : "31.21,121.5"
}
}
}
复合查询
相关性算法
当我们利用match查询时，文档结果会根据与搜索词条的关联度打分(_ score) ,返回结果时按照分值降序排列。
例如，我们搜索"虹桥如家"，结果如下:
可见词条出现次数越多，TF越高，相关性就越高。所以早期我们计算文档得分就是计算TF。因为【虹桥，如家】两个分词，就先计算虹桥，然后计算如家的TF，相加就可以了。
但是这种算法有一种问题，【如家】这个词在三篇文档中都有出现，再去把【如家】进行累加毫无意义。后面为了避免这种在每个文档中都出现这个词的情况，这种词的权重比较低，所以我们引入新的算法：
逆文档频率
文档总数/ 包含词条的文档总数。比方说我们拿【如家】为例，包含【如家】的文档有3个，而文档总数也是3个，3除3为1，因此Log1 = 0，代表这个如家的权重就是0。
相反如果是【虹桥】呢？包含【虹桥】的文档有1个，而文档总和是3个，3除1=3，Log 3 = 0.477，所以【虹桥】的权重就比较高，因为这个词在文档中出现的次数越少，权重则越高。将来得分也就越高。
最终得分就是TF乘IDF，再累加。
这就是业界常用的 TF-IDF算法。
但是在我们ES中并没有使用这种算法，（早期ES是有使用过），从ES的5.1开始就已经没有再使用这种算法。而采用了新的算法：
这种算法不会受词频影响较大，在传统TF算法中，词频越高，将来得分会无限增加。但是BM25算法最终得分趋于一种水平。
Function Score Query
使用function score query,可以修改文档的相关性算分(query score) ,根据新得到的算分排序。
# 算分函数
GET /hotel/_search
{
"query": {
"function_score": {
"query": {
"match": {
"all": "外滩"
}
},
"functions": [
{
"filter": {
"term": {
"brand": "如家"
}
},
"weight": 10
}
]
}
}
}
其他使用的案例查阅官方文档
官方文档
复合查询 Boolean Query
修改前
# 复合查询
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"name": "如家"
}
},
{
"geo_distance":{
"distance":"10km",
"location":{
"lat":31.21,
"lon":121.5
}
}
}
],
"must_not": [
{
"range":{
"price": {
"gt": 400
}
}
}
]
}
}
}
修改后：（将geo_distance 这种不需要参与算法的，放入filter里，可以提高查询效率）
# 复合查询
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"name": "如家"
}
}
],
"must_not": [
{
"range":{
"price": {
"gt": 400
}
}
}
],
"filter": [
{
"geo_distance":{
"distance":"10km",
"location":{
"lat":31.21,
"lon":121.5
}
}
}
]
}
}
}
一般情况下，关键字搜索放到must里，其他的尽量放到must_not和filter里
2.搜索结果处理
1.排序
# 按用户评价降序，评价相同按照价格升序排序
GET /hotel/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"score": {
"order": "desc"
},
"price": {
"order": "asc"
}
}
]
}
获取经纬度的方式 - 高德开放平台
# 找到121.393598,31.316488周围的酒店，距离升序排序
# 113.260791,23.128016 广州 （查询结果都是深圳的）
GET /hotel/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"_geo_distance": {
"order": "asc",
"unit": "km",
"location": {
"lat": 23.128016,
"lon": 113.260791
}
}
}
]
}
你一旦做了排序，相关性打分就没有意义了。所以这时候ES会放弃打分， 效率提高。
2.分页
elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。
elasticsearch中通过修改from、size参数来控制要返回的分页结果：
ES使用的倒排索引，所以它是不适合分页的，它其实是逻辑上的分页，
比方说我现在要查询990到1000这10条数据，对于ES来说只能是查出从0到1000的所有数据，然后再去截取990到1000的这一部分，这是因为其数据结构决定的。这种在单点查询是没有问题的，在生产环境为了让ES存储更多的数据，一定会做集群，而且ES天生就是支持集群的。一旦做了集群，ES就会把数据做拆分。
放到不同的机器上，拆分出的每一份我们叫做分片，每一片上的数据是不一样的。现在我要按照价格做排序，集群ES就不知道是找哪个分片上的前1000条。而是把所有分片上的前1000名，都取出来合并重新作个排序，才是前1000条。
首先在每个数据分片上都排序并查询前1000条文档。
然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档
最后从这1000条中，选取从990开始的10条文档
在生成环境下，像百度，ES集群达到数千台，意味着要在每一台上截取1000个，至少百万级别的截取量。还要排序五百万条记录。内存消耗非常大。
如果搜索页数过深，或者结果集（from + size）越大，对内存和CPU的消耗也越高。因此ES设定结果集查询的上限是10000
面临深度分页问题，要在业务上杜绝。
如果有这样的需求怎么办？
针对深度分页，ES提供了两种解决方案，官方文档：
•search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
•scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。
from + size：
•优点：支持随机翻页
•缺点：深度分页问题，默认查询上限（from + size）是10000
•场景：百度、京东、谷歌、淘宝这样的随机翻页搜索
after search：
•优点：没有查询上限（单次查询的size不超过10000）
•缺点：只能向后逐页查询，不支持随机翻页
•场景：没有随机翻页需求的搜索，例如手机向下滚动翻页
scroll：
•优点：没有查询上限（单次查询的size不超过10000）
•缺点：会有额外内存消耗，并且搜索结果是非实时的
•场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。
3.高亮
# 高亮查询 默认情况下，ES搜索字段必须与高亮字段一致
GET /hotel/_search
{
"query": {
"match": {
"all": "如家"
}
},
"highlight": {
"fields": {
"name": {
"require_field_match": "false"
}
}
}
}
4.总结
3.RestClient查询文档
match_all
/**
* 测试matchall
*/
@Test
void MatchAll() throws IOException {
SearchRequest request = new SearchRequest("hotel");
request.source().query(QueryBuilders.matchAllQuery());
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
String json = hit.getSourceAsString();
System.out.println("json = " + json);
}
}
match和multi_match
/**
* 测试match和multimatch
*/
@Test
void Match() throws IOException {
SearchRequest request = new SearchRequest("hotel");
//单字段查询
// QueryBuilders builder1 = QueryBuilders.matchQuery("all", "如家");
//多字段查询
MultiMatchQueryBuilder builder2 = QueryBuilders.multiMatchQuery("如家","name","business");
request.source().query(builder2);
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
String json = hit.getSourceAsString();
System.out.println("json = " + json);
}
}
term和range
/**
* 测试termAndRange
*/
@Test
void termAndRange() throws IOException {
SearchRequest request = new SearchRequest("hotel");
//TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("city", "深圳");
RangeQueryBuilder price = QueryBuilders.rangeQuery("price").gte(100).lte(150);
request.source().query(price);
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
String json = hit.getSourceAsString();
System.out.println("json = " + json);
}
}
bool查询
/**
* boolQuery
*/
@Test
void boolQuery() throws IOException {
SearchRequest request = new SearchRequest("hotel");
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
boolQueryBuilder.must(QueryBuilders.termQuery("city","深圳"));
boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(250));
request.source().query(boolQueryBuilder);
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
String json = hit.getSourceAsString();
System.out.println("json = " + json);
}
}
分页排序
/**
* fenyeANDpaixu
*/
@Test
void fenyeANDpaixu() throws IOException {
SearchRequest request = new SearchRequest("hotel");
request.source().query(QueryBuilders.matchAllQuery());
//分页
request.source().from(0).size(5);
//价格排序
request.source().sort("price", SortOrder.ASC);
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
String json = hit.getSourceAsString();
System.out.println("json = " + json);
}
}
高亮
/**
* 高亮
*/
@Test
void highlight() throws IOException {
SearchRequest request = new SearchRequest("hotel");
request.source().highlighter(
new HighlightBuilder().field("name").requireFieldMatch(false));
//搜索如家，把如家高亮
MatchQueryBuilder builder1 = QueryBuilders.matchQuery("all", "如家");
request.source().query(builder1);
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
SearchHits searchHits = response.getHits();
long total = searchHits.getTotalHits().value;
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
HotelDoc hotelDoc = JSON.parseObject(hit.getSourceAsString(),HotelDoc.class);
//处理高亮
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (!CollectionUtils.isEmpty(highlightFields)) {
//高亮字段
HighlightField highlightField = highlightFields.get("name");
if(highlightField != null){
//取出高亮字段第一个
String name = highlightField.getFragments()[0].string();
hotelDoc.setName(name);
}
}
System.out.println("hotelDoc = " + hotelDoc);
}
}