SpringBoot整合Spring Data Elasticsearch

「爱情、让人受尽委屈。」 2022-04-17 02:52 234阅读 0赞

# 一.SprignBoot整合Spring Data Elasticsearch #

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

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

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

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

## 1.1.简介 ##

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 1]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 2]

特征：

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

## 1.2.创建Demo工程 ##

我们新建一个demo，学习Elasticsearch

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.czxy</groupId>
        <artifactId>bos-es</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>bos-es</name>
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.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</artifactId>
            </dependency>
            <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.properties文件配置：

spring.data.elasticsearch.cluster-name=my-application
    spring.data.elasticsearch.cluster-nodes=http://127.0.0.1:9300

## 1.3.索引操作 ##

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

SpringBoot-data-elasticsearch提供了面向对象的方式操作elasticsearch

业务：创建一个商品对象，有这些属性：

答：id，title，category，brand，price，图片地址

在SpringDataElasticSearch中，只需要操作对象，就可以操作elasticsearch中的数据

> 实体类

首先我们准备好实体类：

public class Item { 
        private Long id;
        private String title; //标题
        private String category;// 分类
        private String brand; // 品牌
        private Double price; // 价格
        private String images; // 图片地址
    }

> 映射—注解

Spring Data通过注解来声明字段的映射属性，有下面的三个注解：

*  `@Document` 作用在类，标记实体类为文档对象，一般有两个属性
    
     *  indexName：对应索引库名称
     *  type：对应在索引库中的类型
     *  shards：分片数量，默认5
     *  replicas：副本数量，默认1
 *  `@Id` 作用在成员变量，标记一个字段作为id主键
 *  `@Field` 作用在成员变量，标记为文档的字段，并指定字段映射属性：
    
     *  type：字段类型，是是枚举：FieldType，可以是text、long、short、date、integer、object等
        
         *  text：存储数据时候，会自动分词，并生成索引
         *  keyword：存储数据时候，不会分词建立索引
         *  Numerical：数值类型，分两类
            
             *  基本数据类型：long、interger、short、byte、double、float、half\_float
             *  浮点数的高精度类型：scaled\_float
                
                 *  需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。
         *  Date：日期类型
            
             *  elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。
     *  index：是否索引，布尔类型，默认是true
     *  store：是否存储，布尔类型，默认是false
     *  analyzer：分词器名称，这里的`ik_max_word`即使用ik分词器

示例：

@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; // 图片地址
    }

> 创建索引

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

![在这里插入图片描述][20181112112039994.png]

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

> 映射

映射相关的API：

![在这里插入图片描述][20181112112048591.png]

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

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

@Test
    public void createIndex() { 
        // 创建索引，会根据Item类的@Document注解信息来创建
        esTemplate.createIndex(Item.class);
        // 配置映射，会根据Item类中的id、Field等字段来自动完成映射
        esTemplate.putMapping(Item.class);
    }

索引信息：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 3]

### 1.3.2.删除索引 ###

删除索引的API：

![在这里插入图片描述][20181112112111778.png]

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

示例：

@Test
    public void deleteIndex() { 
        esTemplate.deleteIndex(Item.class);
        // 根据索引名字删除
        //esTemplate.deleteIndex("item1");
    }

结果：OK

## 1.4.新增文档数据 ##

### 1.4.1.Repository接口 ###

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

来看下Repository的继承关系：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 4]

我们看到有一个ElasticsearchCrudRepository接口：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 5]

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

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

接下来，我们测试新增数据：

### 1.4.2.新增一个对象 ###

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

去页面查询看看：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 6]

### 1.4.3.批量新增 ###

代码：

