第 4-8 课：Spring Boot 集成 ElasticSearch_replicas = 0,shards = 1-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_34227896/article/details/103914117

本文详细介绍如何在SpringBoot项目中集成ElasticSearch，通过示例演示基本的CRUD操作及高级查询技巧，如分页、模糊和聚合查询。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ElasticSearch 是⼀个开源的搜索引擎，建⽴在⼀个全⽂搜索引擎库 Apache Lucene™ 基础之上。 Lucene

可以说是当下最先进、⾼性能、全功能的搜索引擎库 —— ⽆论是开源还是私有。

ElasticSearch 使⽤ Java 编写的，它的内部使⽤的是 Lucene 做索引与搜索，它的

⽬的是使全⽂检索变得简

单，通过隐藏 Lucene 的复杂性，取⽽代之提供了⼀套简单⼀致的 RESTful API 。

然⽽， ElasticSearch 不仅仅是 Lucene ，并且也不仅仅只是⼀个全⽂搜索引擎，它可以被下⾯这样准确地形

容：

⼀个分布式的实时⽂档存储，每个字段可以被索引与搜索
⼀个分布式实时分析搜索引擎
能胜任上百个服务节点的扩展，并⽀持 PB 级别的结构化或者⾮结构化数据

ElasticSearch 已经被各⼤互联⽹公司验证其抢到的检索能⼒：

Wikipedia 使⽤ ElasticSearch 提供带有⾼亮⽚段的全⽂搜索，还有 search-as-you-type 和 did-youmean 的建议；
《卫报》使⽤ ElasticSearch 将⽹络社交数据结合到访客⽇志中，实时的给编辑们提供公众对于新⽂章的反馈；
Stack Overflflow 将地理位置查询融⼊全⽂检索中去，并且使⽤ more-like-this 接⼝去查找相关的问题与答案；
GitHub 使⽤ ElasticSearch 对 1300 亿⾏代码进⾏查询。⼩故事

关于 ElasticSearch 有⼀个⼩故事，在这⾥也分享给⼤家：

多年前， Shay Banon 是⼀位刚结婚不久的失业开发者，由于妻⼦要去伦敦学习厨师，他便跟着也去

了。在他找⼯作的过程中，为了给妻⼦构建⼀个⻝谱的搜索引擎，他开始构建⼀个早期版本的

Lucene 。

直接基于 Lucene ⼯作会⽐较困难，因此 Shay 开始抽象 Lucene 代码以便 Java 程序员可以在应⽤中添

加搜索功能，他发布了他的第⼀个开源项⽬，叫做 “Compass” 。

后来 Shay 找到了⼀份⼯作，这份⼯作处在⾼性能和内存数据⽹格的分布式环境中，因此⾼性能的、实

时的、分布式的搜索引擎也是理所当然需要的，然后他决定重写 Compass 库使其成为⼀个独⽴的服务

叫做 ElasticSearch 。

第⼀个公开版本出现在 2010 年 2 ⽉，在那之后 ElasticSearch 已经成为 GitHub 上最受欢迎的项⽬之

⼀，代码贡献者超过 300 ⼈。⼀家主营 ElasticSearch 的公司就此成⽴，他们⼀边提供商业⽀持⼀边开 GitChat

发新功能，不过 ElasticSearch 将永远开源且对所有⼈可⽤。

Shay 的妻⼦依旧等待着她的⻝谱搜索 ……

在没有 Spring Boot 之前 Java 程序员使⽤ ElasticSearch ⾮常痛苦，需要对接链接资源、进⾏⼀些列的封装

等操作。 Spring Boot 在 spring-data-elasticsearch 的基础上进⾏了封装，让 Spring Boot 项⽬⾮常⽅便的去

操作 ElasticSearch ，如果前⾯了解过 JPA 技术的话，会发现他的操作语法和 JPA ⾮常的类似。

值得注意的是， Spring Data ElasticSearch 和 ElasticSearch 是有对应关系的，不同的版本之间不兼容，

Spring Boot 2.1 对应的是 Spring Data ElasticSearch 3.1.2 版本。

Spring Data ElasticSearch	ElasticSearch
3.1.x	6.2.2
3.0.x	5.5.0
2.1.x	2.4.0
2.0.x	2.2.0
1.3.x	1.5.2

Spring Boot 集成 ElasticSearch

测试 CustomerRepository

创建⼀个测试类引⼊ CustomerRepository ：

@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomerRepositoryTest {
 @Autowired
 private CustomerRepository repository;
}

做⼀个数据插⼊测试：

@Test
public void saveCustomers() {
 repository.save(new Customer("Alice", "北京",13));
 repository.save(new Customer("Bob", "北京",23));
 repository.save(new Customer("neo", "⻄安",30));
 repository.save(new Customer("summer", "烟台",22));
}

repository 已经帮我们默认实现了很多的⽅法，其中就包括 save(); 。

