SpringBoot整合ElasticSearch实现模糊查询，排序，分页，高亮

川长思鸟来 2024-03-26 18:45 29阅读 0赞

**目录**

前言

1.框架集成-SpringData-整体介绍

1.1Spring Data Elasticsearch 介绍

2.框架集成Spring Data Elasticsearch

2.1版本说明

2.2.idea创建一个springboot项目

2.3.导入依懒

2.3.增加配置文件

2.4Spring Boot 主程序。

2.5.数据实体类

2.6.配置类

2.7.DAO 数据访问对象

3.框架集成-SpringData-集成测试-索引操作

4.框架集成-SpringData-集成测试-文档操作

5.框架集成-SpringData-集成测试-文档搜索

6.demo地址

--------------------

### **前言** ###

推荐首先查看spring boot对应elasticsearch版本，选择合适的版本整合，推荐以spring boot版本为主，因为项目中集成的框不止是es，根据spring boot去安装对应版本的es。  
[Spring Data Elasticsearch - 参考文档][Spring Data Elasticsearch -]，这是官方文档，建议一定参照文档，这个文档真的很详细。

![2e05c85b8fd547d5a06dda7d49924aeb.png][]

springboot操作elasticsearch有两种常用方式：

*  **Spring Data Elasticsearch**

这是Spring官方最推荐的，就像JPA，Mybatisplus一样，在DAO层继承ElasticsearchRepository接口，就可以使用封装好的一些常见的操作了，用起来简单方便。

![21a7418d96e04b7ebdfa3043480f739f.png][]

文档： [Spring 数据弹性搜索 - 参考文档][Spring _ -]

*  **ElasticsearchRestTemplate**

封装的就是`High Level REST Client`，这是基于HTTP协议的客户端，是ES官方推荐使用的，也是可以使用的，但是要求对ES的DSL语句熟悉，方便自己做复杂的增删改查。

![e81b63cedef84519909a2229c22150a2.png][]

> 映射标注概述
> 
> 使用元数据来驱动对象到文档的映射。 元数据取自可以注释的实体属性。`MappingElasticsearchConverter`
> 
> 以下注释可用：
> 
>  *  `@Document`：在类级别应用，以指示此类是映射到数据库的候选项。 最重要的属性是（查看 API 文档以获取完整的属性列表）：
>     
>      *  `indexName`：要在其中存储此实体的索引的名称。 这可以包含一个 SpEL 模板表达式，例如`"log-#{T(java.time.LocalDate).now().toString()}"`
>      *  `createIndex`：标记是否在存储库引导时创建索引。 默认值为 *true*。 请参阅[使用相应映射自动创建索引][Link 1]
>  *  `@Id`：在字段级别应用，以标记用于标识目的的字段。
>  *  `@Transient`， ， ： 有关详细信息，请参阅以下控制写入[和读取哪些属性一节。][Link 2]`@ReadOnlyProperty``@WriteOnlyProperty`
>  *  `@PersistenceConstructor`：标记给定的构造函数 - 甚至是受包保护的构造函数 - 以便在从数据库中实例化对象时使用。 构造函数参数按名称映射到检索到的文档中的键值。
>  *  `@Field`：应用于字段级别并定义字段的属性，大多数属性映射到相应的 [Elasticsearch 映射][Elasticsearch]定义（以下列表不完整，请查看注释 Javadoc 以获取完整参考）：
>     
>      *  `name`：将在 Elasticsearch 文档中表示的字段名称，如果未设置，则使用 Java 字段名称。
>      *  `type`：字段类型可以是文本、关键字、长整型、*整数、短整型、字节、双精度、浮点型、Half\_Float型、Scaled\_Float、日期、Date\_Nanos、布尔值、二进制、Integer\_Range、Float\_Range、Long\_Range、Double\_Range、Date\_Range、Ip\_Range、对象、嵌套、IP、令牌计数、渗滤器、扁平化、Search\_As\_You\_Type*之一。 请参阅 [Elasticsearch 映射类型][Elasticsearch 1]。 如果未指定字段类型，则默认为 。 这意味着，不会为该属性写入映射条目，并且 Elasticsearch 将在存储此属性的第一个数据时动态添加映射条目（查看 Elasticsearch 文档以了解动态映射规则）。`FieldType.Auto`
>      *  `format`：一种或多种内置日期格式，请参阅下一节[日期格式映射][Link 3]。
>      *  `pattern`：一种或多种自定义日期格式，请参阅下一节[日期格式映射][Link 3]。
>      *  `store`：标记原始字段值是否应存储在 Elasticsearch 中，默认值为 *false*。
>      *  `analyzer`， ， ，用于指定自定义分析器和规范化器。`searchAnalyzer``normalizer`
>  *  `@GeoPoint`：将字段标记为*geo\_point*数据类型。 如果字段是类的实例，则可以省略。`GeoPoint`
>  *  `@ValueConverter`定义用于转换给定属性的类。 与注册的 Spring 不同，这只转换带注释的属性，而不是给定类型的每个属性。`Converter`
> 
> 映射元数据基础设施在一个单独的 spring-data-commons 项目中定义，该项目与技术无关。

