使用 es 实现动态集合

最新推荐文章于 2024-07-13 15:23:26 发布
最新推荐文章于 2024-07-13 15:23:26 发布
阅读量59 收藏 1
点赞数 1
文章标签： elasticsearch 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c515153841/article/details/134904416
版权

工作中有时候需要根据条件配置的方式实现动态集合呢？本案例讲解一种通用的方案，如下：

（以下仅部分主要逻辑）

一、需要定义条件中需要的字段

        定义字段及可以被选择的关系列表

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;


@Getter
public enum FilterColumn implements EnumerationType {

    PRODUCT_TITLE("product title", false, "title", IS_EQUAL_TO, IS_NOT_EQUAL_TO, CONTAINS),
    PRODUCT_TAG("product tag", true, "tag_id", IS_EQUAL_TO, IS_NOT_EQUAL_TO),
    UPDATE_TIME("update time", true, "updated_at", IS_EQUAL_TO),
    CREATE_TIME("create time", true, "created_at", IS_EQUAL_TO),
    COST_PRICE("cost price", true, "cost_price_cent", IS_EQUAL_TO, IS_NOT_EQUAL_TO, IS_GREATER_THAN, IS_LESS_THAN),
    SELLING_PRICE("selling price", true, "selling_price_cent", IS_EQUAL_TO, IS_NOT_EQUAL_TO, IS_GREATER_THAN,IS_LESS_THAN),
    INVENTORY("inventory", true,"inventory", IS_EQUAL_TO, IS_NOT_EQUAL_TO, IS_GREATER_THAN, IS_LESS_THAN),
    CATEGORY("category", true, "product_category_id", IS_EQUAL_TO, IS_NOT_EQUAL_TO),
    BRAND_NAME("brand name", false, "id", IS_EQUAL_TO), // id
    COLLECTION("collection", true, "collection", IS_EQUAL_TO),
    ;

    private final String type;
    private final boolean isNumber;
    private final String columnName;
    private final FilterRelation[] supportedRelations;

    FilterColumn(String type, boolean isNumber, String columnName, FilterRelation... supportedRelations) {
        this.type = type;
        this.columnName = columnName;
        this.isNumber = isNumber;
        this.supportedRelations = supportedRelations;
    }

    @JsonCreator
    public static FilterColumn create (String name) {
        if(name == null) {
            throw new IllegalArgumentException();
        }
        return Enum.valueOf(FilterColumn.class, name.trim().replaceAll(" ", "_").toUpperCase());
    }

    @Override
    @JsonValue
    public String getType() {
        return type;
    }

    @Override
    public String getFriendlyType() {
        return null;
    }

    public boolean verifyCondition(String condition) {
        if (this.equals(UPDATE_TIME)) {
            return TimeCondition.findByType(condition) != null;
        } else if(this.equals(CREATE_TIME)){
            return TimeCondition.findByType(condition) != null;
        } else if (isNumber) {
            return NumberUtils.isDigits(condition);
        }
        return StringUtils.isNotBlank(condition);
    }
}

二、定义条件的执行方式

        如 等于、不等于、大于、小于等关系

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import lombok.Getter;


@Getter
public enum FilterRelation implements EnumerationType {

    /**
     * collection 筛选条件支持方式
     */
    IS_EQUAL_TO("is equal to", "="),
    IS_NOT_EQUAL_TO("is not equal to", "!="),
    CONTAINS("contains", "like"),
    IS_GREATER_THAN("is greater than", ">"),
    IS_LESS_THAN("is less than", "<");

    private final String type;
    private final String operator;

    FilterRelation(String type, String operator) {
        this.type = type;
        this.operator = operator;
    }

    @JsonCreator
    public static FilterColumn create (String name) {
        if(name == null) {
            throw new IllegalArgumentException();
        }
        return Enum.valueOf(FilterColumn.class, name.trim().replaceAll(" ", "_").toUpperCase());
    }

    @Override
    @JsonValue
    public String getType() {
        return type;
    }

    @Override
    public String getFriendlyType() {
        return null;
    }
}

三、创建集合及条件对象

/**
 * 集合对象
 */
@Data
public class Collection {
    
    private Long id;

