Spring Data Elasticsearch快速实战

前面几期博客我总结了Elasticsearch的Restful API原生操作

参考：

ElasticSearch分布式搜索引擎简介及其增删改查那些事

ElasticSearch分布式搜索引擎-基本查询

ElasticSearch分布式搜索引擎高级查询都在这了

ElasticSearch关于聚合-桶-度量不再愁

本篇重点介绍Spring为我们提供的Elasticsearch客户端

Elasticsearch提供的Java客户端有一些不太方便的地方：

很多地方需要拼接Json字符串，在java中拼接字符串有多恐怖你应该懂的

需要自己把对象序列化为json存储

查询到结果也需要自己反序列化为对象

因此，我们这里就不去了解原生的Elasticsearch客户端API了

而是学习Spring提供的套件：Spring Data Elasticsearch

Spring Data Elasticsearch是Spring Data项目下的一个子模块。

扫描二维码关注公众号，回复： 11193946 查看本文章

查看 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 Data Elasticsearch快速实战

环境准备
Template索引操作

创建索引和映射

文档操作(CRUD)

新增
基本查询
自定义方法

高级查询

自定义查询
分页查询

聚合

环境准备

我们使用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());
        }
    }

JunSIr_deCp

原创文章 208 获赞 165 访问量 14万+

关注私信