es时间段查询

已于 2022-01-26 16:27:07 修改
阅读量7.1k 收藏 1
点赞数 2
文章标签： elasticsearch 大数据 big data
于 2022-01-26 16:24:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42053840/article/details/122704217
版权

下面展示一些 内联代码片。

es时间段查询

记录一下学习es的艰辛之旅

刚接触es 的时候，就来个需求dsl都不会写，直接硬上，结果就是第一段这种情况，先查范围再分割，蠢方法还觉得写的分割算法很厉害，结果过了半年再看直接es自带方法，虽然是es5，没那么多花里胡哨的方法，但是够用上，321上链接（时间段的起止可以用hutool工具包，更加方便一点，虽然但是能用就行）

  /**
     * 24小时HTTP请求方式
     *
     * @param params
     * @return
     */
    @Override
    public JSONObject findApiLogByThourHttp(JSONObject params) {
        JSONObject result = new JSONObject();
        try {
            JSONObject ap = new JSONObject();
            List<String> hintList = new ArrayList<String>();
            //参数校验
//            if (StringUtils.isBlank(params.getString("start_time"))) {
//                hintList.add("start_time");
//            }
            if (StringUtils.isBlank(params.getString("time_range"))) {
                hintList.add("time_range");
            }
            if (!hintList.isEmpty()) {
                result.put("code", ResponseCode.C0001);
                result.put("keyword", org.apache.commons.lang3.StringUtils.join(hintList));
                return result;
            }
            List<InvokeModel> list = new ArrayList<>();
            long current = System.currentTimeMillis();
            long zero1 = current / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();
            long zero = getStartTimeOfDay();
            long twelve = zero + 24 * 60 * 60 * 1000 - 1;//今天23点59分59秒的毫秒数
            long l = System.currentTimeMillis() - System.currentTimeMillis() % 3600000;
            //long onehour = current - 24 * 60 * 60 * 1000 - 1;
            long onehour;
            long jgtime = 0;
            String ttnum = params.getString("time_range");
            switch (ttnum) {
                case "1":
                    onehour = current - 1 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 1000;
                    break;
                case "24":
                    onehour = current - 24 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 60 * 1000;
                    break;
                case "7":
                    onehour = zero - 7 * 24 * 60 * 60 * 1000 ;
                    current=twelve;
                    jgtime=24 * 60 * 60 * 1000;
                    break;
                case "30":
                   /* Calendar now = Calendar.getInstance();
                    Date nowtime = new Date();
                    now.setTime(nowtime);         //塞入当前日期
                    now.set(Calendar.HOUR_OF_DAY, 0);   //将时分秒设置成0，便于格式获取，若格式的为yyyy-MM-dd则不需要
                    now.set(Calendar.MINUTE, 0);
                    now.set(Calendar.SECOND, 0);
                    now.add(Calendar.MONTH, -1);
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
                    Date date = simpleDateFormat.parse(String.valueOf(now.getTime()));
                    onehour = date.getTime() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();*/
//                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//                    sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
                    Date date =new Date();
                    date.setTime(zero);
                    Calendar now = Calendar.getInstance();
                    now.setTime(date);         //塞入当前日期
                    now.add(Calendar.MONTH, -1);
                    onehour = now.getTimeInMillis();
                    current=twelve;
                    jgtime=24 * 60 * 60 * 1000;
                    break;
                default:
                    onehour = current - 1 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 1000;
                    break;

            }
            //    System.out.println("zerooo"+zero+"twwlwllw"+twelve);
            long time = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).parse("2021-05-07 20:00:00", new ParsePosition(0)).getTime() / 1000;

            // 闭区间//1小时范围内
            QueryBuilder qb1 = QueryBuilders.rangeQuery("start_time").gte(onehour).lte(current);
            //  .includeLower(true)     // 包含上界
            //.includeUpper(true);      // 包含下届
            // 大于//成功的
            // QueryBuilder qb2 = QueryBuilders.rangeQuery("id").gt(1);w
            // 过滤多条件
            QueryBuilder qb;
            if (params.get("service_id") != null && params.get("service_id") != "") {
                QueryBuilder qb3 = QueryBuilders.termQuery("service_id.keyword", params.get("service_id"));
                // 单个字符串//状态是成功的
                if (params.get("status") != null && params.get("status") != "") {
                    // 单个字符串//状态是成功的
                    QueryBuilder qb0 = QueryBuilders.termQuery("status", params.get("status"));
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb0).must(qb3);
                } else {
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb3);
                }
            } else {
                if (params.get("status") != null && params.get("status") != "") {
                    // 单个字符串//状态是成功的
                    QueryBuilder qb0 = QueryBuilders.termQuery("status", params.get("status"));
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb0);
                } else {
                    qb = QueryBuilders.boolQuery().must(qb1);
                }
            }
            JSONObject json = new JSONObject();
            json.put("query",JSON.parseObject(qb.toString()));
            json.put("size",10000);
            JSONArray jsonArray=new JSONArray();
            JSONObject jobj=new JSONObject();
            jobj.put("start_time","desc");
            jsonArray.add(jobj);
            json.put("sort",jsonArray);
            Map<String, String> map = RestLowEsHttpUtil.RestLowEsHttpUtil(this.getHost(),json.toString(),"POST",database+"/ds_invoke");
            if("-1".equals(map.get("code"))){
                result.put("code", ResponseCode.FAILED);
                return result;
            }
            JSONObject dataObject = JSON.parseObject(map.get("data"));
            JSONObject hitsObject = (JSONObject) dataObject.get("hits");
            JSONArray hitsListArray = (JSONArray) hitsObject.get("hits");
            List<InvokeModel> invokeModelList =  new ArrayList<>();
            for(int i=0;i<hitsListArray.size();i++) {
                JSONObject sourceObject = (JSONObject) hitsListArray.getJSONObject(i).get("_source");
                InvokeModel invokeModel = JSON.toJavaObject(sourceObject,InvokeModel.class);
                invokeModelList.add(invokeModel);
            }
