1. 程式人生 > >elasticsearch 整合springboot

elasticsearch 整合springboot

和jpa類似,很簡單,很強大。

pom

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

application.yml

spring:
  data:
    elasticsearch:
      cluster-name: elasticsearch
      cluster-nodes: 192.168.56.101:9300

實體類及註解

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

Spring Data通過註解來宣告欄位的對映屬性,有下面的三個註解:

  • @Document 作用在類,標記實體類為文件物件,一般有兩個屬性
    • indexName:對應索引庫名稱
    • type:對應在索引庫中的型別
    • shards:分片數量,預設5
    • replicas:副本數量,預設1
  • @Id 作用在成員變數,標記一個欄位作為id主鍵
  • @Field 作用在成員變數,標記為文件的欄位,並指定欄位對映屬性:
    • type:欄位型別,取值是列舉:FieldType
    • index:是否索引,布林型別,預設是true
    • store:是否儲存,布林型別,預設是false
    • analyzer:分詞器名稱 

CRUD基本操作

建立索引和對映

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

刪除索引

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

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

Repository文件操作

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

我們只需要定義介面,然後繼承它就OK了。

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

新增文件

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

批量新增

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

修改文件

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

基本查詢

@Test
public void testFind(){
    // 查詢全部,並安裝價格降序排序
    Iterable<Item> items = this.itemRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));
    items.forEach(item-> System.out.println(item));
}

自定義方法

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

雖然基本查詢和自定義方法已經很強大了,但是如果是複雜查詢(模糊、萬用字元、詞條查詢等)就顯得力不從心了。此時,我們只能使用原生查詢。

高階查詢

基本查詢

先看看基本玩法

@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提供很多可用的查詢方式,但是不夠靈活。如果想玩過濾或者聚合查詢等就很難了。

自定義查詢

先來看最基本的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介面,因此可直接迭代得到當前頁的資料
  • 其它屬性: 

分頁查詢

利用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頁開始**。

排序

排序也通用通過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進行分組:

@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>的子介面:

 AggregatedPagePage功能的基礎上,拓展了與聚合相關的功能,它其實就是對聚合結果的一種封裝,大家可以對照聚合結果的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());
    }

}