# 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)

ElasticSearch(1)

# 1.消息队列




![image.png](/static/img/fe85c7921c1eea8c76fb91d0d230e0e9.image.webp)
# 2.基础概念

![image.png](/static/img/bb525212a719ad153fb3457d03da8005.image.webp)
# 3.Hello World案例
## (1)publisherTest

```java
public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.42.10");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
```
## (2)ConsumerTest代码

```java
public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.42.10");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
```

![image.png](/static/img/bc4f32e6ebcc763a50489c240003cceb.image.webp)
# 4.Spring AMQP

![image.png](/static/img/f18b8b360e93cb5f99b7e44fe277cb30.image.webp)
利用Spring AMQP实现HelloWorld案例

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

```pom
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
```
编写配置

![image.png](/static/img/09c2b9e35ae8c4607c5da6dc7158ce8d.image.webp)
编写测试

```java
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void RabbitMqTest(){
        String queueName = "simple.queue";
        String message = "Hello World";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}
```

![image.png](/static/img/a83aa3bbf2b52b3e3a1cd54393f55cbf.image.webp)
接收消息

![image.png](/static/img/02804effa0c65fbb564371af16f27843.image.webp)
# 5.工作队列 work queue

![image.png](/static/img/a733e23d6dbfa9f37491822006546bb2.image.webp)
案例

![image.png](/static/img/30d560ca5e12f4f79daba2e5c9a5c4ef.image.webp)
发布50条数据到队列

```java
    @Test
    public  void RabbitMqTestWorkQueue() throws InterruptedException {
        String queueName = "simple.queue";
        String message = "Hello World__";
        for (int i = 1;i<=50;i++){
            rabbitTemplate.convertAndSend(queueName,message+i);
            Thread.sleep(20);
        }
    }
```
接受数据

```java
    @RabbitListener(queues = "simple.queue")
    public void lisstenerWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息:["+msg+"]");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void lisstenerWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息:["+msg+"]"+ LocalTime.now());
        Thread.sleep(200);
    }
```
显示数据

```log
消费者2接收到消息:[Hello World__1]16:28:43.674
消费者1接收到消息:[Hello World__2]
消费者1接收到消息:[Hello World__4]
消费者1接收到消息:[Hello World__6]
消费者2接收到消息:[Hello World__3]16:28:43.874
消费者1接收到消息:[Hello World__8]
消费者1接收到消息:[Hello World__10]
消费者1接收到消息:[Hello World__12]
消费者1接收到消息:[Hello World__14]
消费者2接收到消息:[Hello World__5]16:28:44.088
消费者1接收到消息:[Hello World__16]
消费者1接收到消息:[Hello World__18]
消费者1接收到消息:[Hello World__20]
消费者2接收到消息:[Hello World__7]16:28:44.304
消费者1接收到消息:[Hello World__22]
消费者1接收到消息:[Hello World__24]
消费者1接收到消息:[Hello World__26]
消费者1接收到消息:[Hello World__28]
消费者2接收到消息:[Hello World__9]16:28:44.517
消费者1接收到消息:[Hello World__30]
消费者1接收到消息:[Hello World__32]
消费者1接收到消息:[Hello World__34]
消费者2接收到消息:[Hello World__11]16:28:44.729
```
当消费者接受数据时会预取数据两个消费者平分数据
![image.png](/static/img/c79defc2bd0deb6c5150eddcf8df16d0.image.webp)
可以修改预取值来控制消费者按照处理速度修改提高效率

```data
消费者2接收到消息:[Hello World__1]16:36:22.113
消费者1接收到消息:[Hello World__2]
消费者1接收到消息:[Hello World__3]
消费者1接收到消息:[Hello World__4]
消费者1接收到消息:[Hello World__5]
消费者1接收到消息:[Hello World__6]
消费者1接收到消息:[Hello World__7]
消费者1接收到消息:[Hello World__8]
消费者2接收到消息:[Hello World__9]16:36:22.346
消费者1接收到消息:[Hello World__10]
消费者1接收到消息:[Hello World__11]
消费者1接收到消息:[Hello World__12]
消费者1接收到消息:[Hello World__13]
消费者1接收到消息:[Hello World__14]
消费者1接收到消息:[Hello World__15]
消费者1接收到消息:[Hello World__16]
消费者2接收到消息:[Hello World__17]16:36:22.597

```
修改过后提高处理速度
# 6.发布订阅模式

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

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

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