//            System.out.println(invokeModelList);
            int total = (Integer) hitsObject.get("total");
//            System.out.println(dataObject);
            if (invokeModelList.size() != 0) {
                JSONObject timedun = new JSONObject();
                long finalJgtime = jgtime;
                long finalCurrent = current;
                invokeModelList.stream().flatMap(e -> {
                    for (long i = onehour; i < finalCurrent; i += finalJgtime) {
                        int j = 0;
                        if (e.getStart_time() > i && e.getStart_time() < i + finalJgtime) {
                            j++;
                        }
                        if (j > 0) {
                            if ((timedun.get(stampToDate(String.valueOf(i))) != null) && (int) timedun.get(stampToDate(String.valueOf(i))) > 0) {
                                timedun.put(stampToDate(String.valueOf(i)), (int) timedun.get(stampToDate(String.valueOf(i))) + 1);
                            } else {
                                timedun.put(stampToDate(String.valueOf(i)), j);
                            }
                        }
                    }
                    return null;
                }).collect(Collectors.toList());
                ap.put("timedun", timedun);
            }
            ap.put("count", total);
            //ap.put("list", list);
            result.put("data", ap);
            result.put("code", ResponseCode.OK);
        } catch (Exception e) {
            logger.error("es add err...\n", e);
            result.put("code", ResponseCode.FAILED);
        }
        return result;
    }


    /**
     * 曲线次数
     *
     * @param params
     * @return
     */
    public JSONObject findApiLogByThourHttpNew(JSONObject params) {
        JSONObject result = new JSONObject();
        try {
            JSONObject ap = new JSONObject();
            List<String> hintList = new ArrayList<String>();
            if (StringUtils.isBlank(params.getString("time_range"))) {
                hintList.add("time_range");
            }
            if (!hintList.isEmpty()) {
                result.put("code", ResponseCode.C0001);
                result.put("keyword", org.apache.commons.lang3.StringUtils.join(hintList));
                return result;
            }

//            String now = DateUtil.now();
//            long nowCurrent=DateUtil.currentSeconds();
//
//            DateUtil.offsetMinute(Date date, int offset)



            List<InvokeModel> list = new ArrayList<>();
            long current = System.currentTimeMillis();
            long zero1 = current / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();
            long zero = getStartTimeOfDay();
            long twelve = zero + 24 * 60 * 60 * 1000 - 1;//今天23点59分59秒的毫秒数
            long l = System.currentTimeMillis() - System.currentTimeMillis() % 3600000;
            //long onehour = current - 24 * 60 * 60 * 1000 - 1;
            long onehour;
            long jgtime = 0;
            String ttnum = params.getString("time_range");
            switch (ttnum) {
                case "1":
                    onehour = current - 1 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 1000;
                    break;
                case "24":
                    onehour = current - 24 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 60 * 1000;
                    break;
                case "7":
                    onehour = zero - 7 * 24 * 60 * 60 * 1000 ;
                    current=twelve;
                    jgtime=24 * 60 * 60 * 1000;
                    break;
                case "30":
                   /* Calendar now = Calendar.getInstance();
                    Date nowtime = new Date();
                    now.setTime(nowtime);         //塞入当前日期
                    now.set(Calendar.HOUR_OF_DAY, 0);   //将时分秒设置成0，便于格式获取，若格式的为yyyy-MM-dd则不需要
                    now.set(Calendar.MINUTE, 0);
                    now.set(Calendar.SECOND, 0);
                    now.add(Calendar.MONTH, -1);
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
                    Date date = simpleDateFormat.parse(String.valueOf(now.getTime()));
                    onehour = date.getTime() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();*/
//                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//                    sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
                    Date date =new Date();
                    date.setTime(zero);
                    Calendar now = Calendar.getInstance();
                    now.setTime(date);         //塞入当前日期
                    now.add(Calendar.MONTH, -1);
                    onehour = now.getTimeInMillis();
                    current=twelve;
                    jgtime=24 * 60 * 60 * 1000;
                    break;
                default:
                    onehour = current - 1 * 60 * 60 * 1000 - 1;
                    jgtime=60 * 1000;
                    break;

            }
            //    System.out.println("zerooo"+zero+"twwlwllw"+twelve);
            long time = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).parse("2021-05-07 20:00:00", new ParsePosition(0)).getTime() / 1000;

            // 闭区间//1小时范围内
            QueryBuilder qb1 = QueryBuilders.rangeQuery("start_time").gte(onehour).lte(current);
            //  .includeLower(true)     // 包含上界
            //.includeUpper(true);      // 包含下届
            // 大于//成功的
            // QueryBuilder qb2 = QueryBuilders.rangeQuery("id").gt(1);w
            // 过滤多条件
            QueryBuilder qb;
            if (params.get("service_id") != null && params.get("service_id") != "") {
                QueryBuilder qb3 = QueryBuilders.termQuery("service_id.keyword", params.get("service_id"));
                // 单个字符串//状态是成功的
                if (params.get("status") != null && params.get("status") != "") {
                    // 单个字符串//状态是成功的
                    QueryBuilder qb0 = QueryBuilders.termQuery("status", params.get("status"));
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb0).must(qb3);
                } else {
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb3);
                }
            } else {
                if (params.get("status") != null && params.get("status") != "") {
                    // 单个字符串//状态是成功的
                    QueryBuilder qb0 = QueryBuilders.termQuery("status", params.get("status"));
                    qb = QueryBuilders.boolQuery().must(qb1).must(qb0);
                } else {
                    qb = QueryBuilders.boolQuery().must(qb1);
                }
            }
            AggregationBuilder agg ;
            switch (ttnum) {
                case "1":
                     agg =  AggregationBuilders.dateHistogram("groupDate").field("start_time").dateHistogramInterval(DateHistogramInterval.MINUTE).offset("-8h");
                    break;
                case "24":
                     agg =  AggregationBuilders.dateHistogram("groupDate").field("start_time").dateHistogramInterval(DateHistogramInterval.HOUR).offset("-8h");
                    break;
                case "7":
                     agg =  AggregationBuilders.dateHistogram("groupDate").field("start_time").dateHistogramInterval(DateHistogramInterval.DAY).offset("-8h");
                    break;
                case "30":
                     agg =  AggregationBuilders.dateHistogram("groupDate").field("start_time").dateHistogramInterval(DateHistogramInterval.DAY).offset("-8h");
                    break;
                default:
                     agg =  AggregationBuilders.dateHistogram("groupDate").field("start_time").dateHistogramInterval(DateHistogramInterval.DAY).offset("-8h");

            }
            JSONObject aggjson=JSONObject.parseObject(agg.toString());
            String dsl1=aggjson.toString();
            aggjson.getJSONObject("groupDate").getJSONObject("date_histogram").remove("order");