文档： [Spring 数据弹性搜索 - 参考文档][Spring _ -]

### 1.框架集成-SpringData-整体介绍 ###

Spring Data是一个用于简化数据库、非关系型数据库、索引库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持 map-reduce框架和云计算数据服务Spring Data可以极大的简化JPA(Elasticsearch)的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD 外，还包括如分页、排序等一些常用的功能。

[Spring Data 的官网][Spring Data]

Spring Data 常用的功能模块如下：

*  Spring Data JDBC
 *  Spring Data JPA
 *  Spring Data LDAP
 *  Spring Data MongoDB
 *  Spring Data Redis
 *  Spring Data R2DBC
 *  Spring Data REST
 *  Spring Data for Apache Cassandra
 *  Spring Data for Apache Geode
 *  Spring Data for Apache Solr
 *  Spring Data for Pivotal GemFire
 *  Spring Data Couchbase
 *  Spring Data Elasticsearch
 *  Spring Data Envers
 *  Spring Data Neo4j
 *  Spring Data JDBC Extensions
 *  Spring for Apache Hadoop

#### 1.1Spring Data Elasticsearch 介绍 ####

Spring Data Elasticsearch基于Spring Data API简化 Elasticsearch 操作，将原始操作Elasticsearch 的客户端API进行封装。Spring Data为Elasticsearch 项目提供集成搜索引擎。Spring Data Elasticsearch POJO的关键功能区域为中心的模型与Elastichsearch交互文档和轻松地编写一个存储索引库数据访问层。

[Spring Data Elasticsearch 官网][Spring Data Elasticsearch]

注意点：

*  ElasticsearchRestTemplate是spring-data-elasticsearch项目中的一个类,和其他spring项目中的 template类似。
 *  在新版的spring-data-elasticsearch 中，ElasticsearchRestTemplate 代替了原来的ElasticsearchTemplate。
 *  原因是ElasticsearchTemplate基于TransportClient，TransportClient即将在8.x 以后的版本中移除。所以，我们推荐使用ElasticsearchRestTemplate。ElasticsearchRestTemplate基于RestHighLevelClient客户端的。
 *  需要自定义配置类，继承AbstractElasticsearchConfiguration，并实现elasticsearchClient()抽象方法，创建RestHighLevelClient对象。

### 2.框架集成Spring Data Elasticsearch ###

#### 2.1版本说明 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>内容</td> 
   <td>版本</td> 
  </tr> 
  <tr> 
   <td>elasticsearch</td> 
   <td>elasticsearch-7.8.0</td> 
  </tr> 
  <tr> 
   <td>springboot</td> 
   <td> <pre>2.3.6.RELEASE</pre> </td> 
  </tr> 
 </tbody> 
</table>

#### 2.2.idea创建一个springboot项目 ####

#### 2.3.导入依懒 ####

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-test</artifactId>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
            </dependency>
        </dependencies>

#### 2.3.增加配置文件 ####

在 resources 目录中增加application.properties文件

