031 Spring Data Elasticsearch学习笔记---重点掌握第5节高级查询和第6节聚合部分

2022-11-21 16:32:43

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

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

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

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

1.简介

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

Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型，同时仍保留底层数据存储的特殊特性。

它使得使用数据访问技术，关系数据库和非关系数据库，map-reduce框架和基于云的数据服务变得容易。这是一个总括项目，其中包含许多特定于给定数据库的子项目。这些令人兴奋的技术项目背后，是由许多公司和开发人员合作开发的。

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

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

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

特征：

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

2.创建Demo工程

我们使用maven(不推荐使用spring的脚手架，因为spring的脚手架的springboot的版本号一直在更新，且不能选择)新建一个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>lucky.elasticsearch</groupId>

    <artifactId>lucky-elasticsearch</artifactId>

    <version>1.0-SNAPSHOT</version>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.1.7.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

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

注意：springboot的版本选择2.1.7,这个版本maven本地仓库中已经存在了。

依赖导入完成后，可见：

application.yml文件配置：

spring:

  data:

    elasticsearch:

      cluster-name: leyou

      cluster-nodes: 127.0.0.1:9300  # 程序连接es的端口号是9300

注意：cluster-name、cluster-nodes是由elasticsearch安装时的配置文件决定的

查看elasticsearch安装时的配置文件可知：https://www.cnblogs.com/luckyplj/p/11582656.html

创建springboot的引导类：

package lucky.elasticsearch;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

 * springboot的引导类

 */

@SpringBootApplication

public class ElasticSearchApplication {

    public static void main(String[] args) {

        SpringApplication.run(ElasticSearchApplication.class);

    }

}

3.实体类及注解

首先我们准备好实体类：

public class Item {

    Long id;

    String title; //标题

    String category;// 分类

    String brand; // 品牌

    Double price; // 价格

    String images; // 图片地址

}

给Item类添加set/get方法

(1)映射

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

@Document 作用在类，标记实体类为文档对象，一般有四个属性
- indexName：对应索引库名称
- type：对应在索引库中的类型
- shards：分片数量，默认5
- replicas：副本数量，默认1
@Id 作用在成员变量，标记一个字段作为id主键
@Field 作用在成员变量，标记为文档的字段，并指定字段映射属性：
- type：字段类型，取值是枚举：FieldType
- index：是否索引，布尔类型，默认是true
- store：是否存储，布尔类型，默认是false
- analyzer：分词器名称：ik_max_word

package lucky.elasticsearch.domain;

import org.springframework.data.annotation.Id;

import org.springframework.data.elasticsearch.annotations.Document;

import org.springframework.data.elasticsearch.annotations.Field;

import org.springframework.data.elasticsearch.annotations.FieldType;

@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; //标题,type指定字段类型，analyzer指定分词器

    @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; // 图片地址，index属性指定是否索引，图片地址不进行分词，不需要进行索引

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getTitle() {

        return title;

    }

    public void setTitle(String title) {

        this.title = title;

    }

    public String getCategory() {

        return category;

    }

    public void setCategory(String category) {

        this.category = category;

    }

    public String getBrand() {

        return brand;

    }

    public void setBrand(String brand) {

        this.brand = brand;

    }

    public Double getPrice() {

        return price;

    }

    public void setPrice(Double price) {

        this.price = price;

    }

    public String getImages() {

        return images;

    }

    public void setImages(String images) {

        this.images = images;

    }

}

4.Template索引操作

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

测试类：ElasticSearchTest.java

package lucky.elasticsearch.test;

import lucky.elasticsearch.domain.Item;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;

import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest

@RunWith(SpringRunner.class)

public class ElasticSearchTest {

    @Autowired

    private ElasticsearchTemplate elasticsearchTemplate;

    @Test

    public void testCreate(){

        // 创建索引，会根据Item类的@Document注解信息来创建

        elasticsearchTemplate.createIndex(Item.class);

        // 配置映射，会根据Item类中的id、Field等字段来自动完成映射

        elasticsearchTemplate.putMapping(Item.class);

    }

}

运行testCreate方法,控制台显示testCreate执行成功(方法颜色为绿色)

打开postman工具进行测试，查询映射 http://localhost:9200/item/_mapping

5.Repository文档操作

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

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

来看下Repository的继承关系：

我们看到有一个ElasticsearchRepository接口：

(1)新增文档

<1>给Item这个实体类添加构造方法(一个无参构造方法，一个带所有参数的构造方法)

package lucky.elasticsearch.domain;

import org.springframework.data.annotation.Id;

import org.springframework.data.elasticsearch.annotations.Document;