//            JSONObject json = new JSONObject();
//            json.put("query",JSON.parseObject(qb.toString()));
//            json.put("size",10000);
//            JSONArray jsonArray=new JSONArray();
//            JSONObject jobj=new JSONObject();
//            jobj.put("start_time","desc");
//            jsonArray.add(jobj);
//            json.put("sort",jsonArray);

            JSONObject json = new JSONObject();
            json.put("query", JSON.parseObject(qb.toString()));
            json.put("size", "0");
            json.put("aggs",aggjson);
            String dsl=json.toString();
            Map<String, String> map = RestLowEsHttpUtil.RestLowEsHttpUtil(this.getHost(),dsl,"POST",database+"/ds_invoke");
            if("-1".equals(map.get("code"))){
                result.put("code", ResponseCode.FAILED);
                return result;
            }
            JSONObject dataObject = JSON.parseObject(map.get("data"));
            JSONObject hitsObject = dataObject.getJSONObject("aggregations").getJSONObject("groupDate");

            JSONArray buckets = hitsObject.getJSONArray("buckets");
            int total = (Integer) dataObject.getJSONObject("hits").get("total");
            JSONObject timedun = new JSONObject();
            buckets.stream().forEach(e->{
                JSONObject obj = (JSONObject) e;
                timedun.put(stampToDate(obj.getString("key")), obj.getIntValue("doc_count"));
            });
            ap.put("timedun", timedun);
            ap.put("count", total);
            //ap.put("list", list);
            result.put("data", ap);
            result.put("code", ResponseCode.OK);
        } catch (Exception e) {
            logger.error("es add err...\n", e);
            result.put("code", ResponseCode.FAILED);
        }
        return result;
    }

