mongoDB聚合函数

已于 2023-05-16 11:12:39 修改
阅读量767 收藏 1
点赞数
分类专栏： MongoDB 文章标签： mongodb 数据库 database
于 2022-05-27 16:59:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Best_Lynn/article/details/125007333
版权
  1. 简单的分组
// 原生写法
db.deviceDataCollection.aggregate([
    {
        $match: {
            "tenantId": "1475652926985990144",
            "ts": {
                $gt: ISODate("2022-09-15T03:39:36Z")
            },
            "statusData": {
                "$ne": null,
                "$exists": true
            }
        }
    },
    {
        $sort: {
            "ts": - 1
        }
    },
    {
        $group: {
            _id:
			"$deviceId",
            ts: 
            {
                "$first": "$ts"
            }
        }
    },
    {
        $match: {
            "deviceId": "1"
        }
    },
    {
        $limit: 10
    }
])

		// java mongoTemplate
		Criteria criteria1 = new Criteria();
		Criteria criteria2 = new Criteria();
		
		Date endDate = new Date();
		Date startDate = new Date(endDate.getTime() - 24 * TIME_ONE_HOUR);
		criteria1.and("ts").gt(startDate).lt(endDate);
		criteria1.and("statusData").exists(true);
		criteria2.and("statusData.online").is("1");
		
		Aggregation agg = Aggregation.newAggregation(
		    Aggregation.match(criteria1),
		    Aggregation.sort(Sort.Direction.DESC, "ts"),
		    Aggregation.group("deviceId")
		        .first("_id").as("id")
		        .first("deviceId").as("deviceId")
		        .first("ts").as("ts")
		        .first("deviceManufacture").as("deviceManufacture")
		        .first("statusData").as("statusData"),
		    Aggregation.match(criteria2),
		    new SkipOperation((pageNum - 1) * pageSize),
		    Aggregation.limit(pageSize)
		);
		AggregationResults<DeviceDataEntity> aggregationResults = mongoTemplate.aggregate(agg, DEFAULT_COLLECTION_NAME, DeviceDataEntity.class);
		List<DeviceDataEntity> mappedResults = aggregationResults.getMappedResults();
  1. 对时间分组后并统计
// 原生写法
db.deviceDataCollection_1452589816758669312.aggregate([
    {
        $match: {
            "deviceId": "84fd27fffe71b688",
            "huatuoDeviceData.commandType": "Data",
            "huatuoDeviceData.sleepBandInfo.status": NumberInt("0"),
            "ts": {
                $gt: ISODate("2022-09-15T03:39:36Z"),
                $lt: ISODate("2022-09-15T03:39:36Z")
            }
        }
    },
    {
        $project: {
            date: {
                $dateToString: {
                    format: '%Y-%m-%d %H:%M',
                    date: '$ts',
                    timezone: "+08:00"
                }
            }
        }
    },
    {
        $group: {
            _id: 
            "$date",
            count: {
            // 1表示 出现一次 统计1次
                $sum: 1
            }
        }
    },
    {
        $match: {
            "count": {
                $gte: 10
            }
        }
    }
])

		// java mongodbTemplate
		String patternType = "%Y-%m-%d %H:%M";

        Criteria criteria1 = new Criteria();
        Criteria criteria2 = new Criteria();

        criteria1.and("deviceId").is(deviceId);
        criteria1.and("huatuoDeviceData.sleepBandInfo.status").is(0);
        criteria2.and("count").gte(10);

        Date startDate = string2Date(startTime, LocalDateTimeUtils.YYYY_MM_DD_HH_MM_SS);
        Date endDate = string2Date(endTime, LocalDateTimeUtils.YYYY_MM_DD_HH_MM_SS);
        if (startDate != null && endDate != null) {
            criteria1.and("ts").gte(startDate).lte(endDate);
        }

        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria1),
                Aggregation.project("ts")
                        .and(DateOperators.DateToString.dateOf("ts").toString(patternType)).as("date"),
                Aggregation.group("date").count().as("count"),
                Aggregation.match(criteria2)
        );

        AggregationResults<DeviceDataEntity> aggregationResults =
                mongoTemplate.aggregate(agg, getCollectionName(tenantId), DeviceDataEntity.class);
        return aggregationResults.getMappedResults().size();

