商城项目构建查询商品信息的ES语句测试拼接的DSL语句查询效果-----商城项目

于 2024-08-23 15:31:00 发布
阅读量496 收藏 9
点赞数 11
分类专栏： 电商项目 # Elastic Search # Spring-Cloud框架 文章标签： 微服务 缓存 后端 spring boot mybatis spring cloud 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/141467245
版权
#程序员如何平衡日常编码工作与提升式学习？# 
package com.alatus.search.service.impl;

import com.alatus.search.config.MallElasticSearchConfig;
import com.alatus.search.constant.EsConstant;
import com.alatus.search.service.MallSearchService;
import com.alatus.search.vo.SearchParam;
import com.alatus.search.vo.SearchResult;
import org.apache.commons.lang.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.NestedQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Service
public class MallSearchServiceImpl implements MallSearchService {
    @Autowired
    private RestHighLevelClient client;
    @Override
    public SearchResult search(SearchParam searchParam) {
//        动态构建出查询所需要的DSL语句
        SearchResult searchResult = null;
//        准备检索请求
        SearchRequest searchRequest = buildSearchRequest(searchParam);
        try {
//        执行查询检索请求
            SearchResponse response = client.search(searchRequest, MallElasticSearchConfig.COMMON_OPTIONS);
//            分析响应数据并封装成返回的数据
            searchResult = buildSearchResult();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return null;
    }

    private SearchResult buildSearchResult() {
        return null;
    }

    //准备检索请求
    private SearchRequest buildSearchRequest(SearchParam searchParam) {
//        构建DSL语句
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        查询条件,模糊查询,过滤,按照属性,分类品牌,价格区间,库存
//        构建了bool-query
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//        must
        if(!StringUtils.isEmpty(searchParam.getKeyword())){
            boolQuery.must(QueryBuilders.matchQuery("skuTitle",searchParam.getKeyword()));
        }
//        filter按照三级分类ID查询
        if(searchParam.getCatalog3Id()!=null){
            boolQuery.filter(QueryBuilders.termQuery("catalogId",searchParam.getCatalog3Id()));
        }
//        filter按照品牌ID查询
        if(searchParam.getBrandId()!=null && !searchParam.getBrandId().isEmpty()){
            boolQuery.filter(QueryBuilders.termsQuery("brandId",searchParam.getBrandId()));
        }
//        filter按照属性ID查询
        if(searchParam.getAttrs()!=null && !searchParam.getAttrs().isEmpty()){
            for (String attrStr : searchParam.getAttrs()) {
                BoolQueryBuilder nestedBoolQuery = QueryBuilders.boolQuery();
                String[] attr = attrStr.split("_");
                String attrId = attr[0];//属性ID
                String[] attrValues = attr[1].split(":");//属性值
                nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrId",attrId));
                nestedBoolQuery.must(QueryBuilders.termsQuery("attrs.attrValue",attrValues));
//                每一个都必须有一个嵌入式的查询
                NestedQueryBuilder attrs = QueryBuilders.nestedQuery("attrs", nestedBoolQuery, ScoreMode.None);
                boolQuery.filter(attrs);
            }
        }
//        按照库存进行查询
        if(searchParam.getHasStock()!=null){
            boolQuery.filter(QueryBuilders.termQuery("hasStock", searchParam.getHasStock()==1));
        }
//        按照价格区间
        if(!StringUtils.isEmpty(searchParam.getSkuPrice())){
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
            String[] price = searchParam.getSkuPrice().split("_");
            if(price.length == 2){
                rangeQuery.gte(price[0]).lte(price[1]);
            }
            else if (price.length == 1) {
                if(searchParam.getSkuPrice().startsWith("_")){
                    rangeQuery.lte(price[0]);
                }
                else if(searchParam.getSkuPrice().endsWith("_")){
                    rangeQuery.gte(price[0]);
                }
            }
            boolQuery.filter(rangeQuery);
        }
//        把所有条件全部封装
        sourceBuilder.query(boolQuery);
//        排序
        if(!StringUtils.isEmpty(searchParam.getSort())){
            String sort = searchParam.getSort();
            String[] sortString = sort.split("_");
            sourceBuilder.sort(sortString[0],sortString[1].equalsIgnoreCase("asc")?SortOrder.ASC:SortOrder.DESC);
        }
//        分页
        if(searchParam.getPageNum()!=null){
            sourceBuilder.from((searchParam.getPageNum()-1)*EsConstant.PRODUCT_PAGESIZE);
            sourceBuilder.size(EsConstant.PRODUCT_PAGESIZE);
        }
//        高亮
        if (!StringUtils.isEmpty(searchParam.getKeyword())){
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("skuTitle");
            highlightBuilder.preTags("<b style='color:red'>");
            highlightBuilder.postTags("</b>");
            sourceBuilder.highlighter(highlightBuilder);
        }
//        聚合分析
        System.out.println(sourceBuilder.toString());
        return new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX},sourceBuilder);
    }
}

