微服务项目之电商--20.Spring Data Elasticsearch创建Demo工程、Template索引、Repository文档操作、聚合、高级查询

系统管理员 2021-11-02 07:56 248阅读 0赞

接上一篇

**目录**

5.Spring Data Elasticsearch

5.1.简介

5.2.创建Demo工程

5.3.实体类及注解

5.4.Template索引操作

5.4.1.创建索引和映射

5.3.2.删除索引

5.4.Repository文档操作

5.4.1.新增文档

5.4.2.批量新增

5.4.3.修改文档

5.4.4.基本查询

5.4.5.自定义方法

5.5.高级查询

5.5.1.基本查询

5.5.2.自定义查询

5.5.4.分页查询

5.5.5.排序

5.6.聚合

5.6.1.聚合为桶

5.6.2.嵌套聚合，求平均值

--------------------

# 5.Spring Data Elasticsearch #

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

*  很多地方需要拼接Json字符串，在java中拼接字符串有多恐怖你应该懂的
 *  需要自己把对象序列化为json存储
 *  查询到结果也需要自己反序列化为对象

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

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

## 5.1.简介 ##

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

查看 Spring Data的官网：[http://projects.spring.io/spring-data/][http_projects.spring.io_spring-data]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70][]

> Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型，同时仍保留底层数据存储的特殊特性。
> 
> 它使得使用数据访问技术，关系数据库和非关系数据库，map-reduce框架和基于云的数据服务变得容易。这是一个总括项目，其中包含许多特定于给定数据库的子项目。这些令人兴奋的技术项目背后，是由许多公司和开发人员合作开发的。

Spring Data 的使命是给各种数据访问提供统一的编程接口，不管是关系型数据库（如MySQL），还是非关系数据库（如Redis），或者类似Elasticsearch这样的索引数据库。从而简化开发人员的代码，提高开发效率。

包含很多不同数据操作的模块：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1][]

Spring Data Elasticsearch的页面：[https://projects.spring.io/spring-data-elasticsearch/][https_projects.spring.io_spring-data-elasticsearch]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2][]

特征：

*  支持Spring的基于`@Configuration`的java配置方式，或者XML配置方式
 *  提供了用于操作ES的便捷工具类**`ElasticsearchTemplate`**。包括实现文档到POJO之间的自动智能映射。
 *  利用Spring的数据转换服务实现的功能丰富的对象映射
 *  基于注解的元数据映射方式，而且可扩展以支持更多不同的数据格式
 *  根据持久层接口自动生成对应实现方法，无需人工编写基本操作代码（类似mybatis，根据接口自动得到实现）。当然，也支持人工定制查询

## 5.2.创建Demo工程 ##

我们新建一个demo，学习Elasticsearch

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4][]

pom依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.leyou.demo</groupId>
    	<artifactId>elasticsearch</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>elasticsearch</name>
    	<description>Demo project for Spring Boot</description>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.0.2.RELEASE</version>
    		<relativePath/> 
    	</parent>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    		<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>
    		</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

## 5.3.实体类及注解 ##

首先我们准备好实体类：

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：分词器名称

示例：

@Document(indexName = "item",type = "docs", shards = 1, replicas = 0)
    public class Item {
        @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.Keyword)
        private String brand; // 品牌
        
        @Field(type = FieldType.Double)
        private Double price; // 价格
        
        @Field(index = false, type = FieldType.Keyword)
        private String images; // 图片地址
    }

## 5.4.Template索引操作 ##

### 5.4.1.创建索引和映射 ###

创建索引

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5][]

ElasticsearchTemplate中提供了创建索引的API：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6][]

可以根据类的信息自动生成，也可以手动指定indexName和Settings

> 映射

映射相关的API：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7][]

可以根据类的字节码信息（注解配置）来生成映射，或者手动编写映射

