ElasticSearch8.4.3 Springboot 复杂查询

最新推荐文章于 2024-03-15 13:25:29 发布
最新推荐文章于 2024-03-15 13:25:29 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： ElasticSearch 文章标签： spring boot java json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34125999/article/details/127800285
版权

1 布尔查询

查询十月份手机类型数据：

GET product_index/_search
{ 
  
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "type.keyword": {
              "value": "手机"
            }
          }
        },
        {
          "range": {
            "createTime": {
              "gte": "2022-10-01",
              "lte": "2022-10-31"
            }
          }
        }
      ]
    }
  }, 
  "size": 10
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ESApplication.class)
@Slf4j
public class BoolSearchTest {

    @Autowired
    private ElasticsearchClient elasticsearchClient;

    private static final String INDEX_NAME = "product_index";

    @Test
    public void boolSearch() {

        boolSearch1("手机", "2022-10-01", "2022-10-31");

        boolSearch2("手机", "2022-10-01", "2022-10-31");
    }

    private void boolSearch2(String type, String startDate, String endDate) {
        try {
            log.info("SearchTest invoke boolSearch2......");
            SearchResponse<ProductPojo> search = elasticsearchClient.search(
                    req -> req.index(INDEX_NAME).size(10)
                            .query(q -> q.bool(b -> b.filter(getQueryList(type, startDate, endDate))))
                    , ProductPojo.class);
            for (Hit<ProductPojo> productHit : search.hits().hits()) {
                System.out.println(JSON.toJSONString(productHit.source()));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private List<Query> getQueryList(String type, String startDate, String endDate) {
        List<Query> list = new ArrayList<>();
        if (StringUtils.isNotBlank(type)) {
            list.add(new Query.Builder().term(t -> t.field("type").value(type)).build());
        }

        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
            list.add(new Query.Builder().range(r -> r.field("createTime").gte(JsonData.of(startDate)).lte(JsonData.of(endDate))).build());
        }
        return list;
    }

    private void boolSearch1(String type, String startDate, String endDate) {
        try {
            log.info("SearchTest invoke boolSearch1......");
            SearchResponse<ProductPojo> search = elasticsearchClient.search(
                    req -> req.index(INDEX_NAME).size(10).query(q -> q.bool(
                            b -> {
                                if (StringUtils.isNotBlank(type)) {
                                    b.filter(t1 -> t1.term(t -> t.field("type").value(type)));
                                }

                                if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
                                    b.filter(r1 -> r1.range(r -> r.field("createTime").gte(JsonData.of(startDate)).lte(JsonData.of(endDate))));
                                }
                                return b;
                            }
                    ))
                    , ProductPojo.class);

            for (Hit<ProductPojo> productHit : search.hits().hits()) {
                System.out.println(JSON.toJSONString(productHit.source()));
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

在这里插入图片描述

2 聚合查询

统计10月手机，不同类型，不同级别，平均价格

GET product_index/_search
{ 
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "type.keyword": {
              "value": "手机"
            }
          }
        },
        {
          "range": {
            "createTime": {
              "gte": "2022-10-01",
              "lte": "2022-10-31"
            }
          }
        }
      ]
    }
  }, 
  "size": 0,
  "aggs": {
    "tagAggs": {
      "terms": {
        "field": "tags.keyword",
        "size": 10000
      },
      "aggs": {
        "levelAggs": {
          "terms": {
            "field": "level.keyword",
            "size": 10000
          },
          "aggs": {
            "avgAggs": {
              "avg": {
                "field": "price"
              }
            }
          }
        }
      }
    }
  }
}

package com.es;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
import co.elastic.clients.elasticsearch._types.aggregations.StringTermsBucket;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.json.JsonData;
import com.es.vo.ProductPojo;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.platform.commons.util.StringUtils;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ESApplication.class)
@Slf4j
public class AggsSearchTest {

    @Autowired
    private ElasticsearchClient elasticsearchClient;


