基于原生org.json.JSONObject和反射Reflect实现的JSON转换解析的工具类！

最新推荐文章于 2024-07-31 09:45:00 发布
最新推荐文章于 2024-07-31 09:45:00 发布
阅读量702 收藏 2
点赞数
分类专栏： 数据处理 理论 文章标签： json java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq912098812/article/details/110390557
版权

背景：业务需要，不可以用第三方json解析的开源项目，然后项目中又有很多接口都需要用到把字符串解析为对象的功能。

于是只能自己用原生的写一个了。吐槽(业务需要)。。。

致谢：

Android框架之路——Json解析一篇就够（原生技术+Gson+FastJson）

利用Java反射机制实现对象与json字符串互相转化

getDeclaredFields()-Reflection反射-获取包括父类在内的所有字段

通过java反射机制获取该类的所有属性类型、值、

正文：

import android.util.Log;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public class JsonUtils {
    private static final String TAG = JsonUtils.class.getSimpleName();

    /**
     * 解析json字符串到实例对象
     *
     * @param clazz 和JSON对应的类的Class，必须拥有setXxx()函数，其中xxx为属性
     * @param json  被解析的JSON字符串
     * @return 返回传入的Object对象实例
     */
    public static <T> T parseJson2Object(String json, Class<T> clazz) {
        JSONObject jsonObject = null;
        try {
            jsonObject = new JSONObject(json);
        } catch (JSONException e) {
            FSLogcat.e(TAG, "Exception:" + e.getMessage());
            return null;
        }
        return parseJson2Object(clazz, jsonObject);
    }

    /**
     * 解析JSONObject对象到具体类，递归算法
     *
     * @param clazz      和JSON对应的类的Class，必须拥有setXxx()函数，其中xxx为属性
     * @param jsonObject 被解析的JSON对象
     * @return 返回传入的Object对象实例
     */
    private static <T> T parseJson2Object(Class<T> clazz, JSONObject jsonObject) {
        T obj = null;
        try {
            //获取clazz的实例
            obj = clazz.newInstance();
            Class tempClass = clazz;
            List<Field> fieldList = new ArrayList<>();
            while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
                fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
                tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
            }
//            Collections.reverse(fieldList);
            // 遍历每个属性，如果为基本类型和String则直接赋值，如果为List则得到每个Item添加后再赋值，如果是其它类则得到类的实例后赋值
            for (Field field : fieldList) {
                try {
                    // 设置属性可操作
                    field.setAccessible(true);
//                    if (field.getName().equals("serialVersionUID")) {
//                        continue;
//                    }
                    FSLogcat.e(TAG, " GenericType = " + field.getGenericType().toString());
                    // 获取字段类型
                    Class<?> typeClazz = field.getType();
                    // 是否基础变量 Boolean,Character,Byte,Short,Integer,Long,Float,Double,Void
                    if (typeClazz.isPrimitive()) {
                        if (field.getGenericType().toString().equals("float")) {
                            Object opt = jsonObject.opt(field.getName());
                            if (opt instanceof Double) {
                                setProperty(obj, field, ((Double) opt).floatValue());
                            } else {
                                setProperty(obj, field, jsonObject.opt(field.getName()));
                            }
                        } else {
                            setProperty(obj, field, jsonObject.opt(field.getName()));
                        }
                    } else {
                        // 得到类型实例
                        Object typeObj;
                        if (typeClazz.isInterface() && typeClazz.getSimpleName().contains("List")) {//Field如果声明为List<T>接口，由于接口的Class对象不能newInstance()，此时需要转化为ArrayList
                            typeObj = ArrayList.class.newInstance();
                        } else {
                            typeObj = typeClazz.newInstance();
                        }
                        if (field.getName().equals("testMap")) {
                            Log.e(TAG, " pause");
                        }
                        if (typeObj instanceof Map) {// 是否为Map
                            try {
                                // 得到Map的JSONObject
                                JSONObject object = jsonObject.getJSONObject(field.getName());
                                // 得到类型的结构，如:java.util.HashMap<com.xxx.xxx>
                                Type type = field.getGenericType();
                                ParameterizedType pt = (ParameterizedType) type;
                                // 获得Map元素键类型
//                              Class<?> keyClass = (Class<?>) pt.getActualTypeArguments()[0];
                                // 获得Map元素值类型
                                Class<?> valueClass = (Class<?>) pt.getActualTypeArguments()[1];
                                JSONArray names = object.names();
                                for (int i = 0; i < names.length(); i++) {
                                    try {
                                        // 默认按map值为String进行解析
                                        String key = names.opt(i).toString();
                                        Object value = parseJson2Object(valueClass, object.getJSONObject(key));
                                        ((Map<String, Object>) typeObj).put(key, value);
                                    } catch (Exception e) {
                                        FSLogcat.e(TAG, "Exception:" + e.getMessage());
                                    }
                                }
                                setProperty(obj, field, typeObj);
                            } catch (Exception e) {
                                FSLogcat.e(TAG, "Exception:" + e.getMessage());
                            }
                        } else if (typeObj instanceof List) {// 是否为List
                            // 得到类型的结构，如:java.util.ArrayList<com.xxx.xxx>
                            Type type = field.getGenericType();
                            ParameterizedType pt = (ParameterizedType) type;
                            // 获得List元素类型
                            Class<?> dataClass = (Class<?>) pt.getActualTypeArguments()[0];
                            // 得到List的JSONArray数组
                            JSONArray jArray = jsonObject.getJSONArray(field.getName());
                            // 将每个元素的实例类加入到类型的实例中
                            for (int i = 0; i < jArray.length(); i++) {
                                //对于数组，递归调用解析子元素
                                try {
                                    ((List<Object>) typeObj).add(parseJson2Object(dataClass, jsonObject.getJSONArray(field.getName()).getJSONObject(i)));
                                } catch (JSONException e) {
                                    FSLogcat.e(TAG, "Exception:" + e.getMessage());
                                }
                            }
                            setProperty(obj, field, typeObj);
                        } else if (typeObj instanceof String) {// 是否为String
                            setProperty(obj, field, jsonObject.opt(field.getName()));
                        } else {//是否为其它对象
                            //递归解析对象
                            try {
                                setProperty(obj, field, parseJson2Object(typeClazz, jsonObject.getJSONObject(field.getName())));
                            } catch (JSONException e) {
                                FSLogcat.e(TAG, "Exception:" + e.getMessage());
                            }
                        }
                    }
                } catch (JSONException e) {
                    FSLogcat.e(TAG, "Exception:" + e.getMessage());
                } catch (IllegalAccessException e) {
                    FSLogcat.e(TAG, "Exception:" + e.getMessage());
                } catch (InstantiationException e) {
                    FSLogcat.e(TAG, "Exception:" + e.getMessage());
                }
            }
        } catch (IllegalAccessException e) {
            FSLogcat.e(TAG, "Exception:" + e.getMessage());
        } catch (InstantiationException e) {
            FSLogcat.e(TAG, "Exception:" + e.getMessage());
        }
        return obj;
    }

    /**
     * 给实例对象的成员变量赋值
     *
     * @param obj      实例对象
     * @param field    要被赋值的成员变量
     * @param valueObj 要被赋值的成员变量的值
     */
    private static void setProperty(Object obj, Field field, Object valueObj) {
        if (valueObj == null) {
            return;
        }
//        // 兼容类继承情况的判断
        Class<?> tempClass = obj.getClass();
        while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
            try {
                Method method = tempClass.getDeclaredMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
                //设置set方法可访问
                method.setAccessible(true);
                //调用set方法为实例对象的成员变量赋值
                method.invoke(obj, valueObj);
                break; // 退出循环
            } catch (NoSuchMethodException e) {
                FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] not found");
                tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
            } catch (IllegalArgumentException e) {
                FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] illegal argument:" + valueObj + "," + e.getMessage());
                break; // 退出循环
            } catch (IllegalAccessException e) {
                FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
                break; // 退出循环
            } catch (InvocationTargetException e) {
                FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
                break; // 退出循环
            } catch (Exception e) {
                FSLogcat.e(TAG, "Exception:" + e.getMessage());
                break; // 退出循环
            }
        }
        // 未兼容类继承后对父类私有方法的获取