我们这里采用类的字节码信息创建索引并映射：

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = ItcastElasticsearchApplication.class)
    public class IndexTest {
    
        @Autowired
        private ElasticsearchTemplate elasticsearchTemplate;
    
        @Test
        public void testCreate(){
            // 创建索引，会根据Item类的@Document注解信息来创建
            elasticsearchTemplate.createIndex(Item.class);
            // 配置映射，会根据Item类中的id、Field等字段来自动完成映射
            elasticsearchTemplate.putMapping(Item.class);
        }
    }

结果：

GET /item
    {
      "item": {
        "aliases": {},
        "mappings": {
          "docs": {
            "properties": {
              "brand": {
                "type": "keyword"
              },
              "category": {
                "type": "keyword"
              },
              "images": {
                "type": "keyword",
                "index": false
              },
              "price": {
                "type": "double"
              },
              "title": {
                "type": "text",
                "analyzer": "ik_max_word"
              }
            }
          }
        },
        "settings": {
          "index": {
            "refresh_interval": "1s",
            "number_of_shards": "1",
            "provided_name": "item",
            "creation_date": "1525405022589",
            "store": {
              "type": "fs"
            },
            "number_of_replicas": "0",
            "uuid": "4sE9SAw3Sqq1aAPz5F6OEg",
            "version": {
              "created": "6020499"
            }
          }
        }
      }
    }

### 5.3.2.删除索引 ###

删除索引的API：

![20190810170041315.png][]

可以根据类名或索引名删除。

示例：

@Test
    public void deleteIndex() {
        esTemplate.deleteIndex("heima");
    }

结果：

![20190810170109183.png][]

## 5.4.Repository文档操作 ##

Spring Data 的强大之处，就在于你不用写任何DAO处理，自动根据方法名或类的信息进行CRUD操作。只要你定义一个接口，然后继承Repository提供的一些子接口，就能具备各种基本的CRUD功能。

我们只需要定义接口，然后继承它就OK了。

public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
    }

来看下Repository的继承关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8][]

我们看到有一个ElasticsearchRepository接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 9][]

### 5.4.1.新增文档 ###

@Autowired
    private ItemRepository itemRepository;
    
    @Test
    public void index() {
        Item item = new Item(1L, "小米手机7", " 手机",
                             "小米", 3499.00, "http://image.leyou.com/13123.jpg");
        itemRepository.save(item);
    }

去页面查询看看：

GET /item/_search

结果：

{
      "took": 14,
      "timed_out": false,
      "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1,
        "max_score": 1,
        "hits": [
          {
            "_index": "item",
            "_type": "docs",
            "_id": "1",
            "_score": 1,
            "_source": {
              "id": 1,
              "title": "小米手机7",
              "category": " 手机",
              "brand": "小米",
              "price": 3499,
              "images": "http://image.leyou.com/13123.jpg"
            }
          }
        ]
      }
    }

### 5.4.2.批量新增 ###

代码：

@Test
    public void indexList() {
        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"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);
    }

再次去页面查询：

{
      "took": 5,
      "timed_out": false,
      "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 3,
        "max_score": 1,
        "hits": [
          {
            "_index": "item",
            "_type": "docs",
            "_id": "2",
            "_score": 1,
            "_source": {
              "id": 2,
              "title": "坚果手机R1",
              "category": " 手机",
              "brand": "锤子",
              "price": 3699,
              "images": "http://image.leyou.com/13123.jpg"
            }
          },
          {
            "_index": "item",
            "_type": "docs",
            "_id": "3",
            "_score": 1,
            "_source": {
              "id": 3,
              "title": "华为META10",
              "category": " 手机",
              "brand": "华为",
              "price": 4499,
              "images": "http://image.leyou.com/13123.jpg"
            }
          },
          {
            "_index": "item",
            "_type": "docs",
            "_id": "1",
            "_score": 1,
            "_source": {
              "id": 1,
              "title": "小米手机7",
              "category": " 手机",
              "brand": "小米",
              "price": 3499,
              "images": "http://image.leyou.com/13123.jpg"
            }
          }
        ]
      }
    }

### 5.4.3.修改文档 ###

