Spring Data Elasticsearch

Elasticsearch在spring中的使用方法
实体类及注解：

package com.nc.es.pojo;

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：对应索引库名称
 *   - type：对应在索引库中的类型
 *   - shards：分片数量，默认5
 *   - replicas：副本数量，默认1
 * - `@Id` 作用在成员变量，标记一个字段作为id主键
 * - `@Field` 作用在成员变量，标记为文档的字段，并指定字段映射属性：
 *   - type：字段类型，取值是枚举：FieldType
 *   - index：是否索引，布尔类型，默认是true
 *   - store：是否存储，布尔类型，默认是false
 *   - analyzer：分词器名称：ik_max_word
 */
@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;

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

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

    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 Item() {

    }

    @Override
    public String toString() {
        return "Item{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", category='" + category + '\'' +
                ", brand='" + brand + '\'' +
                ", price=" + price +
                ", images='" + images + '\'' +
                '}';
    }
}

Elasticsearch的使用方法：

package com.nc.es;

import com.nc.es.pojo.Item;
import com.nc.es.repository.ItemRepositoryI;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
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.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.query.FetchSourceFilter;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;

@SpringBootTest(classes = NcEsApplication.class)
@RunWith(SpringRunner.class)
public class test {
    @Autowired
    ElasticsearchTemplate elasticsearchTemplate;
    @Autowired
    ItemRepositoryI itemRepository;

    //聚合为桶
    @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());
        }

    }

    //分页功能
    @Test
    public void testFindDoc1(){
        NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
        nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("title","小米"));



        //分页条件
//        nativeSearchQueryBuilder.withPageable(PageRequest.of())
        //排序
        nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
        Page<Item> page = this.itemRepository.search(nativeSearchQueryBuilder.build());

        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        System.out.println(page.getContent());

    }

    //查询功能
    @Test
    public void testFindDoc(){
        NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
        nativeSearchQueryBuilder.withQuery(QueryBuilders.matchQuery("title","小米"));
        //nativeSearchQueryBuilder.withQuery(QueryBuilders.termQuery("brand","haier"));

        Page<Item> items = this.itemRepository.search(nativeSearchQueryBuilder.build());
        items.forEach(item ->
                System.out.println(item));

    }

    //查询功能
    @Test
    public void testFind(){
        //根据id查询
//        Optional<Item> optional = itemRepository.findById(1L);
//        //如果optional存在就获取
//        if (optional.isPresent()){
//            Item item = optional.get();
//            System.out.println(item);
//        }

        //自定义查询         title
//        List<Item> items = itemRepository.findByTitle("小米");
//        items.forEach(System.out::println);

        //自定义查询         价格区间
//        List<Item> items = itemRepository.findByPriceBetween(3000.00,4000);
//        items.forEach(System.out::println);

        //查询所有，并按照价格降序排序
//        Iterable<Item> items = this.itemRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));
//        items.forEach(item -> System.out.println(item));
        //分页
        Page<Item> items = itemRepository.findAll(PageRequest.of(1, 2));
        items.forEach(item -> System.out.println(item));

    }



    //添加功能
    @Test
    public void testDoc(){
//        Item item = new Item(1L, "小米手机7", " 手机",
//                "小米", 3499.00, "http://image.nc.com/13123.jpg");
        //一行添加
//        itemRepository.save(item);

        ArrayList<Item> list = new ArrayList<>();
        list.add(new Item(2L, "坚果手机R1", " 手机", "锤子", 3699.00, "http://image.nc.com/123.jpg"));
        list.add(new Item(3L, "华为META10", " 手机", "华为", 4499.00, "http://image.nc.com/3.jpg"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);


    }
    //创建索引
    @Test
    public void testIndex(){
        elasticsearchTemplate.createIndex(Item.class);
        elasticsearchTemplate.putMapping(Item.class);
    }
    //删除索引
    @Test
    public void testDelIndex(){
        elasticsearchTemplate.deleteIndex(Item.class);
    }
}