Sentienl

# 1.数据聚合



![image.png](/static/img/b3bd2c9dae71111fffd4302995b1c97f.image.webp)

DSL实现聚合

![image.png](/static/img/a390a659aac3e5744081997fb4edfd03.image.webp)

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
      }
    }
  }
}
```
自定义排序规则

![image.png](/static/img/025fe922c1b17b9678a9394e0caae7b0.image.webp)


```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
        ,
         "order": {
          "_count": "asc"
        }
      }
    }
  }
}
```
限定搜索范围

![image.png](/static/img/a699815cf33c107fbe45dd64b64e1a3c.image.webp)

```DSL
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200
      }
    }
  }, 
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
        ,
         "order": {
          "_count": "asc"
        }
      }
    }
  }
}
```
嵌套聚合

![image.png](/static/img/d818a1d391991c6abca28173cd302a4c.image.webp)

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}
```
嵌套聚合排序

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "scoreAgg.avg": "desc"
        }
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}
```
RestClient实现聚合

![image.png](/static/img/916665525ac5b6d5996d23a53a595565.image.webp)

```java
    @Test
    public void testClientJuHe() throws IOException {
        SearchRequest request = new SearchRequest("hotel");
        request.source().size(0);
        request.source().aggregation(
                AggregationBuilders.terms("brand_agg")
                        .field("brand")
                        .size(20)
        );
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        System.out.println(response);
    }
```
# 2.自动补全分词

![image.png](/static/img/cebb7339e5271acbfe895d0e656b7c57.image.webp)

自定义分词器

![image.png](/static/img/fe512659c100df40e4b1dec363ddad8d.image.webp)


![image.png](/static/img/07a90fa9378057f8b85a34cf15e1214d.image.webp)

```DSL
// 自定义拼音分词器
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
   "properties": { 
    "name":{
      "type":"text",
      "analyzer":"my_analyzer"
    }
    }
  }
}
```
settings中配置的分词器只对当前索引库生效,除非指明索引库

```DSL
POST /test/_analyze
{
  "text": ["如家酒店真不错"],
  "analyzer": "my_analyzer"
}

```
自动补全查询

![image.png](/static/img/9acb2309ab49d7ac2052999ec8304139.image.webp)

自动补全测试

```DSL
// 自动补全的索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}
// 示例数据
POST test/_doc
{
  "title": ["Sony", "WH-1000XM3"]
}
POST test/_doc
{
  "title": ["SK-II", "PITERA"]
}
POST test/_doc
{
  "title": ["Nintendo", "switch"]
}

// 自动补全查询
POST /test/_search
{
  "suggest": {
    "title_suggest": {
      "text": "s", // 关键字
      "completion": {
        "field": "title", // 补全字段
        "skip_duplicates": true, // 跳过重复的
        "size": 10 // 获取前10条结果
      }
    }
  }
}
```

实现酒店项目自动补全功能


```DSL
// 酒店数据索引库
PUT /hotel
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart",
        "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": "text_anlyzer",
        "search_analyzer": "ik_smart"
      },
      "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
    }
  }
}
```
自动补全的restAPI

![image.png](/static/img/798f41fb2633de9997c888092da9f2bb.image.webp)

解析结果

![image.png](/static/img/74dcc1b148bcc35e54b3b0b1e27880ed.image.webp)

```java
    @Test
    public void testSuggestions() throws IOException {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(
                new SuggestBuilder().addSuggestion(
                        "suggestions",
                        SuggestBuilders.completionSuggestion("suggestion")
                                .prefix("hp")
                                .skipDuplicates(true)
                                .size(10)
                )
        );


        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        Suggest suggest = response.getSuggest();

        CompletionSuggestion completionSuggestion=  suggest.getSuggestion("suggestions");

        List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getOptions();

        for (CompletionSuggestion.Entry.Option option : options) {
            String s = option.getText().toString();
            System.out.println(s);
        }
    }