修改和新增是同一个接口，区分的依据就是id，这一点跟我们在页面发起PUT请求是类似的。

### 5.4.4.基本查询 ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 10][]

我们来试试查询所有：

@Test
    public void testFind(){
        // 查询全部，并安装价格降序排序
        Iterable<Item> items = this.itemRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));
        items.forEach(item-> System.out.println(item));
    }

结果：

![20190810170353984.png][]

### 5.4.5.自定义方法 ###

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

比如：你的方法名叫做：findByTitle，那么它就知道你是根据title查询，然后自动帮你完成，无需写实现类。

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

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

例如，我们来按照价格区间查询，定义这样的一个方法：

public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
    
        /**
         * 根据价格区间查询
         * @param price1
         * @param price2
         * @return
         */
        List<Item> findByPriceBetween(double price1, double price2);
    }

然后添加一些测试数据：

@Test
    public void indexList() {
        List<Item> list = new ArrayList<>();
        list.add(new Item(1L, "小米手机7", "手机", "小米", 3299.00, "http://image.leyou.com/13123.jpg"));
        list.add(new Item(2L, "坚果手机R1", "手机", "锤子", 3699.00, "http://image.leyou.com/13123.jpg"));
        list.add(new Item(3L, "华为META10", "手机", "华为", 4499.00, "http://image.leyou.com/13123.jpg"));
        list.add(new Item(4L, "小米Mix2S", "手机", "小米", 4299.00, "http://image.leyou.com/13123.jpg"));
        list.add(new Item(5L, "荣耀V10", "手机", "华为", 2799.00, "http://image.leyou.com/13123.jpg"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);
    }

不需要写实现类，然后我们直接去运行：

@Test
    public void queryByPriceBetween(){
        List<Item> list = this.itemRepository.findByPriceBetween(2000.00, 3500.00);
        for (Item item : list) {
            System.out.println("item = " + item);
        }
    }

结果：

![20190810170515132.png][]

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

## 5.5.高级查询 ##

### 5.5.1.基本查询 ###

先看看基本玩法

@Test
    public void testQuery(){
        // 词条查询
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
        // 执行查询
        Iterable<Item> items = this.itemRepository.search(queryBuilder);
        items.forEach(System.out::println);
    }

Repository的search方法需要QueryBuilder参数，elasticSearch为我们提供了一个对象QueryBuilders：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 11][]

QueryBuilders提供了大量的静态方法，用于生成各种不同类型的查询对象，例如：词条、模糊、通配符等QueryBuilder对象。

结果：

![2019081017060423.png][]

elasticsearch提供很多可用的查询方式，但是不够灵活。如果想玩过滤或者聚合查询等就很难了。

### 5.5.2.自定义查询 ###

先来看最基本的match query：

@Test
    public void testNativeQuery(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本的分词查询
        queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米"));
        // 执行搜索，获取结果
        Page<Item> items = this.itemRepository.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：总页数
 *  Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据
 *  其它属性：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 12][]

结果：

![20190810170654526.png][]

### 5.5.4.分页查询 ###

利用`NativeSearchQueryBuilder`可以方便的实现分页：

@Test
    public void testNativeQuery(){
        // 构建查询条件
        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.itemRepository.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);
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 13][]

可以发现，**Elasticsearch中的分页是从第0页开始**。

### 5.5.5.排序 ###

排序也通用通过`NativeSearchQueryBuilder`完成：

@Test
    public void testSort(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本的分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
    
        // 排序
        queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));
    
        // 执行搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 打印总条数
        System.out.println(items.getTotalElements());
        items.forEach(System.out::println);
    }

结果：

![20190810170755473.png][]

## 5.6.聚合 ##

### 5.6.1.聚合为桶 ###

桶就是分组，比如这里我们按照品牌brand进行分组：

@Test
    public void testAgg(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
        // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand"));
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合，
        // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) {
            // 3.4、获取桶中的key，即品牌名称
            System.out.println(bucket.getKeyAsString());
            // 3.5、获取桶中的文档数量
            System.out.println(bucket.getDocCount());
        }
    
    }

