Spring Cloud（五）elasticsearch

elasticsearch

初识elasticsearch

elasticseach是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。

elasticsearch结合kibana、Logstash、Beats，也就是elastic stack(ELK)。被广泛应用在日志数据分析、实时监控等领域。

其中elasticsearch是elastic stack的核心，负责存储、搜索和分析数据。

正向索引和倒排索引

传统数据库（如MySQL）采用正向索引，例如给下表（tb_goods）中的id创建索引：

正向索引的搜索过程是逐条扫描：

正向索引基于文档id创建索引，查询词条时必须先找到文档，而后判断是否包含词条。

elasticsearch采用倒排索引：

• 文档（document）:每条数据就是一个文档
• 词条（term）：文档按照语义分成的词语

倒排索引会根据文档中词语的语义进行分词，对词条创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档id，然后获取到文档。

搜索时会根据词条进行查询，若匹配则返回其对应id：

倒排索引中包含两部分内容

• 词条词典（Term Dictionary）：记录所有词条，以及词条与倒排列表（Posting List）之间的关系，会给词条创建索引，提高查询和插入效率。
• 倒排列表（Posting List）：记录词条所在的文档id、词条出现频率、词条在文档中的位置等信息。
• • 文档id：用于快速获取文档
• • 词条频率（TF）：文档在词条出现的次数，用于评分。

与MySQL概念对比

文档
elasticsearch是面向文档存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中。

索引
索引是相同文档类型的集合。

概念对比：

架构：

• Mysql：擅长事务类型的操作，可以确保数据的安全性和一致性。
• Elastic search：擅长海量数据的搜索、分析、计算
  

分词器

es在创建倒排索引时需要对文档分词，在搜索时，需要对用户输入内容进行分词。但默认的分词规则对中文处理并不友好。

在kibana的DevTools中测试：

POST /_analyze
{
  "analyzer": "standard",
  "text": "黑马程序员学习Java太棒了！"
}

语法说明：

• POST：请求方式
• /_analyze：请求路径，这里省略了http://ip:port，有kibana帮我们补充
• 请求参数，json风格：
  analyzer：分词器类型，这里默认的standard分词器。
  text：要分词的内容。

处理中文分词，一般会使用IK分词器。

IK分词器包含两种模式：

• ik_smart：最少切分，粗粒度。
• ik_max_word：最细切分，细粒度。

ik分词器拓展词库

修改ik分词器目录中的config目录中的IkAnalyzer.cfg.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">ext.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

在ext.dic文件中，添加要拓展的词语即可。

Ik分词器停用词库

修改ik分词器目录中的config目录中的IkAnalyzer.cfg.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">ext.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords">stopword.dic</entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

在stopword.dic文件中，添加要禁用的词语即可。

索引库操作

mapping属性

mapping是对索引库中文档的约束，常见的mapping属性包括：

• type：字段数据类型，常见的简单类型有：
  字符串：text（可分词的文本）、keyword（精确值，例如品牌、国家）
  数值：long、integer、short、byte、double、float
  布尔：boolean
  日期：date
  对象：object
• index：是否创建索引，默认为true。
• analyzer：使用哪种分词器。
• properties：该字段的子字段。

创建索引库

ES中通过Restful请求操作索引库、文档。请求内容用DSL语句来表示，创建索引库和mapping的DSL语法如下：

PUT /heima
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": false
      },
      "name":{
        "type": "object",
        "properties": {
          "firstname": {
            "type": "keyword"
          },
          "secondname": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

查看索引库

语法：

GET /索引库名

删除索引库

语法：

DELETE /索引库名

修改索引库

索引库和mapping一旦创建就无法修改，但是可以添加新的字段

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名": {
      "type": "integer"
    }
  }
}

文档操作

添加文档

新增文档的DSL语法如下：

POST /heima/_doc/1
{
  "info": "黑马程序员Java讲师！",
  "email": "1272085519@qq.com",
  "name": {
    "firstname": "云",
    "secondname": "赵"
  }
}

查看文档

GET /索引库名/_doc/文档id

示例：

GET /heima/_doc/1

删除索引库的语法

DELETE /索引库名/_doc/文档id

示例：

DELETE /heima/_doc/1

修改文档

方式一：全量修改，会删除旧文档，添加新文档

PUT /heima/_doc/1
{
  "info": "黑马程序员Java讲师！",
  "email": "zhaoyun@qq.com",
  "name": {
    "firstname": "云",
    "secondname": "赵"
  }
}

方式二：增量修改，修改指定字段值