```

实现酒店的自动补全


```java
@Override
    public List<String> suggestion(String key) {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(
                new SuggestBuilder().addSuggestion(
                        "suggestions",
                        SuggestBuilders.completionSuggestion("suggestion")
                                .prefix(key)
                                .skipDuplicates(true)
                                .size(10)
                )
        );


        try {
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);

            Suggest suggest = response.getSuggest();

            CompletionSuggestion completionSuggestion=  suggest.getSuggestion("suggestions");

            List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getOptions();

            List<String> result = new ArrayList<>();

            for (CompletionSuggestion.Entry.Option option : options) {
                String s = option.getText().toString();
                result.add(s);
            }
            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
```
# 3.数据同步


![image.png](/static/img/29523f5ff855b2d56c1a39443583ea4c.image.webp)

## (1)同步调用

![image.png](/static/img/e44bda5084aa7f08e67b26f666ef5fb0.image.webp)

## (2)异步通知

![image.png](/static/img/95cd48cea9bf94780c7e1f1eb100626e.image.webp)

## (3)监听binlog

![image.png](/static/img/3c982d4e848e74bd37bf02adcd24ed82.image.webp)

总结

![image.png](/static/img/2dee8e0ab4a4f16f73d57fb89666bebb.image.webp)

ElasticSearch(2)

# 1.elasticsearch中的搜索结果处理


案例1

![image.png](/static/img/599817cdfa41175414210d2944e3b2fb.image.webp)


```DSL
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
    "sort":[
      {
      "score":"desc"
        
      },
      {
        "price":"asc"
    }
    ]
}

```
案例2

![image.png](/static/img/fd5537b4ddbc79477a696e79f2550a05.image.webp)

```DSL
# 31.034661 121.612282
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
  "sort":[
    {
      "_geo_distance": {
        "location": {
          "lat": 31.034661,
          "lon": 121.612282
        },
        "order": "asc",
        "unit": "km"
      }
    }]
}
```
# 2.分页结果

![image.png](/static/img/661d3d913087eecd8cc3556fafc11981.image.webp)

示例

```DSL
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
  "sort":[
    {
      "price":"asc"
    }
    ],
    "from": 0,
    "size": 20
}
```
深度分页问题

![image.png](/static/img/33e5371276e71222de599d7ebf30fff1.image.webp)

解决方案

![image.png](/static/img/7af7671f30fe6ace60c44e342f285e7f.image.webp)

# 3.结果高亮显示

![image.png](/static/img/86589a24119d1664d4dd130591542400.image.webp)

```DSL
GET /hotel/_search
{
  "query":{
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}
```
# 4.使用RestClient实现es查询
快速入门
![image.png](/static/img/b6b3f17eb31721e68a45bf75b3151120.image.webp)

```java
    @Test
    void testMatchAll() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        request.source().query(QueryBuilders.matchAllQuery());
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);

        System.out.println(response);
    }
```

解析结果


![image.png](/static/img/edae04a5514f506e13ee96801c7b71db.image.webp)

```java
    @Test
    void testMatchAll() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        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);
        }

    }
```

match查询


![image.png](/static/img/874bcd79b1cf35facb107c14d9ed990b.image.webp)


```java
    @Test
    void testMatch() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        request.source().query(QueryBuilders.matchQuery("all","如家"));
//        发送请求
        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);
        }

    }
```

精确查询


![image.png](/static/img/254fa6cf6ef6532fd7c66aa0cea2a111.image.webp)

复合查询


![image.png](/static/img/97cf0db2085e7c1f796100831bbcd1c8.image.webp)


```java
    @Test
    void testBoolQuery() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//       创建boolQueryBuilder对象
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//      添加term
        boolQueryBuilder.must(QueryBuilders.termQuery("city","上海"));
//        添加range
        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);
        }

    }
```

# 5.使用RestClient实现结果处理


![image.png](/static/img/b3c25962c1c92050f629cd2a77a8ca9a.image.webp)


```java
    @Test
    void testPageAndSort() throws IOException {
//        准备reuqest

        int page = 2, size = 5;
        SearchRequest request = new SearchRequest("hotel");
        request.source().query(QueryBuilders.matchAllQuery());
        request.source().sort("price", SortOrder.ASC);
        request.source().from((page-1)*size).size(size);
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long total = searchHits.getTotalHits().value;
        System.out.println("共"+total+"条数据");
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
            System.out.println(hotelDoc.toString());
        }

    }