> \# es 服务地址  
> elasticsearch.host=127.0.0.1  
> \# es 服务端口  
> elasticsearch.port=9200  
> \# 配置日志级别,开启 debug 日志  
> logging.level.com.es=debug

#### 2.4Spring Boot 主程序。 ####

package com.example;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
    
    
    /**
     * @author 24412
     */
    @SpringBootApplication
    public class SpringBootElasticSearchApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringBootElasticSearchApplication.class, args);
        }
    
    }

#### 2.5.数据实体类 ####

package com.example.es;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    import org.springframework.data.annotation.Id;
    import org.springframework.data.elasticsearch.annotations.Document;
    import org.springframework.data.elasticsearch.annotations.Field;
    import org.springframework.data.elasticsearch.annotations.FieldType;
    
    /**
     * @author 24412
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    @Document(indexName = "shopping", shards = 3, replicas = 1)
    public class Product {
        /**
         * type : 字段数据类型
         * analyzer : 分词器类型
         * index : 是否索引(默认:true)
         * Keyword : 短语,不进行分词
         */
    
        /**
         *     商品唯一标识 必须有 id,这里的 id 是全局唯一的标识，等同于 es 中的"_id"
         */
        @Id
        private Long id;
    
        @Field(type = FieldType.Text, analyzer = "ik_max_word")
        private String title;//商品名称
    
        @Field(type = FieldType.Keyword)
        private String category;//分类名称
    
        @Field(type = FieldType.Double)
        private Double price;//商品价格
    
        @Field(type = FieldType.Keyword, index = false)
        private String images;//图片地址
    }

#### 2.6.配置类 ####

package com.example.config;
    
    import lombok.Data;
    import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestClientBuilder;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
    
    /** ElasticsearchRestTemplate基于RestHighLevelClient客户端的。
     * 需要自定义配置类，继承AbstractElasticsearchConfiguration，
     * 并实现elasticsearchClient()抽象方法，创建RestHighLevelClient对象。
     * @author 24412
     */
    @ConfigurationProperties(prefix = "elasticsearch")
    @Configuration
    @Data
    public class ElasticsearchConfig extends AbstractElasticsearchConfiguration{
         /**
         * 设置为static方便后面调用
         */
        public static RestHighLevelClient restHighLevelClient;
        private String host ;
        private Integer port ;
        /**
         * 重写父类方法
         */
        @Override
        public RestHighLevelClient elasticsearchClient() {
            RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
            restHighLevelClient = new RestHighLevelClient(builder);
            return restHighLevelClient;
        }
    }

#### 2.7.DAO 数据访问对象 ####

import com.lun.model.Product;
    import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface ProductDao extends ElasticsearchRepository<Product, Long>{
    
    }

### 3.框架集成-SpringData-集成测试-索引操作 ###

package com.example;
    
    import com.example.es.Product;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringDataESIndexTest {
        //注入 ElasticsearchRestTemplate
        @Autowired
        private ElasticsearchRestTemplate elasticsearchRestTemplate;
        //创建索引并增加映射配置
        @Test
        public void createIndex(){
            //创建索引，系统初始化会自动创建索引
            System.out.println("创建索引");
        }
    
        @Test
        public void deleteIndex(){
            //创建索引，系统初始化会自动创建索引
            boolean flg = elasticsearchRestTemplate.deleteIndex(Product.class);
            System.out.println("删除索引 = " + flg);
        }
    }

### 4.框架集成-SpringData-集成测试-文档操作 ###