@Test
    public void indexList() { 
        List<Item> list = new ArrayList<>();
        list.add(new Item(2L, "坚果手机R1", " 手机", "锤子", 3699.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(3L, "华为META10", " 手机", "华为", 4499.00, "http://image.baidu.com/13123.jpg"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);
    }

再次去页面查询：

### 1.4.4.修改 ###

elasticsearch中本没有修改，它的是该是先删除在新增

修改和新增是同一个接口，区分的依据就是id。

public void index(){
        Item item = new Item(1L, "苹果XSMax", " 手机",
                "小米", 3499.00, "http://image.baidu.com/13123.jpg");
        itemRepository.save(item);
    }

查看结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 7]

## 1.5.查询 ##

### 1.5.1.基本查询 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 8]

我们来试试查询所有：

@Test
        public void testQueryAll(){ 
            // 查找所有
            //Iterable<Item> list = this.itemRepository.findAll();
            // 对某字段排序查找所有 Sort.by("price").descending() 降序
            // Sort.by("price").ascending():升序
            Iterable<Item> list = this.itemRepository.findAll(Sort.by("price").ascending());
    
            for (Item item:list){ 
                System.out.println(item);
            }
        }

结果：

![在这里插入图片描述][201811121122516.png]

### 1.5.2.自定义方法 ###

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

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

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

<table> 
 <thead> 
  <tr> 
   <th>Keyword</th> 
   <th>Sample</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>And</code></td> 
   <td><code>findByNameAndPrice</code></td> 
  </tr> 
  <tr> 
   <td><code>Or</code></td> 
   <td><code>findByNameOrPrice</code></td> 
  </tr> 
  <tr> 
   <td><code>Is</code></td> 
   <td><code>findByName</code></td> 
  </tr> 
  <tr> 
   <td><code>Not</code></td> 
   <td><code>findByNameNot</code></td> 
  </tr> 
  <tr> 
   <td><code>Between</code></td> 
   <td><code>findByPriceBetween</code></td> 
  </tr> 
  <tr> 
   <td><code>LessThanEqual</code></td> 
   <td><code>findByPriceLessThan</code></td> 
  </tr> 
  <tr> 
   <td><code>GreaterThanEqual</code></td> 
   <td><code>findByPriceGreaterThan</code></td> 
  </tr> 
  <tr> 
   <td><code>Before</code></td> 
   <td><code>findByPriceBefore</code></td> 
  </tr> 
  <tr> 
   <td><code>After</code></td> 
   <td><code>findByPriceAfter</code></td> 
  </tr> 
  <tr> 
   <td><code>Like</code></td> 
   <td><code>findByNameLike</code></td> 
  </tr> 
  <tr> 
   <td><code>StartingWith</code></td> 
   <td><code>findByNameStartingWith</code></td> 
  </tr> 
  <tr> 
   <td><code>EndingWith</code></td> 
   <td><code>findByNameEndingWith</code></td> 
  </tr> 
  <tr> 
   <td><code>Contains/Containing</code></td> 
   <td><code>findByNameContaining</code></td> 
  </tr> 
  <tr> 
   <td><code>In</code></td> 
   <td><code>findByNameIn(Collection&lt;String&gt;names)</code></td> 
  </tr> 
  <tr> 
   <td><code>NotIn</code></td> 
   <td><code>findByNameNotIn(Collection&lt;String&gt;names)</code></td> 
  </tr> 
  <tr> 
   <td><code>Near</code></td> 
   <td><code>findByStoreNear</code></td> 
  </tr> 
  <tr> 
   <td><code>True</code></td> 
   <td><code>findByAvailableTrue</code></td> 
  </tr> 
  <tr> 
   <td><code>False</code></td> 
   <td><code>findByAvailableFalse</code></td> 
  </tr> 
  <tr> 
   <td><code>OrderBy</code></td> 
   <td><code>findByAvailableTrueOrderByNameDesc</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.baidu.com/13123.jpg"));
        list.add(new Item(2L, "坚果手机R1", "手机", "锤子", 3699.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(3L, "华为META10", "手机", "华为", 4499.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(4L, "小米Mix2S", "手机", "小米", 4299.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(5L, "荣耀V10", "手机", "华为", 2799.00, "http://image.baidu.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);
        }
    }

结果：

![在这里插入图片描述][20181112112315470.png]

### 1.5.3.自定义查询 ###

先来看最基本的match query：

@Test
    public void search(){ 
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
        // 搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 总条数
        long total = items.getTotalElements();
        System.out.println("total = " + total);
        for (Item item : items) { 
            System.out.println(item);
        }
    }

*  NativeSearchQueryBuilder：Spring提供的一个查询条件构建器，帮助构建json格式的请求体
 *  QueryBuilders.matchQuery(“title”, “小米手机”)：利用QueryBuilders来生成一个查询。QueryBuilders提供了大量的静态方法，用于生成各种不同类型的查询：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 9]

*  `Page<item>`：默认是分页查询，因此返回的是一个分页的结果对象，包含属性：
    
     *  totalElements：总条数
     *  totalPages：总页数
     *  Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据
     *  其它属性：
    
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 10]

结果：

![在这里插入图片描述][20181112112350329.png]

总的测试代码：

/** * * termQuery * wildcardQuery * fuzzyquery * booleanQuery * numericRangeQuery * */
        @Test
        public void testMathQuery(){ 
            // 创建对象
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 在queryBuilder对象中自定义查询
            //matchQuery:底层就是使用的termQuery
            queryBuilder.withQuery(QueryBuilders.matchQuery("title","坚果"));
            //查询，search 默认就是分页查找
            Page<Item> page = this.itemRepository.search(queryBuilder.build());
            //获取数据
            long totalElements = page.getTotalElements();
            System.out.println("获取的总条数:"+totalElements);
    
            for(Item item:page){ 
                System.out.println(item);
            }
    
    
        }
    
    
        /** * termQuery:功能更强大，除了匹配字符串意外，还可以匹配int/long/double/float/.... */
        @Test
        public void testTermQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
            builder.withQuery(QueryBuilders.termQuery("price",998.0));
            // 查找
            Page<Item> page = this.itemRepository.search(builder.build());
    
            for(Item item:page){ 
                System.out.println(item);
            }
        }
    
        @Test
        public void testBooleanQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
    
            builder.withQuery(
                    QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("title","华为"))
                                             .must(QueryBuilders.matchQuery("brand","华为"))
            );
    
            // 查找
            Page<Item> page = this.itemRepository.search(builder.build());
            for(Item item:page){ 
                System.out.println(item);
            }
        }
    
    
        @Test
        public void testFuzzyQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
            builder.withQuery(QueryBuilders.fuzzyQuery("title","faceoooo"));
            Page<Item> page = this.itemRepository.search(builder.build());
            for(Item item:page){ 
                System.out.println(item);
            }
    
        }

