Elasticsearch分布式搜索笔记
Elasticsearch
1.初识Elasticsearch
1.1 什么是elasticsearch
elasticsearch是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。
elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。被广泛应用在日志数据分析、实时监控等领域。
发展历史
小结
1.2 正向索引和倒排索引
正向索引
基于文档id创建索引。查询词条是必须先找到文档，然后判断是否包含词条
当数据量很大时，要逐条扫描很多数据，性能差
倒排索引(inverted index)
In computer science, an inverted index (also referred to as a postings list, postings file, or inverted file) is a database index storing a mapping from content, such as words or numbers, to its locations in a table, or in a document or a set of documents (named in contrast to a forward index, which maps from documents to content). The purpose of an inverted index is to allow fast full-text searches, at a cost of increased processing when a document is added to the database. The inverted file may be the database file itself, rather than its index. It is the most popular data structure used in document retrieval systems,[1] used on a large scale for example in search engines. Additionally, several significant general-purpose mainframe-based database management systems have used inverted list architectures, including ADABAS, DATACOM/DB, and Model 204.
There are two main variants of inverted indexes: A record-level inverted index（记录水平的倒排索引） (or inverted file index or just inverted file) contains a list of references to documents for each word. A word-level inverted index（单词水平的倒排索引） (or full inverted index or inverted list) additionally contains the positions of each word within a document.[2] The latter form offers more functionality (like phrase searches), but needs more processing power and space to be created.后者功能更加强大，但是需要更高的算力和存储空间
小结
1.3 相关概念
elasticsearch面向文档存储，文档数据会被序列化为json格式后，存储到elasticsearch中。
索引（Index）：相同类型的文档的集合
映射（mapping）：索引中文档的字段约束信息，类似表的结构约束
与mysql的概念对比
应用场景对比
mysql：擅长事务类型操作，可以确保数据的安全和一致性
Elasticsearch：擅长海量数据的搜索、分析、计算
总结
1.4 安装es
见文档
开启elasticsearch容器和kibana容器
docker start es
docker start kibana
2.ES实操
2.1 DSL 操作索引库
mapping属性
创建
PUT /索引库名称
{
"mappings": {
"properties": {
"字段名":{
"type": "text",
"analyzer": "ik_smart"
},
"字段名2":{
"type": "keyword",
"index": "false"
},
"字段名3":{
"properties": {
"子字段": {
"type": "keyword"
}
}
},
// ...略
}
}
}
查询
GET /索引库名
删除
DELETE /索引库名
还支持其他语法
DELETE /test
DELETE /test1,test2
DELETE /test_*
DELETE /_all
修改（添加索引）
ES无法对某一个字段进行删除或修改，但是允许添加新的字段到mapping中
PUT /索引库名/_mapping
{
"properties":{
"新字段名":{
"type": "text",
"index": false,
"analyzer": "ik_smart"
}
}
}
2.2 DSL 文档操作
添加文档
POST /索引库名/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
"字段3": {
"子属性1": "值3",
"子属性2": "值4"
},
// ...
}
示例
POST /heima/_doc/1
{
"info": "黑马程序员Java讲师",
"email": "[email protected]",
"name": {
"firstName": "云",
"lastName": "赵"
}
}
查询文档
GET /{索引库名称}/_doc/{id}
删除文档
DELETE /{索引库名}/_doc/{id}
修改文档
全量修改
全量修改是覆盖原来的文档，其本质是：
- 根据指定的id删除文档
- 新增一个相同id的文档
注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。
PUT /{索引库名}/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
// ... 略
}
示例
PUT /heima/_doc/1
{
"info": "黑马程序员高级Java讲师",
"email": "[email protected]",
"name": {
"firstName": "云",
"lastName": "赵"
}
}
增量修改
增量修改是只修改指定id匹配的文档中的部分字段。
POST /{索引库名}/_update/文档id
{
"doc": {
"字段名": "新的值",
}
}
示例
POST /heima/_update/1
{
"doc": {
"email": "[email protected]"
}
}
总结
-
创建文档：POST /{索引库名}/_doc/文档id { json文档 }
-
查询文档：GET /{索引库名}/_doc/文档id
-
删除文档：DELETE /{索引库名}/_doc/文档id
-
修改文档：
- 全量修改：PUT /{索引库名}/_doc/文档id { json文档 }
- 增量修改：POST /{索引库名}/_update/文档id { “doc”: {字段}}
3.RestClient
3.0.导入Demo
3.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;
3.0.2.导入项目
然后导入课前资料提供的项目:
项目结构如图：
3.0.3.mapping映射分析
mapping要考虑的问题：
- 字段名
- 字段数据类型
- 是否参与搜索
- 是否需要分词
- 如果分词，分词器是什么？
其中
-
字段名和数据类型根据表结构就能得出
-
而是否参与搜索和是否分词是业务强相关的，要根据具体需求具体分析得出
例如，分析下图的tb_hotel表的数据结构
id 比较特殊，在es中写入的是字符串类型，并且id本身应该是不可分割的
name 酒店名称，字符串类型，应该是可分词，使用ik_max_word分词器
address 酒店地址，字符串类型；不参与搜索，精确值，index为false，不创建索引；
price 酒店价格，整数类型；参与搜索、排序、过滤等操作，index为默认的true，创建索引；
score 酒店评分，整数类型；参与搜索、排序、过滤等操作，index为默认的true，创建索引；
brand 酒店品牌，字符串类型；精确值；参与搜索，index为默认的true，创建索引；
city 酒店城市，字符串类型；精确值；参与搜索，index为默认的true，创建索引；
star_name 酒店星级，字符串类型；精确值；参与搜索，index为默认的true，创建索引；
business 商圈,字符串类型；精确值；参与搜索，index为默认的true，创建索引；
location 维度，经度 地理坐标类型；精确值；参与搜索，index为默认的true，创建索引；
pic 图片路径，字符串类型；不参与搜索，精确值，index为false，不创建索引；
经过分析，得出mappings
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说明：
3.0.4.初始化RestClient
在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。
分为三步：
1）引入es的RestHighLevelClient依赖：
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>elasticsearch-rest-high-level-clientartifactId>
dependency>
2）因为SpringBoot默认的ES版本是7.6.2，所以我们需要覆盖默认的ES版本：
<properties>
<java.version>1.8java.version>
<elasticsearch.version>7.12.1elasticsearch.version>
properties>
3）初始化RestHighLevelClient：
初始化的代码如下：
如果要搭建集群，可以通过HttpHost.create()添加多个IP端口
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200"),
HttpHost.create("http://192.168.150.101:9201"),
HttpHost.create("http://192.168.150.101:9202")
));
这里为了单元测试方便，我们创建一个测试类HotelIndexTest，然后将初始化的代码编写在@BeforeEach方法中：
package cn.itcast.hotel;
import org.apache.http.HttpHost;
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(
HttpHost.create("http://192.168.150.101:9200")
));
}
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
3.1.索引库操作
3.1.1.创建索引库
创建索引库的API如下：
代码分为三步：
- 1）创建Request对象。因为是创建索引库的操作，因此Request是CreateIndexRequest。
- 2）添加请求参数，其实就是DSL的JSON参数部分。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。
- 3）发送请求，client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。
完整示例
在hotel-demo的cn.itcast.hotel.constants包下，创建一个类，定义mapping映射的JSON字符串常量：
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测试类中，编写单元测试，实现创建索引：
@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);
}
3.1.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("hotel");
// 2.发送请求
client.indices().delete(request, RequestOptions.DEFAULT);
}
3.1.3.判断索引库是否存在
判断索引库是否存在，本质就是查询，对应的DSL是：
GET /hotel
因此与删除的Java代码流程是类似的。依然是三步走：
- 1）创建Request对象。这次是GetIndexRequest对象
- 2）准备参数。这里是无参
- 3）发送请求。改用exists方法
@Test
void testExistsHotelIndex() throws IOException {
// 1.创建Request对象
GetIndexRequest request = new GetIndexRequest("hotel");
// 2.发送请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.输出
System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}
3.1.4.总结
JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。
索引库操作的基本步骤：
- 初始化RestHighLevelClient
- 创建XxxIndexRequest。XXX是Create、Get、Delete
- 准备DSL（ Create时需要，其它是无参）
- 发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete
3.2文档操作
3.2.1.新增文档
我们要将数据库的酒店数据查询出来，写入elasticsearch中。
准备工作
索引库实体类
数据库查询后的结果是一个Hotel类型的对象。结构如下：
为了与索引库操作分离，我们再次参加一个测试类，做两件事情：
- 初始化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();
}
}
语法说明
新增文档的DSL语句如下：
POST /{索引库名}/_doc/1
{
"name": "Jack",
"age": 21
}
对应的java代码如图：
可以看到与创建索引库类似，同样是三步走：
- 1）创建Request对象
- 2）准备请求参数，也就是DSL中的JSON文档
- 3）发送请求
变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。
完整代码
我们导入酒店数据，基本流程一致，但是需要考虑几点变化：
- 酒店数据来自于数据库，我们需要先查询出来，得到hotel对象
- hotel对象需要转为HotelDoc对象
- HotelDoc需要序列化为json格式
因此，代码整体步骤如下：
- 1）根据id查询酒店数据Hotel
- 2）将Hotel封装为HotelDoc
- 3）将HotelDoc序列化为JSON
- 4）创建IndexRequest，指定索引库名和id
- 5）准备请求参数，也就是JSON文档
- 6）发送请求
在hotel-demo的HotelDocumentTest测试类中，编写单元测试：
@Test
void testAddDocument() throws IOException {
// 1.根据id查询酒店数据
Hotel hotel = hotelService.getById(61083L);
// 2.转换为文档类型
HotelDoc hotelDoc = new HotelDoc(hotel);
// 3.将HotelDoc转json
String json = JSON.toJSONString(hotelDoc);
// 1.准备Request对象
IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
// 2.准备Json文档
request.source(json, XContentType.JSON);
// 3.发送请求
client.index(request, RequestOptions.DEFAULT);
}
3.2.2.查询文档
语法说明
查询的DSL语句如下：
GET /hotel/_doc/{id}
非常简单，因此代码大概分两步：
- 准备Request对象
- 发送请求
不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。完整代码如下：
可以看到，结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可。
与之前类似，也是三步走：
- 1）准备Request对象。这次是查询，所以是GetRequest
- 2）发送请求，得到结果。因为是查询，这里调用client.get()方法
- 3）解析结果，就是对JSON做反序列化
完整代码
在hotel-demo的HotelDocumentTest测试类中，编写单元测试：
@Test
void testGetDocumentById() throws IOException {
// 1.准备Request
GetRequest request = new GetRequest("hotel", "61082");
// 2.发送请求，得到响应
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析响应结果
String json = response.getSourceAsString();
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println(hotelDoc);
}
3.2.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("hotel", "61083");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}
3.2.4.修改文档
语法说明
修改我们讲过两种方式：
- 全量修改：本质是先根据id删除，再新增
- 增量修改：修改文档中的指定字段值
在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：
- 如果新增时，ID已经存在，则修改
- 如果新增时，ID不存在，则新增
这里不再赘述，我们主要关注增量修改。
代码示例如图：
与之前类似，也是三步走：
- 1）准备Request对象。这次是修改，所以是UpdateRequest
- 2）准备参数。也就是JSON文档，里面包含要修改的字段
- 3）更新文档。这里调用client.update()方法
完整代码
在hotel-demo的HotelDocumentTest测试类中，编写单元测试：
@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("hotel", "61083");
// 2.准备请求参数
request.doc(
"price", "952",
"starName", "四钻"
);
// 3.发送请求
client.update(request, RequestOptions.DEFAULT);
}
3.2.5批量导入文档
案例需求：利用BulkRequest批量将数据库数据导入到索引库中。
步骤如下：
-
利用mybatis-plus查询酒店数据
-
将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）
-
利用JavaRestClient中的BulkRequest批处理，实现批量新增文档
语法说明
批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。
其中提供了一个add方法，用来添加其他请求：
可以看到，能添加的请求包括：
- IndexRequest，也就是新增
- UpdateRequest，也就是修改
- DeleteRequest，也就是删除
因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：
其实还是三步走：
- 1）创建Request对象。这里是BulkRequest
- 2）准备参数。批处理的参数，就是其它Request对象，这里就是多个IndexRequest
- 3）发起请求。这里是批处理，调用的方法为client.bulk()方法
我们在导入酒店数据时，将上述代码改造成for循环处理即可。
完整代码
在hotel-demo的HotelDocumentTest测试类中，编写单元测试：
@Test
void testBulkRequest() throws IOException {
// 批量查询酒店数据
List<Hotel> hotels = hotelService.list();
// 1.创建Request
BulkRequest request = new BulkRequest();
// 2.准备参数，添加多个新增的Request
for (Hotel hotel : hotels) {
// 2.1.转换为文档类型HotelDoc
HotelDoc hotelDoc = new HotelDoc(hotel);
// 2.2.创建新增文档的Request对象
request.add(new IndexRequest("hotel")
.id(hotelDoc.getId().toString())
.source(JSON.toJSONString(hotelDoc), XContentType.JSON));
}
// 3.发送请求
client.bulk(request, RequestOptions.DEFAULT);
}
3.2.6.小结
文档操作的基本步骤：
- 初始化RestHighLevelClient
- 创建XxxRequest。XXX是Index、Get、Update、Delete、Bulk
- 准备参数（Index、Update、Bulk时需要）
- 发送请求。调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk
- 解析结果（Get时需要）
4.DSL Query
查询语法
见文档
5.数据聚合
数据聚合能干什么
详情见官方文档-数据聚合
聚合将您的数据汇总为指标、统计数据或其他分析。 聚合可帮助您回答以下问题：
- 我网站的平均加载时间是多少？
- 根据交易量，谁是我最有价值的客户？
- 在我的网络上什么会被视为大文件？
- 每个产品类别中有多少产品？
常见有三类聚合
-
桶（Bucket）聚合：用来对文档做分组
- TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
- Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
-
度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
- Avg：求平均值
- Max：求最大值
- Min：求最小值
- Stats：同时求max、min、avg、sum等
-
**管道（pipeline）**聚合：其它聚合的结果为基础做聚合
DSL实现聚合
见文档
6.自动补全
什么是自动补全？
安装拼音分词器
要实现根据字母做补全，就必须对文档按照拼音分词。在GitHub上恰好有elasticsearch的拼音分词插件。地址：https://github.com/medcl/elasticsearch-analysis-pinyin
安装方式与IK分词器一样，分三步：
①解压
②上传到虚拟机中，elasticsearch的plugin目录
③重启elasticsearch
④测试
如何知道elasticsearch的plugin目录？
docker volume inspect es-plugins
重启es
docker restart es
在Console中测试：
POST /_analyze
{
"text": "如家酒店还不错",
"analyzer": "pinyin"
}
其他部分见文档
自定义分词器
DSL实现自动补全查询
RestAPI实现自动补全
7.数据同步
定义
即数据库数据与es索引库数据的同步
当mysql数据库的数据发生改变时，elasticseatch也必须跟着改变，这就是数据同步
问题分析
同步调用
缺点：耦合度太高、稳定性低、性能差
异步通知
引入消息中间件
优点：耦合度降低、性能提高
缺点：依赖MQ服务器的可靠性、复杂度提高
监听binlog
binlog是MySQL的机制，以事件形式记录了对MySQL数据库执行更改的所有操作。
好文推荐：MySQL之binlog
引入canal中间件监听mysql的binlog
优点：耦合更低
缺点：加重了MySQL服务器的负担
数据同步的其他部分见文档
8.ES集群
es集群结构
注意：同一结点对分片数据的备份不同
其他见文档