POST /heima/_update/1
{
  "doc": {
    "email": "zy@itcast.cn"
  }
}

RestClient操作索引库

初始化JavaRestClient

步骤1：引入es的RestHighLevelClient依赖

        <!-- elasticsearch -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.12.1</version>
        </dependency>

步骤二：因为Spring Boot默认的ES版本是7.6.2，所以需要覆盖默认的ES版本：

    <properties>
        <java.version>1.8</java.version>
        <elasticsearch.version>7.12.1</elasticsearch.version>
    </properties>

步骤三：初始化RestHighLevelCilent：

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

创建库索引

需要DSL语句，这里的DSL语句封装成了一个静态常量：

package cn.itcast.hotel.constants;

/**
 * @version 1.0
 * @Description
 * @Author 月上叁竿
 * @Date 2022-05-23 14:20
 **/
public class HotelConstants {
    public static final String MAPPING_TEMPLATE = "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\": {\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"address\": {\n" +
            "        \"type\": \"text\"\n" +
            "      },\n" +
            "      \"price\": {\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"score\": {\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"brand\": {\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"city\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"starName\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\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" +
            "      \"all\": {\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
}

    @Test
    void createHotelIndex() throws IOException {
        // 1.创建request对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 2.准备请求的参数 DSL语句
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 3.发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }

删除库索引

    @Test
    void deleteHotelIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        client.indices().delete(request,RequestOptions.DEFAULT);
    }

库索引是否存在

    @Test
    void ifExistsHotelIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest("hotel");
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.err.println(exists ? "索引库存在" : "索引库不存在!");
    }

关闭客户端连接

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }

RestClient操作文档

初始化JavaRestClient

@SpringBootTest
public class HotelDocumentTest {
    private RestHighLevelClient client;

    @Autowired
    private HotelService hotelService;

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

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }

添加文档

   @Test
    void testAddDocument() throws IOException {
        // 根据id查询酒店信息
       Hotel hotel = hotelService.getById(61083);
        // 转换为文档类型 得到索引库类型
       HotelDoc hotelDoc = new HotelDoc(hotel);

       // 1.准备Request对象
       IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
       //2.准备Json文档
       request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
       // 3.发送请求
       client.index(request, RequestOptions.DEFAULT);
   }

查询文档

   @Test
    void testGetDocumentById() throws IOException {
        // 1.准备Request
       GetRequest request = new GetRequest("hotel", "61083");
        // 2.发送请求，得到响应
       GetResponse response = client.get(request, RequestOptions.DEFAULT);
        // 3.解析响应结果
       String json = response.getSourceAsString();

       HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
       System.out.println(hotelDoc);
   }

修改文档

   @Test
    void testUpdateDocument() throws IOException {
    	// 1.创建request对象
       UpdateRequest request = new UpdateRequest("hotel", "61083");
		// 2.准备参数，每2个参数为一对key value
       request.doc(
               "price","952",
               "starName","四钻"
       );
		// 3.更新文档
       client.update(request, RequestOptions.DEFAULT);
   }

删除文档

   @Test
    void deleteDocument() throws IOException {
       // 1.创建request对象
       DeleteRequest request = new DeleteRequest("hotel", "61083");
		// 2.删除文档
       client.delete(request, RequestOptions.DEFAULT);
   }

批量导入数据

   @Test
    void testBulkRequest() throws IOException {
        // 批量查询酒店数据
       List<Hotel> hotels = hotelService.list();

       // 1.创建request
       BulkRequest request = new BulkRequest();
       // 2，准备参数，添加多个新增的request
       for (Hotel hotel : hotels) {
           // 转换为文档类型
           HotelDoc hotelDoc = new HotelDoc(hotel);

           // 创建新增文档的request对象
           request.add(new IndexRequest("hotel")
                   .id(hotel.getId().toString())
                   .source(JSON.toJSONString(hotelDoc),XContentType.JSON));
       }
       // 3.发送请求
       client.bulk(request, RequestOptions.DEFAULT);
   }

DSL查询文档

DSL Query的分类

Elasticsearch提供了基于JSON的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

全文检索查询

全文检索查询，会对用户输入的内容分词，常用于搜索框搜索。

• match查询：全文检索查询的一种，会对用户输入内容分词，然后去倒排索引库检索，语法如下：

GET /indexName/_search
{
  "query": {
    "match": {
	  "FIELD": "TEXT"
	}
  }
}

# match查询
GET /hotel1/_search
{
  "query": {
    "match": {
      "all": "外滩如家"
    }
  }
}