//        try {
//            Class<?> clazz = obj.getClass();
//            //获取类的setXxx方法，xxx为属性
//            // getMethods(),该方法是获取本类以及父类或者父接口中所有的公共方法(public修饰符修饰的)
//            Method method = clazz.getMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
//            // getDeclaredMethods(),该方法是获取本类中的所有方法，包括私有的(private、protected、默认以及public)的方法。
            Method method = clazz.getDeclaredMethod("set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1), field.getType());
//            //设置set方法可访问
//            method.setAccessible(true);
//            //调用set方法为实例对象的成员变量赋值
//            method.invoke(obj, valueObj);
//        } catch (NoSuchMethodException e) {
//            FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] not found");
//        } catch (IllegalArgumentException e) {
//            FSLogcat.e(TAG, "method [set" + field.getName().substring(0, 1).toUpperCase(Locale.getDefault()) + field.getName().substring(1) + "] illegal argument:" + valueObj + "," + e.getMessage());
//        } catch (IllegalAccessException e) {
//            FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
//        } catch (InvocationTargetException e) {
//            FSLogcat.e(TAG, "IllegalAccessException:" + e.getMessage());
//        }
    }

    /**
     * 可以解析自定义的对象、map、List、数组、基本数据类型、String
     *
     * @param value
     * @return
     */
    public static String object2JsonString(Object value) {
        if (value == null) {
            return "null";
        }
        if (value instanceof Boolean) {
            return value.toString();
        }
        if (value instanceof String) {
            return "\"" + escape((String) value) + "\"";
        }
        if (value instanceof Double) {
            if (((Double) value).isInfinite() || ((Double) value).isNaN()) {
//                return "null";
                return "0";
            } else {
                return value.toString();
            }
        }
        if (value instanceof Float) {
            if (((Float) value).isInfinite() || ((Float) value).isNaN()) {
//                return "null";
                return "0";
            } else {
                return value.toString();
            }
        }
        if (value instanceof Number) {
            return value.toString();
        }
        if (value instanceof Map) {
            return map2Json((Map) value);
        }
        if (value instanceof Collection) {
            return coll2Json((Collection) value);
        }
        if (value.getClass().isArray()) {
            return array2Json(value);
        }
        return customObject2Json(value);
    }

    private static String array2Json(Object array) {
        if (null == array) {
            return "null";
        }
        StringBuffer sb = new StringBuffer();
        sb.append('[');
        // 此处减1是为了下面的 逗号 追加
        int len = Array.getLength(array) - 1;
        if (len > -1) {
            int i;
            for (i = 0; i < len; i++) {
                sb.append(object2JsonString(Array.get(array, i))).append(",");
            }
            sb.append(object2JsonString(Array.get(array, i)));
        }
        sb.append(']');
        return sb.toString();
    }

    private static String coll2Json(Collection coll) {
        if (null == coll) {
            return "null";
        }
        StringBuffer sb = new StringBuffer();
        sb.append('[');
        for (Iterator it = coll.iterator(); it.hasNext(); ) {
            sb.append(object2JsonString(it.next()));
            if (it.hasNext()) {
                sb.append(",");
            }
        }
        sb.append(']');
        return sb.toString();
    }

    private static String customObject2Json(Object obj) {
        Class tempClass = obj.getClass();
        List<Field> fieldList = new ArrayList<>();
        while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
            fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
            tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
        }
        Map map = new HashMap();
        for (Field f : fieldList) {
            if (Modifier.isStatic(f.getModifiers())) {
                continue;
            }
            String name = f.getName();
            f.setAccessible(true);
            Object value = null;
            try {
                value = f.get(obj);
            } catch (IllegalAccessException e) {
                value = null;
                FSLogcat.e(TAG, "Exception:" + e.getMessage());
            }
            map.put(name, value);
        }
        tempClass = null;
        fieldList = null;
        return map2Json(map);