2.1. 分组后 结果是list 再聚合

db.getCollection("deviceDataCollection_1481152175999807489").aggregate([
    {
        "$match": {
            "deviceId": "JPUS000407",
            "commonDeviceData.extraCode": "291",
            "commonDeviceData.commonDeviceExtraData.status": "5",
            "commonDeviceData.commonDeviceExtraData.snoreTimes": {
                "$ne": 0
            },
            "ts": {
                "$gte": ISODate("2022-09-21T12:00:07Z"),
                "$lte": ISODate("2022-09-22T00:00:07Z")
            }
        }
    },
    {
        "$group": {
            "_id": {
                $dateToString: {
                    format: '%Y-%m-%d %H:%M:%S',
                    date: '$commonDeviceData.eventTime'
                }
            },
            "snore": {
                "$push": "$commonDeviceData.commonDeviceExtraData.snoreTimes"
            }
        }
    }
])

在这里插入图片描述
用 $push 结果会是list 无法统计 所以要给一个策略 取list里的哪一条

db.getCollection("deviceDataCollection_1481152175999807489").aggregate([
    {
        "$match": {
            "deviceId": "JPUS000407",
            "commonDeviceData.extraCode": "291",
            "commonDeviceData.commonDeviceExtraData.snoreTimes": {
                "$ne": 0
            },
            "ts": {
                "$gte": ISODate("2022-09-21T12:00:07Z"),
                "$lte": ISODate("2022-09-22T00:00:07Z")
            }
        }
    },
    {
        "$project": {
            date: {
                $dateToString: {
                    format: '%Y-%m-%d %H:%M:%S',
                    date: '$ts'
                }
            },
            "snore": 
            "$commonDeviceData.commonDeviceExtraData.snoreTimes",
            "deviceId": "$deviceId"
        }
    },
    {
        "$group": {
            "_id": "$date"
            ,
            "snore": {
                "$first": "$snore"
            },
            "deviceId": {
                "$first": "$deviceId"
            }
        }
    },
    {
        "$group": {
            "_id": "$deviceId",
            count: {
                "$sum": "$snore"
            }
        }
    }
])

用$first 取每组第一条 , 得到list, 再根据一个deviceId(相同的字段) 将list聚合成一条.

String patternType = "%Y-%m-%d %H:%M:%S";
        Criteria snoreCriteria = new Criteria();
        snoreCriteria.and("deviceId").is(deviceId);
        snoreCriteria.and("commonDeviceData.extraCode").is("291");
        if (startDate != null && endDate != null) {
            snoreCriteria.and("ts").gte(startDate).lte(endDate);
        }
        snoreCriteria.and("commonDeviceData.commonDeviceExtraData.snoreTimes").ne(0);
        Aggregation snoreAgg = Aggregation.newAggregation(
                Aggregation.match(snoreCriteria),
                Aggregation.project("commonDeviceData.eventTime", "commonDeviceData.commonDeviceExtraData.snoreTimes", "deviceId")
                        .and(DateOperators.DateToString.dateOf("ts").toString(patternType)).as("date")
                        .and("commonDeviceData.commonDeviceExtraData.snoreTimes").as("snore")
                        .and("deviceId").as("deviceId"),
                Aggregation.group("date")
                        .first("snore").as("snore")
                        .first("deviceId").as("deviceId"),
                Aggregation.group("deviceId")
                        .sum("snore").as("count")
        );
        AggregationResults<SleepDataEntity> snoreAggregationResults =
                mongoTemplate.aggregate(snoreAgg, getCollectionName(tenantId), SleepDataEntity.class);
        }

2.2 按半小时为一组,聚合数据