```

RestClient处理高亮

![image.png](/static/img/d580f20d55590a061bd2b89688e47d1a.image.webp)


```java
    @Test
    void testHeightLight() throws IOException {
//        准备reuqest
        int page = 2, size = 5;
        SearchRequest request = new SearchRequest("hotel");
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long total = searchHits.getTotalHits().value;
        System.out.println("共"+total+"条数据");
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json,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.toString());
        }

    }
```

地理距离排序


![image.png](/static/img/43bdaa86eeba48f54065980d628d1732.image.webp)

添加权重



![image.png](/static/img/91f0c490400dbe3bff5758c3a81d2ed9.image.webp)


案例关键代码


```java
package cn.itcast.hotel.service.impl;

import cn.itcast.hotel.mapper.HotelMapper;
import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.pojo.HotelDoc;
import cn.itcast.hotel.pojo.PageResult;
import cn.itcast.hotel.pojo.RequestParams;
import cn.itcast.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.unit.DistanceUnit;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.swing.text.Highlighter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {

    // 注入Elasticsearch的高级客户端
    @Autowired
    private RestHighLevelClient client;

    /**
     * 酒店搜索方法
     * @param requestParams 搜索请求参数
     * @return 分页结果
     */
    @Override
    public PageResult search(RequestParams requestParams) {
        try {
            // 1. 准备SearchRequest，指定索引名为"hotel"
            SearchRequest request = new SearchRequest("hotel");

            // 2. 构建基本查询条件
            buildBasicQuery(requestParams, request);

            // 3. 设置分页参数
            int page = requestParams.getPage();
            int size = requestParams.getSize();
            request.source().from((page-1)*size).size(size);

            // 4. 地理位置排序（如果提供了位置参数）
            String location = requestParams.getLocation();
            if(location != null && !"".equals(location)){
                request.source().sort(SortBuilders.geoDistanceSort("location", new GeoPoint(location))
                        .order(SortOrder.ASC)  // 按距离升序排序
                        .unit(DistanceUnit.KILOMETERS));  // 距离单位为公里
            }

            // 5. 执行搜索请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            
            // 6. 处理搜索结果并返回
            return handleResponse(response);
        } catch (IOException e) {
            throw new RuntimeException("搜索酒店失败", e);
        }
    }

    /**
     * 构建基本查询条件
     * @param requestParams 请求参数
     * @param request SearchRequest对象
     */
    private void buildBasicQuery(RequestParams requestParams, SearchRequest request) {
        // 1. 创建布尔查询构建器
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        // 2. 关键字查询
        String key = requestParams.getKey();
        if (key == null || key.equals("")){
            // 如果关键字为空，则匹配所有文档
            boolQueryBuilder.must(QueryBuilders.matchAllQuery());
        } else {
            // 否则在"all"字段中搜索关键字
            boolQueryBuilder.must(QueryBuilders.matchQuery("all", key));
        }

        // 3. 城市过滤条件
        if (requestParams.getCity() != null && !requestParams.getCity().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("city", requestParams.getCity()));
        }

        // 4. 品牌过滤条件
        if (requestParams.getBrand() != null && !requestParams.getBrand().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("brand", requestParams.getBrand()));
        }

        // 5. 星级过滤条件
        if (requestParams.getStarName() != null && !requestParams.getStarName().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("starName", requestParams.getStarName()));
        }

        // 6. 价格范围过滤
        if (requestParams.getMaxPrice() != null && requestParams.getMinPrice() != null){
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price")
                    .gte(requestParams.getMinPrice())  // 大于等于最小值
                    .lte(requestParams.getMaxPrice())); // 小于等于最大值
        }

        // 7. 构建函数评分查询（广告置顶功能）
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery(
                boolQueryBuilder,
                new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                QueryBuilders.termQuery("isAd", true),  // 广告标识字段
                                ScoreFunctionBuilders.weightFactorFunction(10)  // 权重因子为10
                        )
                }
        );
        
        // 8. 将查询设置到请求中
        request.source().query(functionScoreQueryBuilder);
    }

    /**
     * 处理搜索响应结果
     * @param response Elasticsearch的搜索响应
     * @return 分页结果对象
     */
    public PageResult handleResponse(SearchResponse response) {
        PageResult pageResult = new PageResult();
        
        // 1. 获取命中结果
        SearchHits searchHits = response.getHits();
        
        // 2. 设置总命中数
        long total = searchHits.getTotalHits().value;
        pageResult.setTotal(total);
        
        // 3. 处理每条命中记录
        SearchHit[] hits = searchHits.getHits();
        List<HotelDoc> hotelDocList = new ArrayList<>();
        
        for (SearchHit hit : hits) {
            // 3.1 将JSON格式的源数据转换为HotelDoc对象
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            
            // 3.2 处理距离排序值（如果有）
            Object[] sortValues = hit.getSortValues();
            if (sortValues != null && sortValues.length > 0) {
                Object sortValue = sortValues[0];
                hotelDoc.setDistance(sortValue);
            }
            
            // 3.3 处理高亮字段（如果有）
            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);
                }
            }
            
            // 3.4 将处理后的酒店文档添加到列表
            hotelDocList.add(hotelDoc);
        }
        
        // 4. 设置结果列表并返回
        pageResult.setHotels(hotelDocList);
        return pageResult;
    }
}
```

RestClient(2)

# 1.什么是RestClient



![image.png](/static/img/5206119bbeb3ebafc66aaf0e7746879c.image.webp)
# 2.实现RestClient案例
导入数据库
![image.png](/static/img/e2c91591008c12c87dfbaab3dbd6338a.image.webp)
编写创建索引库的语句

![image.png](/static/img/5aecb6e3f93cb3793fe81f20c0d78487.image.webp)

![image.png](/static/img/d7e2c38cf9ffc977d58ebdad8cd4c33b.image.webp)

使用copy_to可以将当前的字段拷贝到其他之中实现同时根据多个字段搜索

```DSL
# 酒店的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"
      },"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