//        Class type = obj.getClass();
//        Field[] fields = type.getDeclaredFields();
//        Map map = new HashMap();
//        for (Field f : fields) {
//            if (Modifier.isStatic(f.getModifiers())) {
//                continue;
//            }
//            String name = f.getName();
//            f.setAccessible(true);
//            Object value = null;
//            try {
//                value = f.get(obj);
//            } catch (IllegalAccessException e) {
//                value = null;
//                FSLogcat.e(TAG, "Exception:" + e.getMessage());
//            }
//            map.put(name, value);
//        }
//        type = null;
//        fields = null;
//        return map2Json(map);
    }

    private static String map2Json(Map map) {
        if (null == map) {
            return "null";
        }
        StringBuffer sb = new StringBuffer();
        sb.append('{');
        for (Iterator it = map.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry entry = (Map.Entry) it.next();
            String key = (String) entry.getKey();
            if (null == key) {
                continue;
            }
            sb.append('\"');
            escape(key, sb);
            sb.append('\"').append(':').append(object2JsonString(entry.getValue()));
            if (it.hasNext()) {
                sb.append(",");
            }
        }
        sb.append('}');
        return sb.toString();
    }

    /**
     * Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).
     *
     * @param s
     * @return
     */
    private static String escape(String s) {
        if (s == null) {
            return null;
        }
        StringBuffer sb = new StringBuffer();
        escape(s, sb);
        return sb.toString();
    }

    private static void escape(String s, StringBuffer sb) {
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            switch (ch) {
                case '"':
                    sb.append("\\\"");
                    break;
                case '\\':
                    sb.append("\\\\");
                    break;
                case '\b':
                    sb.append("\\b");
                    break;
                case '\f':
                    sb.append("\\f");
                    break;
                case '\n':
                    sb.append("\\n");
                    break;
                case '\r':
                    sb.append("\\r");
                    break;
                case '\t':
                    sb.append("\\t");
                    break;
//                case '/':
//                    sb.append("\\/");
//                    break;
                case '/':
                    sb.append("/");
                    break;
                default:
                    if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F') || (ch >= '\u2000' && ch <= '\u20FF')) {
                        String ss = Integer.toHexString(ch);
                        sb.append("\\u");
                        for (int k = 0; k < 4 - ss.length(); k++) {
                            sb.append('0');
                        }
                        sb.append(ss.toUpperCase());
                    } else {
                        sb.append(ch);
                    }
            }
        }
    }
}