    private static final String INDEX_NAME = "product_index";

    @Test
    public void aggsTest() {
        aggSearchTest1("手机", "2022-10-01", "2022-10-31");
        aggSearchTest2("手机", "2022-10-01", "2022-10-31");
    }

    private void aggSearchTest2(String type, String startDate, String endDate) {
        try {
            SearchResponse<ProductPojo> search = elasticsearchClient.search(req ->
                            req.index(INDEX_NAME).size(0)
                                    .query(q -> q.bool(b -> b.filter(getQueryList(type, startDate, endDate))))
                                    .aggregations(getAggs())
                    ,
                    ProductPojo.class);

            List<StringTermsBucket> tagAggs = search.aggregations().get("tagAggs").sterms().buckets().array();
            for (StringTermsBucket tagBucket : tagAggs) {
                String tag = tagBucket.key();
                List<StringTermsBucket> levelAggs = tagBucket.aggregations().get("levelAggs").sterms().buckets().array();
                log.info("tag:{}", tag);
                for (StringTermsBucket levelBucket : levelAggs) {
                    String level = levelBucket.key();
                    double avgAggs = levelBucket.aggregations().get("avgAggs").avg().value();
                    log.info("level:{},avgAggs:{}", level, avgAggs);
                }
                log.info("############################");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    public Map<String, Aggregation> getAggs() {

        Aggregation.Builder.ContainerBuilder tagAggs = new Aggregation.Builder().terms(t -> t.field("tags.keyword").size(10000));
        Aggregation.Builder.ContainerBuilder levelAggs = new Aggregation.Builder().terms(t -> t.field("level.keyword").size(10000));
        Aggregation.Builder.ContainerBuilder avgAggs = new Aggregation.Builder().avg(avg -> avg.field("price"));

        levelAggs.aggregations("avgAggs", avgAggs.build());
        tagAggs.aggregations("levelAggs", levelAggs.build());

        Map<String, Aggregation> map = new HashMap<>();
        map.put("tagAggs", tagAggs.build());
        return map;
    }


    private void aggSearchTest1(String type, String startDate, String endDate) {


        try {
            SearchResponse<ProductPojo> search = elasticsearchClient.search(req ->
                            req.index(INDEX_NAME).size(0)
                                    .query(q -> q.bool(b -> b.filter(getQueryList(type, startDate, endDate))))
                                    .aggregations("tagAggs",
                                            tagAggs -> tagAggs.terms(t -> t.field("tags.keyword").size(10000))
                                                    .aggregations("levelAggs", levelAggs -> levelAggs.terms(t -> t.field("level.keyword").size(10000))
                                                            .aggregations("avgAggs", avgAggs -> avgAggs.avg(a -> a.field("price")))
                                                    )
                                    )
                    ,
                    ProductPojo.class);

            List<StringTermsBucket> tagAggs = search.aggregations().get("tagAggs").sterms().buckets().array();
            for (StringTermsBucket tagBucket : tagAggs) {
                String tag = tagBucket.key();
                List<StringTermsBucket> levelAggs = tagBucket.aggregations().get("levelAggs").sterms().buckets().array();

                log.info("tag:{}", tag);
                for (StringTermsBucket levelBucket : levelAggs) {
                    String level = levelBucket.key();
                    double avgAggs = levelBucket.aggregations().get("avgAggs").avg().value();
                    log.info("level:{},avgAggs:{}", level, avgAggs);
                }
                log.info("############################");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }

    private List<Query> getQueryList(String type, String startDate, String endDate) {
        List<Query> list = new ArrayList<>();
        if (StringUtils.isNotBlank(type)) {
            list.add(new Query.Builder().term(t -> t.field("type").value(type)).build());
        }

        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
            list.add(new Query.Builder().range(r -> r.field("createTime").gte(JsonData.of(startDate)).lte(JsonData.of(endDate))).build());
        }
        return list;
    }


}

在这里插入图片描述

3 【桶】聚合查询

统计10月手机，不同类型，不同级别，平均价格最低的手机以及价格

GET product_index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "type.keyword": {
              "value": "手机"
            }
          }
        },
        {
          "range": {
            "createTime": {
              "gte": "2022-10-01",
              "lte": "2022-10-31"
            }
          }
        }
      ]
    }
  },
  "size": 0,
  "aggs": {
    "tagAggs": {
      "terms": {
        "field": "tags.keyword",
        "size": 10000
      },
      "aggs": {
        "levelAggs": {
          "terms": {
            "field": "level.keyword",
            "size": 10000
          },
          "aggs": {
            "avgAggs": {
              "avg": {
                "field": "price"
              }
            }
          }
        },
        "minAvgLevel": {
          "min_bucket": {
            "buckets_path": "levelAggs>avgAggs"
          }
        }
      }
    }
  }
}