package com.example;
    
    import com.example.dao.ProductDao;
    import com.example.es.Product;
    import org.junit.jupiter.api.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Sort;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 文档操作
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest
    class SpringBootElasticSearchApplicationTests {
        @Autowired
        private ProductDao productDao;
    
        /**
         * 新增
         */
        @Test
        public void testAdd() {
            Product product = new Product();
            product.setId(1L);
            product.setTitle("小米手机");
            product.setCategory("手机");
            product.setPrice(1999.00);
            product.setImages("http://image.baidu.com/13123.jpg");
            productDao.save(product);
        }
    
        /**
         * 修改
         */
        @Test
        public void testUpdate() {
            Product product = new Product();
            product.setId(1L);
            product.setTitle("华为手机");
            product.setCategory("手机");
            product.setPrice(2999.00);
            product.setImages("http://image.baidu.com/13123.jpg");
            productDao.save(product);
        }
    
        /**
         * 根据id查询
         */
        @Test
        public void testFindById() {
            Product product = productDao.findById(1L).get();
            System.out.println(product);
        }
    
        /**
         * 查询全部
         */
        @Test
        public void testFindAll() {
            productDao.findAll().forEach(System.out::println);
        }
    
        /**
         * 删除
         */
        @Test
        public void testDelete() {
            productDao.deleteById(1L);
    
        }
    
        /**
         * 批量插入
         */
        @Test
        public void testBatchAdd() {
            List<Product> list = new ArrayList<>();
            for (int i = 0; i < 100; i++) {
                Product product = new Product();
                product.setId(Long.valueOf(i));
                product.setTitle("华为手机" + i);
                product.setCategory("手机");
                product.setPrice(2999.00);
                product.setImages("http://image.baidu.com/13123.jpg");
                list.add(product);
            }
            productDao.saveAll(list);
        }
    
        /**
         * 分页查询
         */
        @Test
        public void testPageQuery() {
            //设置排序(排序方式，正序还是倒序，排序的 id)
            Sort sort = Sort.by(Sort.Direction.DESC, "id");
            //设置分页(页码，每页显示的条数)
            //当前页码0开始
            int currentPage = 0;
            //每页显示的条数
            int pageSize = 10;
            //设置分页
            PageRequest pageRequest = PageRequest.of(currentPage, pageSize, sort);
            //分页查询
            productDao.findAll(pageRequest).forEach(System.out::println);
        }
    
    
    
    }

### 5.框架集成-SpringData-集成测试-文档搜索 ###

