Elasticsearch Java API + Spring Boot集成 实战入门(基础篇)
- 一、初始Elasticseach
-
- 1、什么是Elasticseach
- 2、Elasticsearch生态
- 2、Elasticsearch结构
- 3、Elasticsearch核心概念
- [4、Elasticsearch 实现全文检索的原理](#4、Elasticsearch 实现全文检索的原理)
- 二、Elasticsearch入门
-
- 1、入门-环境安装准备
- 2、实战入门
-
- 2.1、kibana控制台操作
- [2.2、RestClient -- Java API操作](#2.2、RestClient -- Java API操作)
- 3、Elasticsearch数据同步方案
- 4、集群
Spring Boot集成Elasticsearch 高级篇 后续更新 请关注 个人主页
一、初始Elasticseach
1、什么是Elasticseach
Elasticseach是一款非常强大的开源搜索引擎,可以帮助我们从海量数据中快速找到需要的内容。结合 kibana 、 Logstash 、 Beats ,也就是 elastic stack ( ELK )。被广泛应用在日志数据分析、实时监控等领域。
2、Elasticsearch生态
Elasticsearch 生态系统非常丰富,包含了一系列工具和功能,帮助用户处理、分析和可视化数据,Elastic Stack 是其核心组成部分。
Elastic Stack(也称为 ELK Stack)由以下几部分组成:
- Elasticsearch:核心搜索引擎,负责存储、索引和搜索数据。
- Kibana:可视化平台,用于查询、分析和展示 Elasticsearch 中的数据。
- Logstash:数据处理管道,负责数据收集、过滤、增强和传输到 Elasticsearch。
- Beats:轻量级的数据传输工具,收集和发送数据到 Logstash 或 Elasticsearch。
Kibana 是 Elastic Stack 的可视化组件,允许用户通过图表、地图和仪表盘来展示存储在 Elasticsearch 中的数据。它提供了简单的查询接口、数据分析和实时监控功能
2、Elasticsearch结构
Elasticsearch采用倒排索引 ,相比mysql的正向索引提高了查询效率。
倒排索引过程:
- 首先进行分词得到词条。
- 倒排根据词条列表查找id查询文档。
- 最后存放结果集。
正向和倒排索引的区别:
正向是根据文档找词条,倒排是根据词条找文档。
3、Elasticsearch核心概念
-
索引(Index):类似于数据库中的表。
-
文档(Document):索引中的每条记录,类似于数据库中的行数据。文档以JSON格式存储。
-
字段(Field):文档中的每个键值对,类似于数据库中的列
-
映射 (Mapping):用于定义文档字段的数据类型以及其处理方式,类似于表结构。
-
集群(Cluster):多个节点组成的群集,用于存储数据并提供搜索功能。集群中的每个节点都可以处理数据。
-
分片(Shard):为了实现横向扩展,ES 将索引拆分成多个分片,每个分片可以分布在不同节点上。
-
副本(Replica):分片的复制品,用于提高可用性和容错性。
和数据库类比:
Elasticsearch 概念 关系型数据库类比 Index Table Document Row Field Column Mapping Schema Shard Partition Replica Backup
4、Elasticsearch 实现全文检索的原理
- 分词
- 倒排索引(根据分词去词表查询文档Id,然后再根据文档Id去查询文档)
二、Elasticsearch入门
1、入门-环境安装准备
1)安装 Elasticsearch
Elasticsearch 更新迭代非常快,所以安装时,一定要注意慎重选择版本号!
由于我们自己的项目用的 Spring Boot 2.x 版本,对应的 Spring Data Elasticsearch 客户端版本是 4.x,支持的 Elasticsearch 是 7.x,所以建议 Elasticsearch 使用 7.x 的版本。
个人中使用的是 7.17 版本,这是 7.x 系列的最后一个版本,包含了该系列所有的 bug 修复和改进,被广泛认为是最稳定的。
💡 可以在 官方文档 了解到版本兼容情况:比如 Spring 6 才支持 Elasticsearch 8.x
如果官网下不动,
已经下载好的 提取码:52jl
注意,安装路径不要包含中文!
Windows 版的 Elasticsearch 压缩包,解压即安装完毕,解压后的 Elasticsearch 的目录结构如下 :
目录 | 含义 |
---|---|
bin | 可执行脚本目录 |
config | 配置目录 |
jdk | 内置 JDK 目录 |
lib | 类库 |
logs | 日志目录 |
modules | 模块目录 |
plugins | 插件目录 |
安装完成后进入 es 的bin目录通过cmd打开命令窗口并执行启动命令:
elasticsearch.bat
可以用 CURL 测试是否启动成功:
curl -X GET "localhost:9200/?pretty"
正常输出如图:
在 Windows 系统上,你还可以选择是否安装为服务,方便启动和管理。
elasticsearch-service.bat
Usage: elasticsearch-service.bat install|remove|start|stop|manager [SERVICE_ID]
2)安装 Kibana
注意,只要是同一套技术,所有版本必须一致!此处都用 7.17 版本!
安装 Kibana:https://www.elastic.co/guide/en/kibana/7.17/install.html
安装完成后进入 kibana 的bin目录cmd打开命令行窗口并执行启动命令:
kibana.bat
但 kibana 默认是英文,不变阅读,可以修改 config/kibana.yml 中的国际化配置:
然后重启 kibana 即可
注意,目前 Kibana 面板没有增加权限校验,所有人都能访问,所以请勿在线上直接部署!
3)测试
尝试利用 Kibana 的开发工具来操作 Elasticsearch 的数据,比如查询:
验证下分词器的效果,比如使用标准分词器:
POST /_analyze
{
"analyzer": "standard",
"text": "我是许苑,I love someone"
}
效果如图,英文被识别为了一个词,但中文未被识别:
默认支持的分词器如下:
- standard:标准分词器。
- simple:简单分词器。
- whitespace:按空格分词。
- stop:带停用词的分词器。
- keyword:不分词,将整个字段作为一个词条。
- pattern:基于正则表达式的分词器。
- ngram 和 edge_ngram:n-gram 分词器。
由于这些分词器都不支持中文,所以需要安装 IK 中文分词器,以满足我们的业务需要。
4)安装 IK 中文分词器(ES 插件)
直接按照官方指引安装即可,注意下载和我们 Elasticsearch 一致的版本,可以在这里找到各版本的插件包:https://release.infinilabs.com/analysis-ik/stable/
在 ES 安装bin目录下执行:
elasticsearch-plugin.bat install https://release.infinilabs.com/analysis-ik/stable/elasticsearch-analysis-ik-7.17.23.zip
安装成功,需要重启 ES:
IK 分词器插件为我们提供了两个分词器:ik_smart 和 ik_max_word。
ik_smart 是智能分词,尽量选择最像一个词的拆分方式,比如"某人"会被识别为一个词
ik_max_word 尽可能地分词,可以包括组合词,比如"好学生"会被识别为 3 个词:好学生、好学、学生
POST /_analyze
{
"analyzer": "standard",
"text": "许苑爱上了某人"
}
2、实战入门
2.1、kibana控制台操作
1、索引库的操作
1)mapping 属性
mapping 是对索引库中文档的约束,常见的 mapping 属性包括:
- type :字段数据类型,常见的简单类型有:
- 字符串: text (可分词的文本)、 keyword (精确值,例如:品牌、国家、 ip 地址)
- 数值: long 、 integer 、 short 、 byte 、 double 、 float
- 布尔: boolean
- 日期: date
- 对象: object
- index :是否创建索引,默认为 true
- analyzer :使用哪种分词器
- properties :该字段的子字段
2)创建索引库
ES 中通过 Restful 请求操作索引库、文档。请求内容用 DSL 语句来表示,
创建索引库和 mapping 的 DSL 语法如下:
json
PUT /索引库名称
{
"mappings": {
"properties": {
" 字段名 ": {
"type": "text",
"analyzer": "ik_smart"
},
" 字段名 2": {
"type": "keyword",
"index": "false"
},
" 字段名 3": {
"properties": {
" 子字段 ": {
"type": "keyword"
}
}
}
}
}
}
举例:
json
PUT /xuyuan
{
"mappings": {
"properties": {
"info":{
"type": "text",
"analyzer": "ik_smart"
},
"email":{
"type": "keyword",
"index": "false"
},
"name":{
"properties": {
"firstName": {
"type": "keyword"
}
}
}
}
}
}
返回结果:
json
{
"acknowledged": true,
"shards_acknowledged": true,
"index": "xuyuan"
}
3)查看索引库
GET /xuyuan
4)删除索引库
DELETE /xuyuan
5)修改索引库
索引库和 mapping 一旦创建无法修改 ,但是可以添加 新的字段,语法如下:
添加字段: PUT / 索引库名 /_mapping
json
PUT /xuyuan/_mapping
{
"properties": {
"age": {
"type": "integer"
}
}
}
2、文档操作
1)新增文档
json
POST /索引库名/_doc/文档 id
{
" 字段 1": " 值 1",
" 字段 2": " 值 2",
" 字段 3": {
" 子属性 1": " 值 3",
" 子属性 2": " 值 4"
}
}
举例:
json
POST /xuyuan/_doc/2
{
"info": "Java工程师",
"email": "2517115657@qq.com",
"age": 20,
"name": {
"firstName": "许苑",
"fullName": "xuyuan"
}
}
返回结果:
json
{
"_index": "xuyuan",
"_id": "2",
"_version": 1,
"result": "created",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"_seq_no": 3,
"_primary_term": 1
}
2)查看文档
GET /索引库名/_doc/文档 id
GET /xuyuan/_doc/2
返回结果:
json
{
"_index": "xuyuan",
"_id": "2",
"_version": 1,
"_seq_no": 3,
"_primary_term": 1,
"found": true,
"_source": {
"info": "Java工程师",
"email": "2517115657@qq.com",
"age": 20,
"name": {
"firstName": "许苑",
"fullName": "xuyuan"
}
}
}
3)删除文档
DELETE /索引库名/_doc/文档 id
DELETE /xuyuan/_doc/2
返回结果:
json
{
"_index": "xuyuan",
"_id": "2",
"_version": 2,
"result": "deleted",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"_seq_no": 4,
"_primary_term": 1
}
4)修改文档
方式一:全量修改,会删除旧文档,添加新文档
json
PUT /xuyuan/_doc/1
{
"info": "Java",
"email": "2517115657@qq.com",
"name": {
"firstName": "oj",
"fullName": "xy"
}
}
返回结果:
json
{
"_index": "xuyuan",
"_id": "1",
"_version": 7,
"result": "updated",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"_seq_no": 8,
"_primary_term": 1
}
方式二:增量修改,修改指定字段值
json
POST /xuyuan/_update/1
{
"doc": {
"email": "github.com/xuyuan-upward"
}
}
5)DSL 查询文档
(1)DSL 查询语法分类
常见的查询类型包括:
- 查询所有:查询出所有数据,一般测试用。例如: match_all
- 全文检索( full text )查询:利用分词器对用户输入内容分词,然后去倒排索引库中匹配。例如:
- match_query
- multi_match_query
- 精确查询:根据精确词条值查找数据,一般是查找 keyword 、数值、日期、 boolean 等类型字段。例如:
- ids
- range
- term
- 地理( geo )查询:根据经纬度查询。例如:
- geo_distance
- geo_bounding_box
- 复合( compound )查询:复合查询可以将上述各种查询条件组合起来,合并查询条件。例如:
- bool
- function_score
(2)DSL Query 基本语法
json
GET /indexName/_search
{
"query": {
" 查询类型 ": {
" 查询条件 ": " 条件值 "
}
}
}
(3)查询所有
json
GET /hotel/_search
{
"query": {
"match_all": {}
}
}
(4)全文检索查询
全文检索查询,会对用户输入内容分词,常用于搜索框搜索:
match查询,根据一个字段查询。
json
GET /hotel/_search
{
"query": {
"match": {
"city": "杭州"
}
}
}
multi_match查询,根据多个字段查询,参与查询字段越多,查询性能越差。
json
GET /hotel/_search
{
"query": {
"multi_match": {
"query": "园",
// 表示查询多个字段
"fields": [
"star_name",
"name"
]
}
}
}
query:你要查询的文本内容。
fields:一个数组,指定你要在其上执行查询的字段。如果你只指定一个字段,则它行为类似于 match 查询。
(5)精确查询
精确查询一般是查找 keyword 、数值、日期、 boolean 等类型字段。所以不会对搜索条件分词。常见的有:
- term :根据词条精确值查询,根据词条精确匹配,一般搜索 keyword 类型、数值类型、布尔类型、日期类型字段。
json
GET /hotel/_search
{
"query": {
"term": {
"city": "上海"
}
}
}
- range :根据值的范围查询
json
GET /hotel/_search
{
"query": {
"range": {
"price": {
"gte": 70,
"lte": 80
}
}
}
}
6)地理查询
根据经纬度查询。常见的使用场景包括:
- 滴滴:搜索我附近的出租车
- 微信:搜索我附近的人
- 位置共享。
json
GET /hotel/_search
{
"query": {
// 经度类型
"geo_bounding_box": {
"location": {
"top_left": {
"lat": 24,
"lon": 35
},
"bottom_right": {
"lat": 22,
"lon": 33
}
}
}
}
}
(7)复合查询(bool function_score->重新算分
)
相关性算分
当我们利用match查询时候,文档结果会根据与搜索词条的关联度打分(_score),返回结果是按照分值降序排列。
相关打分算法,如下图所示:
算分函数查询,可以控制文档相关性算分,控制文档排名。
- 过滤条件:哪些文档要加分
- 算分函数:如何计算 function score(用于对某个字段或者多个字段重新计算得分)
- 加权方式: function score 与 query score 如何运算
json
GET /hotel/_search
{
"query": {
"function_score": {
"query": {
"match": {
"all": " 外滩 "
}
},
"functions": [
{
"filter": {
"term": {
"id": "1"
}
},
"weight": 10
}
],
"boost_mode": "multiply"
}
}
}
bool 查询
布尔查询是一个或多个查询子句的组合。子查询的组合方式有:
- must :必须匹配每个子查询,类似"与"
- should :选择性匹配子查询,类似"或"
- must_not :必须不匹配,不参与算分,类似"非",不参与算分尽量加上去,可以提高查询效率
- filter :必须匹配,不参与算分
搜索品牌包含"如家",价格不高于400 ,在坐标 23.21,33.5 周围 1000km范围内的酒店。
json
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"brand": "如家"
}
}
],
"must_not": [
{
"range": {
"price": {
"gt": 400
}
}
}
],
"filter": [
{
"geo_distance": {
"distance": "1000km",
"location": {
"lat": 23.21,
"lon": 33.5
}
}
}
]
}
}
}
搜索结果的处理
(1)排序
默认Elasticsearch是支持对结果进行排序的,默认是根据相关度的算分( _score )来排序。可以排序字段类型有: keyword类型、数值类型、地理坐标类型、日期类型等。
json
GET /hotel/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"price": "desc" // 排序字段和排序方式 ASC 、 DESC
}
]
}
2)分页
elasticsearch 默认情况下只返回 top10 的数据。而如果要查询更多数据就需要修改分页参数了。
elasticsearch 中通过修改 from 、 size 参数来控制要返回的分页结果:
json
GET /hotel/_search
{
"query": {
"match_all": {}
},
"from": 0, // 分页开始的位置,默认为0
"size": 10, // 期望获取的文档总数
"sort": [
{"price": "asc"}
]
}
3)深度分页问题
ES 是分布式的,所以会面临深度分页问题。例如按 price 排序后,获取 from = 990 , size =10 的数据:
聚合所有结果,重新排序选取前 1000 个。
首先在每个数据分片上都排序并查询前1000 条文档。
然后将所有节点的结果聚合,在内存中重新排序选出前 1000 条文档。
最后从这 1000 条中,选取从 990 开始的10 条文档。
如果搜索页数过深,或者结果集( from +size )越大,对内存和 CPU 的消耗也越高。因此 ES 设定结果集查询的上限是 10000。
针对深度分页, ES 提供了一种较好解决方案,官方文档:
• search after :分页时需要排序,原理是从上一次的排序值开始,查询下一页数据。官方推荐使用的方式。
(4)高亮
高亮:就是在搜索结果中把搜索关键字突出显示。
原理是这样的:
将搜索结果中的关键字用标签标记出来
在页面中给标签添加 css 样式
json
GET /hotel/_search
{
"query": {
"term": {
"city": {
"value": "杭州"
}
}
},
"highlight": {
"fields": {
"city": {
"pre_tags": "<em>",
"post_tags": "<em>"
}
}
}
}
返回结果以高亮形式返回:
json
{
"took": 0,
"timed_out": false,
"_shards": {
"total": 1,
"successful": 1,
"skipped": 0,
"failed": 0
},
"hits": {
"total": {
"value": 1,
"relation": "eq"
},
"max_score": 1.23585,
"hits": [
{
"_index": "hotel",
"_id": "1",
"_score": 1.611585,
"_source": {
"name": "许苑",
"email": "z.cn",
"price": 12,
"score": 12,
"brand": "汉庭",
"city": "杭州",
"star_name": "五星",
"business": "虹桥",
"location": "23.423424, 34.32131",
"pic": "/1/2/3"
},
"highlight": {
"city": [
"<em>杭州<em>"
]
}
}
]
}
}
2.2、RestClient -- Java API操作
什么是 RestClient
ES 官方提供了各种不同语言的客户端,用来操作 ES 。这些客户端的本质就是组装 DSL 语句,通过 http 请求发送给ES 。官方文档地址: https://www.elastic.co/guide/en/elasticsearch/client/index.html
利用 JavaRestClient 实现创建、删除索引库,判断索引库是否存在。
1、RestClient 操作索引库(Mapping)
1)分析数据结构
mapping 要考虑的问题:
字段名、数据类型、是否参与搜索、是否分词、如果分词,分词器是什么?
将数据导入数据,与此同时实现mysql同步到es
sql
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;
酒店索引:
json
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"
},
"star_name":{
"type": "keyword"
},
"business":{
"type": "keyword"
},
"location":{
"type": "geo_point"
},
"pic":{
"type": "keyword",
"index": false
}
}
}
}
2)初始化 JavaRestClient
引入依赖
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
初始化RestHighLevelClient
java
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200")
));
3)创建索引库
java
private 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" +
" },\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" +
" },\n" +
" \"city\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"star_name\":{\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" +
" }\n" +
" }\n" +
"}";
@Test
public void testCreateHotelIndex() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 Request 对象
CreateIndexRequest request = new CreateIndexRequest("hotel");
// 2.请求参数, MAPPING_TEMPLATE是静态常量字符串,内容是创建索引库的 DSL语句
request.source(MAPPING_TEMPLATE, XContentType.JSON);
// 3.发起请求
CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
System.out.println(response);
}
4)删除索引库
java
@Test
public void testDeleteHotelIndex() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 Request对象
DeleteIndexRequest request = new DeleteIndexRequest("hotel");
// 2.发起请求
AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
System.out.println(delete);
}
5)判断索引库是否存在
java
@Test
public void testExistsHotelIndex() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 Request对象
GetIndexRequest request = new GetIndexRequest("hotel");
// 2.发起请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.输出
System.out.println(exists);
}
2、RestClient 操作文档
1)添加酒店数据到索引库
java
@Test
public void testIndexDocument() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
String source= "{\n" +
" \"name\": \"xuyuan\",\n" +
" \"email\": \"2517115657@qq.com\"\n" +
"}";
// 1.创建 request对象
IndexRequest request = new IndexRequest("hotel").id("1");
// 2.准备 JSON文档
request.source(source, XContentType.JSON);
// 3.发送请求
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
System.out.println(response);
client.close();
}
2)根据 id 查询酒店数据
java
@Test
public void testGetDocumentById() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 request对象
GetRequest request = new GetRequest("hotel", "1");
// 2.发送请求,得到结果
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析结果
String json = response.getSourceAsString();
System.out.println(json);
client.close();
}
3)根据 id 修改酒店数据
修改文档数据有两种方式:
方式一:全量更新。再次写入 id 一样的文档,就会删除旧文档,添加新文档
方式二:局部更新。只更新部分字段,我们演示方式二
java
@Test
public void testUpdateDocumentById() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 request对象
UpdateRequest request = new UpdateRequest("hotel", "1");
// 2.准备参数,每 2个参数为一对 key value
request.doc(
"email", "23212133@163.com"
);
// 3.更新文档
client.update(request, RequestOptions.DEFAULT);
client.close();
}
4)根据 id 删除文档数据
java
@Test
public void testDeleteDocumentById() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
// 1.创建 request对象
DeleteRequest request = new DeleteRequest("hotel", "1");
// 2.删除文档
client.delete(request, RequestOptions.DEFAULT);
client.close();
}
2、RestClient 进行DSL文档查询
(1)查询所有
json
@Test
public void testMatchAll() throws IOException {
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://localhost:9200")
));
try {
// 1.准备 Request
SearchRequest request = new SearchRequest("hotel");
// 2.组织 DSL参数
request.source().query(QueryBuilders.matchAllQuery());
// 3.发送请求,得到响应结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//解析响应结果
SearchHits searchHits = response.getHits();
// 4.1.查询的总条数
long total = searchHits.getTotalHits().value;
// 4.2.查询的结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 4.3.得到 source
String json = hit.getSourceAsString();
System.out.println(json);
}
}finally {
client.close();
}
}
(2)全文检索查询
全文检索的 match 和 multi_match 查询与 match_all 的 API 基本一致。差别是查询条件,也就是 query 的部分。
同样是利用 QueryBuilders 提供的方法:
json
//单字段查询
QueryBuilders.matchQuery("all", " 如家 ");
//多字段查询
QueryBuilders.multiMatchQuery(" 如家 ", "name", "business");
(3)精确查询
精确查询常见的有 term 查询和 range 查询,同样利用 QueryBuilders 实现:
json
//词条查询
QueryBuilders.termQuery("city", " 杭州 ");
//范围查询
QueryBuilders.rangeQuery("price").gte(100).lte(150);
(4)复合查询
精确查询常见的有 term 查询和 range 查询,同样利用 QueryBuilders 实现:
json
//创建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//添加 must条件
boolQuery.must(QueryBuilders.termQuery("city", " 杭州 "));
//添加 filter条件
boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
json
(5)排序和分页
//查询
request.source().query(QueryBuilders.matchAllQuery());
//分页
request.source().from(0).size(5);
//价格排序
request.source().sort("price", SortOrder.ASC);
(6)高亮
json
request.source().highlighter(new HighlightBuilder().field("name")
//是否需要与查询字段匹配
.requireFieldMatch(false));
3、Elasticsearch数据同步方案
(1)elasticsearch 与 mysql 之间的数据同步
- 方案一:基于中间队列的异步同步(异步通知)
消息队列Rabbitmq实现ES与MySQL数据同步方案 后续补上 请关注个人主页
- 方案二:监听binlog(Canal 阿里巴巴开源的一个项目,支持从MySQL的binlog获取变更并进行实时同步。
CanalRabbitmq实现ES与MySQL数据同步方案 后续补上 请关注个人主页 - 方案三:基于定时全量同步(Batch Full Sync)定时全量同步实现ES与MySQL数据同步方案 后续补上
- 方案四(简单版):通过Spring Boot的定时任务实现对过去一分钟更新的数据进行增量同步到ES。
4、集群
(1)ES 集群的分布式存储
当新增文档时,应该保存到不同分片,保证数据均衡,那么 coordinating node 如何确定数据该存储到哪个分片呢?
elasticsearch 会通过 hash 算法来计算文档应该存储到哪个分片:
说明:
shard = hash(_routing) % number_of_shards
_routing 默认是文档的 id
算法与分片数量有关,因此索引库一旦创建,分片数量不能修改!
(1)ES 集群的分布式查询
elasticsearch 的查询分成两个阶段:
scatter phase :分散阶段, coordinating node 会把请求分发到每一个分片。
gather phase :聚集阶段, coordinating node 汇总 data node 的搜索结果,并处理为最终结果集返回给用户。