package com.alatus.search.service.impl;

import com.alatus.search.config.MallElasticSearchConfig;
import com.alatus.search.constant.EsConstant;
import com.alatus.search.service.MallSearchService;
import com.alatus.search.vo.SearchParam;
import com.alatus.search.vo.SearchResult;
import org.apache.commons.lang.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.NestedQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Service
public class MallSearchServiceImpl implements MallSearchService {
    @Autowired
    private RestHighLevelClient client;
    @Override
    public SearchResult search(SearchParam searchParam) {
//        动态构建出查询所需要的DSL语句
        SearchResult searchResult = null;
//        准备检索请求
        SearchRequest searchRequest = buildSearchRequest(searchParam);
        try {
//        执行查询检索请求
            SearchResponse response = client.search(searchRequest, MallElasticSearchConfig.COMMON_OPTIONS);
//            分析响应数据并封装成返回的数据
            searchResult = buildSearchResult();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return null;
    }

    private SearchResult buildSearchResult() {
        return null;
    }

    //准备检索请求
    private SearchRequest buildSearchRequest(SearchParam searchParam) {
//        构建DSL语句
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//        查询条件,模糊查询,过滤,按照属性,分类品牌,价格区间,库存
//        构建了bool-query
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//        must
        if(!StringUtils.isEmpty(searchParam.getKeyword())){
            boolQuery.must(QueryBuilders.matchQuery("skuTitle",searchParam.getKeyword()));
        }
//        filter按照三级分类ID查询
        if(searchParam.getCatalog3Id()!=null){
            boolQuery.filter(QueryBuilders.termQuery("catalogId",searchParam.getCatalog3Id()));
        }
//        filter按照品牌ID查询
        if(searchParam.getBrandId()!=null && !searchParam.getBrandId().isEmpty()){
            boolQuery.filter(QueryBuilders.termsQuery("brandId",searchParam.getBrandId()));
        }
//        filter按照属性ID查询
        if(searchParam.getAttrs()!=null && !searchParam.getAttrs().isEmpty()){
            for (String attrStr : searchParam.getAttrs()) {
                BoolQueryBuilder nestedBoolQuery = QueryBuilders.boolQuery();
                String[] attr = attrStr.split("_");
                String attrId = attr[0];//属性ID
                String[] attrValues = attr[1].split(":");//属性值
                nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrId",attrId));
                nestedBoolQuery.must(QueryBuilders.termsQuery("attrs.attrValue",attrValues));
//                每一个都必须有一个嵌入式的查询
                NestedQueryBuilder attrs = QueryBuilders.nestedQuery("attrs", nestedBoolQuery, ScoreMode.None);
                boolQuery.filter(attrs);
            }
        }
//        按照库存进行查询
        if(searchParam.getHasStock()!=null){
            boolQuery.filter(QueryBuilders.termQuery("hasStock", searchParam.getHasStock()==1));
        }
//        按照价格区间
        if(!StringUtils.isEmpty(searchParam.getSkuPrice())){
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
            String[] price = searchParam.getSkuPrice().split("_");
            if(price.length == 2){
                rangeQuery.gte(price[0]).lte(price[1]);
            }
            else if (price.length == 1) {
                if(searchParam.getSkuPrice().startsWith("_")){
                    rangeQuery.lte(price[0]);
                }
                else if(searchParam.getSkuPrice().endsWith("_")){
                    rangeQuery.gte(price[0]);
                }
            }
            boolQuery.filter(rangeQuery);
        }
//        把所有条件全部封装
        sourceBuilder.query(boolQuery);
//        排序
        if(!StringUtils.isEmpty(searchParam.getSort())){
            String sort = searchParam.getSort();
            String[] sortString = sort.split("_");
            sourceBuilder.sort(sortString[0],sortString[1].equalsIgnoreCase("asc")?SortOrder.ASC:SortOrder.DESC);
        }
//        分页
        if(searchParam.getPageNum()!=null){
            sourceBuilder.from((searchParam.getPageNum()-1)*EsConstant.PRODUCT_PAGESIZE);
            sourceBuilder.size(EsConstant.PRODUCT_PAGESIZE);
        }
//        高亮
        if (!StringUtils.isEmpty(searchParam.getKeyword())){
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("skuTitle");
            highlightBuilder.preTags("<b style='color:red'>");
            highlightBuilder.postTags("</b>");
            sourceBuilder.highlighter(highlightBuilder);
        }
//        聚合分析
        System.out.println(sourceBuilder.toString());
        return new SearchRequest(new String[]{EsConstant.PRODUCT_INDEX},sourceBuilder);
    }
}

GET alatusmall_product/_search?size=100
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "skuTitle": {
              "query": "小米",
              "operator": "OR",
              "prefix_length": 0,
              "max_expansions": 50,
              "fuzzy_transpositions": true,
              "lenient": false,
              "zero_terms_query": "NONE",
              "auto_generate_synonyms_phrase_query": true,
              "boost": 1
            }
          }
        }
      ],
      "filter": [
        {
          "term": {
            "catalogId": {
              "value": 225,
              "boost": 1
            }
          }
        },
        {
          "nested": {
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "attrs.attrId": {
                        "value": "13",
                        "boost": 1
                      }
                    }
                  },
                  {
                    "terms": {
                      "attrs.attrValue": [
                        "天玑8300",
                        "麒麟9000s"
                      ],
                      "boost": 1
                    }
                  }
                ],
                "adjust_pure_negative": true,
                "boost": 1
              }
            },
            "path": "attrs",
            "ignore_unmapped": false,
            "score_mode": "none",
            "boost": 1
          }
        },
        {
          "nested": {
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "attrs.attrId": {
                        "value": "15",
                        "boost": 1
                      }
                    }
                  },
                  {
                    "terms": {
                      "attrs.attrValue": [
                        "2023"
                      ],
                      "boost": 1
                    }
                  }
                ],
                "adjust_pure_negative": true,
                "boost": 1
              }
            },
            "path": "attrs",
            "ignore_unmapped": false,
            "score_mode": "none",
            "boost": 1
          }
        },
        {
          "term": {
            "hasStock": {
              "value": false,
              "boost": 1
            }
          }
        },
        {
          "range": {
            "skuPrice": {
              "from": "",
              "to": "6000",
              "include_lower": true,
              "include_upper": true,
              "boost": 1
            }
          }
        }
      ],
      "adjust_pure_negative": true,
      "boost": 1
    }
  },
  "sort": [
    {
      "skuPrice": {
        "order": "asc"
      }
    }
  ],
  "highlight": {
    "pre_tags": [
      "<b style='color:red'>"
    ],
    "post_tags": [
      "</b>"
    ],
    "fields": {
      "skuTitle": {}
    }
  }
}

 GET alatusmall_product/_search?size=100
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "skuTitle": {
              "query": "小米",
              "operator": "OR",
              "prefix_length": 0,
              "max_expansions": 50,
              "fuzzy_transpositions": true,
              "lenient": false,
              "zero_terms_query": "NONE",
              "auto_generate_synonyms_phrase_query": true,
              "boost": 1
            }
          }
        }
      ],
      "filter": [
        {
          "term": {
            "catalogId": {
              "value": 225,
              "boost": 1
            }
          }
        },
        {
          "nested": {
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "attrs.attrId": {
                        "value": "13",
                        "boost": 1
                      }
                    }
                  },
                  {
                    "terms": {
                      "attrs.attrValue": [
                        "天玑8300",
                        "麒麟9000s"
                      ],
                      "boost": 1
                    }
                  }
                ],
                "adjust_pure_negative": true,
                "boost": 1
              }
            },
            "path": "attrs",
            "ignore_unmapped": false,
            "score_mode": "none",
            "boost": 1
          }
        },
        {
          "nested": {
            "query": {
              "bool": {
                "must": [
                  {
                    "term": {
                      "attrs.attrId": {
                        "value": "15",
                        "boost": 1
                      }
                    }
                  },
                  {
                    "terms": {
                      "attrs.attrValue": [
                        "2023"
                      ],
                      "boost": 1
                    }
                  }
                ],
                "adjust_pure_negative": true,
                "boost": 1
              }
            },
            "path": "attrs",
            "ignore_unmapped": false,
            "score_mode": "none",
            "boost": 1
          }
        },
        {
          "term": {
            "hasStock": {
              "value": false,
              "boost": 1
            }
          }
        },
        {
          "range": {
            "skuPrice": {
              "from": "",
              "to": "6000",
              "include_lower": true,
              "include_upper": true,
              "boost": 1
            }
          }
        }
      ],
      "adjust_pure_negative": true,
      "boost": 1
    }
  },
  "sort": [
    {
      "skuPrice": {
        "order": "asc"
      }
    }
  ],
  "highlight": {
    "pre_tags": [
      "<b style='color:red'>"
    ],
    "post_tags": [
      "</b>"
    ],
    "fields": {
      "skuTitle": {}
    }
  }
}

