Elasticsearch基本用法(2)--Spring Data Elasticsearch

2022-11-21 16:32:55

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

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

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

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

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

特征：

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

5.2.创建Demo工程

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/> <!-- 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文件配置：

spring:

  data:

    elasticsearch:

      cluster-name: elasticsearch

      cluster-nodes: 192.168.25.128: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.创建索引和映射

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

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

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.删除索引

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

示例：

@Test

public void deleteIndex() {

    esTemplate.deleteIndex("heima");

}

5.4.Repository文档操作

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

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

public interface ItemRepository extends ElasticsearchRepository<Item,Long> {

}

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提供了一些基本的查询方法：

查询所有：

@Test

public void testFind(){

    // 查询全部，并安装价格降序排序

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

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

}

5.4.5.自定义方法

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

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

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

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

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

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

    }

}

如果是复杂查询（模糊、通配符、词条查询等）就显得力不从心了。只能使用原生查询。

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

}

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

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

}

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

}

@Test

public void testQuery(){

    // 创建构造器

    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();

    // 过滤

    String[] str = {"id","title","price"};

    queryBuilder.withSourceFilter(new FetchSourceFilter(str,null));

    // 排序

    queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));

    // 分页

    queryBuilder.withPageable(PageRequest.of(0,2));

    Page<Item> result = repository.search(queryBuilder.build());

    long total = result.getTotalElements();

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

    int totalPages = result.getTotalPages();

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

    List<Item> list = result.getContent();

    list.forEach(System.out::println);

}

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

    }

}

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

    }

}

其他方法：

 @Test

    public void testSubAgg() {

        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();

        queryBuilder.withSourceFilter(new FetchSourceFilter(null, null));

        // 在品牌聚合桶内进行嵌套聚合，求平均值

        queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand").subAggregation(AggregationBuilders.avg("priceAvg").field("price")));

        AggregatedPage<Item> aggpage = elasticsearchTemplate.queryForPage(queryBuilder.build(),Item.class);

        Aggregations aggregations = aggpage.getAggregations();

        StringTerms agg = aggregations.get("brands");

        List<StringTerms.Bucket> buckets = agg.getBuckets();

        for (StringTerms.Bucket bucket : buckets) {

//            获取桶中的key，即品牌名称 , 获取桶中的文档数量

            System.out.println("bucket.getKeyAsString() = " + bucket.getKeyAsString()+",共"+bucket.getDocCount());

//            获取子聚合结果

            InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");

            System.out.println("avg.getValue() = " + avg.getValue());

        }

    }

码农公寓