db.deviceDataCollection_1544241345868197888.aggregate([{
    $match: {
        "deviceId": "84fd27fffe7a277f",
        "$or": [{
            "commonDeviceData.commonDeviceExtraData.heartRate": {
                "$ne": "0"
            },
            "commonDeviceData.commonDeviceExtraData.status": {
                "$ne": "1"
            }
        }, {
            "commonDeviceData.commonDeviceExtraData.status": "1"
        }],
        "ts": {
            "$gte": ISODate("2023-02-22T12:00:00Z"),
            "$lte": ISODate("2023-02-23T23:59:59Z")
        }
    }
}, {
    $project: {
        "date": {
            "$subtract": [
                
                {
                    "$subtract": ["$ts", new Date("1970-01-01")]
                },
                {
                    "$mod": [
                        
                        {
                            "$subtract": ["$ts", new Date("1970-01-01")]
                        },
                        1000 * 60 * 30
                    ]
                }
            ]
        },
        "status": "$commonDeviceData.commonDeviceExtraData.status",
        "heartRate": {
            "$convert": {
                "input": "$commonDeviceData.commonDeviceExtraData.heartRate",
                "to": "int",
                "onError": 0,
                "onNull": 0
            }
        },
        "respiratoryRate": {
            "$convert": {
                "input": "$commonDeviceData.commonDeviceExtraData.respiratoryRate",
                "to": "int",
                "onError": 0,
                "onNull": 0
            }
        }
    }
}, {
    $group: {
        "_id": "$date",
        "heartRateAvg": {
            "$avg": "$heartRate"
        },
        "breathAvg": {
            "$avg": "$respiratoryRate"
        },
        "status": {
            "$last": "$status"
        },
        "date": {
            "$last": "$date"
        }
    }
}, {
    $project: {
        "date": {
            "$add": [ISODate("1970-01-01T00:00:00Z"), "$date"]
        },
        "heartRateAvg": 1,
        "breathAvg": 1,
        "status": 1
    }
}])

Aggregation agg = Aggregation.newAggregation(
        Aggregation.match(criteria),
        Aggregation.project()
                // 按半小时聚合，每半个小时聚合一条
                .andExpression("{$subtract:{{$subtract:{'$ts',new java.util.Date(0L)}},{$mod:{{$subtract: {'$ts',new java.util.Date(0L)}},1000 * 60 * 30}}}}").as("date")
                .and("commonDeviceData.commonDeviceExtraData.status").as("status")
                .and(ConvertOperators.Convert.convertValueOf("commonDeviceData.commonDeviceExtraData.heartRate")
                        .to("int")
                        .onErrorReturn(0)
                        .onNullReturn(0))
                .as("heartRate")
                .and(ConvertOperators.Convert.convertValueOf("commonDeviceData.commonDeviceExtraData.respiratoryRate")
                        .to("int")
                        .onErrorReturn(0)
                        .onNullReturn(0))
                .as("respiratoryRate"),
        Aggregation.group("date")
                .avg("heartRate").as("heartRateAvg")
                .avg("respiratoryRate").as("breathAvg")
                .last("status").as("status")
                .last("date").as("date"),
        Aggregation.project()
                .andExpression("{$add:{new java.util.Date(0L),'$date'}}").as("date")
                .and("heartRateAvg").as("heartRateAvg")
                .and("breathAvg").as("breathAvg")
                .and("status").as("status")
).withOptions(allowDiskOptions);
  1. 求平均
// 原生写法
db.deviceDataCollection_1452589816758669312.aggregate([
    {
        $match: {
            "deviceId": "84fd27fffe71b688",
            "huatuoDeviceData.sleepBandInfo.status": NumberInt("0"),
            "ts": {
                $gt: ISODate("2022-09-15T03:39:36Z"),
                $lt: ISODate("2022-09-15T03:39:36Z")
            }
        }
    },
    {
        $group: {
            _id: 
            '$deviceId',
            breathAvg: {
                $avg: "$huatuoDeviceData.sleepBandInfo.breathingRate"
            },
            heartRateAvg: {
                $avg: "$huatuoDeviceData.sleepBandInfo.heartRate"
            }
        }
    }
])

		// java template
		Criteria criteria = new Criteria();

        criteria.and("deviceId").is(deviceId);
        criteria.and("huatuoDeviceData.sleepBandInfo.status").is(0);
        Date startDate = string2Date(startTime, LocalDateTimeUtils.YYYY_MM_DD_HH_MM_SS);
        Date endDate = string2Date(endTime, LocalDateTimeUtils.YYYY_MM_DD_HH_MM_SS);
        if (startDate != null && endDate != null) {
            criteria.and("ts").gte(startDate).lte(endDate);
        }

        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria),
                // 这里的group字段无所谓
                // avg as 的字段名要和实体对应上
                Aggregation.group("deviceId")
                    .avg("huatuoDeviceData.sleepBandInfo.breathingRate").as("breathAvg")
                    .avg("huatuoDeviceData.sleepBandInfo.heartRate").as("heartRateAvg")
        );

        AggregationResults<SleepDataEntity> aggregationResults =
                mongoTemplate.aggregate(agg, getCollectionName(tenantId), SleepDataEntity.class);
        if (!CollectionUtils.isEmpty(aggregationResults.getMappedResults())){
            return aggregationResults.getMappedResults().get(0);
        }
        return null;