package com.es;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
import co.elastic.clients.elasticsearch._types.aggregations.BucketMetricValueAggregate;
import co.elastic.clients.elasticsearch._types.aggregations.StringTermsBucket;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.json.JsonData;
import com.es.vo.ProductPojo;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.platform.commons.util.StringUtils;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ESApplication.class)
@Slf4j
public class BucketAggsSearchTest {

    @Autowired
    private ElasticsearchClient elasticsearchClient;

    private static final String INDEX_NAME = "product_index";


    @Test
    public void bucketAggsSearchTest() {

        searchBucketAggsTest1("手机", "2022-10-01", "2022-10-31");

        searchBucketAggsTest2("手机", "2022-10-01", "2022-10-31");
    }

    private void searchBucketAggsTest2(String type, String startDate, String endDate) {
        try {
            SearchResponse<ProductPojo> search = elasticsearchClient.search(req -> req
                            .index(INDEX_NAME).size(0)
                            .query(q -> q.bool(b -> b.filter(getQueryList(type, startDate, endDate))))
                            .aggregations(getAggs())
                    , ProductPojo.class);

            List<StringTermsBucket> tagAggs = search.aggregations().get("tagAggs").sterms().buckets().array();
            for (StringTermsBucket tagBucket : tagAggs) {
                String tag = tagBucket.key();
                BucketMetricValueAggregate minAvgLevel = tagBucket.aggregations().get("minAvgLevel").bucketMetricValue();
                List<String> levels = minAvgLevel.keys();
                double minAvg = minAvgLevel.value();
                log.info("tag:{} , levels:{},minAvg:{}", tag, levels, minAvg);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private Map<String, Aggregation> getAggs() {

        Aggregation.Builder.ContainerBuilder tagAggs = new Aggregation.Builder().terms(t -> t.field("tags.keyword").size(10000));
        Aggregation.Builder.ContainerBuilder levelAggs = new Aggregation.Builder().terms(t -> t.field("level.keyword").size(10000));
        Aggregation.Builder.ContainerBuilder avgAggs = new Aggregation.Builder().avg(avg -> avg.field("price"));
        Aggregation.Builder.ContainerBuilder minBucket = new Aggregation.Builder().minBucket(path -> path.bucketsPath(p -> p.single("levelAggs>avgAggs")));

        levelAggs.aggregations("avgAggs", avgAggs.build());
        tagAggs.aggregations("levelAggs", levelAggs.build());
        tagAggs.aggregations("minAvgLevel", minBucket.build());

        Map<String, Aggregation> map = new HashMap<>();
        map.put("tagAggs", tagAggs.build());
        return map;
    }


    private void searchBucketAggsTest1(String type, String startDate, String endDate) {

        try {
            SearchResponse<ProductPojo> search = elasticsearchClient.search(req -> req
                            .index(INDEX_NAME).size(0)
                            .query(q -> q.bool(b -> b.filter(getQueryList(type, startDate, endDate))))
                            .aggregations("tagAggs", tagAggs -> tagAggs.terms(t -> t.field("tags.keyword").size(10000))
                                    .aggregations("levelAggs", levelAggs -> levelAggs.terms(t -> t.field("level.keyword").size(10000))
                                            .aggregations("avgAggs", avgAggs -> avgAggs.avg(a -> a.field("price"))))
                                    .aggregations("minAvgLevel", minAvgLevel -> minAvgLevel.minBucket(min -> min.bucketsPath(p -> p.single("levelAggs>avgAggs"))))
                            )
                    , ProductPojo.class);
            List<StringTermsBucket> tagAggs = search.aggregations().get("tagAggs").sterms().buckets().array();
            for (StringTermsBucket tagBucket : tagAggs) {
                String tag = tagBucket.key();

                BucketMetricValueAggregate minAvgLevel = tagBucket.aggregations().get("minAvgLevel").bucketMetricValue();
                List<String> levels = minAvgLevel.keys();
                double minAvg = minAvgLevel.value();
                log.info("tag:{} , levels:{},minAvg:{}", tag, levels, minAvg);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    private List<Query> getQueryList(String type, String startDate, String endDate) {
        List<Query> list = new ArrayList<>();
        if (StringUtils.isNotBlank(type)) {
            list.add(new Query.Builder().term(t -> t.field("type").value(type)).build());
        }

        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
            list.add(new Query.Builder().range(r -> r.field("createTime").gte(JsonData.of(startDate)).lte(JsonData.of(endDate))).build());
        }
        return list;
    }


}
响彻天堂丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
最新版本springboot集成elasticsearch
05-25
一、概述 一般来说我们开发Elasticsearch会选择使用集成springboot，在网上找的springboot集成elasticsearch文章几乎都是extends ElasticsearchRepository的方式来实现。但是新版本ElasticsearchRepository里的方法基本上已经过时了。 我们去spring官网去看下， 可以看到，官方的github上的示例改成extends CrudRepository p.s. 写此文章出于以下几点考虑 目前网上找到的elasticsearch教程都比较旧 ElasticsearchRepository方法在新版本基本过时了 基于springdata的CrudRepository操作ES封装的比较完善，但网上的教程比较少 二、准备工作 1、下载elasticsearch 2、elasticsearch-head (方便查看ES中的索引及数据) 3、Kibana(方便开发通过rest api 调试ES，有代码提示) 4、中文分词elasticsearch-analysis-ik （ik） 1、下载ela
springboot项目查询es中的日志内容
04-21
自己系统配置了切面将所需操作数据存入elasticSearch后，使用java进行查询操作es，从而查看筛选日志。前端采用的是layUi，进行简单的筛选和展示
SpringBoot3整合Elasticsearch8.x之全面保姆级教程
最新发布
热爱编程的你我
03-15 2479
SpringBoot3整合Elasticsearch8.x之全面保姆级教程,非常全面
Elasticsearch 7基于springboot的应用
08-12
Elasticsearch 7基于springboot的应用及详细的笔记，包含完整的代码，非常适合初始者上手
Springboot + ElasticSearch + Mysql 的增删改查 附源码 和 资源.rar
04-17
springboot 整合 elasticsearch demo(内含增删改查)以及基本es操作 效果图在这里 ：https://blog.csdn.net/Japhet_jiu/article/details/105581997
springboot整合elasticsearch8
winsanity的博客
10-12 4302
springboot整合elasticsearch8
Springboot3.1+Elasticsearch8.x匹配查询
weixin_43189060的博客
06-16 3112
在这里面，spring-boot-starter-data-elasticsearch是3.1.0的，里面的spring-data-elasticsearch是5.1.0的，服务器上的Elasticsearch用的是8.7.0的。中配置，新版的配置与旧版的不太一样，从ElasticsearchProperties.java中可以看到，前缀是spring.elasticsearch，主机配置项已经变成了。第一步当然是配置依赖。
ElasticSearch序列 - SpringBoot整合ES：范围查询 range
你今天真好看呀
03-29 3911
如果您需要搜索文本类型的数据，可以使用其他类型的查询，例如match查询、prefix查询、wildcard查询、regexp查询等。需要注意的是，使用range查询搜索字符串类型的数据时，查询结果是基于字典序的，而不是基于数值大小的。总之，您可以使用range查询来搜索字符串类型的数据，但是在索引时需要将字段映射为keyword类型，以便将其视为未经分词的字符串。文本类型的字段只能映射为text类型。字符串类型的字段可以映射为keyword类型或text类型，而文本类型的字段只能映射为text类型。
SpringBoot3.0 整合 ElasticSearch8.5.0 及使用
weixin_46925850的博客
12-06 5813
SpringBoot3.0 整合 ElasticSearch8.5.0 及使用
springboot整合elasticsearch8组合条件查询
winsanity的博客
10-12 2521
springboot整合elasticsearch8组合条件查询
Spring Boot集成Elasticsearch复杂查询
m0_63021062的博客
10-13 930
项目中经常会遇到一些比较复杂的查询,如何使用RestHighLevelClient来实现查询呢，本文将讲解Spring Boot采用RestHighLevelClient如何实现高级查询。
SpringBoot整合Spring Data Elasticsearch的过程详解
08-25
主要介绍了SpringBoot整合Spring Data Elasticsearch的过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot整合Elasticserach搜索引擎
云丶言的博客
08-16 799
Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。`Elasticsearch是用Java语言开发的`，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。
ES 22 - Elasticsearch中如何进行日期(数值)范围查询
热门推荐
weixin_30608131的博客
07-29 1万+
目录 1 范围查询的符号 2 数值范围查询 3 时间范围查询 3.1 简单查询示例 3.2 关于时间的数学表达式(date-math) 3.3 关于时间的四舍五入 4 日期格式化范围查询(format) 5 时区范围...
ElasticSearch Java SpringBoot根据时间范围分组求和
叫我泪下的博客
05-08 1886
需求是这样的： 近7天的用户登陆统计，根据日期来返回的要是data:[{date：“2021-04-01”,count:“1”}] @Autowired private ElasticsearchTemplate elasticsearchTemplate; SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd"); //这个是获取7天前的时间，比如说今天是4月29,7天前就是4月23， //因为要包括今天，输出为"2021-04-23
【SpringBoot】整合Elasticsearch 操作索引及文档
m0_65563175的博客
06-16 3347
踩坑太多了。。。这里表明一下Spring Boot2.4以上版本可能会出现问题，所以我降到了2.2.1.RELEASE。对于现在2023年6月而言，Es版本已经到了8.8，而SpringBoot版本已经到了3.x版本。如果是高版本的Boot在配置类的时候会发现RestHighLevelClient已过时。从官网也可以看的出来RestHighLevelClient已过时。所以这篇博文中不会用到关于RestHighLevelClient的Api。。
elasticsearch整合springboot（一）
qq_39750835的博客
08-12 344
1.配置文件 1.1 加入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> <version>2.2.2.RELEASE</version&.
elasticsearch查询（多条件、时间范围、分页 ）
jsiostream的博客
02-14 1万+
代码： public List queryByTagLogs(String logType, Map&amp;amp;lt;String, Object&amp;amp;gt; contextMap, Date startTime, Date endTime) { List list = new ArrayList(); // 1.创建并设置SearchSourceBuilder对象 ...
SpringBoot时间区间查询详细教程
Y5819的博客
09-16 2914
SpringBoot时间区间查询详细教程
elasticsearch基于springboot的模糊查询
03-14
可以回答这个问题。Elasticsearch是一个开源的搜索引擎，可以通过Spring Boot集成使用。模糊查询可以通过使用通配符或模糊查询语句来实现。例如，使用通配符查询可以使用*或?来匹配不确定的字符，使用模糊查询语句可以使用~符号来指定模糊程度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

响彻天堂丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值