前两篇文章讲述了一下如果搭建es的环境，这篇文章分享一下SpringBoot 中如何使用es,毕竟现在SpringBoot已经成为开发后台的主流框架了。

1、引入es 的依赖

新建SpringBoot 项目的时候在nosql 里面勾选上spring-data-elasticsarch 就可以了。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

lomok 的插件 <dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.20</version>
<scope>provided</scope>
</dependency>

2、配置es

  data:
    elasticsearch:
      client:
        reactive:
          username: my-elasticsearch
          endpoints: 127.0.0.1:9301,127.0.0.1:9302,127.0.0.1:9303

3、新建商品的实体类

@Document(indexName = "goods",type = "detail",shards = 3,replicas = 1)
public class EsGoods {
    @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; // 图片地址
}

@Document 作用在类，标记实体类为文档对象，一般有四个属性

　　indexName：对应索引库名称

　　type：对应在索引库中的类型

　　shards：分片数量，默认5

　　replicas：副本数量，默认1

@Id 作用在成员变量，标记一个字段作为id主键

@Field 作用在成员变量，标记为文档的字段，并指定字段映射属性：

　　type：字段类型，取值是枚举：FieldType

　　index：是否索引，布尔类型，默认是true

　　store：是否存储，布尔类型，默认是false

　　analyzer：分词器名称：ik_max_word

IK分词器有两种分词模式：ik_max_word和ik_smart模式。

 ik_max_word： 会将文本做最细粒度的拆分
 ik_smart：会做最粗粒度的拆分

3、配置es

配置之前首先说明一下SpringBoot的版本为 2.1.3.RELEASE,最新版的2.2.1 的和下面的写法不一样。

spring:
  data:
    elasticsearch:
      cluster-name: my-elasticsearch
      cluster-nodes: 127.0.0.1:9301,127.0.0.1:9302,127.0.0.1:9303

4、测试

4.1 创建索引和映射

   @Autowired
    private ElasticsearchTemplate  elasticsearchTemplate;
  /**
     * 创建索引和映射
     */
    @Test
    public void createIndexAndMapping() {
        //创建索引，会根据EsGoods类的@Document注解信息来创建
        elasticsearchTemplate.createIndex(EsGoods.class);
        //配置映射，会根据EsGoods类中的id、Field等字段来自动完成映射
        elasticsearchTemplate.putMapping(EsGoods.class);
    }

创建索引和映射.png

4.2删除索引

/**
 * 删除索引
 */
@Test
public  void  deleteIndex(){
    elasticsearchTemplate.deleteIndex("goods"); 
}

}

4.3 新增文档

新增和查询文档需要新建一个接口继承ElasticsearchRepository

/**
 * @author: sjx
 * @date: 2019/11/23 22:34
 * @description: 文档操作
 */
public interface GoodsRepository extends ElasticsearchRepository<EsGoods, Long> {
}

   @Test
    public void addDocument() {
        List<EsGoods> goodsList = new ArrayList<>();
        goodsList.add(new EsGoods(1L, "联想-拯救者", "电脑", "联想", 5000.0, "1.jpg"));
        goodsList.add(new EsGoods(2L, "apple-pro", "电脑", "苹果", 15000.0, "2.jpg"));
        goodsList.add(new EsGoods(3L, "戴尔-灵越", "电脑", "戴尔", 6000.0, "3.jpg"));
        goodsList.add(new EsGoods(4L, "华硕-A45", "电脑", "华硕", 4000.0, "4.jpg"));
        goodsList.add(new EsGoods(5L, "小米-pro", "电脑", "小米", 3000.0, "5.jpg"));
        goodsList.add(new EsGoods(6L, "华为-Meta10", "电脑", "华为", 5000.0, "6.jpg"));
        //保存一个
        //goodsRepository.save();
        //保存多个
        goodsRepository.saveAll(goodsList);
    }

新增文档.png

4.4 修改文档

    /**
     * 修改文档
     * 修改文档这块和jpa 的操作如出一辙。
     */
    @Test
    public void updateDocument() {
        EsGoods esGoods = new EsGoods(1L, "联想-拯救者", "电脑", "联想", 6000.0, "1.jpg");
        //修改价格
        goodsRepository.save(esGoods);
    }

4.5 查询

    /**
     * 根据id 查询
     */
    @Test
    public void findById() {
        Optional<EsGoods> optional = goodsRepository.findById(2L);
        System.out.println(optional.get());
    }
    /**
     * 查询所有
     */
    @Test
    public void findAll() {
        Iterable<EsGoods> all = goodsRepository.findAll();
        for (EsGoods esGoods : all) {
            System.out.println(esGoods);
        }
    }

5 、自定义查询方法

Spring Data 的提供一个强大功能，是根据方法名称自动实现功能，下述自定义规范：

规范.png

