mongoDB工具类以及测试类【java】

最新推荐文章于 2024-05-04 09:38:05 发布
最新推荐文章于 2024-05-04 09:38:05 发布
阅读量150 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/zyxs/p/9106358.html
版权

java操作mongo工具类

package Utils;

import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.UpdateResult;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.bson.Document;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class MongoDBUtil {
    private static MongoDBUtil mongoDBUtil;

    private static final String PLEASE_SEND_IP = "没有传入ip或者端口号";
    private static final String PLEASE_INSTANCE_MONGOCLIENT = "请实例化MongoClient";
    private static final String PLEASE_SEND_MONGO_REPOSITORY = "请指定要删除的mongo库";
    private static final String DELETE_MONGO_REPOSITORY_EXCEPTION = "删除mongo库异常";
    private static final String DELETE_MONGO_REPOSITORY_SUCCESS = "批量删除mongo库成功";
    private static final String NOT_DELETE_MONGO_REPOSITORY = "未删除mongo库";
    private static final String DELETE_MONGO_REPOSITORY = "成功删除mongo库：";
    private static final String CREATE_MONGO_COLLECTION_NOTE = "请指定要创建的库";
    private static final String NO_THIS_MONGO_DATABASE = "未找到指定mongo库";
    private static final String CREATE_MONGO_COLLECTION_SUCCESS = "创建mongo库成功";
    private static final String CREATE_MONGO_COLLECTION_EXCEPTION = "创建mongo库错误";
    private static final String NOT_CREATE_MONGO_COLLECTION = "未创建mongo库collection";
    private static final String CREATE_MONGO_COLLECTION_SUCH = "创建mongo库collection：";
    private static final String NO_FOUND_MONGO_COLLECTION = "未找到mongo库collection";
    private static final String INSERT_DOCUMEN_EXCEPTION = "插入文档失败";
    private static final String INSERT_DOCUMEN_SUCCESSS = "插入文档成功";


    private static final Logger logger = Logger.getLogger(MongoDBUtil.class);

    private MongoDBUtil(){

    }

    private static class SingleHolder{
        private static MongoDBUtil mongoDBUtil = new MongoDBUtil();
    }

    public static MongoDBUtil instance(){

        return SingleHolder.mongoDBUtil;
    }

    public static MongoDBUtil getMongoDBUtilInstance(){
        if(mongoDBUtil == null){
            return new MongoDBUtil();
        }
        return mongoDBUtil;
    }

    /**
     * 获取mongoDB连接
     * @param host
     * @param port
     * @return
     */
    public MongoClient getMongoConnect(String host,Integer port){

        if(StringUtils.isBlank(host) || null == port){
            logger.error(PLEASE_SEND_IP);
            return null;
        }

        return new MongoClient(host, port);
    }


    /**
     * 批量删除mongo库
     * @param mongoClient
     * @param dbNames
     * @return
     */
    public String bulkDropDataBase(MongoClient mongoClient,String...dbNames){

        if(null == mongoClient) return PLEASE_INSTANCE_MONGOCLIENT;

        if(null==dbNames || dbNames.length==0){
            return PLEASE_SEND_MONGO_REPOSITORY;
        }
        try {
            Arrays.asList(dbNames).forEach(dbName -> mongoClient.dropDatabase(dbName));
            logger.info(DELETE_MONGO_REPOSITORY_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            logger.error(DELETE_MONGO_REPOSITORY_EXCEPTION);
        }
        return dbNames == null ? NOT_DELETE_MONGO_REPOSITORY:DELETE_MONGO_REPOSITORY + String.join(",",dbNames);
    }


    /**
     * 创建指定database的collection
     * @param mongoClient
     * @param dbName
     * @param collections
     * @return
     */
    public String createCollections(MongoClient mongoClient,String dbName,String...collections){

        if(null == mongoClient) return PLEASE_INSTANCE_MONGOCLIENT;

        if(null==collections || collections.length==0){
            return CREATE_MONGO_COLLECTION_NOTE;
        }

        MongoDatabase mongoDatabase = mongoClient.getDatabase(dbName);
        if(null == mongoDatabase) return NO_THIS_MONGO_DATABASE;

        try {
            Arrays.asList(collections).forEach(collection ->  mongoDatabase.createCollection(collection));
            logger.info(CREATE_MONGO_COLLECTION_SUCCESS);
            return collections == null ? NOT_CREATE_MONGO_COLLECTION:CREATE_MONGO_COLLECTION_SUCH + String.join(",",collections);
        }catch (Exception e){
            e.printStackTrace();
            logger.error(CREATE_MONGO_COLLECTION_EXCEPTION);
        }

        return null;
    }

    /**
     * 获取MongoCollection
     * @param mongoClient
     * @param dbName
     * @param collection
     * @return
     */
    public MongoCollection<Document> getMongoCollection(MongoClient mongoClient,String dbName,String collection){

        if(null == mongoClient) return null;

        if(StringUtils.isBlank(dbName)) return null;

        if(StringUtils.isBlank(collection)) return null;

        MongoDatabase mongoDatabase = mongoClient.getDatabase(dbName);

        MongoCollection<Document> collectionDocuments = mongoDatabase.getCollection(collection);

        if(null == collectionDocuments) return null;

        return collectionDocuments;
    }

    /**
     * 获取到MongoClient
     * @param ip
     * @param port
     * @param userName
     * @param dbName
     * @param psw
     * @returnMongoClient
     */
    public static MongoClient getMongoClientByCredential(String ip,int port,String userName,String dbName,String psw){
        ServerAddress serverAddress = new ServerAddress(ip,port);
        List<ServerAddress> addrs = new ArrayList<ServerAddress>();
        addrs.add(serverAddress);

        //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
        MongoCredential credential = MongoCredential.createScramSha1Credential(userName, dbName, psw.toCharArray());
        List<MongoCredential> credentials = new ArrayList<MongoCredential>();
        credentials.add(credential);

        //通过连接认证获取MongoDB连接
        MongoClient mongoClient = new MongoClient(addrs,credentials);
        return mongoClient;
    }


    /**
     * 插入文档数据
     * @param mongoCollection
     * @param params
     */
    public void insertDoucument(final MongoCollection<Document> mongoCollection, final Map<String,Object> params){
        if(null == mongoCollection) {
            logger.info(NO_FOUND_MONGO_COLLECTION);
            return;
        }

        try {
            Document document = new Document();
            params.keySet().stream().forEach(field -> document.append(field, params.get(field)));

            List<Document> documents = new ArrayList<>();
            documents.add(document);
            mongoCollection.insertMany(documents);
            logger.info(INSERT_DOCUMEN_SUCCESSS);
        }catch (Exception e){
            e.printStackTrace();
            logger.error(INSERT_DOCUMEN_EXCEPTION);
        }
    }

    /**
     * 更新文档
     * @param mongoCollection
     * @param conditionParams
     * @param updateParams
     */
    public  void updateDocument(final MongoCollection<Document> mongoCollection,final Map<String,Object> conditionParams,
                               final Map<String,Object> updateParams,final boolean MultiUpdate
    ){

        if(null == mongoCollection) return;

        if (null == conditionParams) return;

        if (null == updateParams) return;


        Document conditonDocument = new Document();
        conditionParams.keySet().stream().filter(p -> null != p).forEach(o -> {
            conditonDocument.append(o,conditionParams.get(o));
        });


        Document updateDocument = new Document();
        updateParams.keySet().stream().filter(p -> null != p).forEach(o -> {
            updateDocument.append(o,updateParams.get(o));
        });
        UpdateResult updateResult = null;
        if (MultiUpdate){//是否批量更新
             updateResult = mongoCollection.updateMany(conditonDocument,new Document("$set",updateDocument));
        }else {
             updateResult = mongoCollection.updateOne(conditonDocument,new Document("$set",updateDocument));
        }
        System.out.println("修改了："+updateResult.getModifiedCount()+" 条数据 ");

    }

    /**
     *条件 删除文档 是否多条删除
     * @param mongoCollection
     * @param multiple
     * @param conditionParams
     * @return
     */
    public long deleteDocument(final MongoCollection<Document> mongoCollection,final boolean multiple,
                               final Map<String,Object> conditionParams){

        if(null == mongoCollection) return 0;

        if(null == conditionParams) return 0;

        Document document = new Document();

        conditionParams.keySet().stream().filter(p -> null != p).forEach(o -> {
            document.append(o,conditionParams.get(o));
        });

        if(multiple) {
            return mongoCollection.deleteMany(document).getDeletedCount();
        }

        //删除文档第一条
        return mongoCollection.deleteOne(document).getDeletedCount();
    }

    /**
     * 查询文档 带条件、范围查找、排序、分页
     * @param mongoCollection
     * @param conditionParams
     * @param limit
     * @param skip
     * @param sortParams
     */
    public FindIterable<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams,
                                                final String op,final String compareField, final Map<String,Integer> gtLtOrOtherParams,
                                                final Map<String,Object> sortParams,final Integer skip,final Integer limit
                                                ){

        if(null == mongoCollection) return null;

        FindIterable<Document> findIterable = mongoCollection.find();
        Document conditionDocument = new Document();
        Document compareDocument = new Document();

        if(null != conditionParams && null != findIterable){

            conditionParams.forEach((k,v) ->{
                if (StringUtils.isNotBlank(k)) {
                    conditionDocument.append(k,v);
                }
            });

            findIterable = findIterable.filter(conditionDocument);

            MongoCursor<Document> mongoCursor = findIterable.iterator();
            while(mongoCursor.hasNext()){
                System.out.println("条件过滤  -->"+mongoCursor.next());
            }
        }

        if(null != findIterable && null != gtLtOrOtherParams){

            Document gtOrLtDoc = new Document();
            gtLtOrOtherParams.forEach((k,v) -> {
                if(StringUtils.isNotBlank(k)) gtOrLtDoc.append(k,v);
            });

            compareDocument = new Document(compareField,gtOrLtDoc);
            findIterable = findIterable.filter(new Document(compareField,compareDocument));
        }

        if (StringUtils.isNotBlank(op)){
            if ("and".equals(op)){
                findIterable = mongoCollection.find(Filters.and(conditionDocument,compareDocument));
            }else if("or".equals(op)){
                findIterable = mongoCollection.find(Filters.or(conditionDocument,compareDocument));
            }else if("not".equals(op)){//排除范围
                findIterable = mongoCollection.find(Filters.and(conditionDocument,Filters.not(compareDocument)));
            }
        }else{//默认是AND查询
            findIterable = mongoCollection.find(Filters.and(conditionDocument,compareDocument));
        }
        MongoCursor<Document> mongoCursor3 = findIterable.iterator();
        while(mongoCursor3.hasNext()){
            System.out.println(op+"过滤  -->"+mongoCursor3.next());
        }

        if(null != sortParams){
            Document sortDocument = new Document();
            sortParams.forEach((k,v) ->{
                if (StringUtils.isNotBlank(k)) {
                    sortDocument.append(k,v);
                }
            });

            findIterable = findIterable.sort(sortDocument);

            MongoCursor<Document> mongoCursor2 = findIterable.iterator();
            while(mongoCursor2.hasNext()){
                System.out.println("排序  -->"+mongoCursor2.next());
            }
        }



        if(null != findIterable && null != limit){
            findIterable = findIterable.limit(limit);
        }
        if(null != findIterable && null != skip){
            findIterable = findIterable.skip(skip);
        }

        return findIterable;
    }


    /**
     * in查询
     * @param mongoCollection
     * @return
     */
    public FindIterable<Document>  queryDocumentIn(final MongoCollection<Document> mongoCollection,String field, List<String> list
    ){

        if(null == mongoCollection) return null;
        FindIterable<Document> findIterable = mongoCollection.find(new Document(field,new Document("$in",list)));
        return findIterable;
    }


    /**
     * 全文查询
     * @param mongoCollection
     * @return
     */
    public FindIterable<Document>  queryDocument(final MongoCollection<Document> mongoCollection
    ){
        if(null == mongoCollection) return null;
        FindIterable<Document> findIterable = mongoCollection.find();
        return findIterable;
    }


    /**
     * 查询文档 简单条件查询
     * @param mongoCollection
     * @param conditionParams
     * @return
     */
    public FindIterable<Document> queryDocument(final MongoCollection<Document> mongoCollection, final Map<String,Object> conditionParams
    ){

        if(null == mongoCollection) return null;

        FindIterable<Document> findIterable = mongoCollection.find();

        if(null == conditionParams || null == findIterable) return findIterable;

        Document document = new Document();
        conditionParams.forEach((k,v)->{
            if (StringUtils.isNotBlank(k)) {
                document.append(k,v);
            }
        });
        findIterable = findIterable.filter(document);

        return findIterable;

    }


    /**
     * 用于输出部分的列信息
     * @param documents
     */
    public static void printDocuments(FindIterable<Document> documents, String[] fields) {
        if (fields != null && fields.length > 0) {
            int num = 0;
            for (Document d : documents) {
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 0; i < fields.length; i++) {
                    /*if(fields[i].equals("catm")){

                    }*/
                    stringBuilder.append(fields[i] + ": "+d.getString(fields[i])+" ");
                }
                System.out.println("第" + (++num) + "条数据： " + stringBuilder);

            }
        }else{
            for (Document d : documents) {
                System.out.println(d.toString());
            }
        }
    }

    /**
     * 用于输出所有的列信息
     * @param documents
     */
    public void printDocuments(FindIterable<Document> documents) {
        int num = 0;
        for (Document d : documents) {
            System.out.println("第" + (++num) + "条数据： " + d.toString());
        }
    }

}

　　