上dsl语句

{
    "size": "0",
    "query": {
        "bool": {
            "adjust_pure_negative": true,
            "must": [
                {
                    "range": {
                        "start_time": {
                            "include_lower": true,
                            "include_upper": true,
                            "from": 1642521600000,
                            "boost": 1,
                            "to": 1643212799999
                        }
                    }
                },
                {
                    "term": {
                        "status": {
                            "boost": 1,
                            "value": "false"
                        }
                    }
                }
            ],
            "boost": 1
        }
    },
    "aggs": {
        "groupDate": {
            "date_histogram": {
                "field": "start_time",
                "offset": -28800000,
                "interval": "1d",
                "keyed": false,
                "min_doc_count": 0
            }
        }
    }
}

如果对你有用，有帮助的话，点个赞再走吧

来杯冰可乐丶
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Elasticsearch（ES）多条件（日期，时段，时分，mac。。）过滤实现案例(6.3版本)
06-21
Elasticsearch（ES）多条件过滤实现案例(6.3版本), 搜索过滤，对日期进行时分秒区间判断，多条件整合优化
l3rt：ElasticSearch监视警报
02-02
L3rt 简单的警报应用程序。 它受到elastalert和Jenkins管道的启发。 目的是为用户提供更复杂的规则系统。 为什么选择l3rt？ 零依赖性。 无需其他数据库。 基础架构即代码友好。 将规则作为常规文件管理 规则配置的无限灵活性 内置的Web UI游乐场 要求功能 当前，l3rt支持以下来源作为输入： 弹性搜索 支持的输出： 想念你的吗？ 添加或提交拉取请求 支持的规则： ElasticSearch： -返回与匹配的消息 ElasticSearch：-由ElasticSearch的search查询完全管理的自由格式规则 ElasticSearch：-返回给定时间段（或多个时间段）内发生的事件数 想念你的吗？ 添加或提交拉取请求 用户界面 您可以使用Web UI创建和调试规则。 只需启动L3rt并转到 如何使用 创建一个配置文件，您需要在其中为所有规则指定通用配置： { " sources " : [ { " url " : " elasticSearch:http://localhost:9200 " } ], " targetSett
Elasticsearch-查询DSL
兴趣是最好的老师
04-28 364
9) 范围查询 range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符 在Postman中，向ES服务器发GET请求：http://127.0.0.1:9200/student/_search 用student索引报错，还是改成自己新建的zhou索引 { "took": 17, "timed_out": false, "_shards": { "total": 1, "successful": 1,
Elasticsearch 查询全部数据，按照时间区间查询数据
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
11-08 4066
在项目开发过程中需要从Elasticsearch中查询日志数据，下面介绍从Elasticsearch中查询索引全部数据，以及按照时间区间查询索引数据。
Elasticsearch 时区(time_zone)记录
Richar1的专栏
12-21 2万+
elasticsearch 默认是以utc时间存储的，现在我创建了两个索引，分别用存储了utc格式 和localtime格式的时间 使用百度echarts折线图展现对transaction_time聚合的结果 图一是对localtime聚合的结果， 图二是对utc时间聚合的结果， 可以看出，在使用es直方图进行聚合的时候，无论存储的的是localtime 还是utc，都会被转换成utc的
Elasticsearch 时间范围查询
Code_LT的博客
07-27 6555
2018-10-01的毫秒值 + 1月, 再四舍五入到最近一天的起始, 结果是: 2018-11-01 00:00:00。: now的毫秒值 - 1小时, 然后四舍五入到最近的一天的起始, 结果是: 2018-10-01 00:00:00.③ “lt”: “2014-11-18||/M” —— 小于日期, 需要向上舍入, 结果是。: now的毫秒值 + 1小时, 结果是: 2018-10-01 13:00:00.: now的毫秒值 - 1小时, 结果是: 2018-10-01 11:00:00.
Elasticsearch中如何进行日期(数值)范围查询总结
qq_44810785的博客
08-03 1万+
踩遍所有烂坑的我又来总结了····哎····希望帮到有缘人吧··基本的用法我套用的网上大部分人的，自己踩出来的坑字体用颜色区分了，你懂吧。
ES根据日期查询数据
oIMcoin的博客
11-21 1万+
ES根据日期查询数据
1.es学习-查询
xiaobai_july的博客
01-18 3604
简单的es语句，sql语句转es语句。
Elasticsearch根据日期(年-月-日 时:分:秒)进行range(时间范围筛选)
热门推荐
weixin_36270623的博客
12-04 2万+
不知不觉要写第二篇文章了 接着第一篇文章，es实现like复合查询，里面案例有用到通过时间(年-月-日 时:分:秒)进行筛选的， 在这里说下如果通过时间筛选需要对index进行mapping设置滴，不然不行的 首先，创建一个索引index PUT /index 好勒，创建好索引了，接下来开始对索引进行mapping设置，相当于定义数据库表字段，不过不用担心设置了多余的mapping字段，没关系...
Python提取特定时间段内数据的方法实例
12-25
python提取特定时间段内的数据 尝试一下： data['Date'] = pd.to_datetime(data['Date']) data = data[(data['Date'] >=pd.to_datetime('20120701')) & (data['Date'] <= pd.to_datetime('20120831'))] 实际测试...
python 实现提取某个索引中某个时间段的数据方法
12-31
如下所示： from elasticsearch import Elasticsearch import datetime ... es = Elasticsearch() return es def get_data(self, day,start,end): index_ = gather-apk-20180330 query_dsl = { size: 100
Elasticsearch（ES）多条件（日期，时段，时分，mac。。）过滤实现案例(2.3.3版本)
06-21
Elasticsearch（ES）多条件过滤实现案例(2.3.3版本)，POST代码，查询过滤，多种条件。
ElasticSearch 入门学习
灰熊
04-23 817
ElasticsSearch 是一个分布式的实时文档存储，每个字段可以被索引与搜索也是一个分布式实时分析搜索引擎也是一个能胜任上百个服务节点的扩展，并支持 PB 级别的结构化或者非结构化数据。
Elasticsearch 开放 inference API 增加了对 OpenAI chat completions 的支持
Elastic 中国社区官方博客
04-21 1896
我们很高兴地宣布在 Elasticsearch 中推出的最新创新：在 Elastic 的中集成了 OpenAI Chat Completions 功能。这一新特性标志着我们在整合尖端人工智能能力至 Elasticsearch 的旅程中又迈出了一步，提供了生成类人文本完成等更多易于使用的功能。更多关于 OpenAI Chat Completions 的用法，请阅读文章 “
分布式版本控制工具 Git 的使用方式
学而不思则罔,思而不学则殆
04-24 1203
Git是一款免费的开源分布式版本控制系统，旨在快速高效地处理从小型到超大型项目的所有项目。它可以追踪文件的更改，并能多人协同开发。代码备份版本控制多人协作权限控制。
Elasticsearch进阶篇(三)：ik分词器的使用与项目应用
后端开发
04-21 972
本文详细介绍了在Elasticsearch中安装、配置和使用IK分词器的过程。首先，它提供了两种安装方式：使用已编译的包文件或者源代码编译。然后，说明了如何将分词器安装到Elasticsearch中，并启动Elasticsearch来验证安装是否成功。接下来，介绍了IK分词器提供的两种主要分词模式：细粒度分词模式（ik_max_word）和智能分词模式（ik_smart），并展示了它们的使用示例。最后，它详细解释了IK分词器的配置文件作用，包括主要的配置文件和自定义词库的使用方法，并提供了相关的参考链接
Oracle Analytics BIEE 操作方法（六）数据格式1：百分比
最新发布
ky0921的博客
04-25 376
有如下公式，将数据显示为按行的百分比。此时数据显示只会有一位小数。
Elasticsearch 索引数据多了，调优，部署方案
weixin_40587144的博客
04-24 385
Elasticsearch 索引数据多了，调优，部署方案
Elasticsearch 时间段查询
03-02
在Elasticsearch中，可以使用时间段查询来检索指定时间范围内的数据。 时间段查询可以通过使用Range Query（范围查询）来实现。具体步骤如下： 1. 创建索引：首先，你需要在Elasticsearch中创建一个索引，并将数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值