4.字段为字符串 处理后求平均

db.deviceDataCollection_1475652926985990144.aggregate([
    {
        $match: {
            "_id": ObjectId("63229e80dea96d55a66a0d47")
        }
    },
    {
        $project: {
            groupId: {
                $convert: {
                    input: "$deviceId",
                    to: "string"
                }
            },
            heartRate: {
                $convert: {
                    input: "$commonDeviceData.commonDeviceExtraData.heartRate",
                    to: "int"
                }
            }
        }
    },
    {
        $group: {
            _id: 
            "$groupId",
            avghr: {
                $avg: "$heartRate"
            }
        }
    }
])

Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria),
                Aggregation.project()
                        .and("deviceId").as("groupId")
                        .and(ConvertOperators.Convert.convertValueOf("commonDeviceExtraData.respiratoryRate").to("int").onErrorReturn(0).onNullReturn(0)).as("breathRate")
                        .and(ConvertOperators.Convert.convertValueOf("commonDeviceExtraData.heartRate").to("int").onErrorReturn(0).onNullReturn(0)).as("heartRate"),
                Aggregation.group("groupId")
                        .avg("breathRate").as("avgbr")
                        .avg("heartRate").as("avghr")
        );

5.or

db.assets_feed.find({
    "tenantId": "1475652926985990144",
    "categoryId": {
        $in: ["62f34c86b9852679528db1e7"]
    },
    $or: [{
        "feedId": null
    }, {
        "feedId": {
            $exists: false
        }
    }]
})

public PageInfo<SimpleFeedEntity> getFeedsByCriteria(SimpleFeedEntity simpleFeedEntity, Integer pageNum, Integer pageSize) {
        Criteria criteria = new Criteria();
        criteria.and("tenantId").is(simpleFeedEntity.getTenantId());
        criteria.and("delFlag").is(false);
        if (StringUtils.isNotBlank(simpleFeedEntity.getId())) {
            criteria.and("_id").is(simpleFeedEntity.getId());
        }
        if (StringUtils.isNotBlank(simpleFeedEntity.getFeedId())) {
            criteria.and("feedId").is(simpleFeedEntity.getFeedId());
        }
        if (null != simpleFeedEntity.getFeedIdExist() && simpleFeedEntity.getFeedIdExist().equals(0) && StringUtils.isBlank(simpleFeedEntity.getFeedId())) {
            criteria.orOperator(Criteria.where("feedId").exists(false),Criteria.where("feedId").is(null));
        }
        if (StringUtils.isNotBlank(simpleFeedEntity.getStartStatus())) {
            criteria.and("startStatus").is(simpleFeedEntity.getStartStatus());
        }
        Query query = new Query(criteria);
        return findPage(pageNum, pageSize, query, SimpleFeedEntity.class);
    }

6.mongoDB update

db.getCollection("assets_feed").find({
    "delFlag": false,
    "durations.min": {
        "$exists": true
    }
}).forEach(function(item) {
    db.getCollection("assets_feed").update({
        _id: item._id
    }, {
        $set: {
            "durations": {
                "time": item.durations.min,
                "unit": "minute"
            }
        }
    });
})

7.mongoDB 批量更新

db.deviceDataCollection_1475652926985990144.update({
    "orgId": "1551852978372079616"
}, {
    $set: {
        "orgId": "1551852978372079617"
    }
}, {
    multi: true
})

8.mongoDB 批量更新时间