• multi_match：与match查询类似，只不过允许同时查询多个字段，语法：

GET /indexName/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", "FIELD2"]
    }
  }
}

# multi_match查询
GET /hotel1/_search
{
  "query": {
    "multi_match": {
      "query": "如家外滩",
      "fields": ["brand","name","business"]
    }
  }
}

match和multi_match的区别：

• match：根据一个字段查询。
• multi_match：根据多个字段查询，参与查询字段越多，查询性能越差。

精确查询

精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：

• term：根据词条精确值查询
• range：根据值的范围查询

term

根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段

GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

# 精确查询-term查询
GET /hotel1/_search
{
  "query": {
    "term": {
      "city": {
        "value": "北京"
      }
    }
  }
}

range

根据数值范围查询，可以是数值、日期的范围

GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": 10,
        "lte": 20
      }
    }
  }
}

# 精确查询-range查询
GET /hotel1/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 500,
        "lte": 700
      }
    }
  }
}

地理查询

根据经纬度查询，例如：

• geo_bounding_box：查询geo_point值落在某个矩形范围的所有文档。

GET /hotel1/_search
{
  "query": {
    "geo_bounding_box": {
      "location":{
        "top_left": {
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": {
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

• geo_distance：查询到指定中心点小于某个距离值的所有文档

# distance查询
GET /hotel1/_search
{
  "query": {
    "geo_distance": {
      "distance": "2km",
      "location": "31.21, 121.5"
    }
  }
}

复合查询

复合(compound)查询可以将其他的简单查询组合起来，实现更复杂的搜索逻辑。

例如：

• fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名，例如百度竞价。

相关性算分

当我们利用match查询时，文档结果会根据与搜索词条的关联度进行打分（即查询后的_score），返回结果时按照分值降序排列。

计算分数的算法如下：

elasticsearch中的相关性打分算法：

• TF-IDF：在elasticsearch5.0之前，会随着词频增加而越来越大。
• BM25：在elasticsearch5.0之后，会随着词频增加而增大，但增长曲线会趋于水平。

Function Score Query

使用function score query，可以修改文档的相关性算分，根据新得到的算分进行排序。

GET /hotel1/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

function score query定义的三要素：

• 过滤条件：哪些文档要加分。
• 算分函数：如何计算function score。
• 加权方式：function score与query score如何计算

Boolean Query

布尔查询是一个或多个查询子句的组合，子查询的组合方式有：

• must：必须匹配每个子查询，类似"与"。
• should：选择性匹配每个子查询，类似"或"。
• must_not：必须不匹配，不参与算分，类似"非"。
• filter：必须匹配，不参与算分。

案例：搜索名字包含如家，价格不高于400，在坐标31.21，121.5周围10km范围内的酒店

GET /hotel1/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "如家"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}

搜索结果处理

排序

elasticsearch支持对搜索结果排序，默认是根据相关度算分（_score）来排序。可以排序的字段类型有：keywork类型、数值类型、地理坐标类型、日期类型。

语法规则如下：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
  	{
  	  "FIELD": "desc"     // 排序字段和排序方式ASC、DESC
  	}
  ]
}

案例：对酒店数据按照用户评价降序排序，评价相同的按照价格升序进行排序

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

案例：实现对酒店数据按照到你的位置坐标的距离升序排序

GET /hotel1/_search
{
  "query": {
    "match_all": {
    }
  },
  "sort": [
    {
      "_geo_distance": {
        "location": {
          "lat": 31.034661,
          "lon": 121.612282
        },
        "order": "asc",
        "unit": "km"
      }
    }
  ]
}

分页

elasticsearch默认情况下只返回top10的数据，如果要查询更多数据就需要修改分页参数了。通过修改from、size参数来控制要返回的分页结果：

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990,  // 分页开始的数据
  "size": 10,   // 期望获取的文档总数
  "sort": [
    { "price": "asc" }
  ]
}

这种from + size的分页查询存在一定问题，在查第990-1000条数据时，需要查前1000条数据，然后将990-1000的数据截取出来。单机情况下我们不觉得这对效率有多大的损耗，但ES是分布式的，所以会面临深度分页问题：

1. 首先在每个数据分片上都排序并查询前1000条文档。
2. 然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档。
3. 最后从这1000条中，选取从990开始的10条文档。

如果搜索页数过深，或者结果集越大，对内存和CPU的消耗也就越高。因此ES设定结果集查询的上限是10000。

针对深度分页，ES提供了两种解决方案：

• search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐√。
• scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。

三种分页方式的总结

from + size：

• 优点：支持随机翻页
• 缺点：深度分页问题，默认查询上限（from + size）是10000。
• 场景：百度、京东、谷歌、淘宝这样的随机翻页搜索。

after search：

• 优点：没有查询上限（单次查询的size不超过10000）
• 缺点：只能向后逐页查询，不支持随机翻页。
• 场景：没有随机翻页需求的搜索，例如手机向下翻滚翻页。

scroll：

• 优点：没有查询上限（单次查询的size不超过10000）
• 缺点：会有额外内存消耗，并且搜索结果是非实时的。
• 场景：海量数据的获取和迁移，从ES7.1开始不推荐，建议用after search方案。

高亮

即在搜索结果中把搜索关键字突出显示。

原理如下：

• 将搜索结果中的关键字用标签标记出来。
• 在页面中给标签添加css样式。

语法：

# 高亮查询，默认情况下搜索字段必须和高亮字段一致
GET /hotel1/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  },
  "highlight": {
    "fields": {     // 指定要高亮的字段
      "name": {
        "pre_tags": "<em>",   // 用来标记高亮字段的前置标
        "post_tags": "</em>",   // 用来标记高亮字段的后置标
        "require_field_match": "false"
      }
    }
  }
}