    // 集合名
    private String title;

    // 是否可用
    private Boolean available;

    // 是否匹配任意一个条件
    private Boolean anyMatch;

    // 集合条件
    private List<CollectionFilter> filters;

}


/**
 * 单个集合条件
 */
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class CollectionFilter implements Entity<Long> {

    private Long id;

    private FilterColumn column;

    private FilterRelation relation;

    private String condition;

    private Long collectionId;

    public static SmartCollectionFilter createFromDTO(
            SmartCollectionFilterDTO collectionFilterDTO, Long collectionId) {
        if (ObjectUtils.isEmpty(collectionFilterDTO)) {
            return null;
        }
        SmartCollectionFilter collectionFilter = new SmartCollectionFilter();
        collectionFilter.setId(IdGenerator.getUID());
        collectionFilter.setColumn(collectionFilterDTO.getColumn());
        collectionFilter.setRelation(collectionFilterDTO.getRelation());
        collectionFilter.setCondition(collectionFilterDTO.getCondition());
        collectionFilter.setCollectionId(collectionId);
        return collectionFilter;
    }

    public boolean updateFromDTO(SmartCollectionFilterDTO dto) {
        boolean isChanged = false;
        if(!ObjectUtils.isEmpty(dto.getColumn()) && !dto.getColumn().equals(getColumn())) {
            setColumn(dto.getColumn());
            isChanged = true;
        }
        if(!ObjectUtils.isEmpty(dto.getRelation()) && !dto.getRelation().equals(getRelation())) {
            setRelation(dto.getRelation());
            isChanged = true;
        }
        if(!StringUtils.isEmpty(dto.getCondition()) && !dto.getCondition().equals(getCondition())) {
            setCondition(dto.getCondition());
            isChanged = true;
        }
        return isChanged;
    }

}

四、查询实现方式

/**
 * 集合条件列表转 es 条件列表
 * @param collectionId
 */
public void buildFilterList(Long collectionId) {
    List<CollectionFilter> filters = collectionService.findByCollectionId(collectionId);
    if (CollectionUtils.isEmpty(filters)) {
        return Page.empty(pageable);
    }
    BoolQueryBuilder builder = new BoolQueryBuilder();
    queryBuilder.filter(builder);
    builder.must(QueryBuilders.termQuery("available", true));
    if (CollectionUtils.isNotEmpty(excludeIds)){
        builder.mustNot(QueryBuilders.termsQuery("_id",excludeIds));
    }
    for (SmartCollectionFilter filter : filters) {
        applyFilter(filter,builder,baseCollection.getAnyMatch());
    }
}


/**
 * 单个条件转 es 条件
 * @param collectionId
 */