我们对插⼊的数据做⼀个查询：

@Test
public void fetchAllCustomers() {
 System.out.println("Customers found with findAll():");
 System.out.println("-------------------------------");
 for (Customer customer : repository.findAll()) {
 System.out.println(customer);
 }
}

输出：

Customers found with findAll():
-------------------------------
Customer{id='aBVS7WYB8U8_i9prF8qm', userName='Alice', address='北京', age=13}
Customer{id='aRVS7WYB8U8_i9prF8rw', userName='Bob', address='北京', age=23}
Customer{id='ahVS7WYB8U8_i9prGMot', userName='neo', address='⻄安', age=30}
Customer{id='axVS7WYB8U8_i9prGMp2', userName='summer', address='北京市海淀区⻄直⻔', 
age=22}

通过查询可以发现，插⼊时⾃动⽣成了 ID 信息。

对插⼊的数据进⾏删除：

@Test
public void fetchAllCustomers() {
 @Test
 public void deleteCustomers() {
 repository.deleteAll();
 repository.deleteByUserName("neo");
 }
}

可以根据属性条件来删除，也可以全部删除。

对属性进⾏修改：

@Test
public void updateCustomers() {
 Customer customer= repository.findByUserName("summer");
 System.out.println(customer);
 customer.setAddress("北京市海淀区⻄直⻔");
 repository.save(customer);
 Customer xcustomer=repository.findByUserName("summer");
 System.out.println(xcustomer);
}

输出：

Customer[id=AWKVYFY4vPQX0UVGnJ7o, userName='summer', address='烟台']
Customer[id=AWKVYFY4vPQX0UVGnJ7o, userName='summer', address='北京市海淀区⻄直⻔']

通过输出发现 summer ⽤户的地址信息已经被变更。

我们可以根据地址信息来查询在北京的顾客信息 :

@Test
public void fetchIndividualCustomers() {
 for (Customer customer : repository.findByAddress("北京")) {
 System.out.println(customer);
 }
}

输出：

Customer{id='aBVS7WYB8U8_i9prF8qm', userName='Alice', address='北京', age=13}
Customer{id='aRVS7WYB8U8_i9prF8rw', userName='Bob', address='北京', age=23}
Customer{id='axVS7WYB8U8_i9prGMp2', userName='summer', address='北京市海淀区⻄直⻔', 
age=22}

通过输出可以发现 ElasticSearch 默认给我们进⾏的就是字段全⽂（模糊）查询。

通过以上的示例发现使⽤ Spring Boot 操作 ElasticSearch ⾮常简单，通过少量代码即可实现我们⽇常⼤部分

的业务需求。

⾼级使⽤

上⾯演示了在 Spring Boot 项⽬中对 ElasticSearch 的增、删、改、查操作，通过上⾯的操作也可以发现操作

ElasticSearch 的语法和 Spring Data JPA 的语法⾮常类似，下⾯介绍⼀些复杂的使⽤场景。

分⻚查询

分⻚查询有两种实现⽅式，第⼀种是使⽤ Spring Data ⾃带的分⻚⽅案，另⼀种是⾃⾏组织查询条件最后封

装进⾏查询。我们先来看第⼀个⽅案：

@Test
public void fetchPageCustomers() {
 Sort sort = new Sort(Sort.Direction.DESC, "address.keyword");
 Pageable pageable = PageRequest.of(0, 10, sort);
 Page<Customer> customers=repository.findByAddress("北京", pageable);
 System.out.println("Page customers "+customers.getContent().toString());
}

这段代码的含义是，分⻚查询地址包含 “ 北京 ” 的客户信息，并且按照地址进⾏排序，每⻚显示 10 条。需要注

意的是排序是使⽤的关键字是 address.keyword ，⽽不是 address ，属性后⾯带 .keyword 代表了精确匹配。

QueryBuilder

我们也可以使⽤ QueryBuilder 来构建分⻚查询， QueryBuilder 是⼀个功能强⼤的多条件查询构建⼯具，可以

使⽤ QueryBuilder 构建出各种各样的查询条件。

@Test
public void fetchPage2Customers() {
QueryBuilder customerQuery = QueryBuilders.boolQuery()
 .must(QueryBuilders.matchQuery("address", "北京"));
 Page<Customer> page = repository.search(customerQuery, PageRequest.of(0, 10));
 System.out.println("Page customers "+page.getContent().toString());
}

使⽤ QueryBuilder 可以构建多条件查询，再结合 PageRequest 最后使⽤ search() ⽅法完成分⻚查询。

BoolQueryBuilder 有⼀些关键字和 AND 、 OR 、 NOT ⼀⼀对应：

must(QueryBuilders):AND
mustNot(QueryBuilders):NOT
should::OR

QueryBuilder 是⼀个强⼤的多条件构建⼯具，有以下⼏种⽤法。

精确查询

单个匹配:

//不分词查询 参数1： 字段名，参数2：字段查询值，因为不分词，所以汉字只能查询⼀个字，英语是⼀个单词
QueryBuilder queryBuilder=QueryBuilders.termQuery("fieldName", "fieldlValue");
//分词查询，采⽤默认的分词器
QueryBuilder queryBuilder2 = QueryBuilders.matchQuery("fieldName", "fieldlValue");

多个匹配：

//不分词查询，参数1：字段名，参数2：多个字段查询值,因为不分词，因此汉字只能查询⼀个字，英语是⼀个
单词
QueryBuilder queryBuilder=QueryBuilders.termsQuery("fieldName", "fieldlValue1","fi
eldlValue2...");
//分词查询，采⽤默认的分词器
QueryBuilder queryBuilder= QueryBuilders.multiMatchQuery("fieldlValue", "fieldName
1", "fieldName2", "fieldName3");
//匹配所有⽂件，相当于就没有设置查询条件
QueryBuilder queryBuilder=QueryBuilders.matchAllQuery();

模糊查询

模糊查询常⻅的 5 个⽅法如下：

//1.常⽤的字符串查询
QueryBuilders.queryStringQuery("fieldValue").field("fieldName");//左右模糊
//2.常⽤的⽤于推荐相似内容的查询
QueryBuilders.moreLikeThisQuery(new String[] {"fieldName"}).addLikeText("pipeidhua
");//如果不指定filedName，则默认全部，常⽤在相似内容的推荐上
//3.前缀查询，如果字段没分词，就匹配整个字段前缀
QueryBuilders.prefixQuery("fieldName","fieldValue");
//4.fuzzy query:分词模糊查询，通过增加 fuzziness 模糊属性来查询，如能够匹配 hotelName 为 te
l 前或后加⼀个字⺟的⽂档，fuzziness 的含义是检索的 term 前后增加或减少 n 个单词的匹配查询
QueryBuilders.fuzzyQuery("hotelName", "tel").fuzziness(Fuzziness.ONE);
//5.wildcard query:通配符查询，⽀持* 任意字符串；？任意⼀个字符
QueryBuilders.wildcardQuery("fieldName","ctr*");//前⾯是fieldname，后⾯是带匹配字符的字
符串
QueryBuilders.wildcardQuery("fieldName","c?r?");

范围查询

//闭区间查询
QueryBuilder queryBuilder0 = QueryBuilders.rangeQuery("fieldName").from("fieldValu
e1").to("fieldValue2");
//开区间查询
QueryBuilder queryBuilder1 = QueryBuilders.rangeQuery("fieldName").from("fieldValu
e1").to("fieldValue2").includeUpper(false).includeLower(false);//默认是 true，也就是
包含
//⼤于
QueryBuilder queryBuilder2 = QueryBuilders.rangeQuery("fieldName").gt("fieldValue"
);
//⼤于等于
QueryBuilder queryBuilder3 = QueryBuilders.rangeQuery("fieldName").gte("fieldValue
");
//⼩于
QueryBuilder queryBuilder4 = QueryBuilders.rangeQuery("fieldName").lt("fieldValue"
);
//⼩于等于
QueryBuilder queryBuilder5 = QueryBuilders.rangeQuery("fieldName").lte("fieldValue
");

多条件查询

QueryBuilders.boolQuery()
QueryBuilders.boolQuery().must();//⽂档必须完全匹配条件，相当于 and
QueryBuilders.boolQuery().mustNot();//⽂档必须不匹配条件，相当于 not

聚合查询

聚合查询分为五步来实现，我们以统计客户总年龄为例进⾏演示。

第⼀步，使⽤ QueryBuilder 构建查询条件：

QueryBuilder customerQuery = QueryBuilders.boolQuery()
 .must(QueryBuilders.matchQuery("address", "北京"));

第⼆步，使⽤ SumAggregationBuilder 指明需要聚合的字段：

SumAggregationBuilder sumBuilder = AggregationBuilders.sum("sumAge").field("age");

第三步，以前两部分的内容为参数构建成 SearchQuery ：

SearchQuery searchQuery = new NativeSearchQueryBuilder()
 .withQuery(customerQuery)
 .addAggregation(sumBuilder)
 .build();

第四步，使⽤ Aggregations 进⾏查询：

Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsEx
tractor<Aggregations>() {
 @Override
 public Aggregations extract(SearchResponse response) {
 return response.getAggregations();
 }
 });

第五步，解析聚合查询结果：

//转换成 map 集合
Map<String, Aggregation> aggregationMap = aggregations.asMap();
//获得对应的聚合函数的聚合⼦类，该聚合⼦类也是个 map 集合，⾥⾯的 value 就是桶 Bucket，我们要获
得 Bucket
InternalSum sumAge = (InternalSum) aggregationMap.get("sumAge");
System.out.println("sum age is "+sumAge.getValue());

以上就是聚合查询的使⽤⽅式。