- 倒排索引:是先找到用户要搜索的词条,根据词条得到保护词条的文档的id,然后根据id获取文档。是根据词条找文档的过程。
我们统一的把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 |
mapping是对索引库中文档的约束,常见的mapping属性包括:
- type:字段数据类型,常见的简单类型有:
- 字符串:text(可分词的文本)、keyword(精确值,例如:品牌、国家、ip地址)
- 数值:long、integer、short、byte、double、float、
- 布尔:boolean
- 日期:date
- 对象:object
- index:是否创建索引,默认为true
- analyzer:使用哪种分词器
- properties:该字段的子字段
ES操作
基础增删改查
- 创建客户端对象 ```java 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(); }
- 添加 -- IndexRequest
```java
@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);
}
查询 — GetRequest
@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); }
删除 — DeleteRequest
@Test void testDeleteDocument() throws IOException { // 1.准备Request DeleteRequest request = new DeleteRequest("hotel", "61083"); // 2.发送请求 client.delete(request, RequestOptions.DEFAULT); }
更新 — UpdateRequest
@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); }
查询文档
全文检索-matchQuery()
- 利用分词器对用户输入内容分词,然后去倒排索引库中匹配
基本流程:
- 对用户搜索的内容做分词,得到词条
- 根据词条去倒排索引库中匹配,得到文档id
根据文档id找到文档,返回给用户
match:根据一个字段查询
- multi_match:根据多个字段查询,参与查询字段越多,查询性能越差
```json
match 查询
GET /hotel/_search { “query”: {
} }"match":{ "all": "外滩如家" # 根据 all 字段进行查询 }
multi_match 查询
GET /hotel/_search { “query”: { “multi_match”:{ “query”: “外滩如家”, “fields”: [“brand”, “name”, “business”] } } }
- RestClient
```java
@Test
void testMatch() throws IOException {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");
// 2.准备DSL
// match 查询
request.source()
.query(QueryBuilders.matchQuery("all", "外滩如家"));
// multi_match 查询
request.source().
query(QueryBuilders.multiMatchQuery("外滩如家", "brand", "name", "business"));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}
精确查找-term/rangeQuery()
- 根据精确词条值查找数据,一般是查找keyword、数值、日期、boolean等类型字段
- term:根据词条精确值查询(查询的条件也必须是不分词的词条。查询时,用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多,反而搜索不到数据)
- range:根据值的范围查询(一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤)
```json
term 查询
GET /hotel/_search { “query”: { “term”: {
} } }"city": { # FIELD属性 "value": "上海" # VALUE属性 }
range查询
GET /hotel/_search { “query”:{ “range”:{ “price”:{ # FIELD属性 “gte”: 1000, # 查询区间 “lte”:3000 } } } }
- RestClient
```java
// term 查询
QueryBuilders.termQuery("city", "上海");
// range 查询
QueryBuilders.rangeQuery("price").gte(1000).lte(3000);
地理查询-geoDistanceQuery()
- 根据经纬度查询
- 搜索我附近的酒店、附近的出租车、搜索我附近的人等
```json
// geo_bounding_box查询(矩形查询)
GET /indexName/_search
{
“query”: {
“geo_bounding_box”: {
} } }"FIELD": { "top_left": { // 左上点 "lat": 31.1, "lon": 121.5 }, "bottom_right": { // 右下点 "lat": 30.9, "lon": 121.7 } }
// 距离查询 geo_distance GET /indexName/_search { “query”: { “geo_distance”: { “distance”: “15km”, // 半径 “location”: “31.21,121.5” // 圆心 FIELD属性 } } }
- RestClient
```java
QueryBuilders.geoDistanceQuery("location") // 字段名
.distance("15", DistanceUnit.KILOMETERS) // 半径
.point(31.21D, 121.5D); // 圆心
复合查询-boolQuery()
- 复合查询可以将上述各种查询条件组合起来,合并查询条件
- fuction score:算分函数查询,可以控制文档相关性算分,控制文档排名
# function_score 算分函数查询
GET /hotel/_search
{
"query": {
"function_score": {
"query": { // 原始查询,可以是任意条件
"match": {
"all": "外滩" // 查询all字段下包含外滩的条目
}
},
"functions": [ // 算分函数
{
"filter": { // 满足的条件,品牌必须是如家
"term": {
"brand": "如家"
}
},
"weight": 2 // 算分权重为2
}
],
"boost_mode": "sum" // 加权模式,求和
}
}
}
- bool query:布尔查询,利用逻辑关系组合多个其它的查询。布尔查询是一个或多个查询子句的组合,每一个子句就是一个子查询。子查询的组合方式有:
- must:必须匹配每个子查询,类似“与”
- should:选择性匹配子查询,类似“或”
- must_not:必须不匹配,不参与算分,类似“非”
- filter:必须匹配,不参与算分
需求:搜索名字包含“如家”,价格不高于400,在坐标31.21,121.5周围10km范围内的酒店。
GET /hotel/_search { "query":{ "bool":{ "must":[ // 名字包含如家 {"match":{"name":"如家" }} ], "must_not":[ // 价格不高于400 {"range":{"price":{"gte":400}}} ], "filter":[ // 周围10km以内 {"geo_distance":{ "distance": "10km", "location":{ "lat":31.21, "lon":121.5}} } ]} } }
RestClient ```java // 准备BooleanQuery BoolQueryBuilder boolQuery = QueryBuilders.boolQuery(); // 添加term boolQuery.must(QueryBuilders.termQuery(“name”, “如家”)); // 添加range boolQuery.mustNot(QueryBuilders.rangeQuery(“price”).gte(400)); // 添加geo_distance
request.source().query(boolQuery);
<a name="xfOKW"></a>
## 搜索结果处理
![image.png](https://cdn.nlark.com/yuque/0/2022/png/21563681/1649575658323-4f04f473-6962-4566-96e8-3413c6fc6a40.png#clientId=u5f377133-3139-4&crop=0&crop=0&crop=1&crop=1&id=Y0A2I&name=image.png&originHeight=688&originWidth=795&originalType=binary&ratio=1&rotation=0&showTitle=false&size=77945&status=done&style=none&taskId=u21c3badc-e294-42f7-bde3-352e88e8be8&title=)
<a name="RSkzN"></a>
### 排序-SortBuilder
elasticsearch默认是根据相关度算分(_score)来排序,但是也支持自定义方式对搜索[结果排序](https://www.elastic.co/guide/en/elasticsearch/reference/current/sort-search-results.html)。可以排序字段类型有:keyword类型、数值类型、地理坐标类型、日期类型等。
- 普通字段排序
```json
GET /hotel/_search
{
"query":{"match_all":{}},
"sort":[
{"score":"desc"}, // 根据分数降序
{"price":"asc"} // 根据价格升序
]
}
- 地理坐标排序
GET /hotel/_search { "query":{"match_all":{}}, "sort":[ { "geo_distance":{ // 位置信息 "location":{ "lat": 31.31, "lon": 32.32 } }, "order":"asc", // 升序 "unit":"km" // 单位km } ] }
分页-from() size()
基本分页:
- from:从第几个文档开始
- size:总共查询几个文档
GET /hotel/_search { "query":{"match_all":{}}, "from": 0, // 从第0条开始(默认) "size": 10, // 获取10个文档 "sort":[{"price": "asc"}] }
RestClient
// 查询
request.source().query(QueryBuilders.matchAllQuery());
// 分页
request.source().from(0).size(10);
// 价格排序
request.source().sort("price", SortOrder.ASC);
- 查询第990~第1000条数据:必须先查询 0~1000条,然后截取其中的990 ~ 1000的这10条
- 集群模式查询查询TOP1000:必须先查询出每个节点的TOP1000,汇总结果后,重新排名,重新截取TOP1000。当查询分页深度较大时,汇总数据过多,对内存和CPU会产生非常大的压力,因此elasticsearch会禁止from+ size 超过10000的请求。
针对深度分页,可采取 search after进行查询
- search after:分页时需要排序,原理是从上一次的排序值开始,查询下一页数据。官方推荐使用的方式。只能向后逐页查询,不支持随机翻页。
高亮-HighlightBuilder
高亮显示的实现分为两步:
- 1)给文档中的所有关键字都添加一个标签,例如
<em>
标签 - 2)页面给
<em>
标签编写CSS样式
注意:
- 高亮搜索必须使用全文检索查询(match, multi_match)
- 高亮是对关键字高亮,因此搜索条件必须带有关键字,而不能是范围这样的查询。
- 默认情况下,高亮的字段,必须与搜索指定的字段一致,否则无法高亮
- 如果要对非搜索字段高亮,则需要添加一个属性:required_field_match=false
GET /hotel/_search
{
"query":{"match":{"all":"如家"}}, // 搜索字段是all
"highlight":{
"fields":{
"name":{"require_field_match":"false"} // 高亮属性为name
}
}
}
RestClient
// 2.1.query request.source().query(QueryBuilders.matchQuery("all", "如家")); // 2.2.高亮 request.source().highlighter( new HighlightBuilder().field("name").requireFieldMatch(false));
高亮的结果与查询的文档结果默认是分离的,并不在一起。
- 因此解析高亮的代码需要额外处理:
- 代码解读:
- 第一步:从结果中获取source。hit.getSourceAsString(),这部分是非高亮结果,json字符串。还需要反序列为HotelDoc对象
- 第二步:获取高亮结果。hit.getHighlightFields(),返回值是一个Map,key是高亮字段名称,值是HighlightField对象,代表高亮值
- 第三步:从map中根据高亮字段名称,获取高亮字段值对象HighlightField
- 第四步:从HighlightField中获取Fragments,并且转为字符串。这部分就是真正的高亮字符串了
- 第五步:用高亮的结果替换HotelDoc中的非高亮结果
聚合-AggregationBuilders
- 实现对数据的统计、分析、运算。实现这些统计功能的比数据库的sql要方便的多,而且查询速度非常快,可以实现近实时搜索效果。
聚合常见的有三类:
- 桶(Bucket)聚合:用来对文档做分组
- TermAggregation:按照文档字段值分组,例如按照品牌值分组、按照国家分组
- Date Histogram:按照日期阶梯分组,例如一周为一组,或者一月为一组
- 度量(Metric)聚合:用以计算一些值,比如:最大值、最小值、平均值等
- Avg:求平均值
- Max:求最大值
- Min:求最小值
- Stats:同时求max、min、avg、sum等
管道(pipeline)聚合:其它聚合的结果为基础做聚合
对酒店品牌进行聚合,根据价格限定聚合范围,并对结果排序
GET /hotel/_search { "query":{"range":{"price": {"lte": 200}}}, // 价格200以下的结果 "size": 0, // 设置size为0,结果中不包含文档,只包含聚合结果 "aggs": { // 定义聚合 "brandAgg": { //给聚合起个名字 "terms": { // 聚合的类型,按照品牌值聚合,所以选择term "field": "brand", // 参与聚合的字段 "size": 20, // 希望获取的聚合结果数量 "order": { "_count": "asc" // 按照_count升序排列 } } } } }
子聚合:对聚合结果进行平均值、最大最小值的统计
GET /hotel/_search { "size": 0, "aggs": { // 聚合查询 "brandAgg": { "terms": { "field": "brand", "size": 20 }, "aggs": { // 是brandAgg聚合的子聚合,也就是分组后对每组分别计算 "score_stats": { // 聚合名称 "stats": { // 聚合类型,这里stats可以计算min、max、avg等 "field": "score" // 聚合字段,这里是score } } } } } }
另外,我们还可以给聚合结果做个排序,例如按照每个桶的酒店平均分做排序:
RestClient
- 聚合查询语法
- 结果处理
RestClient查询操作
查询的基本步骤是:
- 创建SearchRequest对象
- 准备Request.source(),也就是DSL。
① QueryBuilders来构建查询条件
② 传入Request.source() 的 query() 方法 - 发送请求,得到结果
- 解析结果(参考JSON结果,从外到内,逐层解析)
这里关键的API有两个,一个是request.source()
,其中包含了查询、排序、分页、高亮等所有功能:
另一个是QueryBuilders
,其中包含match、term、function_score、bool等各种查询:
响应结果的解析:
elasticsearch返回的结果是一个JSON字符串,结构包含:
hits
:命中的结果total
:总条数,其中的value是具体的总条数值max_score
:所有结果中得分最高的文档的相关性算分hits
:搜索结果的文档数组,其中的每个文档都是一个json对象_source
:文档中的原始数据,也是json对象
因此,我们解析响应结果,就是逐层解析JSON字符串,流程如下:
SearchHits
:通过response.getHits()获取,就是JSON中的最外层的hits,代表命中的结果SearchHits#getTotalHits().value
:获取总条数信息SearchHits#getHits()
:获取SearchHit数组,也就是文档数组SearchHit#getSourceAsString()
:获取文档结果中的_source,也就是原始的json文档数据
案例一:复合查询+分页
- 根据名称搜索酒店,并根据品牌、价格区间进行筛选,返回分页结果 ```java /* 搜索业务 / public PageResult search(RequestParams params) { // 创建 SearchRequest 对象 SearchRequest request = new SearchRequest(“hotel”); // 构建 boolQuery buildBasicQuery(params, request); // 分页 request.source().from(params.getFrom()).size(params.getSize()); // 处理响应结果 // … }
/* 构建 boolQuery 复合查找对象 / private void buildBasicQuery(RequestParams params, SearchRequest request) { // 1. 构建 boolQuery BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 2.关键字搜索 (must + matchQuery)
String key = params.getKey();
if (key == null || "".equals(key)) {
boolQuery.must(QueryBuilders.matchAllQuery());
} else {
boolQuery.must(QueryBuilders.matchQuery("all", key));
}
// 3.品牌筛选 (filter + termQuery)
if (params.getBrand() != null && !params.getBrand().equals("")) {
boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
}
// 4.价格区间 (filter + rangeQuery)
if (params.getMinPrice() != null && params.getMaxPrice() != null) {
boolQuery.filter(QueryBuilders
.rangeQuery("price")
.gte(params.getMinPrice())
.lte(params.getMaxPrice())
);
}
// 5.放入 request.source()
request.source().query(boolQuery);
}
<a name="BFWOD"></a>
### 案例二:根据距离排序
- request.source().sort(SortBuilders)
```java
@Override
public PageResult search(RequestParams params) {
try {
// 1.准备Request
SearchRequest request = new SearchRequest("hotel");
// 2.准备DSL
// 2.1.query
buildBasicQuery(params, request);
// 2.2.分页
int page = params.getPage();
int size = params.getSize();
request.source().from((page - 1) * size).size(size);
// 2.3.排序
String location = params.getLocation();
if (location != null && !location.equals("")) {
request.source().sort(SortBuilders
.geoDistanceSort("location", new GeoPoint(location))
.order(SortOrder.ASC)
.unit(DistanceUnit.KILOMETERS)
);
}
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
return handleResponse(response);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
案例三:function_socre查询
- 这里的需求是:让指定酒店排名靠前。因此我们需要给这些酒店添加一个标记,这样在过滤条件中就可以根据这个标记来判断,是否要提高算分。比如,我们给酒店添加一个字段:isAD,Boolean类型
这样function_score包含3个要素就很好确定了:
- 过滤条件:判断isAD 是否为true
- 算分函数:我们可以用最简单暴力的weight,固定加权值
- 加权方式:可以用默认的相乘,大大提高算分
我们可以将之前写的boolean查询作为原始查询条件放到query中,接下来就是添加过滤条件、算分函数、加权模式了。所以原来的代码依然可以沿用。
// 算分控制
FunctionScoreQueryBuilder functionScoreQuery =
QueryBuilders.functionScoreQuery(
// 原始查询,相关性算分的查询
boolQuery,
// function score的数组
new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
// 其中的一个function score 元素
new FunctionScoreQueryBuilder.FilterFunctionBuilder(
// 过滤条件
QueryBuilders.termQuery("isAD", true),
// 算分函数
ScoreFunctionBuilders.weightFactorFunction(10)
)
});
request.source().query(functionScoreQuery);
ES深入
MySQL数据库同步
方案一:同步调用
基本步骤如下:
- hotel-demo对外提供接口,用来修改elasticsearch中的数据
- 酒店管理服务在完成数据库操作后,直接调用hotel-demo提供的接口,
方案二:异步通知
流程如下:
- hotel-admin对mysql数据库数据完成增、删、改后,发送MQ消息
- hotel-demo监听MQ,接收到消息后完成elasticsearch数据修改
方案三:监听binlog
流程如下:
- 给mysql开启binlog功能
- mysql完成增、删、改操作都会记录在binlog中
- hotel-demo基于canal监听binlog变化,实时更新elasticsearch中的内容
方式一:同步调用
- 优点:实现简单,粗暴
- 缺点:业务耦合度高
方式二:异步通知
- 优点:低耦合,实现难度一般
- 缺点:依赖mq的可靠性
方式三:监听binlog
- 优点:完全解除服务间耦合
- 缺点:开启binlog增加数据库负担、实现复杂度高
集群
新增文档
解读:
1)新增一个id=1的文档
2)对id做hash运算,假如得到的是2,则应该存储到shard-2
3)shard-2的主分片在node3节点,将数据路由到node3,同时node3成为coordinating node
4)协调节点将数据转发给对应primary sharding所在的data node
4)保存文档:data node节点上的primary sharding处理请求,写入数据库并同步给shard-2的副本replica-2,在node2节点
6)返回结果给coordinating-node节点
集群分布式查询
elasticsearch的查询分成两个阶段:
scatter phase:分散阶段,coordinating node会把请求分发到每一个分片
gather phase:聚集阶段,coordinating node汇总data node的搜索结果,并处理为最终结果集返回给用户
流程:
- 客户端发送请求给任意节点,该节点成为协调节点
- 协调节点将请求广播给所有数据节点,数据节点上的分片会处理请求
- 每个分片向协调节点返回查询数据的ID、节点信息、分片信息等,协调节点汇总结果并排序
- 协调节点向包含ID的分片发送get请求,整合响应数据后返回给客户端