mongo用到的比较常量定义

public enum MongoConst {
    GT("$gt"),
    LT("$lt"),
    GTE("$gte"),
    LTE("$lte"),
    AND("and"),
    OR("or"),
    NOT("not");
    private String compareIdentify;

    MongoConst(String compareIdentify) {
        this.compareIdentify = compareIdentify;
    }
    public String getCompareIdentify() {
        return compareIdentify;
    }
}

　　

工具类的测试类

package test;

import Utils.MongoConst;
import Utils.MongoDBUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MongoTest02 {

    public static void main(String[] args) {
        MongoDBUtil mongoDBUtil = MongoDBUtil.getMongoDBUtilInstance();
        MongoClient meiyaClient = mongoDBUtil.getMongoClientByCredential("127.0.0.1",27017,"my","my","my");

        try {
            MongoCollection<Document> collection = mongoDBUtil.getMongoCollection(meiyaClient,"test","hobby");
            Map<String,Object> insert = new HashMap<>();
               //1、测试增加
           /* insert.put("name","zy");
            insert.put("age","12");
            insert.put("date","2018-04-02T09:44:02.658+0000");
            insert.put("school","厦门理工");
            mongoDBUtil.insertDoucument(collection,insert);*/
            //2、测试条件、范围、排序查询
           /* Map<String,Object> conditions = Maps.newHashMap();
            conditions.put("name","张元");
            Map<String,Integer> compares = Maps.newHashMap();
            compares.put(MongoConst.GT.getCompareIdentify(),20);
            compares.put(MongoConst.LTE.getCompareIdentify(),28);
            String opAnd = MongoConst.AND.getCompareIdentify();
            Map<String,Object> sortParams = Maps.newHashMap();
            sortParams.put("age",-1);
            FindIterable<Document> documents = mongoDBUtil.queryDocument(collection,null,opAnd,"age",compares,sortParams,null,2);
            mongoDBUtil.printDocuments(documents);*/
           //3、in查询
            /*List<String> names = Lists.newArrayList("张媛","zy","zyy");
            FindIterable<Document> documents = mongoDBUtil.queryDocumentIn(collection,"name",names);
            mongoDBUtil.printDocuments(documents);*/
            //4 批量删除
            /*Map<String,Object> conditionParams = Maps.newHashMap();
            conditionParams.put("school","厦门理工");
            long count = mongoDBUtil.deleteDocument(collection,true,conditionParams);
            System.out.println(count);*/
            //更新
            Map<String,Object> queryParams = Maps.newHashMap();
            queryParams.put("school","修改了学校");
            Map<String,Object> updateParams = Maps.newHashMap();
            updateParams.put("name","修改了名字");
            mongoDBUtil.updateDocument(collection,queryParams,updateParams,false);
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }

    }
}

　　