RestClient查询文档

快速入门

查询的基本步骤：

1. 创建SearchRequest对象。
2. 准备Request.source()，也就是DSL。
   ①QueryBuilder来构建查询条件。 ②传入Request.source()的query()方法。
3. 发送请求，得到结果。
4. 解析结果。（参考JSON结果，从外到内，逐层解析）

    @Test
    void testMatchAll() throws IOException {
        // 1. 准备request
        SearchRequest request = new SearchRequest("hotel1");
        // 2.准备DSL
        request.source().query(QueryBuilders.matchAllQuery());
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        SearchHits searchHits = response.getHits();
        // 总条数
        long value = searchHits.getTotalHits().value;
        System.out.println("文档总条数为：" + value);
        // 文档数组
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            System.out.println(hotelDoc);
        }
    }

全文检索查询、精确查询、复合查询

全文检索的match和multi_match查询与match_all的API基本一致，差别是查询条件，也就是"query"的部分。

    @Test
    void testMatch() throws IOException {
        // 1. 准备request
        SearchRequest request = new SearchRequest("hotel1");
        // 2.准备DSL
        request.source().query(QueryBuilders.matchQuery("all", "如家"));
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
		SearchHits searchHits = response.getHits();
        // 总条数
        long value = searchHits.getTotalHits().value;
        System.out.println("文档总条数为：" + value);
        // 文档数组
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            System.out.println(hotelDoc);
        }
    }

精确查询常见的有term查询和range查询，同样利用QueryBuilders实现

    @Test
    void testBoolQuery() throws IOException {
        // 1. 准备request
        SearchRequest request = new SearchRequest("hotel1");
        // 2.准备DSL
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.termQuery("city","上海"));
        boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));

        request.source().query(boolQuery);
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        dealResponse(response);
    }

注：对解析进行了抽取，抽取后的代码如下：

    void dealResponse(SearchResponse response) {
        // 4.解析响应
        SearchHits searchHits = response.getHits();
        // 总条数
        long value = searchHits.getTotalHits().value;
        System.out.println("文档总条数为：" + value);
        // 文档数组
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            System.out.println(hotelDoc);
        }
    }

排序、分页、高亮

排序、分页

搜索结果的排序和分页是与query同级的参数

    @Test
    void testPageAndSort() throws IOException {
        // 页码，每页的大小
        int page = 2, size = 5;

        // 1. 准备request
        SearchRequest request = new SearchRequest("hotel1");
        // 2.准备DSL
        // 2.1 query
        request.source().query(QueryBuilders.matchAllQuery());
        // 2.2 排序
        request.source().sort("price", SortOrder.ASC);
        // 2.3 分页
        request.source().from((page - 1) * size).size(5);

        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        dealResponse(response);
    }

高亮

    @Test
    void testHighLight() throws IOException {
        // 1. 准备request
        SearchRequest request = new SearchRequest("hotel1");
        // 2.准备DSL
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        SearchHits searchHits = response.getHits();
        // 4.1 获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("共搜索到" + total + "条数据");
        // 4.2 文档数组
        SearchHit[] hits = searchHits.getHits();
        // 4.3 遍历
        for (SearchHit hit : hits) {
            // 获取文档source
            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);
        }
    }