Spring Data Elasticsearch快速实战
前面几期博客我总结了Elasticsearch的Restful API原生操作
参考:
ElasticSearch分布式搜索引擎简介及其增删改查那些事
本篇重点介绍Spring为我们提供的Elasticsearch客户端
Elasticsearch提供的Java客户端有一些不太方便的地方:
- 很多地方需要拼接Json字符串,在java中拼接字符串有多恐怖你应该懂的
- 需要自己把对象序列化为json存储
- 查询到结果也需要自己反序列化为对象
因此,我们这里就不去了解原生的Elasticsearch客户端API了
而是学习Spring提供的套件:Spring Data Elasticsearch
Spring Data Elasticsearch是Spring Data项目下的一个子模块。
查看 Spring Data的官网:http://projects.spring.io/spring-data/
官方介绍
Spring Data for Elasticsearch is part of the umbrella Spring Data project which aims to provide a familiar and consistent Spring-based programming model for for new datastores while retaining store-specific features and capabilities.
The Spring Data Elasticsearch project provides integration with the Elasticsearch search engine. Key functional areas of Spring Data Elasticsearch are a POJO centric model for interacting with a Elastichsearch Documents and easily writing a Repository style data access layer.
用于Elasticsearch的Spring Data是Spring Data项目的一部分,该项目旨在为新数据存储提供熟悉且一致的基于Spring的编程模型,同时保留特定于存储的功能。 Spring Data Elasticsearch项目提供了与Elasticsearch搜索引擎的集成。 Spring Data Elasticsearch的关键功能区域是一个以POJO为中心的模型,该模型用于与Elastichsearch文档进行交互并轻松编写存储库样式的数据访问层
spring data elasticsearch特征:
- 支持Spring的基于
@Configuration
的java配置方式,或者XML配置方式- 提供了用于操作ES的便捷工具类**
ElasticsearchTemplate
。包括实现文档到POJO之间的自动智能映射**。- 利用Spring的数据转换服务实现的功能丰富的对象映射
- 基于注解的元数据映射方式,而且可扩展以支持更多不同的数据格式
- 根据持久层接口自动生成对应实现方法,无需人工编写基本操作代码(类似mybatis,根据接口自动得到实现)。当然,也支持人工定制查询
文章目录
环境准备
我们使用spring脚手架新建一个工程,学习Elasticsearch
pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.7.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.junsir</groupId>
<artifactId>testspringes</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>testspringes</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
application.yml文件配置:
spring:
data:
elasticsearch:
cluster-name: elasticsearch
cluster-nodes: 192.168.56.101:9300
实体类配置:
package com.junsir.testspringes.pojo;
public class Item {
Long id;
String title; //标题
String category;// 分类
String brand; // 品牌
Double price; // 价格
String images; // 图片地址
}
映射:
Spring Data通过注解来声明字段的映射属性,有下面的三个注解:
@Document
作用在类,标记实体类为文档对象,一般有四个属性- indexName:对应索引库名称
- type:对应在索引库中的类型
- shards:分片数量,默认5
- replicas:副本数量,默认1
@Id
作用在成员变量,标记一个字段作为id主键@Field
作用在成员变量,标记为文档的字段,并指定字段映射属性:- type:字段类型,取值是枚举:FieldType
- index:是否索引,布尔类型,默认是true
- store:是否存储,布尔类型,默认是false
- analyzer:分词器名称:ik_max_word
基于此,将实体类添加以上注解
@Document(indexName = "item",type = "docs", shards = 1, replicas = 0)
public class Item {
@Id
Long id;
@Field(type = FieldType.Text,analyzer = "ik_max_word")
String title; //标题
@Field(type = FieldType.Keyword)
String category;// 分类
@Field(type = FieldType.Keyword)
String brand; // 品牌
@Field(type = FieldType.Double)
Double price; // 价格
@Field(index = false, type = FieldType.Keyword)
String images; // 图片地址
}
//setter...getter...构造器
Template索引操作
创建索引和映射
创建索引
在测试类下创建索引:
@SpringBootTest
class TestspringesApplicationTests {
@Autowired
private ElasticsearchTemplate template ;
@Test
void contextLoads() {
}
@Test
void testCreat() {
// 创建索引,会根据Item类的@Document注解信息来创建
template.createIndex(Item.class) ;
// 配置映射,会根据Item类中的id、Field等字段来自动完成映射
template.putMapping(Item.class) ;
}
}
在Kibana工具中可以查询到索引了
索引删除也很简单
template.deleteIndex(Item.class) ;
文档操作(CRUD)
新增
Spring Data 的强大之处,就在于你不用写任何DAO处理,自动根据方法名或类的信息进行CRUD操作。只要你定义一个接口,然后继承Repository提供的一些子接口,就能具备各种基本的CRUD功能
我们我们只需要定义接口,然后继承它就OK了
public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
}
@SpringBootTest
class TestspringesApplicationTests {
@Autowired
private ItemRepository repository ;
@Test
void testCreatDocument() {
Item item = new Item(1L, "小米手机7", " 手机",
"小米", 3499.00, "http://image.com/13123.jpg") ;
repository.save(item) ;
}
}
批量新增:
@Test
void testCreatDocument() {
List<Item> list = new ArrayList<>();
list.add(new Item(2L, "坚果手机R1", " 手机", "锤子", 3699.00, "http://image.leyou.com/123.jpg"));
list.add(new Item(3L, "华为META10", " 手机", "华为", 4499.00, "http://image.leyou.com/3.jpg"));
// 接收对象集合,实现批量新增
repository.saveAll(list);
}
基本查询
ElasticsearchRepository提供了一些基本的查询方法:
示例
@Test
void testQuery() {
//返回迭代器
Iterable<Item> items = this.repository.findAll();
items.forEach(item -> System.out.println(item));
}
自定义方法
Spring Data 的另一个强大功能,是根据方法名称自动实现功能。
比如:你的方法名叫做:findByTitle,那么它就知道你是根据title查询,然后自动帮你完成,无需写实现类。只需要在Reposity接口定义好方法以及参数即可
当然,方法名称要符合一定的约定:
Keyword | Sample | Elasticsearch Query String |
---|---|---|
And |
findByNameAndPrice |
{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}} |
Or |
findByNameOrPrice |
{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}} |
Is |
findByName |
{"bool" : {"must" : {"field" : {"name" : "?"}}}} |
Not |
findByNameNot |
{"bool" : {"must_not" : {"field" : {"name" : "?"}}}} |
Between |
findByPriceBetween |
{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}} |
LessThanEqual |
findByPriceLessThan |
{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}} |
GreaterThanEqual |
findByPriceGreaterThan |
{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}} |
Before |
findByPriceBefore |
{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}} |
After |
findByPriceAfter |
{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}} |
Like |
findByNameLike |
{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}} |
StartingWith |
findByNameStartingWith |
{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}} |
EndingWith |
findByNameEndingWith |
{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}} |
Contains/Containing |
findByNameContaining |
{"bool" : {"must" : {"field" : {"name" : {"query" : "**?**","analyze_wildcard" : true}}}}} |
In |
findByNameIn(Collection<String>names) |
{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}} |
NotIn |
findByNameNotIn(Collection<String>names) |
{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}} |
Near |
findByStoreNear |
Not Supported Yet ! |
True |
findByAvailableTrue |
{"bool" : {"must" : {"field" : {"available" : true}}}} |
False |
findByAvailableFalse |
{"bool" : {"must" : {"field" : {"available" : false}}}} |
OrderBy |
findByAvailableTrueOrderByNameDesc |
{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}} |
虽然基本查询和自定义方法已经很强大了,但是如果是复杂查询(模糊、通配符、词条查询等)就显得力不从心了。此时,我们只能使用原生查询。
高级查询
先看看基本玩法
@Test
void testQuery() {
//词条查询
MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title","小米");
//执行查询
Iterable<Item> items = this.repository.search(queryBuilder);
items.forEach(System.out::println);
}
Repository的search方法需要QueryBuilder参数,elasticSearch为我们提供了一个对象QueryBuilders:
QueryBuilders提供了大量的静态方法,用于生成各种不同类型的查询对象,例如:词条、模糊、通配符等QueryBuilder对象。
自定义查询
@Test
void testQuery() {
//构建JSON查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
//添加基本的分词查询
queryBuilder.withQuery(QueryBuilders.matchQuery("title","小米")) ;
//执行搜索,获取结果
Page<Item> items = this.repository.search(queryBuilder.build()) ;
//获取总条数
System.out.println(items.getTotalElements());
//打印总页数
System.out.println(items.getTotalPages());
items.forEach(System.out::println);
}
NativeSearchQueryBuilder:Spring提供的一个查询条件构建器,帮助构建json格式的请求体
Page<item>
:默认是分页查询,因此返回的是一个分页的结果对象,包含属性:
-
totalElements:总条数
-
totalPages:总页数
分页查询
void testQuery() {
// 构建查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本的分词查询
queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
// 初始化分页参数
int page = 0;
int size = 3;
// 设置分页参数
queryBuilder.withPageable(PageRequest.of(page, size));
// 执行搜索,获取结果
Page<Item> items = this.repository.search(queryBuilder.build());
// 打印总条数
System.out.println(items.getTotalElements());
// 打印总页数
System.out.println(items.getTotalPages());
// 每页大小
System.out.println(items.getSize());
// 当前页
System.out.println(items.getNumber());
items.forEach(System.out::println);
}
注意:Elasticsearch中的分页是从第0页开始
排序也通过NativeSearchQueryBuilder
完成:
// 排序
queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));
聚合
聚合为桶
这里我们按照品牌brand进行分组:
@Test
void testQuery() {
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder() ;
//不查询任何结果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""},null)) ;
//添加一个新聚合,类型为terms词条,名称为brands,聚合字段brand
queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand")) ;
//查询
AggregatedPage<Item> items = (AggregatedPage<Item>) this.repository.search(queryBuilder.build());
/*
* 解析
* */
/* 从结果中取出名为brands的聚合
因为是利用String类型字段来进行的term聚合,所以结果要强转为StringTerm类型*/
StringTerms agg = (StringTerms) items.getAggregation("brands");
//获取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
for (StringTerms.Bucket bucket :buckets){
//获取桶的key即品牌名称
System.out.println(bucket.getKeyAsString());
//获取桶中文档数量
System.out.println(bucket.getDocCount());
}
}
-
AggregationBuilders
:聚合的构建工厂类。所有聚合都由这个类来构建,它提供了很多类型的聚合: -
AggregatedPage
:聚合查询的结果类。它是Page<T>
的子接口AggregatedPage
在Page
功能的基础上,拓展了与聚合相关的功能,它其实就是对聚合结果的一种封装,大家可以对照聚合结果的JSON结构来看。而返回的结果都是Aggregation类型对象,不过根据字段类型不同,又有不同的子类表示
结果会将相同品牌聚合到一起,我们可以利用API获取我们想要的数据
我们看下页面的查询的JSON结果与Java类的对照关系:
最后再看一个嵌套聚合的案例
@Test
void testQuery() {
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder() ;
//不查询任何结果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""},null)) ;
//添加一个新聚合,类型为terms词条,名称为brands,聚合字段brand
queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand").subAggregation(AggregationBuilders.avg("priceAvg").field("price"))) ;// 在品牌聚合桶内进行嵌套聚合,求平均值
//查询
AggregatedPage<Item> items = (AggregatedPage<Item>) this.repository.search(queryBuilder.build());
/*
* 解析
* */
/* 从结果中取出名为brands的聚合
因为是利用String类型字段来进行的term聚合,所以结果要强转为StringTerm类型*/
StringTerms agg = (StringTerms) items.getAggregation("brands");
//获取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
for (StringTerms.Bucket bucket :buckets){
//获取桶的key即品牌名称
System.out.println(bucket.getKeyAsString());
//获取桶中文档数量
System.out.println(bucket.getDocCount());
//获取子聚合
InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
System.out.println("平均价格"+avg.getValue());
}
}