![image.png](/static/img/cb7317d4ca1c357f5d651cb440ec65dc.image.webp)

```pom

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.12.1</version>
        </dependency>
```
springboot管理了elasticsearch的版本需要添加覆盖版本
![image.png](/static/img/9671bd809c4b2c5de83aaec583dc8359.image.webp)
覆盖版本
![image.png](/static/img/f9b36a7dc0408003a2f29ec46ec0cd75.image.webp)
版本全部变为7.12.1（与搭建的elasticsearch一致）
![image.png](/static/img/26d02509d81ddd95f4ad251ed1e50a8b.image.webp)
在测试类中编写初始化和销毁代码

```java
ublic class HotelIndexTest {
    private RestHighLevelClient client;


    @BeforeEach
    void setUp(){
        this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.42.10:9200")))
    }
    

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}
```
编写创建索引库代码
![image.png](/static/img/a78eabbdaa4259acad5a6da88da6e27e.image.webp)

```java
    @Test
    void testCreateHotelIndex() throws IOException {
        // 创建request对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 请求参数
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 发起请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }
```
编写一个类存放创建索引库的语句

```java
package cn.itcast.hotel.constants;

public class HotelConstants {
    public final static 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" +
            "      },\"city\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\"starName\":{\n" +
            "        \"type\": \"keyword\"\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" +
            "      }\n" +
            "      ,\"all\":{\n" +
            "         \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
}

```
运行代码查询平台创建成功

```java
{
  "hotel" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "address" : {
          "type" : "keyword",
          "index" : false
        },
        "brand" : {
          "type" : "keyword"
        },
        "business" : {
          "type" : "keyword"
        },
        "city" : {
          "type" : "keyword"
        },
        "id" : {
          "type" : "keyword"
        },
        "location" : {
          "type" : "geo_point"
        },
        "name" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "pic" : {
          "type" : "keyword",
          "index" : false
        },
        "price" : {
          "type" : "integer"
        },
        "score" : {
          "type" : "integer"
        },
        "starName" : {
          "type" : "keyword"
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "hotel",
        "creation_date" : "1759399676974",
        "number_of_replicas" : "1",
        "uuid" : "aRnUh_l1Thi3hABSvrbm_w",
        "version" : {
          "created" : "7120199"
        }
      }
    }
  }
}

```

删除索引库判断索引库是否存在

![image.png](/static/img/0f11147d0b915a9a8413b056d24a5b42.image.webp)