显示的结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 14][]

关键API：

*  `AggregationBuilders`：聚合的构建工厂类。所有聚合都由这个类来构建，看看他的静态方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 15][]

`AggregatedPage`：聚合查询的结果类。它是`Page<T>`的子接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 16][]

`AggregatedPage`在`Page`功能的基础上，拓展了与聚合相关的功能，它其实就是对聚合结果的一种封装，大家可以对照聚合结果的JSON结构来看。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 17][]

而返回的结果都是Aggregation类型对象，不过根据字段类型不同，又有不同的子类表示

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 18][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 19][]

### 5.6.2.嵌套聚合，求平均值 ###

代码：

@Test
    public void testSubAgg(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
        // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand")
            .subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶内进行嵌套聚合，求平均值
        );
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合，
        // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) {
            // 3.4、获取桶中的key，即品牌名称  3.5、获取桶中的文档数量
            System.out.println(bucket.getKeyAsString() + "，共" + bucket.getDocCount() + "台");
    
            // 3.6.获取子聚合结果：
            InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
            System.out.println("平均售价：" + avg.getValue());
        }
    
    }

结果：

![20190810171011257.png][]

[http_projects.spring.io_spring-data]: http://projects.spring.io/spring-data/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70]: /images/20211102/568d116493ec4df2a78b6ebef4ca1d79.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 1]: /images/20211102/ff30fc8d9b854a29a778c743202ef341.png
[https_projects.spring.io_spring-data-elasticsearch]: https://projects.spring.io/spring-data-elasticsearch/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 2]: /images/20211102/c99dfccd20074fc29e0e558881ed8e87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 3]: /images/20211102/d4c835a3c32e477fadfc987ed53a39c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 4]: /images/20211102/575fef981f794e16a78c600fd2b146d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 5]: /images/20211102/ba4159e71ca84527aac87f113151c160.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 6]: /images/20211102/7d6999ca9942426088f70e8ff39bdb41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 7]: /images/20211102/d2547c50a37c41eb99f8a84169dddbf9.png
[20190810170041315.png]: /images/20211102/f29db58eacd64109ad5db4d77f09ca91.png
[20190810170109183.png]: /images/20211102/183936ad128643c28db1c61dae29bfd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 8]: /images/20211102/6339d674a014433f963248ce5e4aade8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 9]: /images/20211102/01de92c5db59452ea4df3c5e42574d74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 10]: /images/20211102/3db1b882c8a94351a5d00148f88e3e8a.png
[20190810170353984.png]: /images/20211102/90537da88cea4a7fbf6883a2720b9169.png
[20190810170515132.png]: /images/20211102/e951717492104700b44aee4fafb17f52.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 11]: /images/20211102/55cd2b4b67dd48d3bd2636f8c232c2a6.png
[2019081017060423.png]: /images/20211102/85f47e3a96124066b643d41283a2e39b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 12]: /images/20211102/567e1e332ac04ec6a8fab00d387303dc.png
[20190810170654526.png]: /images/20211102/c4e0925613a54edfbe45c3be79be62f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 13]: /images/20211102/704e6c17b39342caaf51f7bf6d6fcbc5.png
[20190810170755473.png]: /images/20211102/586ae8d1afeb4964ab74ce2104e664c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 14]: /images/20211102/4dac4d1d6dff4ab8a5de98bc97cebd3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 15]: /images/20211102/7f452832099345509ef5431e95d9776b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 16]: /images/20211102/3530493e22ce4ee6bc70f88c349569f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 17]: /images/20211102/e2b28eb5a0c3412d9527fe08848587eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 18]: /images/20211102/b2685692aff24dd3a3c4c504b1d8de37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTA5NTA4_size_16_color_FFFFFF_t_70 19]: /images/20211102/f650e76db610456b9971c9f64dcc992e.png
[20190810171011257.png]: /images/20211102/052e6fc6466a478590b90771910df7d9.png