import org.springframework.data.elasticsearch.annotations.Field;

import org.springframework.data.elasticsearch.annotations.FieldType;

@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; //标题,type指定字段类型，analyzer指定分词器

    @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; // 图片地址，index属性指定是否索引，图片地址不进行分词，不需要进行索引

    //无参构造方法

    public Item() {

    }

    //带所有参数的构造方法

    public Item(Long id, String title, String category, String brand, Double price, String images) {

        this.id = id;

        this.title = title;

        this.category = category;

        this.brand = brand;

        this.price = price;

        this.images = images;

    }

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getTitle() {

        return title;

    }

    public void setTitle(String title) {

        this.title = title;

    }

    public String getCategory() {

        return category;

    }

    public void setCategory(String category) {

        this.category = category;

    }

    public String getBrand() {

        return brand;

    }

    public void setBrand(String brand) {

        this.brand = brand;

    }

    public Double getPrice() {

        return price;

    }

    public void setPrice(Double price) {

        this.price = price;

    }

    public String getImages() {

        return images;

    }

    public void setImages(String images) {

        this.images = images;

    }

}

<2>定义接口ItemRepository

package lucky.elasticsearch.repository;

import lucky.elasticsearch.domain.Item;

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**

 * ItemRepository继承Repository提供的一些子接口(子接口功能更丰富)，例如ElasticsearchRepository，就能具备各种基本的CRUD功能

 * <Item,Long> 泛型 参数1：实体类，参数2 ：主键id的类型

 */

public interface ItemRepository extends ElasticsearchRepository<Item,Long>{

}

<3>ElasticSearchTest测试类中添加如下内容：

@Autowired

private ItemRepository itemRepository;

 　　/**

     * 新增文档

     */

    @Test

    public void testCreateDocument() {

        Item item = new Item(1L, "小米手机7", " 手机","小米", 3499.00, "http://image.leyou.com/13123.jpg");

        itemRepository.save(item);

    }

执行方法后，打开postman工具进行测试

(2)批量增加

 /**

     * 批量增加文档

     */

    @Test

    public void testCreateDocumentList() {

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

    }

执行方法后，打开postman工具进行测试

(3)修改文档

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

(4)基本查询

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

案例：查询全部，并按照价格降序排序

<1>先给Item这个实体类添加toString方法

@Override

    public String toString() {

        return "Item{" +

                "id=" + id +

                ", title='" + title + '\'' +

                ", category='" + category + '\'' +

                ", brand='" + brand + '\'' +

                ", price=" + price +

                ", images='" + images + '\'' +

                '}';

    }

<2>ElasticSearchTest测试类中添加如下内容

@Test

    public void testFind(){

        // 查询全部，并按照价格降序排序

        Iterable<Item> items = this.itemRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));

        items.forEach(item-> System.out.println(item));

    }

(5)自定义方法

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

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

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

案例：我们来按照价格区间查询

<1>ItemRepository接口中定义这样的一个方法：

package lucky.elasticsearch.repository;

import lucky.elasticsearch.domain.Item;

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import java.util.List;

/**

 * ItemRepository继承Repository提供的一些子接口(子接口功能更丰富)，例如ElasticsearchRepository，就能具备各种基本的CRUD功能

 * <Item,Long> 泛型 参数1：实体类，参数2 ：主键id的类型

 */

public interface ItemRepository extends ElasticsearchRepository<Item,Long>{

    /**

     * 根据价格区间查询

     * @param price1

     * @param price2

     * @return

     */

    List<Item> findByPriceBetween(double price1, double price2);

}

<2>然后添加一些测试数据：

/**

     * 批量增加文档

     */

    @Test

    public void testCreateDocumentList() {

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

    }

<3>ElasticSearchTest测试类中添加如下内容

@Test

public void queryByPriceBetween(){

    List<Item> list = this.itemRepository.findByPriceBetween(3000.00, 4000.00);

    for (Item item : list) {

        System.out.println("item = " + item);

    }

<4>不需要写实现类，然后我们直接去运行,运行结果如下图。

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

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(点击该类，进入该类后，alt+7)：

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

执行结果：

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

(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接口，因此可直接迭代得到当前页的数据
其它属性：

控制台输出结果：

(3)分页查询

利用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);

    }

结果：

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

(4)排序

排序也通用通过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);

    }

结果：

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

        }

    }

显示结果：

关键API:

AggregationBuilders：聚合的构建工厂类。所有聚合都由这个类来构建

AggregatedPage：聚合查询的结果类

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

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

    }

}

测试结果：

码农公寓

相关文章