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

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

Spring Data Elasticsearch

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

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

ElasticsearchRestTemplate

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

映射标注概述

使用元数据来驱动对象到文档的映射。元数据取自可以注释的实体属性。MappingElasticsearchConverter

以下注释可用：

@Document：在类级别应用，以指示此类是映射到数据库的候选项。最重要的属性是（查看 API 文档以获取完整的属性列表）：

indexName：要在其中存储此实体的索引的名称。这可以包含一个 SpEL 模板表达式，例如"log-#{T(java.time.LocalDate).now().toString()}"

createIndex：标记是否在存储库引导时创建索引。默认值为 true。请参阅使用相应映射自动创建索引

@Id：在字段级别应用，以标记用于标识目的的字段。

@Transient，，：有关详细信息，请参阅以下控制写入和读取哪些属性一节。@ReadOnlyProperty@WriteOnlyProperty

@PersistenceConstructor：标记给定的构造函数 - 甚至是受包保护的构造函数 - 以便在从数据库中实例化对象时使用。构造函数参数按名称映射到检索到的文档中的键值。

@Field：应用于字段级别并定义字段的属性，大多数属性映射到相应的 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 将在存储此属性的第一个数据时动态添加映射条目（查看 Elasticsearch 文档以了解动态映射规则）。FieldType.Auto

format：一种或多种内置日期格式，请参阅下一节日期格式映射。

pattern：一种或多种自定义日期格式，请参阅下一节日期格式映射。

store：标记原始字段值是否应存储在 Elasticsearch 中，默认值为 false。

analyzer，，，用于指定自定义分析器和规范化器。searchAnalyzernormalizer

@GeoPoint：将字段标记为geo_point数据类型。如果字段是类的实例，则可以省略。GeoPoint

@ValueConverter定义用于转换给定属性的类。与注册的 Spring 不同，这只转换带注释的属性，而不是给定类型的每个属性。Converter

映射元数据基础设施在一个单独的 spring-data-commons 项目中定义，该项目与技术无关。

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

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

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

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 官网

注意点：

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版本说明

内容	版本
elasticsearch	elasticsearch-7.8.0
springboot	2.3.6.RELEASE

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/499049