### 1.5.4.分页查询 ###

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

@Test
    public void searchByPage(){ 
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
        // 分页：
        int page = 0;
        int size = 2;
        queryBuilder.withPageable(PageRequest.of(page,size));
    
        // 搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 总条数
        long total = items.getTotalElements();
        System.out.println("总条数 = " + total);
        // 总页数
        System.out.println("总页数 = " + items.getTotalPages());
        // 当前页
        System.out.println("当前页：" + items.getNumber());
        // 每页大小
        System.out.println("每页大小：" + items.getSize());
    
        for (Item item : items) { 
            System.out.println(item);
        }
    }

结果：

![在这里插入图片描述][20181112112406250.png]

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

### 1.5.5.排序 ###

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

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

结果：

![在这里插入图片描述][20181112112415658.png]

## 1.6.聚合 ##

聚合可以让我们极其方便的实现对数据的统计、分析。例如：

*  什么品牌的手机最受欢迎？
 *  这些手机的平均价格、最高价格、最低价格？
 *  这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

### 1.6.1 基本概念 ###

Elasticsearch中的聚合，包含多种类型，最常用的两种，一个叫`桶`，一个叫`度量`：

> **桶（bucket）**

桶的作用，是按照某种方式对数据进行分组，每一组数据在ES中称为一个`桶`，例如我们根据国籍对人划分，可以得到`中国桶`、`英国桶`，`日本桶`……或者我们按照年龄段对人进行划分：010,1020,2030,3040等。