转载于:https://www.cnblogs.com/zyxs/p/9106358.html

weixin_34377919
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mongoDB 数据库工具类
03-15
mongoDB工具类，实际项目开发中自己编写的，经测试无bug，放心使用
用过 mongodb 吧， 这三个大坑踩过吗？
寒冰屋的专栏
08-20 1003
一：背景 1. 讲故事 前段时间有位朋友在微信群问，在向 mongodb 中插入的时间为啥取出来的时候少了 8 个小时，8 在时间处理上是一个非常敏感的数字，又吉利又是一个普适的话题，后来我想想初次使用 mongodb 的朋友一定还会遇到各种新坑，比如说：插入的数据取不出来，看不爽的 ObjectID，时区不对等等，这篇就和大家一起聊一聊。 二：1号坑 插进去的数据取不出来 1. 案例展示 这个问题是使用强类型操作 mongodb 你一定会遇到的问题，案例代码如下： class Pro
springboot集成 mongodb以及mongodb简单工具类
寂夜了无痕的博客
03-10 594
springboot集成 mongodb以及mongodb简单工具类
14.MongoDBUtils工具类
weixin_33766168的博客
01-23 566
1. 1 public class DbUtils { 2 3 public static MongoCollection&lt;Document&gt; getMongoCollection(String localhost, int port) { 4 MongoClient mongoClient = new MongoClient(localhost, ...
java操作mongodb的工具类
05-16
java操作mongodb的工具类,增删查改方法
自己的mongodb的CRUD封装
weixin_34357436的博客
04-13 207
工具类：package Utils; import com.google.common.collect.Lists; import com.mongodb.MongoClient; import com.mongodb.MongoCredential; import com.mongodb.ServerAddress; import com.mongodb.client.Find...
mongodb Java 工具类
u010391342的博客
07-29 1406
package com.mongodb; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.bson.Document; import org.bson.conversions.Bson; import org.bson.types.ObjectId; import org.slf4
mongodb java 类_mongoDB工具类以及测试类【java】
weixin_28958727的博客
02-15 146
java操作mongo工具类package Utils;import com.mongodb.MongoClient;import com.mongodb.MongoCredential;import com.mongodb.ServerAddress;import com.mongodb.client.FindIterable;import com.mongodb.client.MongoCol...
spring MongoDB 集成crud操作(简单封装)
lvwenwen
01-24 293
oyhk　学习笔记 这两天一直在学习mongodb,由于我的博客网站想把mysql替换成mongodb,为什么会有这样的冲动,我通过收集一些资料,关于mongodb 跟 mysql 的对比...发现性能上mongodb比上mysql是高出很多倍...无论是增,删,修,查的操作.....都比mysql效率好...但是,我也看到,mongodb是文档型数据库...做一些高级查询的时候就可能产生麻烦...
java mongodb 封装类_MongoDB初探及JAVA工具类封装
weixin_35211615的博客
02-16 567
MongoDB 搭建及JAVA工具类封装MongoDB 搭建及JAVA工具类封装MongoDB 简介基本语法Mongo服务器搭建安装包下载环境变量配置Mongo基本配置Mongo起飞JAVA工具类封装MongoDB 简介MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类...
SpringBoot整合MongoDB测试demo
02-15
Springboot整合MongoDB，包含Mongo的工具类以及测试类，只需配置自己的mongodb地址，开箱即用
java针对mongo操作的封装，完全面向对象，无需修改，可直接使用
06-13
完全面向对象的mongo封装，maven工程源码，可直接install导出jar包引用，支持基本的增删改查和分页等，使用反射对javaBean实体进行映射，所有方法参数只需要传javaBean就行了，支持带密码连接,即拿即用，无需修改。
java基础测试题，基础坑，算法题，工具类，面试题.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
mongodb-entity-generator:用于测试环境的 MongoDB 实体生成器
06-28
mongodb-实体生成器用于测试环境的 MongoDB 实体生成器
XCYN：记录了常用的工具类和一些的Demo
02-01
简要概述电子书读书笔记XCYN.Common封装了SQLServer工具类，redis / mongoDB的常用接口，缓存，农历，加密/解密，邮件，JSON，XML，请求，验证，串行转换等工具类XCYN.MVC ASP.NET MVC中路由，布局，应用控制反转...
node中mongoose使用CRUD示例
qq_34412985的博客
12-30 264
var mongoose = require('mongoose') var Schema = mongoose.Schema // 1. 连接数据库 // 指定连接的数据库不需要存在，当你插入第一条数据之后就会自动被创建出来 mongoose.connect('mongodb://localhost/itcast') // 2. 设计文档结构（表结构） // 字段名称就是表结构中的属性名称...
如何自己封装一个轻量，高效的mongoDB数据库对象模型工具
weixin_45091270的博客
07-14 300
如何自己封装一个轻量，高效的mongoDB数据库对象模型工具 需要掌握： mongoDB数据库 node-mongodb-native es6，es7新特性（async，await，Promise） 单例模式 GitHub和npm上有很多优秀的在node.js异步环境下对mongodb进行便捷操作的对象模型工具 ，例如常用的mongoose等。使用起来难免会有些复杂，这里我们手动自己封装一个对象模型工具。 优点： 轻量 高效 话不多说直接上代码： const Config = require("./
Redis 实战之压缩列表
最新发布
奔走的蚂蚁的博客
05-04 1054
压缩列表是一种为节约内存而开发的顺序型数据结构。压缩列表被用作列表键和哈希键的底层实现之一。压缩列表可以包含多个节点，每个节点可以保存一个字节数组或者整数值。添加新节点到压缩列表， 或者从压缩列表中删除节点， 可能会引发连锁更新操作， 但这种操作出现的几率并不高。
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1219
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
springboot操作mongodb
06-28
3.创建实体类：创建一个代表MongoDB集合的Java类，并使用@Document注释指定MongoDB集合的名称。 4.创建存储库接口：创建一个扩展MongoRepository接口的接口，并提供实体类和主键类型作为泛型参数。该接口将自动生成...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值