```java
@Configurable
public class FanoutConfig {

//    创建交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
//创建消息队列1
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("itcast.fanout1");
    }
//绑定消息队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
//创建消息队列2
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("itcast.fanout2");
    }
//绑定消息队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}
```
编写接收消息代码

```java
    @RabbitListener(queues = "fanout.queue1")
    public void lisstenerWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息:["+msg+"]");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void lisstenerWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息:["+msg+"]"+ LocalTime.now());
        Thread.sleep(200);
    }
```
修改publisher端代码

```java
    @Test
    public void RabbitMqTestWorkQueue2() throws InterruptedException {
        String queueName = "itcast.fanout";
        String message = "Hello World test fanout";
        rabbitTemplate.convertAndSend(queueName,"",message);
    }
```
# 7.路由模式

![image.png](/static/img/35ab95e35999185b6a42cc241cc40db4.image.webp)
修改消费者监听代码

```java
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void listenDirectQueue1(String msg)   {
        System.out.println("消费者接收到direct.queue1消息:"+msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg)   {
        System.out.println("消费者接收到direct.queue2消息:"+msg);
    }
```
修改发布者发布代码

```java
    @Test
    public void RabbitMqTestWorkQueue2() throws InterruptedException {
        String queueName = "itcast.direct";
        String message = "Hello yellow";
        rabbitTemplate.convertAndSend(queueName,"yellow",message);
    }
```
发布者只发布给yellow
# 8.发布订阅 TopicExchange
通配符订阅
![image.png](/static/img/1bc8f6d4a0f28ba9d955da464db156c6.image.webp)
交换机配置部分不变修改listen部分代码

```java
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listenTopicQueue1(String msg)   {
        System.out.println("消费者接收到topic.queue1消息:"+msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listenTopicQueue2(String msg)   {
        System.out.println("消费者接收到topic.queue2消息:"+msg);
    }
```
发送端测试

```java
    @Test
    public void RabbitMqTestTopicQueue3() throws InterruptedException {
        String queueName = "itcast.topic";
        String message = "Hello china";
        rabbitTemplate.convertAndSend(queueName,"china.news",message);
    }
```
# 9.消息转换器

## (1)创建一个消息队列

```java
    @Bean
    public Queue fanoutQueue3(){
        return new Queue("object.queue");
    }
```
## (2)向"object.queue"发送对象数据

```java
    @Test
    public  void sendObjectQueue(){
        Map<String,Object> msg = new HashMap<>();
        msg.put("name","柳岩");
        msg.put("age",18);
        rabbitTemplate.convertAndSend("object.queue",msg);
    }
```
## (3)获取数据
![image.png](/static/img/0f941692ea5c804e85be55808ed52fe3.image.webp)
上面传输的对象数据并没有配置消息转换器无法直接查看
## (4)配置消息转换器
![image.png](/static/img/4e3274bb1bc9b6ce9cfb9d5e011304cf.image.webp)

```pom
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.9.10</version>
        </dependency>
```

```java
    @Bean
    public MessageConverter jsonMessageConverter() {
        return new Jackson2JsonMessageConverter();
    }
```
![image.png](/static/img/5df653ba2654499c65b3f3a441f0961a.image.webp)
消息转换器配置成功

## (5)消费端输出接收到的消息

配置消息转换器并编写队列监听代码
```java
    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg)   {
        System.out.println("接收到object.queue:"+msg);
    }
```

RabbitMQ

# 1.拉取Docker镜像



```shell
docker pull nginx
```
`[root@localhost ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
d107e437f729: Pull complete 
cb497a329a81: Pull complete 
f1c4d397f477: Pull complete 
f72106e86507: Pull complete 
899c83fc198b: Pull complete 
a785b80f5a67: Pull complete 
6c50e4e0c439: Pull complete 
Digest: sha256:d5f28ef21aabddd098f3dbc21fe5b7a7d7a184720bc07da0b6c9b9820e97f25e
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
`
# 2.