private void applyFilter(CollectionFilter filter, BoolQueryBuilder queryBuilder, Boolean anyMatch) {
    switch (filter.getColumn()) {
        case PRODUCT_TITLE : {
            switch (filter.getRelation()) {
                case  IS_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.termQuery("title.keyword", filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.termQuery("title.keyword", filter.getCondition()));
                    break;
                }
                case  IS_NOT_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(new BoolQueryBuilder().mustNot(QueryBuilders.termQuery("title.keyword", filter.getCondition())));
                    else
                        queryBuilder.mustNot(QueryBuilders.termQuery("title.keyword", filter.getCondition()));
                    break;
                }
                case  CONTAINS : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.wildcardQuery("title.keyword","*" +  filter.getCondition() + "*"));
                    else
                        queryBuilder.must(QueryBuilders.wildcardQuery("title.keyword", "*" +  filter.getCondition()+ "*"));
                    break;
                }
            }
            break;
        }
        case PRODUCT_TAG :
        {
            switch (filter.getRelation()) {
                case  IS_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.termQuery("tagIds", filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.termQuery("tagIds", filter.getCondition()));
                    break;
                }
                case  IS_NOT_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(new BoolQueryBuilder().mustNot(QueryBuilders.termQuery("tagIds", filter.getCondition())));
                    else
                        queryBuilder.mustNot(QueryBuilders.termQuery("tagIds", filter.getCondition()));
                    break;
                }
            }
            break;
        }
        case UPDATE_TIME :
        {
            if (filter.getRelation() == FilterRelation.IS_EQUAL_TO) {
                if (filter.getCondition().trim().equals("latest 30 days")) {
                    if (anyMatch)
                    queryBuilder.should(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 30*24*60*60*1000l));
                    else
                    queryBuilder.must(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 30*24*60*60*1000l));
                } else if (filter.getCondition().trim().equals("latest 15 days")) {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                } else if (filter.getCondition().trim().equals("latest 7 days")) {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("updatedAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                }

            } else  {
                queryBuilder.must(QueryBuilders.rangeQuery("updatedAt").lt(-100));
            }
            break;
        }
        case CREATE_TIME :
        {
            if (filter.getRelation() == FilterRelation.IS_EQUAL_TO) {
                if (filter.getCondition().trim().equals("latest 30 days")) {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 30*24*60*60*1000l));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 30*24*60*60*1000l));
                } else if (filter.getCondition().trim().equals("latest 15 days")) {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 15*24*60*60*1000l));
                } else if (filter.getCondition().trim().equals("latest 7 days")) {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 7*24*60*60*1000l));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("createdAt").gte(System.currentTimeMillis() - 7*24*60*60*1000l));
                }

            }
            break;
        }
        case SELLING_PRICE :
        {
            switch (filter.getRelation()) {
                case  IS_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.termQuery("priceMin", filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.termQuery("priceMin", filter.getCondition()));
                    break;
                }
                case  IS_NOT_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(new BoolQueryBuilder().mustNot(QueryBuilders.termQuery("priceMin", filter.getCondition())));
                    else
                        queryBuilder.mustNot(QueryBuilders.termQuery("priceMin", filter.getCondition()));
                    break;
                }
                case  IS_GREATER_THAN : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("priceMin").gte(filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("priceMin").gte(filter.getCondition()));
                    break;
                }
                case  IS_LESS_THAN : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.rangeQuery("priceMin").lte(filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.rangeQuery("priceMin").lte(filter.getCondition()));
                    break;
                }
            }
            break;
        }
        case INVENTORY :
        {
            break;
        }
        case CATEGORY :
        {
            switch (filter.getRelation()) {
                case  IS_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.termQuery("categoryIds", filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.termQuery("categoryIds", filter.getCondition()));
                    break;
                }
                case  IS_NOT_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(new BoolQueryBuilder().mustNot(QueryBuilders.termQuery("categoryIds", filter.getCondition())));
                    else
                        queryBuilder.mustNot(QueryBuilders.termQuery("categoryIds", filter.getCondition()));
                    break;
                }
            }
            break;
        }
        case COLLECTION: {
            BaseCollection collection = collectionService.findOne(Long.valueOf(filter.getCondition()));
            if (!collection.getAvailable() && collection.getType().equals(CollectionType.CUSTOM)) {
                break;
            }
            List<SmartCollectionFilter> filters = collectionService.findByCollectionId(collection.getId());
            if (CollectionUtils.isEmpty(filters)) {
                break;
            }
            BoolQueryBuilder subBuilder = new BoolQueryBuilder();
            for (SmartCollectionFilter subFilter : filters) {
                applyFilter(subFilter, subBuilder, collection.getAnyMatch());
            }
            if (anyMatch) {
                queryBuilder.should(subBuilder);
            } else {
                queryBuilder.must(subBuilder);
            }
            break;
        }
        case BRAND_NAME :
        {
            switch (filter.getRelation()) {
                case  IS_EQUAL_TO : {
                    if (anyMatch)
                        queryBuilder.should(QueryBuilders.termQuery("brandIds", filter.getCondition()));
                    else
                        queryBuilder.must(QueryBuilders.termQuery("brandIds", filter.getCondition()));
                    break;
                }
            }
            break;
        }
        case DAY_ORDER: // @Author masl - 2022/4/29 11:47 上午
        {
            List<String> spus = new ArrayList<>();
            if (filter.getRelation() == FilterRelation.IS_GREATER_THAN) {
                spus = productServiceFacade.findSpuByOrder(1, Integer.valueOf(filter.getCondition()));
            }
            if (filter.getRelation() == FilterRelation.IS_LESS_THAN) {
                spus = productServiceFacade.findSpuByOrder(2, Integer.valueOf(filter.getCondition()));
            }
            if (CollectionUtils.isNotEmpty(spus)) {
                if (anyMatch)
                    queryBuilder.should(QueryBuilders.termsQuery("spu.keyword", spus));
                else
                    queryBuilder.must(QueryBuilders.termsQuery("spu.keyword", spus));
            }
            break;
        }
    }
}

