通过Spring Data ElasticSearch 来使用ElasticSearch

最新推荐文章于 2024-10-08 11:18:55 发布

qq_20768305

最新推荐文章于 2024-10-08 11:18:55 发布

阅读量6.9k

点赞数 5

分类专栏： Elasticsearch spring Data ElasticSearch 文章标签： elasticsearch spring boot

本文链接：https://blog.csdn.net/qq_20768305/article/details/107041857

版权

Elasticsearch 同时被 2 个专栏收录

4 篇文章 1 订阅

订阅专栏

spring Data ElasticSearch

1 篇文章 0 订阅

订阅专栏

通过一个小案例来学习Spring Data ElasticSearch

创建一个Spring Boot工程

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

application.yml:

server:
  port: 8081

spring:
  application:
    name: es-application
  data:
    elasticsearch:
      cluster-nodes: 192.168.227.136:9300
      cluster-name: elasticsearch

创建文档对应的实体类：

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Document(indexName = "item", type = "docs", shards = 1, replicas = 0)
public class Item implements Serializable {

    @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(type = FieldType.Keyword,index = false)
    private String images; // 图片地址
}

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

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

继承一个Spring Data ElasticSearch 定义的父类

public interface ItemRepository extends ElasticsearchRepository<Item,Long> {


}

通过单元测试来学习ElasticSearch：

创建索引：

@SpringBootTest
@RunWith(SpringRunner.class)
public class EsTest {

    @Autowired
    private ElasticsearchTemplate template;

    @Autowired
    private ItemRepository itemRepository;

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

新增文档：

  @Test
    public void createDocument() {
        Item item = new Item();
        item.setId(1L);
        item.setCategory("手机");
        item.setBrand("小米");
        item.setImages("http://image.ping.com/13123.jpg");
        item.setPrice(1999.2);
        item.setTitle("小米手机7");

        itemRepository.save(item);

    }

批量新增：

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

修改文档

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

基本查询

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

 @Test
    public void findById() {
        Optional<Item> item = itemRepository.findById(1L);
        System.out.println(item);
    }

    /**
     * 查询全部，并按照价格降序排序
     */
    @Test
    public void findAll() {
        Iterable<Item> all = itemRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));

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

    }

自定义方法

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

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

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

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

/**
     * /**
     *      * 根据价格区间查询
     *      * @param price1
     *      * @param price2
     *      * @return
     *      */
    @Test
    public void findByPriceBetween() {
        List<Item> itemList = itemRepository.findByPriceBetween(1500.0, 4000.0);
        itemList.forEach(item -> System.out.println(item));
    }

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

高级查询

基本查询

先看看基本玩法

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

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

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

QueryBuilders提供了大量的静态方法，用于生成各种不同类型的查询对象，例如：词条、模糊、通配符等QueryBuilder对象。
在这里插入图片描述
elasticsearch提供很多可用的查询方式，但是不够灵活。如果想玩过滤或者聚合查询等就很难了。

自定义查询

先来看最基本的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());
        items.forEach(System.out::println);

    }

NativeSearchQueryBuilder：Spring提供的一个查询条件构建器，帮助构建json格式的请求体

Page<item>：默认是分页查询，因此返回的是一个分页的结果对象，包含属性：

totalElements：总条数
totalPages：总页数
Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据
其它属性：

在这里插入图片描述

分页查询

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

/**
     * 利用NativeSearchQueryBuilder实现分页
     */
    @Test
    public void testNativeQuery2() {
        // 构建查询条件
        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页开始。

排序

排序也通用通过NativeSearchQueryBuilder完成：

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


    }

聚合为桶

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

/**
     * 按照品牌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：聚合查询的结果类。它是Page<T>的子接口：

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

在这里插入图片描述
而返回的结果都是Aggregation类型对象，不过根据字段类型不同，又有不同的子类表示
我们看下页面的查询的JSON结果与Java类的对照关系：

嵌套聚合，求平均值

/**
     * 嵌套聚合，求平均值
     */
    @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());
        }


    }