// 时间加一天
db.getCollection("deviceDataCollection_1475652926985990144").find({
    "deviceId": "SAD23423432"
}).forEach(function(item) {
    db.getCollection("deviceDataCollection_1475652926985990144").update({
        _id: item._id
    }, {
        $set: {
            ts: 
            new Date(item.ts.getTime() + 1000 * 3600 * 24)
        }
    });
})
MongoDB 聚合函数的统计查询 - Educoder
PixelDyno的博客
08-15 921
聚合函数是用于执行数据处理操作的工具，可以对集合中的文档进行分组、过滤、排序、限制和计算。通过使用聚合函数，我们可以轻松地从大量的数据中提取出我们所需的信息。通过灵活使用 MongoDB 的聚合函数，我们可以方便地进行数据统计和分析。无论是简单的计数、求和，还是复杂的多阶段聚合操作，MongoDB 都可以提供强大的功能来满足我们的需求。在本文中，我们将重点介绍如何使用 MongoDB 的聚合函数进行查询和统计操作。方法并传入定义好的聚合查询管道，我们可以执行聚合操作并得到查询结果。
mongodb 聚合函数求平均值及时差处理
pengfeng111833的专栏
10-31 2470
最近因为公司需要做一些小时平均和每日平均的统计，于是去找了下mongodb的系统函数。通过avg和聚合查询实现了结果，但是发现统计的时候mongodb函数$dateToString: { format: "%Y-%m-%d %H", date: "$beginTime" }转化后也还是格林治时间，统计结果跟北京时间差了8小时。于是找了很多资料通过date: { $add: ["$b...
mongo聚合函数（aggregate）java版
04-10
mongo聚合函数（aggregate）java版， 类似mysql的group。 对应查询语句可查看 https://blog.csdn.net/xu180/article/details/89175663
mongodb 聚合函数
数据库
04-27 197
1.count 这个函数很好理解，和其他数据库一样，就是做一个count操作 select count(*) from tab1 =db.tab1.count() 以上例子很好理解，但是如果在操作中有skip，limit这种操作的话，那么count会忽略掉这些操作，必须加入一个true参数 比如：db.tab1.find().skip(1),limit(2).count()和db.tab1...
MongoDB聚合函数
最新发布
Dxy1239310216的博客
08-15 414
MongoDB的聚合函数提供了强大的数据处理能力，无论是简单的统计还是复杂的分析，都可以通过聚合操作实现。聚合管道是MongoDB中数据聚合的首选方法，它灵活且强大，能够满足大部分数据处理需求。同时，单一目的聚合方法和MapReduce也提供了额外的选项，以适应不同的使用场景。通过合理选择和组合这些聚合函数，可以高效地处理和分析MongoDB中的数据。
Mongodb笔记八：聚合函数
zhusongziye的博客
09-08 1140
本文数据见笔记前几节。 一、聚合 aggregate 聚合主要用于计算数据，类似sql中的sum()、avg() 语法： db.集合名称.aggregate( [ { 管道 : { 表达式 } } ] ) ---PS: 多个表达式必须加中括号，只有一个可不加 管道：管道一般用于将当前命令的输出结果作为下一个命令的输入，在mongodb中，...
MongoDB——聚合操作详解
吴声子夜歌的博客
11-21 4927
聚合（Aggregation）为集合文档数据提供各种处理数据方法，并返回计算结果。 MongoDB提供了3种方式来执行聚合命令： 聚合管道方法 map-reduce方法 单一目标聚合方法 1. 聚合管道方法 聚合管道方法又可以直接理解为合计流水线法，就是把集合里若干含数值型的文档记录，其键对应的值进行各种分类统计。该方法支持分片集合操作。 db.collection_name.aggregate( [ {$match:{<field>}}, //统计查找条件 {$group:{&l
学习MongoDB--（6-1）：聚合（初级聚合函数使用）
DrifterJ's Stash
08-12 8096
前面主要介绍了MongoDB的基础操作及索引相关内容，同关系型数据库一样，MongoDB同样也提供了对聚合函数的支持！并且因为其集合没有模式这种特殊性，MongoDB对聚合还有了更强大的支持！ 这次我们先来看看一些基本的聚合函数的使用。 【count】 集合的count函数是最简单的聚合函数，返回集合中文档的数量，也可以接受一个查询文档，统计符合这个查询的文档数量： > db.user.f
Mongodb聚合函数count、distinct、group如何实现数据聚合操作
12-16
Mongodb中自带的基本聚合函数有三种：count、distinct和group。下面我们分别来讲述一下这三个基本聚合函数。 （1）count 作用：简单统计集合中符合某种条件的文档数量。 使用方式：db.collection.count
mongoDB中聚合函数java处理示例详解
08-26
MongoDB 中聚合函数 Java 处理示例详解 MongoDB 中聚合函数是 MongoDB 中一种强大的数据处理工具，能够对数据进行复杂的处理和分析。在 Java 中，使用 MongoDB 的聚合函数可以实现对数据的高效处理和查询。本文将...
mongo聚合函数
博客
04-10 979
mongo聚合函数 aggregate 类似mysql的group 若在java中使用，可下载此文档https://download.csdn.net/download/xu180/11102227 认证概况 按时间分类 "%Y%m%d%H" db.T_LOGINLOG.aggregate( [{ "$match" : { "$and" : [{ "loginTime" : { "$gt...
MongoDB聚合函数介绍
chucan0749的博客
12-08 484
一、sql与mongo聚合函数对应关系 SQL中 mongodb中 WHERE $match GROUP BY $group HAVING $match SELECT $proje...
mongodb聚合函数操作
pigisyou147的专栏
12-14 919
今天碰到需要统计热门标签，也就是标签名访问次数，用sql很简单 select lable_id,count(*) as count from table where state>-1 group label 但是mongodb显然没那么轻松，故在网络上收集资料，本地测试，最终解决了问题 代码如下： DBCollection myColl = db.getCollection("to
MongoTemplate 聚合操作
热门推荐
SHGU
02-08 5万+
第一部分在写具体的业务之前我们先说明一下文档定义：PT@Document(collection = "pt") public class PT implements Serializable { @Id private String id; /**学生id **/ private String student_Id; /** 学生姓名 **/ ...
mongoTemplate聚合操作
奔跑的蜗牛的博客
07-10 1万+
准备数据 customer 集合，数据类型如下：（只是部分数据，数据量太多就不一一列出） { "_id" : ObjectId("594c78a1c5fea52a445b8cd2"), "probMac" : "141FBA789098", "devcMac" : "BC3AEA0E50CB", "inTime" : "20170612133513", "outTime" : "20170612
MongoDB聚合操作详解
qq_44027353的博客
07-28 667
数组列存放的数据是来自被Join集合的适配文档，如果没有，集合为空（即 为[ ])操作具有两个阶段：处理每个文档并向每个输入文档发射一个或多个对象的map阶段，以及reduce组合map操作的输出阶段。投影操作， 将原始字段投影成指定名称，也就是mysql中的字段别名功能。筛选管道操作和其他管道操作配合时候时，尽量放到开始阶段，这样可以减少后续管道操作符要操作的文档数，提升效率。操作只会在过程中维持前n个结果，其中n是指定的限制，而MongoDB只需要将n个项存储在内存中。
mongodb 聚合详解
maoyeqiu的专栏
09-12 2805
聚合（aggregate）框架提供一种方法来计算汇总值，虽然映射化简是强大的，但它往往比简单的汇总任务更困难，如字段值总和或平均值。MongoDB的聚合框架实现sum()、avg()、group by等聚合操作。通过聚合框架，还可对返回的结果进行处理，实现一些特殊需求，例如数据过滤、别名显示、增加字段、提取子字段等。
MongoTemplate实现mongodb聚合管道查询
小蜜蜂1010的博客
09-10 4416
mongodb聚合管道查询操作，使用mongotemplate进行集合管道查询操作，以及注意事项
MongoDB聚合函数mapreduce
05-17
MongoDB的聚合函数mapreduce是一种用于处理大规模数据的方法，它可以将数据集合分成多个小块进行处理，并将结果合并起来生成最终的输出。mapreduce包含两个部分：map和reduce。 map函数是对数据集合进行初步处理的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值