林中山野
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
ElasticSearch官方测试数据
09-14
Elasticsearch（ES）是一种流行的开源全文搜索引擎，它基于Lucene库构建，被广泛用于大数据分析、日志聚合、实时搜索和索引等场景。官方提供的测试数据集是检验Elasticsearch功能、性能和稳定性的关键资源，可以帮助...
Elasticsearch 开发手册
09-08
在数据抽取 ELT 领域，ES 全家桶 ELK（Elasticsearch+Logstash+Kibana）赫赫有名。 Elasticsearch 基本概念： * 倒排索引：Elasticsearch 为什么快，核心设计理念就是采用了倒排索引机制。倒排索引的方式是，根据 ...
关于esyui的table表格动态列显示
青曲
05-18 689
有两种方法可以实现， 第一种是右键表格的头，然后是下拉框显示表格头的动态显示，感觉客户体验不太好，每次只能一个一个的显示或者隐藏。 第二种是弹出一个窗口，选一个隐藏一个，客户选完之后，就可以关闭弹出窗口了。
es优化 动态索引 json写法 script 聚合
heqiang1995的博客
12-21 1454
es7去掉了类型 get post 就是参数带在哪里 put 更新或创建数据（指定id） post创建文档是随机的id _search 查数据 _mapping 索引结构 curl -X GET "localhost:9200/_cat/indices?v" { "query": { "bool": { "must": [ { "range": { "happen_time": { "from": "2021-11-29 00:00:00",
ElasticSearch系列03：ES的数据类型
From Zero To Hero
04-30 4933
引言：上一节，我们学习了ES的基本概念和ES的数据架构【关注公众号：ZeroTeHero，获取上节内容】。今天，TeHero将为大家讲解ES的数据类型。 数据的存储，都是需要预先确定好数据的类型的，不管是关系型数据库mysql还是非关系型数据库MongoDB，都有一套数据类型系统（两者很类似，但也有区别）。那么ES的数据类型有哪些呢？TeHero为你倾情讲解^~^。 ES的...
ElasticSearch全文搜索引擎之查询API操作详解
weixiaohuai的博客
10-09 2003
一、简介 前面一篇文章已经总结一些索引和文档相关的操作API，本篇文章主要介绍Java客户端中如何使用查询搜索引擎中的数据，同样还是基于RestHighLevelClient实现。 二、查询API详解 es查询API使用大体步骤： 构造SearchRequest查询请求对象，支持设置超时时间等信息； 构造QueryBuilder对象，常见的QueryBuilder有BoolQueryBuilder、MatchQueryBuilder、RangeQueryBuilder等； 构造SearchSou
ES笔记（一）- 查询详解
buzhidao
09-15 765
private int currentPage = 1; //当前页 private int pageSize = 5;//显示的条数 //测试查询文档2 @Test void testSearchDocument2() throws IOException { SearchRequest request = new SearchRequest(); //添加、设置索引 //new String[indices.size...
Elasticsearch ES实现GEO位置搜索
Lyndon的专栏
01-09 1296
ES中实现GEO位置搜索
ElasticSearch入门：使用ES来实现模糊查询功能
热门推荐
qq_37426635的博客
05-13 1万+
ElasticSearch入门：使用ES来实现模糊查询功能需求描述方案设计代码设计测试中遇到的问题总结与心得 需求描述 本文针对在工作中遇到的需求：通过es来实现模糊查询来进行总结；模糊查询的具体需求是：查询基金/A股/港股等金融数据，要求可以根据字段，拼音首字母，部分拼音全称进行联想查询；需要注意的是，金融数据名称中可能不止包含汉字，还有英文，数字，特殊字符等。 方案设计 常用的es模糊查询出于性能问题，官方建议是慎重使用的，但一般针对于与其他es查询相比，如果和其他搜索工具相比，es的模糊查询性能还是不
php使用ElasticSearch
小坚的技术博客
03-08 2233
Elasticsearch 是一个分布式的、开源的搜索分析引擎，支持各种数据类型，包括文本、数字、地理、结构化、非结构化。
elasticsearch pipelineI详解：原理与使用
码到三十五
06-22 1万+
在Elasticsearch的数据处理流程中，Pipeline API为数据的预处理和转换提供了强大的工具。随着Elasticsearch 5.x版本之后Ingest Node的引入，Pipeline API的引入为开发者们提供了更多的灵活性和便利性。本文将对Pipeline API的原理、具体使用方法及其在实际场景中的应用进行更加详细的探讨。
springboot集成ElasticSearch使用completion实现补全功能
刘大猫
04-19 2711
说明：使用RestHighLevelClient 实现输入框补全功能 springboot代码 kibana代码 springboot代码 依赖 <!--ES--> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> &lt
java使用elasticsearch分组进行聚合查询过程解析
08-25
在 Java 中，我们可以使用 Elasticsearch 的 Java 客户端来实现对 Elasticsearch 的操作。Elasticsearch 的 Java 客户端提供了多种方式来连接 Elasticsearch，例如使用 TransportClient 或者使用 RESTful API。 在...
elasticsearch7.17.10-最新支持Java1.8版本
06-19
2. **倒排索引**：Elasticsearch使用倒排索引机制进行快速的全文搜索，将每个词项指向包含该词的文档集合，而不是将每个文档指向其包含的词项，大大提升了搜索效率。 3. **RESTful API**：Elasticsearch采用HTTP和...
Elasticsearch介绍及使用教程.docx
01-02
Elasticsearch 介绍及使用教程 Elasticsearch 是一个开源的高扩展的分布式全文检索引擎，可以近乎实时的存储、检索数据。本文将介绍 Elasticsearch 的核心概念、与关系型数据库的对比、应用场景，并提供实用的安装...
CentOS7 安装 git 命令
弘毅_hao的博客
07-10 461
centos7 安装 最新版 git 命令
【ElasticSearch】ES 5.6.15 向量插件支持
qq_20623849的博客
07-10 421
低版本ES 向量插件支持
链接追踪系列-00.es设置日志保存7天-番外篇
最新发布
suanhengzi的博客
07-13 258
ELK日志我们一般都是按天存储，例如索引名为"zipkin-span-2023-03-24"，因为日志量所占的存储是非常大的，我们不能一直保存，而是要定期清理旧的，这里就以保留7天日志为例。自动清理7天以前的日志可以用定时任务的方式，这样就需要加入多一个定时任务，可能不同服务记录的索引名又不一样，这样用定时任务配还是没那么方便。说明：创建索引模板(elk_template)，index.lifecycle.name把上面的自动删除策略绑定到elk索引模板。delete：删除阶段，7天执行删除索引动作。
昇思25天学习打卡营第6天|函数式自动微分
wwt72的博客
07-09 1292
通常将函数的loss设置为函数的第一个输出，其他的输出即为辅助数据。如下代码中，mindspore.grad 的求导索引为 (2, 3)，表示 function1 函数的参数 w 和 b。损失函数（代价函数）是用来衡量模型预测值与真实值之间差异的函数，不同的损失函数适用于不同类型的问题。，通过调用 mindspore.grad 函数，生成求导函数，用于计算给定函数的梯度或微分函数。> 使用 grad 获得微分函数是一种函数变换，即输入为函数，输出也为函数。为了优化模型参数，需要求参数对loss的导数，即。
01 - Elasticsearch 简单而高效的管道查询语言 - 刘晓国 重庆 2024.4.27
04-29
Elasticsearch 管道查询语言 (ES|QL) 是一种简单而高效的语言，专为在 Elasticsearch 中管理和处理数据而设计。它被开发为一个现代管道语言，旨在促进数据探索的效率和灵活性。ES|QL 支持复杂的查询流程，通过将一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

林中山野

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

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

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

打赏作者

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

抵扣说明：

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

余额充值