Spring Data Elasticsearch_小试牛刀

Dear 丶 2023-03-13 06:04 2阅读 0赞

# Spring Data Elasticsearch快速实战 #

> **前面几期博客我总结了Elasticsearch的Restful API原生操作**
> 
> **参考：**
> 
> **[ElasticSearch分布式搜索引擎简介及其增删改查那些事][ElasticSearch]**
> 
> **[ElasticSearch分布式搜索引擎-基本查询][ElasticSearch_-]**
> 
> **[ElasticSearch分布式搜索引擎高级查询都在这了][ElasticSearch 1]**
> 
> **[ElasticSearch关于聚合-桶-度量不再愁][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/][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

![format_png][]

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/> 
        </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工具中可以查询到索引了

![format_png 1][]

索引删除也很简单

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) ;
        }
    }

![format_png 2][]

**批量新增**：

@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);
        }

![format_png 3][]

### 基本查询 ###

ElasticsearchRepository提供了一些基本的查询方法：

![format_png 4][]

示例

@Test
        void testQuery() {
        
            //返回迭代器
            Iterable<Item> items = this.repository.findAll();
            items.forEach(item -> System.out.println(item));
        }

![format_png 5][]

### 自定义方法 ###

Spring Data 的另一个强大功能，是根据方法名称自动实现功能。

比如：你的方法名叫做：findByTitle，那么它就知道你是根据title查询，然后自动帮你完成，无需写实现类。只需要在Reposity接口定义好方法以及参数即可

当然，方法名称要符合一定的约定：

<table> 
 <thead> 
  <tr> 
   <th>Keyword</th> 
   <th>Sample</th> 
   <th>Elasticsearch Query String</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>And</code></td> 
   <td><code>findByNameAndPrice</code></td> 
   <td><code>{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Or</code></td> 
   <td><code>findByNameOrPrice</code></td> 
   <td><code>{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Is</code></td> 
   <td><code>findByName</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"name" : "?"}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Not</code></td> 
   <td><code>findByNameNot</code></td> 
   <td><code>{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Between</code></td> 
   <td><code>findByPriceBetween</code></td> 
   <td><code>{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>LessThanEqual</code></td> 
   <td><code>findByPriceLessThan</code></td> 
   <td><code>{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>GreaterThanEqual</code></td> 
   <td><code>findByPriceGreaterThan</code></td> 
   <td><code>{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Before</code></td> 
   <td><code>findByPriceBefore</code></td> 
   <td><code>{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>After</code></td> 
   <td><code>findByPriceAfter</code></td> 
   <td><code>{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Like</code></td> 
   <td><code>findByNameLike</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>StartingWith</code></td> 
   <td><code>findByNameStartingWith</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>EndingWith</code></td> 
   <td><code>findByNameEndingWith</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Contains/Containing</code></td> 
   <td><code>findByNameContaining</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"name" : {"query" : "**?**","analyze_wildcard" : true}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>In</code></td> 
   <td><code>findByNameIn(Collection&lt;String&gt;names)</code></td> 
   <td><code>{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>NotIn</code></td> 
   <td><code>findByNameNotIn(Collection&lt;String&gt;names)</code></td> 
   <td><code>{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>Near</code></td> 
   <td><code>findByStoreNear</code></td> 
   <td><code>Not Supported Yet !</code></td> 
  </tr> 
  <tr> 
   <td><code>True</code></td> 
   <td><code>findByAvailableTrue</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"available" : true}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>False</code></td> 
   <td><code>findByAvailableFalse</code></td> 
   <td><code>{"bool" : {"must" : {"field" : {"available" : false}}}}</code></td> 
  </tr> 
  <tr> 
   <td><code>OrderBy</code></td> 
   <td><code>findByAvailableTrueOrderByNameDesc</code></td> 
   <td><code>{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}</code></td> 
  </tr> 
 </tbody> 
</table>

虽然基本查询和自定义方法已经很强大了，但是如果是复杂查询（模糊、通配符、词条查询等）就显得力不从心了。此时，我们只能使用原生查询。

## 高级查询 ##

先看看基本玩法

@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对象。

![format_png 6][]

![format_png 7][]

### 自定义查询 ###

@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：总页数

![format_png 8][]

### 分页查询 ###

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`：聚合的构建工厂类。所有聚合都由这个类来构建，它提供了很多类型的聚合：
    
    ![format_png 9][]
 *  `AggregatedPage`：聚合查询的结果类。它是`Page<T>`的子接口
    
    `AggregatedPage`在`Page`功能的基础上，拓展了与聚合相关的功能，它其实就是对聚合结果的一种封装，大家可以对照聚合结果的JSON结构来看。
    
    而返回的结果都是Aggregation类型对象，不过根据字段类型不同，又有不同的子类表示
    
    ![format_png 10][]

![format_png 11][]

结果会将相同品牌聚合到一起，我们可以利用API获取我们想要的数据

我们看下页面的查询的JSON结果与Java类的对照关系：

![format_png 12][]

最后再看一个嵌套聚合的案例

@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());
            }
        }

![format_png 13][]

[ElasticSearch]: https://blog.csdn.net/JunSIrhl/article/details/106057477
[ElasticSearch_-]: https://blog.csdn.net/JunSIrhl/article/details/106062192
[ElasticSearch 1]: https://blog.csdn.net/JunSIrhl/article/details/106063107
[ElasticSearch_-_-]: https://blog.csdn.net/JunSIrhl/article/details/106065535
[http_projects.spring.io_spring-data]: http://projects.spring.io/spring-data/
[format_png]: /images/20230312/810b4983d9564931a67b0457a399f2c7.png
[format_png 1]: /images/20230312/00f61a28ff564175af4942605b5977e9.png
[format_png 2]: /images/20230312/d1ac34f0c7b44605bd192a560b7a67cb.png
[format_png 3]: /images/20230312/95c1cbb6763842919522bfa98d1bf6c0.png
[format_png 4]: /images/20230312/25039b59305141a990692afcbc270bd7.png
[format_png 5]: /images/20230312/33bb83288c474897bda30c4f78514f8f.png
[format_png 6]: /images/20230312/daaadcf040c646d69af6ec88e556a42e.png
[format_png 7]: /images/20230312/a96f82c949784c1eb4727fc6138bfac1.png
[format_png 8]: /images/20230312/85a01915f6f443e0b844211c5a957baf.png
[format_png 9]: /images/20230312/f483960614114748ab6ad4034829842e.png
[format_png 10]: /images/20230312/35b8628d60b84e42bc37feb56a39e2c1.png
[format_png 11]: /images/20230312/0a61ee735b1340b19306fab82349b4c4.png
[format_png 12]: /images/20230312/3c33a821ae1c4265882fc4e031d07af3.png
[format_png 13]: /images/20230312/3a90376c9e084b2983ca2a7eb7fdcb6d.png