旧约Alatus
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java的es的查询语句_ElasticSearch 常用的查询语句
weixin_36212539的博客
02-26 1974
使用ES时候发现了一篇挺好的文章，收集下来分享给大家。Filter DSLterm 过滤term主要用于精确匹配哪些值，比如数字，日期，布尔值或 not_analyzed 的字符串(未经分析的文本数据类型)：{ "term": { "age": 26 }}{ "term": { "date": "2014-09-01" }}{ "term": { "public": true }}{ "ter...
ElasticSearch-DSL语句使用-Kibana界面操作
weixin_34067359的博客
01-24 691
Query DSL结构化查询介绍 Query DSL是一个Java开源框架用于构建类型安全的SQL查询语句。采用API代替传统的拼接字符串来构造查询语句。目前Querydsl支持的平台包括JPA,JDO，SQL，Java Collections，RDF，Lucene，Hibernate Search。elasticsearch提供了一整套基于JSON的查询DSL语言来定义查询。 Query DSL当作是一系列的抽象的查询表达式树(AST)特定查询能够包含其它的查询，(如 bool ), 有些查询能够包含过滤
es查询语句拼接 java_fast-es-query-builder：迅速构建ElasticSearch查询语句，甚至可以不写一行实现代码...
weixin_39775910的博客
03-04 262
fast-elasticsearch-query-builderA fast way to build ElasticSearch query dsl string, even without writing implement code.Read this in other languages: English, 简体中文BriefYou can integrate it in your pro...
es查询语句拼接 java_JAVA使用ElasticSearch查询in和not in的实现方式
weixin_39713805的博客
02-27 894
JAVA使用ElasticSearch查询in和not in的实现方式发布时间：2020-08-22 16:03:11来源：脚本之家阅读：119作者：执笔记忆的空白ElasticSearchElasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款...
【业务功能篇90】微服务-springcloud-检索服务-ElasticSearch实战运用-DSL语句
studyday1的博客
08-30 1581
商品检索页面我们放在search服务中处理，首页我们需要在mall-search服务中支持Thymeleaf。添加对应的依赖
ElasticSearch语法整理-DSL语言高级查询
m0_60162373的博客
03-29 4534
Domain Specific Language 领域专用语言 DSL由叶子查询子句和复合查询子句两种子句组成。 无查询条件 无查询条件是查询所有，默认是查询所有的索引库的数据，或者使用match_all表示所有 GET /es_db/_doc/_search { "query":{ "match_all":{} } } 有查询条件 查询命令GET POST 都可以 1、叶子条件查询(单字段查询条件) 1.1 模糊匹配 match : 通过match关
Elasticsearch中【文档查询】DSL语句以及对应的Java实现
m0_69594200的博客
04-29 1123
Elasticsearch提供了基于JSON的DSL（）来定义查询。：查询出所有数据，一般测试用。例如：match_all：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：idsrangeterm：根据经纬度查询。例如：：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：bool。
黑马畅购商城---5.商品搜索-Elasticsearch-DSL
IT大神帅杰的博客
02-22 1783
学习目标 Elasticsearch安装 1 2 3 docker安装Elasticsearch 系统参数问题 跨域操作 IK分词器配置 Kibana的使用->==DSL语句== Kibana->DSL语句操作->Elasticsearch ==ES导入商品搜索数据== 1 2 Sku数据导入到Elasticsea...
ElasticSearch-查询语句详解
大灰狼的小绵羊哥哥的博客
04-13 746
url参数搜索 这种方式就是类似于get请求，将请求参数拼接到链接上，例GET /school/student/_search?参数，多个参数用&分开 查询所有 命令：GET /school/student/_search 返回： { "took": 7, //查询耗时，毫秒 "timed_out": false, //是否超时，timeout 不是停止执行查询，它仅仅是告知正在协调的节点返回到目前为止收集的结果并且关闭连接 "_shards": { "tota.
elastic-builder:Elasticsearch查询DSL的Node.js实现
05-02
Elasticsearch兼容性elastic-builder是为5.x查询DSL elastic-builder 。 但是，该库也应可与2.x一起使用。 对于较旧版本的DSL，您可以尝试或 大部分情况下， elastic-builder也与elasticsearch 6.0（alpha）兼容。 ...
django-elasticsearch-dsl-drf：将Elasticsearch DSL与Django REST框架集成
02-05
标题和描述提到了"django-elasticsearch-dsl-drf"，这是一个用于集成Elasticsearch DSL（Domain Specific Language）与Django REST框架的库。这意味着它旨在帮助开发者在Django应用中轻松地使用Elasticsearch进行...
ES-elasticsearch 常用语句
03-26
Elasticsearch 查询语句
elasticSearch查询语句DSL
06-27
在这篇资源中，我们将详细介绍如何使用DSL来构建复杂的查询语句，以满足各种搜索需求。首先，我们将学习DSL的基本结构和语法规则，包括查询、过滤器、聚合和排序等核心概念。通过深入了解DSL的语法，您将能够灵活地...
elasticsearch-analysis-ik-8.11.0
11-27
1. 安装：将`elasticsearch-analysis-ik-8.11.0.jar`文件放入Elasticsearch的`plugins`目录下，并确保所有依赖项（如`httpclient-4.5.13.jar`、`commons-codec-1.11.jar`等）也已正确放置。 2. 配置：在Elastic...
Docker 部署loki日志 用于微服务
u014007519的专栏
08-19 1005
因为每次去查看日志都去登录服务器去查询相关日志文件，还有不同的微服务，不同日期的文件夹，超级麻烦，因为之前用过ELK，原本打算用ELK，在做技术调研的时候发现了一个轻量级的日志系统Loki，果断采用Loki部署。这个地址是你采集日志后发送给loki的网络地址, 如果不同的服务器则采用Ip地址访问，如果同一台服务器可以用127.0.0.1 发送。我这里是docker内部的连接 所以是这样的。如果是其他的地址就配置自己的ip地址。我这里是单个服务器系统部署，如果是多个服务器的话，修改链接配置即可。
微服务：配置管理和配置热更新
安晴晚风的博客
08-19 1198
微服务：配置管理和配置热更新
微服务中的Sidecar模式
weixin_45770491的博客
08-19 985
sidecar是服务网络架构的产物。Sidecar，全称 Sidecar proxy，为在应用程序旁运行的单独的进程，它可以为应用程序添加许多功能，而无需在应用程序中添加额外的第三方组件，或修改应用程序的代码或配置。将应用程序的功能划分为单独的进程运行在同一个最小调度单元中（例如 Kubernetes 中的 Pod）可以被视为 sidecar 模式。在软件架构中， Sidecar 连接到父应用并且为其添加扩展或者增强功能。Sidecar 应用与主应用程序松散耦合。
认识微服务
最新发布
m0_74197695的博客
08-19 1056
微服务是一种软件架构风格，它将一个大型的应用程序拆分成一组小的、自治的服务单元。每个服务单元都运行在独立的进程中，通过轻量级的通信机制（如HTTP/RESTful API、消息队列等）进行交互，并且可以使用不同的编程语言、框架和技术栈来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值