package com.example;
    
    import com.example.config.ElasticsearchConfig;
    import com.example.dao.ProductDao;
    import com.example.es.Product;
    import org.elasticsearch.action.search.SearchRequest;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.common.unit.Fuzziness;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.FuzzyQueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.index.query.TermQueryBuilder;
    import org.elasticsearch.search.aggregations.AggregationBuilders;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
    import org.elasticsearch.search.sort.*;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
    import org.springframework.data.elasticsearch.core.SearchHits;
    import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
    import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.io.IOException;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringDataESSearchTest {
        @Autowired
        private ElasticsearchRestTemplate elasticsearchRestTemplate;
    
        @Autowired
        private ProductDao productDao;
    
        /**
         * term 查询
         * search(termQueryBuilder) 调用搜索方法，参数查询构建器对象
         */
        @Test
        public void termQuery() {
            TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "华为手机99");
            QueryBuilders.boolQuery().must(termQueryBuilder);
            Iterable<Product> products = productDao.search(termQueryBuilder);
            for (Product product : products) {
                System.out.println(product);
            }
        }
    
        /**
         * term 查询加分页
         */
        @Test
        public void termQueryByPage() {
            int currentPage = 0;
            int pageSize = 5;
            //设置查询分页
            PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
            TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "华为手机");
            Iterable<Product> products =
                    productDao.search(termQueryBuilder, pageRequest);
            for (Product product : products) {
                System.out.println(product);
            }
        }
    
        /**
         * 高亮查询
         */
        @Test
        public void testHighlight() {
            //构建查询条件
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.should(QueryBuilders.matchQuery("title", "华为手机"));
            //设置高亮字段
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            //设置标签前缀
            highlightBuilder.preTags("<font color='red'>");
            //设置标签后缀
            highlightBuilder.postTags("</font>");
            //设置高亮字段
            highlightBuilder.field("title");
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(boolQuery)
                    .withHighlightBuilder(highlightBuilder)
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 高亮查询加分页
         */
        @Test
        public void testHighlightByPage() {
            //当前页
            int currentPage = 0;
            //每页显示条数
            int pageSize = 5;
            //设置查询分页
            PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
            //构建查询条件
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.should(QueryBuilders.matchQuery("title", "华为手机"));
            //设置高亮字段
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            //设置标签前缀
            highlightBuilder.preTags("<font color='red'>");
            //设置标签后缀
            highlightBuilder.postTags("</font>");
            //设置高亮字段
            highlightBuilder.field("title");
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(boolQuery)
                    .withHighlightBuilder(highlightBuilder)
                    .withPageable(pageRequest)
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 模糊查询
         */
        @Test
        public void testFuzzyQuery() {
            //构建查询条件
            FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery("title", "华为").fuzziness(Fuzziness.ONE);
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(fuzzyQuery)
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 最大查询
         */
        @Test
        public void testMaxQuery() {
            FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery("title", "华为").fuzziness(Fuzziness.ONE);
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(fuzzyQuery)
                    .addAggregation(AggregationBuilders.max("maxAge").field("age"))
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 分组查询
         */
        @Test
        public void testGroupQuery() {
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .addAggregation(AggregationBuilders.terms("title").field("price"))
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 范围查询
         */
        @Test
        public void testRangeQuery() {
            //构建条件查询：id为30-50，按价格分组
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.must(QueryBuilders.rangeQuery("id").from(30).to(50));
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(boolQuery)
                    .addAggregation(AggregationBuilders.terms("title").field("price"))
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * 组合查询
         */
        @Test
        public void testConditionQuery() {
            //构建条件查询：id为30-50，按价格分组
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.must(QueryBuilders.rangeQuery("id").from(30).to(50));
            // 构建查询
            NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withQuery(boolQuery)
                    .addAggregation(AggregationBuilders.terms("title").field("price"))
                    .build();
            //执行查询
            SearchHits<Product> searchHits = elasticsearchRestTemplate.search(searchQuery, Product.class);
            //获取查询结果
            searchHits.forEach(searchHit -> {
                System.out.println(searchHit.toString());
            });
        }
    
        /**
         * TODO 查询排序  ElasticsearchConfig.restHighLevelClient
         */
        @Test
        public void testSortQuery() throws IOException {
            //里面可以放多个索引
            SearchRequest request = new SearchRequest("shopping");
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            //按照id倒序排列（score会失效返回NaN）
            sourceBuilder.sort(SortBuilders.fieldSort("_id").order(SortOrder.DESC));
            //执行查询
            SearchResponse response = ElasticsearchConfig.restHighLevelClient.search(request, RequestOptions.DEFAULT);
            //打印结果信息
            org.elasticsearch.search.SearchHits hits = response.getHits();
            System.out.println("timeout:" + response.isTimedOut());
            System.out.println("total:" + hits.getTotalHits());
            System.out.println("MaxScore:" + hits.getMaxScore());
            System.out.println("hits========>>");
            hits.forEach(hit -> {
                System.out.println(hit.getSourceAsString());
            });
            System.out.println("<<========");
        }
    
    }

### 6.demo地址 ###

[SpringBoot整合ElasticSearch小demo: SpringBoot整合ElasticSearch小demo][SpringBoot_ElasticSearch_demo_ SpringBoot_ElasticSearch_demo]

[Spring Data Elasticsearch -]: https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#preface.metadata
[2e05c85b8fd547d5a06dda7d49924aeb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0a5cec9c1b204b6eb7c642a115b34776.png
[21a7418d96e04b7ebdfa3043480f739f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e88cd4e77bd246eba7eec403d4657c84.png
[Spring _ -]: https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#elasticsearch.operations
[e81b63cedef84519909a2229c22150a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e2100dd2d3e54ea9b2550d2020052763.png
[Link 1]: https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#elasticsearch.repositories.autocreation
[Link 2]: https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#elasticsearch.mapping.meta-model.annotations.read-write
[Elasticsearch]: https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping.html
[Elasticsearch 1]: https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-types.html
[Link 3]: https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#elasticsearch.mapping.meta-model.annotations.date-formats
[Spring Data]: https://spring.io/projects/spring-data
[Spring Data Elasticsearch]: https://spring.io/projects/spring-data-elasticsearch
[SpringBoot_ElasticSearch_demo_ SpringBoot_ElasticSearch_demo]: https://gitee.com/here-comes-brother-fei/SpringBootElasticSearchDemo.git