Elasticsearch中提供的划分桶的方式有很多：

*  Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组
 *  Histogram Aggregation：根据数值阶梯分组，与日期类似
 *  Terms Aggregation：根据词条内容分组，词条内容完全匹配的为一组
 *  Range Aggregation：数值和日期的范围分组，指定开始和结束，然后按段分组
 *  ……

综上所述，我们发现bucket aggregations 只负责对数据进行分组，并不进行计算，因此往往bucket中往往会嵌套另一种聚合：metrics aggregations即度量

> **度量（metrics）**

分组完成以后，我们一般会对组中的数据进行聚合运算，例如求平均值、最大、最小、求和等，这些在ES中称为`度量`

比较常用的一些度量聚合方式：

*  Avg Aggregation：求平均值
 *  Max Aggregation：求最大值
 *  Min Aggregation：求最小值
 *  Percentiles Aggregation：求百分比
 *  Stats Aggregation：同时返回avg、max、min、sum、count等
 *  Sum Aggregation：求和
 *  Top hits Aggregation：求前几
 *  Value Count Aggregation：求总数
 *  ……

**注意**：在ES中，需要进行聚合、排序、过滤的字段其处理方式比较特殊，因此不能被分词。这里我们将color和make这两个文字类型的字段设置为keyword类型，这个类型不会被分词，将来就可以参与聚合

### 1.6.2.聚合为桶 ###

桶就是分组，比如这里我们按照品牌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());
        }
    
    }

显示的结果：

![在这里插入图片描述][20181112112435975.png]

关键API：

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 11]

ValueCountBuilder vcb=  AggregationBuilders.count("count_uid").field("uid");
    （2）去重统计某个字段的数量（有少量误差）
     CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
    （3）聚合过滤
    FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
    （4）按某个字段分组
    TermsBuilder tb=  AggregationBuilders.terms("group_name").field("name");
    （5）求和
    SumBuilder  sumBuilder=	AggregationBuilders.sum("sum_price").field("price");
    （6）求平均
    AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
    （7）求最大值
    MaxBuilder mb= AggregationBuilders.max("max_price").field("price"); 
    （8）求最小值
    MinBuilder min=	AggregationBuilders.min("min_price").field("price");
    （9）按日期间隔分组
    DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
    （10）获取聚合里面的结果
    TopHitsBuilder thb=  AggregationBuilders.topHits("top_result");
    （11）嵌套的聚合
    NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
    （12）反转嵌套
    AggregationBuilders.reverseNested("res_negsted").path("kps ");

*  `AggregatedPage`：聚合查询的结果类。它是`Page<T>`的子接口：  
    ![在这里插入图片描述][20181112112504972.png]  
    `AggregatedPage`在`Page`功能的基础上，拓展了与聚合相关的功能，它其实就是对聚合结果的一种封装。
    
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 12]
    
    而返回的结果都是Aggregation类型对象，不过根据字段类型不同，又有不同的子类表示

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 13]

### 1.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());
        }
    
    }

结果：

![在这里插入图片描述][20181112112547391.png]

## 1.7.基本概念 ##

Elasticsearch也是基于Lucene的全文检索库，本质也是存储数据，很多概念与MySQL类似的。

对比关系：

索引库（indices）--------------------------------Databases 数据库

类型（type）-----------------------------Table 数据表

文档（Document）----------------Row 行

字段（Field）-------------------Columns 列

详细说明：