不足：目前在Map<K,V>结构的数据解析时，只支持Map<K,V>的key为String类型的数据。（PS：Map<K,V>其实是可以使用对象类型做Key的。）

很尴尬，因为原生的new JSONObject(json);时如果json字符串里边的Map<K,V>的key是对象会直接报异常。。。

目前没找到好的方法解决，但是也够用了，如果有找到办法的麻烦知会我一声，以共同进步！非常感谢！！！

有个小男神
关注
专栏目录
org.json.JSONObject引用依赖包
03-01
org.json.JSONObject引用依赖包 org.json.JSONObject引用依赖包 org.json.JSONObject引用依赖包 org.json.JSONObject引用依赖包
json库-java解析json数据类库
05-07
将文件下载后解压缩，将获取到的jar包添加到java工程中，然后就可以进行调用了。
JAVA JSONObject
最新发布
xycxycooo的博客
07-31 569
JSONObject是一个非常强大的工具，用于在Java中处理JSON数据。通过上述示例，你应该能够理解如何创建、操作和解析JSON对象。希望这些内容能够帮助你更好地在Java项目中使用JSON数据。
介绍4款json的java类库 及 其性能测试
weixin_30823833的博客
08-06 61
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language,Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，这些特性使JSON成为理想的数据交换语言。 ...
java json 库_超级灵活的 Java JSON 库
weixin_39961636的博客
02-12 174
不是已经有 objectMapper.readValue 了吗？为什么还需要一个新的 JSON 库呢？因为我发现下面这几个场合已有的库无法满足我的需求， 所以发明了 jsoniter(json-iterator)：和 PHP 打交道： 如果你要的是 int，他们可能给你 100 也可能给你 "100"。如果你要的是对象，他们在空值的时候可能给你个 []。处理大量的 JSON：解析大量的 JSON，...
Java三方库-JSON库
qq_42936379的博客
07-16 1034
this(null);super(t);自定义序列化器根据属性值有条件的序列化对象。
json中date(JSONObject)引发的血案
HealerJean梦想博客
12-29 3683
前言 1、测试bean 1、包含集合的测试bean package com.hlj.data.res.test; import io.swagger.annotations.ApiModel; import lombok.Data; import lombok.experimental.Accessors; import java.math.BigDecimal; import java.u...
( 持续更新，目前含 200+ 工具类 ) DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。
afkT 的博客
09-24 5033
About DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。 该项目尽可能的便于开发人员，快捷、快速开发安全可靠的项目，以及内置部分常用的资源文件，如color.xml、(toast) layout.xml等 Gradle Step 1. Add the JitPack repository to your build fil...
JSON 学习笔记
fanxiaobin
03-20 3763
一、简介 中文官网：http://www.json.org/json-zh.html   JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON 使用 Javascript语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。 目前非常多的动态（PHP，JSP，.NET）编程语言都支持JS...
Realm-Android
...
11-10 3969
  Realm Java 让你能够高效地编写 app 的模型层代码，保证你的数据被安全、快速地存储。参考下列示例来开始你的 Realm 之旅： // Define you model class by extending RealmObject public class Dog extends RealmObject { private String name; pri...
