Spring Data Elasticsearch

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

• 很多地方需要拼接Json字符串，在java中拼接字符串有多恐怖你應該懂的
• 需要自己把對象序列化為json存儲
• 查詢到結果也需要自己反序列化為對象

因此，這里就不講解原生的Elasticsearch客戶端API了。

而是學習Spring提供的套件：Spring Data Elasticsearch。

1.簡介

Spring Data Elasticsearch是Spring Data項目下的一個子模塊。

查看 Spring Data的官網：http://projects.spring.io/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工程

我們新建一個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.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.56.101:9300

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

4.Template索引操作

4.1.創建索引和映射

創建索引

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

可以根據類的信息自動生成，也可以手動指定indexName和Settings

映射

映射相關的API：

可以根據類的字節碼信息（注解配置）來生成映射，或者手動編寫映射

我們這里采用類的字節碼信息創建索引並映射：

@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"
        }
      }
    }
  }
}

4.2.刪除索引

刪除索引的API：

可以根據類名或索引名刪除。

示例：

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

結果：

5.Repository文檔操作

Spring Data 的強大之處，就在於你不用寫任何DAO處理，自動根據方法名或類的信息進行CRUD操作。只要你定義一個接口，然后繼承Repository提供的一些子接口，就能具備各種基本的CRUD功能。

我們只需要定義接口，然后繼承它就OK了。

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

來看下Repository的繼承關系：

我們看到有一個ElasticsearchRepository接口：

5.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.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.3.修改文檔

修改和新增是同一個接口，區分的依據就是id，這一點跟我們在頁面發起PUT請求是類似的。

5.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.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);
    }
}

結果：

雖然基本查詢和自定義方法已經很強大了，但是如果是復雜查詢（模糊、通配符、詞條查詢等）就顯得力不從心了。此時，我們只能使用原生查詢。

6.高級查詢

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

QueryBuilders提供了大量的靜態方法，用於生成各種不同類型的查詢對象，例如：詞條、模糊、通配符等QueryBuilder對象。

結果：

elasticsearch提供很多可用的查詢方式，但是不夠靈活。如果想玩過濾或者聚合查詢等就很難了。

6.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接口，因此可直接迭代得到當前頁的數據
• 其它屬性：

結果:

6.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頁開始。

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

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：聚合查詢的結果類。它是Page<T>的子接口：

AggregatedPage在Page功能的基礎上，拓展了與聚合相關的功能，它其實就是對聚合結果的一種封裝，大家可以對照聚合結果的JSON結構來看。

而返回的結果都是Aggregation類型對象，不過根據字段類型不同，又有不同的子類表示

我們看下頁面的查詢的JSON結果與Java類的對照關系：

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

}

結果：