<table> 
 <thead> 
  <tr> 
   <th>概念</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>索引库（indices)</td> 
   <td>indices是index的复数，代表许多的索引，</td> 
  </tr> 
  <tr> 
   <td>类型（type）</td> 
   <td>类型是模拟mysql中的table概念，一个索引库下可以有不同类型的索引，比如商品索引，订单索引，其数据格式不同。不过这会导致索引库混乱，因此未来版本中会移除这个概念</td> 
  </tr> 
  <tr> 
   <td>文档（document）</td> 
   <td>存入索引库原始的数据。比如每一条商品信息，就是一个文档</td> 
  </tr> 
  <tr> 
   <td>字段（field）</td> 
   <td>文档中的属性</td> 
  </tr> 
  <tr> 
   <td>映射配置（mappings）</td> 
   <td>字段的数据类型、属性、是否索引、是否存储等特性</td> 
  </tr> 
 </tbody> 
</table>

是不是与Lucene中的概念类似。

另外，在Elasticsearch有一些集群相关的概念：

*  索引集（Indices，index的复数）：逻辑上的完整索引
 *  分片（shard）：数据拆分后的各个部分
 *  副本（replica）：每个分片的复制

要注意的是：Elasticsearch本身就是分布式的，因此即便你只有一个节点，Elasticsearch默认也会对你的数据进行分片和副本操作，当你向集群添加新数据时，数据也会在新加入的节点中进行平衡。

\#\#2.8bug1：Must be in the format host:port!

![在这里插入图片描述][20181112112620424.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 14]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]: /images/20220417/6cdfab66932e4969b307d7e2b8433a23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 1]: /images/20220417/195e4bcec8594da4a577a477d8d05a48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 2]: /images/20220417/fed05da615814dbfa0bfda3852d0499c.png
[20181112112039994.png]: /images/20220417/7cdb1d88fe2e428d9b1cc999c988e3e6.png
[20181112112048591.png]: /images/20220417/53fa2a21f00147b2aadd8ca97fc11a6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 3]: /images/20220417/6ba5c519c5d041a08b46ad2f2e00c1ff.png
[20181112112111778.png]: /images/20220417/1fcc8f44188a4ca0b17b8e3183ebaa35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 4]: /images/20220417/e5f0292707114fc194827e75b7a1ed57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 5]: /images/20220417/35c3a708d23944e1b91dbe902f726896.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 6]: /images/20220417/1106181feef045d8a38976fd17bc93a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 7]: /images/20220417/56c8d32699d74c1c9af276316cc77701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 8]: /images/20220417/8e7f79e79085468096adb5045e355b82.png
[201811121122516.png]: /images/20220417/e4acb561bd0f42cfba0878a70ee89a05.png
[20181112112315470.png]: /images/20220417/c9330547530e46069facbcb4b3b8edc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 9]: /images/20220417/44a63e03bd2442b7b07484c38077a152.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 10]: /images/20220417/495de50a784d4d2bbc40ebb23099c8c0.png
[20181112112350329.png]: /images/20220417/bcdcbde1185149c4bb349c947e56c0e7.png
[20181112112406250.png]: /images/20220417/b2cc05439a1445c89d921331718ce302.png
[20181112112415658.png]: /images/20220417/fe7309f410374763aa6a01236cc82ec2.png
[20181112112435975.png]: /images/20220417/e3750debc598484ea4359c5242187ca0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 11]: /images/20220417/b07bb4a1648e4bdab549e2bdc49bb1de.png
[20181112112504972.png]: /images/20220417/c23dd06f2a90402e80535fdc10acacc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 12]: /images/20220417/74d8207863f547458a040d1162dd2065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 13]: /images/20220417/148507b1b81c4c3ea7a0e960a1024900.png
[20181112112547391.png]: /images/20220417/7696909d5b3f467aba780598c3a64d55.png
[20181112112620424.png]: /images/20220417/2e1a321940cc43388c9ccd8fd7c65182.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 14]: /images/20220417/426aabb347ba45f787621b22bb3d4bab.png