规范.png

    /**
     * 自定义价查询
     */
    @Test
    public void findByPrice() {
        //价格大于5000的
        List<EsGoods> result = goodsRepository.findByPriceAfter(5000);
        System.out.println("============价格大于等于5000的============");
        System.out.println(result);
        //价格小于5000的
        System.out.println("============价格小于等于5000的============");
        List<EsGoods> byPriceBefore = goodsRepository.findByPriceBefore(5000);
        System.out.println(byPriceBefore);
        //价格等于5000的
        System.out.println("============价格等于5000的============");
        List<EsGoods> byPrice = goodsRepository.findByPrice(5000);
        System.out.println(byPrice);
    }
    /**
     * 查询价格大于等于 price 的商品
     * @param price
     * @return
     */
 public interface GoodsRepository extends ElasticsearchRepository<EsGoods, Long> {
    /**
     * 查询价格大于等于 price 的商品
     * @param price
     * @return
     */
    List<EsGoods> findByPriceAfter(double price);
    /**
     * 查询商品价格小于等于 price的商品
     */
    List<EsGoods> findByPriceBefore(double price);

    /**
     * 查询价格等于price 的商品
     */
    List<EsGoods> findByPrice(double price);

}
============价格大于等于5000的============
[EsGoods(id=2, title=apple-pro, category=电脑, brand=苹果, price=15000.0, images=2.jpg), EsGoods(id=6, title=华为-Meta10, category=电脑, brand=华为, price=5000.0, images=6.jpg), EsGoods(id=1, title=联想-拯救者, category=电脑, brand=联想, price=6000.0, images=1.jpg), EsGoods(id=3, title=戴尔-灵越, category=电脑, brand=戴尔, price=6000.0, images=3.jpg)]
============价格小于等于5000的============
[EsGoods(id=5, title=小米-pro, category=电脑, brand=小米, price=3000.0, images=5.jpg), EsGoods(id=4, title=华硕-A45, category=电脑, brand=华硕, price=4000.0, images=4.jpg), EsGoods(id=6, title=华为-Meta10, category=电脑, brand=华为, price=5000.0, images=6.jpg)]
============价格等于5000的============
[EsGoods(id=6, title=华为-Meta10, category=电脑, brand=华为, price=5000.0, images=6.jpg)]

6、高级查询

QueryBuilders 提供了大量的静态方法，用于生成各种不同类型的查询对象，例如：词条、模糊、通配符等

    /**
     * 词条查询
     */
    @Test
    public void testQuery(){
        // 词条查询
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "pro");
        // 执行查询
        Iterable<EsGoods> items = goodsRepository.search(queryBuilder);
        items.forEach(System.out::println);
    }
EsGoods(id=5, title=小米-pro, category=电脑, brand=小米, price=3000.0, images=5.jpg)
EsGoods(id=2, title=apple-pro, category=电脑, brand=苹果, price=15000.0, images=2.jpg)

7、 自定义查询

/**
     * 自定义查询
     */
    @Test
    public void customizeQuery() {
        //构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        //添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.matchQuery("title", "pro"));
        //执行搜索,获取结果
        Page<EsGoods> search = goodsRepository.search(queryBuilder.build());
        System.out.println("总页数：" + search.getTotalPages());
        System.out.println("总记录数:" + search.getTotalElements());
        search.forEach(System.out::println);
    }

总页数：1
总记录数:2
EsGoods(id=5, title=小米-pro, category=电脑, brand=小米, price=3000.0, images=5.jpg)
EsGoods(id=2, title=apple-pro, category=电脑, brand=苹果, price=15000.0, images=2.jpg)

NativeSearchQueryBuilder：Spring提供的一个查询条件构建器，帮助构建json格式的请求体。
Page<item>：默认是分页查询，因此返回的是一个分页的结果对象，包含属性：
　　totalElements：总条数
　　totalPages：总页数
　　Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据

8、分页+排序查询

/**
     * 分页+排序查询
     */
    @Test
    public void testNativePageQuery() {
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本的分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "电脑"));
        // 设置分页参数 从第0 也开始每页显示十个数据
        queryBuilder.withPageable(PageRequest.of(0, 10));
        //设置排序 按照电脑的价格进行升序排列
        queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
        // 执行搜索，获取结果
        Page<EsGoods> items = goodsRepository.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);
    }

总条数：6
总页数:1
每页大小：10
当前页：0
EsGoods(id=5, title=小米-pro, category=电脑, brand=小米, price=3000.0, images=5.jpg)
EsGoods(id=4, title=华硕-A45, category=电脑, brand=华硕, price=4000.0, images=4.jpg)
EsGoods(id=6, title=华为-Meta10, category=电脑, brand=华为, price=5000.0, images=6.jpg)
EsGoods(id=1, title=联想-拯救者, category=电脑, brand=联想, price=6000.0, images=1.jpg)
EsGoods(id=3, title=戴尔-灵越, category=电脑, brand=戴尔, price=6000.0, images=3.jpg)
EsGoods(id=2, title=apple-pro, category=电脑, brand=苹果, price=15000.0, images=2.jpg)

9、聚合查询

  /**
     * 聚合查询
     * 按品牌分组查询
     */
    @Test
    public void brandAggregated() {
        //构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brands
        queryBuilder.addAggregation(
                AggregationBuilders.terms("brands").field("brand"));
        // 查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<EsGoods> aggPage = (AggregatedPage<EsGoods>) goodsRepository.search(queryBuilder.build());
        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() + ":" +bucket.getDocCount());
        }
    }
华为:1
华硕:1
小米:1
戴尔:1
联想:1
苹果:1

10、嵌套查询

 /**
     * 嵌套查询
     */
    @Test
    public void testSubAvgAgg(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
        queryBuilder.addAggregation(
                AggregationBuilders.terms("brands").field("brand")
                        .subAggregation(AggregationBuilders.avg("avgPrice").field("price")) // 在品牌聚合桶内进行嵌套聚合，求平均值
        );
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<EsGoods> aggPage = (AggregatedPage<EsGoods>) this.goodsRepository.search(queryBuilder.build());
        // 3.1、从结果中取出名为brands的那个聚合，
        // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        buckets.forEach(bucket -> {
            // 3.4、获取桶中的key，即品牌名称 ; 获取桶中的文档数量 ;获取平均值结果：
            InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("avgPrice");
            System.out.println(bucket.getKeyAsString() + "共" + bucket.getDocCount() +",平均售价："+ avg.getValue() );
        });
    }
华为共1,平均售价：5000.0
华硕共1,平均售价：4000.0
小米共1,平均售价：3000.0
戴尔共1,平均售价：6000.0
联想共1,平均售价：6000.0
苹果共1,平均售价：15000.0