java json工具库
03-25
处理json、的java lib 使用见：www.json.org
Java json jar包 包括全部6个包 可以直接使用
11-10
JAVA使用 json必须用到的jar包 否则JSONObject.fromObject 报错
java操作json的类库 google-gson
07-13
被大多数开发者所使用的java操作json的类库，成熟，简单。
java json 相关的所有jar包
03-16
json 字符串处理的所有jar包，只要全部导入即可.
java使用json的必备7个jar包
05-30
在java中使用json需要引入以下六个jar包，分别为： commons-lang-2.4.jar commons-collections-3.2.1.jar commons-beanutils-1.8.3.jar json-lib-2.4-jdk15.jar ezmorph-1.0.6.jar commons-logging-1.1.3.jar 如果缺少上面任何一个包，会有如下错误： commons-beanutils-1.8.0.jar不加这个包 java.lang.NoClassDefFoundError: org/apache/commons/beanutils/DynaBean commons-collections.jar 不加这个包 java.lang.NoClassDefFoundError: org/apache/commons/collections/map/ListOrderedMap commons-lang-2.4.jar不加这个包 java.lang.NoClassDefFoundError: org/apache/commons/lang/exception/NestableRuntimeException commons-logging-1.1.1.jar不加这个包 java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory ezmorph-1.0.4.jar不加这个包 java.lang.NoClassDefFoundError: net/sf/ezmorph/Morpher json-lib-2.3-jdk15.jar不加这个包 java.lang.NoClassDefFoundError: net/sf/json/JSONObject 需要主要的是commons-lang-2.4.jar不能由commons-lang3-3.1.jar替换， 两者目录有所区别。 以上，仅做学习记录整理。
fastjson源码--进大厂的最后一脚
weixin_41563161的博客
12-24 1138
fastjson源码–进大厂的最后一脚 1.序 记得春招面试的时候的面试官问有读过什么源码没有，自己只是稍微看了一下fastjson的，并且当时最尴尬的是自己对着自己的笔记给面试官读的，然后就顺利的拿下了大厂的offer。所以源码还是值得读的。读源码会让我们有更多的思考在里面，学习的设计思想的魅力。今天就把fastjson整理一下。 2.详细 2.1 JSON 2.1.1 什么是JSON 让我们先来认识一下JSON是什么。以下是百度百科的内容。 简单来说， Json是一种轻量级的数据交换格式，采用一种“键
Java——常用JSON解析库详解（fastjson2、gson、jackson）
吴声子夜歌的博客
02-07 3295
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，相比xml数据交换格式来说，因为解析xml比较的复杂且需要编写大段的代码，所以客户端和服务器的数据交换格式往往通过JSON来进行交换。JSON简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构。fastjson：阿里gson：谷歌jackson：SpringMVC自带。
Java json库
lostdiver的博客
04-12 288
使用同一json库不可用其他json库一个库解析另一个库生成的东西那就解析不出来一个是fastJson  一个是net.sf.json   所以解析不揣
import org.json.JSONObject和import org.json.Simple.JSONObject;
05-25
这两个导入语句的区别在于使用的是不同的JSON库。 `org.json.JSONObject` 是原生的JSON库，它提供了一些基本的JSON解析和构建功能。 而 `org.json.simple.JSONObject` 则是一个简化版的JSON库，它提供了一些更加易用的JSON解析和构建功能，适用于一些简单的JSON操作。 如果你需要进行更加复杂的JSON操作，建议使用原生的JSON库。如果只是进行一些简单的JSON操作，可以考虑使用简化版的JSON库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值