```java
    @Test
    void testGetHotelIndex() throws IOException {
        // 创建request对象
        GetIndexRequest request = new GetIndexRequest("hotel");
        // 发起判断索引库是否存在
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        // 输出结果
        System.out.println(exists);
    }
```

```java
    @Test
    void testDeleteHotelIndex() throws IOException {
        // 创建request对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        // 发起删除请求
        client.indices().delete(request, RequestOptions.DEFAULT);
    }
```
# 3.文档的增删改查
编写添加文档代码

```java
    @Test
    void testInsertIndex() throws IOException {
        // 根据id查询hotel数据
        Hotel hotel= hotelService.getById(36934L);
        //        将hotel转成hotelDoc
        HotelDoc hotelDoc = new HotelDoc(hotel);
//        创建request对象
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());

        request.source(JSON.toJSONString(hotelDoc),XContentType.JSON);

        client.index(request, RequestOptions.DEFAULT);

    }
```

添加成功在可视化平台上查询 添加成功

![image.png](/static/img/453aff83c5efc87b159af4c33c869485.image.webp)

根据id查询文档


![image.png](/static/img/42bc49d3f4c6409ba13d5a17711903d5.image.webp)

```java
    @Test
    void testGetDocument() throws IOException {
//        创建request对象
        GetRequest request = new GetRequest("hotel","36934");
//        获取response
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
//        解析返回数据
        String json = response.getSourceAsString();
//        打印结果
        HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
        System.out.println(hotelDoc.toString());
    }
```

修改文档

```java
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest request = new UpdateRequest("hotel","36934");
        request.doc("price","952","starName","四钻");
        client.update(request, RequestOptions.DEFAULT);
    }
```

删除文档

```java
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest request = new DeleteRequest("hotel","36934");
        client.delete(request, RequestOptions.DEFAULT);
    }
```

总结

![image.png](/static/img/2a6de8de9acb0aef1ee2b6964a3a7f81.image.webp)

# 4.文档的批量导入功能

![image.png](/static/img/6b4d7c1d3fab656a47936194a34d4b28.image.webp)

代码示例


```java
    @Test
    void testRangeIndexDocument() throws IOException {
     // 使用mybatis-plus读取数据库数据
        List<Hotel> hotelList = hotelService.list();
        BulkRequest request = new BulkRequest();
        for (Hotel hotel : hotelList) {
            HotelDoc hotelDoc = new HotelDoc(hotel);
            request.add(new IndexRequest("hotel").id(hotelDoc.getId().toString()).source(JSON.toJSONString(hotelDoc),XContentType.JSON));
        }
        client.bulk(request, RequestOptions.DEFAULT);
    }
```

# 5.elasticsearch搜索功能

DSL查询

![image.png](/static/img/6e52a6b48acbead635380e3a30816056.image.webp)

基本语法
查询所有
![image.png](/static/img/13871c0be5a24aa8f88b5748f84a4168.image.webp)
```DSL
GET /hotel/_search
{
  "query":{
  "match_all":{
    
  }
  }
}
```
全文检索查询（搜索框搜索）

![image.png](/static/img/b6dc20114b16a49f2373b15f35ccfa06.image.webp)


![image.png](/static/img/307d71910c3e832adc89857cd0925812.image.webp)

使用all搜索设置好的字段

```DSL
# match 单字段查询
Get /hotel/_doc/_search
{
  "query":{
    "match":{
      "all":"外滩"
    }
    
  }
}
```

```DSL
# multi_match 多字段查询
Get /hotel/_doc/_search
{
  "query":{
    "multi_match":{
      "query":"外滩如家",
      "fields":["brand","name","business"]
    }
    
  }
}
```
精确查询


![image.png](/static/img/84c969f4bb09909f700c32aa1e9a1df0.image.webp)

![image.png](/static/img/ce7152107152e47d128e1b4e55b1455d.image.webp)
```DSL
# term查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city" : {
        "value": "北京"
      }
    }
  }
}
```
价格在 100到300（包含100 300）

```DSL
# range
GET /hotel/_search
{
  "query":{
    "range":{
      "price":{
        "gte":100,
        "lte":300
      }
    }
  }
}
```
价格在 1341到3000（不包含1341 3000）

```DSL
GET /hotel/_search
{
  "query":{
    "range":{
      "price":{
        "gt":1341,
        "lt":3000
      }
    }
  }
}
```

地理查询

geo_bounding_box

![image.png](/static/img/26ba8e368cf3b67985d302c87b96e592.image.webp)

geo_distance

![image.png](/static/img/2e59196ccdcc4e08837bccb6c9fee6ff.image.webp)

```DSL
GET /hotel/_search
{
  "query":{
    "geo_distance":{
      "distance":"15km",
      "location":"31.21,121.5"
    }
  }
}

```

复合查询

![image.png](/static/img/3c067c75b523faf5dd7caf6b6360f019.image.webp)

![image.png](/static/img/7884f5f6d237e80fe6c31a8db6cecb15.image.webp)

![image.png](/static/img/a2d8d9a7463f08aad26dd5dd50788279.image.webp)

控制查询

![image.png](/static/img/ef1afeda7e7ab54e0b743b924cf30c93.image.webp)

控制品牌为如家的酒店放在最上面

```DSL
# function score
GET /hotel/_search
{
  "query":{
    "function_score": {
      "query": {
        "match":{
          "all":"外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 100
        }
      ],
      "boost_mode": "multiply"
    }
  }
}
```


![image.png](/static/img/98f4d9fdea5459a0e75ceeffaadd4259.image.webp)

案例

![image.png](/static/img/fa2ec2c33a660e4efcdc24128398ce63.image.webp)

```DSL
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
            }
          }
        }
      ]
    }
  }
}
```
在filter中的内容不参与算分降低性能消耗

RestClient(1)

# 1.elasticsearch介绍



![image.png](/static/img/c8cdd575c51a3fd66f5139e99b1addbe.image.webp)
![image.png](/static/img/6fec0f491602131d10bf9d34c67f1c28.image.webp)
# 2.正向索引和倒排索引

![image.png](/static/img/bb4234cf8223a9e203445c1bc9e87fa1.image.webp)
概念对比

![image.png](/static/img/8c08b09aff1568fde2ee669f5280acce.image.webp)
# 3。安装elastsearch
# 4.安装kibana

```sh
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601 \
kibana:7.12.1

```
# 5.分词器
安装分词器
## (1)到github下载ik，放入挂载es-plugins的卷中
![image.png](/static/img/e8e9c7d09a8060e08dbaced68b48f81c.image.webp)
重启es实例
# 6.配置分词器的禁用和拓展词
![image.png](/static/img/4288c6396118a411d40b9af9ed3770c9.image.webp)
创建禁用词和拓展词的文件
![image.png](/static/img/1485dbab296f2053475fd844db567061.image.webp)
重启es使配置的拓展词库和禁用词生效
# 7.索引库操作
mapping属性
![image.png](/static/img/9abc8798a65d0a1d7bbc55bdf67dbded.image.webp)
# 8.创建索引库
![image.png](/static/img/76dafe14b4195d4151763ca5948dbbc7.image.webp)

```DSL
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"
          }
        }
      }
    }
    
  }
}
```
查询和删除索引库

![image.png](/static/img/9138b7ff977564c19419c9ecffbe9e58.image.webp)
修改索引库（禁止直接修改原索引库）
![image.png](/static/img/9e4cce600b40940ceaa11430cec964ee.image.webp)
# 8.文档操作
文档插入

```DSL
POST /heima/_doc/1
{
  "info":"测试数据",
  "email":"test@qq.com",
  "name":{
    "firstName":"测",
    "lastName":"试"
  }
}
```
返回

```log
{
  "_index" : "heima",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}
```
查询和删除文档

```DSL
# 查询文档
GET /heima/_doc/1


# 删除文档
DELETE /heima/_doc/1
```
# 9.修改文档
全量修改
![image.png](/static/img/5e9cb099d3db4995448aca3ca28a1fe0.image.webp)
会将原文档删除并重新添加（既能修改又能更新）

增量修改
![image.png](/static/img/f138cdef4863d6b88188407f3aab9706.image.webp)


![image.png](/static/img/bd741fc8cbbd4bac592da77ccfdd3880.image.webp)