Spring MVC JSON转换自定义注解

最新推荐文章于 2024-06-01 12:08:46 发布
最新推荐文章于 2024-06-01 12:08:46 发布
阅读量482 收藏
点赞数
分类专栏： Spring MVC 文章标签： spring mvc 自定义注解 JSON转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013905323/article/details/84814994
版权
本文介绍了一个Spring MVC应用中如何使用JSONHttpMessageConverter进行JSON转换，并实现漂亮的格式化及记录功能。此外，还展示了如何通过自定义注解RequestAttribute来简化参数获取过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.JSON转换

package cn.com.shopec.app.convert;

import cn.com.shopec.app.common.Result;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.http.HttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotWritableException;

import java.io.IOException;
import java.io.OutputStream;


/**
 * Created by guanfeng.li on 2016/7/18.
 */
public class JSONHttpMessageConverter extends FastJsonHttpMessageConverter {

    private Log log = LogFactory.getLog(JSONHttpMessageConverter.class);

    //字符集
    private String charset = "UTF-8";
    //漂亮格式化
    private boolean prettyFormat = false;
    private boolean recordeResult = true;

    @Override
    protected void writeInternal(Object obj, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        if(obj instanceof Result){
//            writer(obj, outputMessage);
            writerResult(obj, outputMessage);
        }else{
            super.writeInternal(obj, outputMessage);
        }
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json转换
     */
    private void writerResult(Object obj, HttpOutputMessage outputMessage) throws IOException {
        Result result = (Result) obj;
        result.addSerializerFeature(SerializerFeature.SortField,SerializerFeature.DisableCircularReferenceDetect);
        if(prettyFormat){
            result.addSerializerFeature(SerializerFeature.PrettyFormat);
        }
        String json = result.toString();
        OutputStream out = null;
        try {
            out = outputMessage.getBody();
            out.write(json.getBytes(charset));
            out.flush();
        } finally {
            out.close();
        }
        if(recordeResult){
            log.info("JSON："+json);
        }
    }

    //json转换
    private void writer(Object obj, HttpOutputMessage outputMessage) throws IOException {
        Result result = (Result) obj;
        result.addSerializerFeature(SerializerFeature.SortField);
        if(prettyFormat){
            result.addSerializerFeature(SerializerFeature.PrettyFormat);
        }
        result.addSerializeFilter(Result.class,"jsonConfig,jsonFeatures,jsonFilter",false);

        SerializerFeature[] features = new SerializerFeature[result.getJsonFeatures()==null?0:result.getJsonFeatures().size()];
        if(result.getJsonFeatures()!=null){
            result.getJsonFeatures().toArray(features);
        }

        SerializeFilter[] filters = new SerializeFilter[result.getJsonFilter()==null?0:result.getJsonFilter().size()];
        if(result.getJsonFilter()!=null){
            result.getJsonFilter().toArray(filters);
        }
        SerializeConfig jsonConfig = result.getJsonConfig();
        String json ;
        if(jsonConfig!=null){
            json = JSON.toJSONString(obj,jsonConfig,filters,features);
        }else{
            json = JSON.toJSONString(obj,filters,features);
        }
        outputMessage.getBody().write(json.getBytes(charset));
        log.info("返回JSON结果：\n"+json);
    }

    public void setCharset(String charset) {
        this.charset = charset;
    }

    public void setPrettyFormat(boolean prettyFormat) {
        this.prettyFormat = prettyFormat;
    }

    public void setRecordeResult(boolean recordeResult) {
        this.recordeResult = recordeResult;
    }
}

 

2.自定义注解

package cn.com.shopec.app.mvc.annotation;

import java.lang.annotation.*;

/**
 * Created by guanfeng.li on 2016/8/26.
 */
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestAttribute {

    String value() default "";

}

 

package cn.com.shopec.app.mvc.support;

import cn.com.shopec.app.mvc.annotation.RequestAttribute;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpServletRequest;

/**
 * Created by guanfeng.li on 2016/8/26.
 */
public class RequestAttributeHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        RequestAttribute requestAttribute = parameter.getParameterAnnotation(RequestAttribute.class);
        if(requestAttribute!=null){
            return true;
        }
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        HttpServletRequest req = webRequest.getNativeRequest(HttpServletRequest.class);
        if(req!=null){
            RequestAttribute requestAttribute = parameter.getParameterAnnotation(RequestAttribute.class);
            String value = requestAttribute.value();
            if(StringUtils.isNotEmpty(value)){
                return req.getAttribute(value);
            }

            if(StringUtils.isEmpty(value)){
                String parameterName = parameter.getParameterName();
                return req.getAttribute(parameterName);
            }
        }
        return null;
    }
}

 3.Spring MVC配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">

	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations" value="classpath:*.properties" />
	</bean>

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>


    <mvc:default-servlet-handler/>

    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="false">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean id="fastJsonHttpMessageConverter" class="cn.com.shopec.app.convert.JSONHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>text/plain;charset=UTF-8</value>
                    </list>
                </property>
                <!--是否漂亮格式化JSON结果-->
                <property name="prettyFormat" value="false"></property>
                <!--是否记录JSON返回结果-->
                <property name="recordeResult" value="false"></property>
            </bean>
        </mvc:message-converters>
        <mvc:argument-resolvers>
            <bean class="cn.com.shopec.app.mvc.support.RequestAttributeHandlerMethodArgumentResolver"></bean>
        </mvc:argument-resolvers>
    </mvc:annotation-driven>

    <!-- 自动扫描controller包下的所有类，使其认为spring mvc的控制器 -->
	<context:component-scan base-package="cn.com.shopec.app.controller" >
    </context:component-scan>
	<!-- 默认的注解映射的支持 -->
	<mvc:annotation-driven />

	<!-- 对静态资源文件的访问 -->
	<!--<mvc:resources mapping="/res/**" location="/res/" />-->

	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="defaultEncoding">
			<value>UTF-8</value>
		</property>
		<property name="maxUploadSize">
			<value>32505856</value><!-- 上传文件大小限制为31M，31*1024*1024 -->
		</property>
		<property name="maxInMemorySize">
			<value>4096</value>
		</property>
	</bean>


    <!--统一异常处理-->
    <bean id="exceptionHandler" class="cn.com.shopec.app.exception.ExceptionHandler"/>

    <!-- 系统错误转发配置[并记录错误日志] -->
    <bean id="exceptionResolver"
          class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--<property name="defaultErrorView" value="error"></property>   &lt;!&ndash; 默认为500，系统错误(error.jsp) &ndash;&gt;-->
        <property name="exceptionMappings">
            <props>
                <prop key="cn.com.shopec.app.exception.ExceptionHandler">error</prop>
            </props>
        </property>
    </bean>

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/public/api/**"/>
            <mvc:mapping path="/app/api/**"/>
            <bean class="cn.com.shopec.app.intercept.CommonIntercept"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/app/api/**"/>
            <mvc:mapping path="/api/**"/>
            <bean class="cn.com.shopec.app.intercept.TokenIntercept"/>
        </mvc:interceptor>
        <!--<mvc:interceptor>-->
            <!--<mvc:mapping path="/wechat/**"/>-->
            <!--<mvc:exclude-mapping path="/wechat/index"/>-->
            <!--<bean class="cn.com.shopec.app.intercept.WechatIntercept"/>-->
        <!--</mvc:interceptor>-->
    </mvc:interceptors>


</beans>

 4.接口消息实体类

package cn.com.shopec.app.common;


import cn.com.shopec.core.common.PageFinder;
import cn.com.shopec.core.common.Query;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.*;

import java.io.Serializable;
import java.lang.reflect.Type;
import java.util.*;

/**
 * Created by guanfeng.li on 2016/7/8.
 * APP接口返回实体类
 */
public class Result implements Serializable {

    //状态码
    private String status = "200";
    //消息提示
    private String msg = "";
    //响应数据
    private Object data;
    //分页
    private PageFinder page;

    //json格式化
    private SerializeConfig jsonConfig;
    //json 特性配置
    private Set<SerializerFeature> jsonFeatures;
    //json 属性过滤
    private Set<SerializeFilter> jsonFilter;

    public Result() {

    }

    public Result(Object data, Query query, long rowCount) {
        this.data = data;
        this.page = new PageFinder<>(query.getPageNo(), query.getPageSize(), rowCount);
    }

    public Result(String status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public Result(Object data) {
        this.data = data;
    }

    public Result(Object data,PageFinder page) {
        this.data = data;
        this.page = page;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * 特性配置
     */
    public Result addSerializerFeature(SerializerFeature... serializerFeatures) {
        addSerializerFeature(3, serializerFeatures);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * 特性配置
     */
    public Result addSerializerFeature(int size, SerializerFeature... serializerFeatures) {
        if (jsonFeatures == null) {
            jsonFeatures = new HashSet<>(size);
        }
        for (SerializerFeature item : serializerFeatures) {
            jsonFeatures.add(item);
        }
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json 属性过滤
     */
    public Result addSerializeFilter(Class<?> clazz, String properties) {
        addSerializeFilter(3, clazz, properties, true);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json 属性过滤
     */
    public Result addSerializeFilter(Class<?> clazz, String properties, boolean isinclude) {
        addSerializeFilter(3, clazz, properties, isinclude);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json 属性过滤
     */
    public Result addSerializeFilter(int size, Class<?> clazz, String properties, boolean isinclude) {
        if (jsonFilter == null) {
            jsonFilter = new HashSet<>();
        }
        if(clazz!=null && properties==null){
            jsonFilter.add(new SimplePropertyPreFilter(clazz));
            return this;
        }
        if(clazz==null && properties!=null){
            jsonFilter.add(new SimplePropertyPreFilter(properties.split(",")));
            return this;
        }
        if (!isinclude) {
            SimplePropertyPreFilter filter = new SimplePropertyPreFilter(clazz);
            filter.getExcludes().addAll(Arrays.asList(properties.split(",")));
            jsonFilter.add(filter);
        } else {
            jsonFilter.add(new SimplePropertyPreFilter(clazz, properties.split(",")));
        }
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * 过滤分页信息
     */
    public Result filterPage(){
        addSerializeFilter(this.getClass(),"page",false);
        return  this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json格式化
     */
    public Result putSerializeConfig(Class cls, ObjectSerializer value) {
        putSerializeConfig(3, cls, value);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * json格式化
     */
    public Result putSerializeConfig(int size, Class cls, ObjectSerializer value) {
        if (jsonConfig == null) {
            jsonConfig = new SerializeConfig(size);
        }
        jsonConfig.put(cls, value);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * 空字符串显示 “”
     * 空集合 []
     * 空Map {}
     * Number 0
     */
    public Result writeNullStringNumberListAsEmpty() {
        addSerializerFeature(5, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullStringAsEmpty,
                SerializerFeature.WriteNullNumberAsZero, SerializerFeature.WriteNullListAsEmpty);
        return this;
    }

    public Result writeNullStringAsEmpty() {
        addSerializerFeature(2, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullStringAsEmpty);
        return this;
    }

    public Result writeNullListAsEmpty() {
        addSerializerFeature(2, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullListAsEmpty);
        return this;
    }

    public Result writeNullNumberAsZero() {
        addSerializerFeature(2, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullNumberAsZero);
        return this;
    }

    /**
     * Created by guanfeng.li   2016/7/19
     * 漂亮格式化
     */
    public Result prettyFormat() {
        addSerializerFeature(SerializerFeature.PrettyFormat);
        return this;
    }

    //添加返回结果
    public Result put(String key, Object value) {
        if (data == null) {
            data = new HashMap();
        } else {
            if (!(data instanceof Map)) {
                return this;
            }
        }

        ((Map) data).put(key, value);
        return this;
    }

    public String getStatus() {
        return status;
    }

    public Result setStatus(String status) {
        this.status = status;
        return this;
    }

    public String getMsg() {
        return msg;
    }

    public Result setMsg(String msg) {
        this.msg = msg;
        return this;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public PageFinder getPage() {
        return page;
    }

    public Result setPage(PageFinder page) {
        this.page = page;
        return this;
    }

    public SerializeConfig getJsonConfig() {
        return jsonConfig;
    }

    public Set<SerializerFeature> getJsonFeatures() {
        return jsonFeatures;
    }

    public Set<SerializeFilter> getJsonFilter() {
        return jsonFilter;
    }

    @Override
    public String toString() {
        if (jsonFilter != null || jsonFeatures != null || jsonConfig != null) {
            addSerializeFilter(Result.class, "jsonConfig,jsonFeatures,jsonFilter", false);
        }
        SerializerFeature[] features = new SerializerFeature[jsonFeatures == null ? 0 : jsonFeatures.size()];
        if (jsonFeatures != null) {
            jsonFeatures.toArray(features);
        }

        SerializeFilter[] filters = new SerializeFilter[jsonFilter == null ? 0 : jsonFilter.size()];
        if (jsonFilter != null) {
            jsonFilter.toArray(filters);
        }
        String json;
        if (jsonConfig != null) {
            json = JSON.toJSONString(this, jsonConfig, filters, features);
        } else {
            json = JSON.toJSONString(this, filters, features);
        }
        return json;
    }
}

 

使用fastjson提供的接口实现自定义的编解码器
lmb55的专栏
05-29 8600
FastJson中文 API 在项目开发中经常会遇到一些业务需要对某些数据进行特殊的定制化处理，fastjson为我们提供了接口可以用于实现自定义的编解码器来完成我们的业务要求。 ObjectSerializer和ObjectDeserializer分别是fastjson的编码器和解码器接口。 ObjectDeserializer接口源码： /** * <p>Interface re...
Spring中自定义JSON注释
m0_37027631的博客
06-06 2816
工具类代码下载地址：链接：http://pan.baidu.com/s/1qYNQOGW 密码：e18w 1、如图1的系统注释，有的时候我们在开发的时候系统的注释并不够用，此时我们可以自己写一些注释来应用的自己项目的开发中，这样更加的灵活方便。本文讲解的是自定义@JSON注释来控制返回指定的json字符串 图1 2、在spring-mvc.xml配置文件中添加如下代码（此处一定要
SpringMVC时间参数绑定--@JsonFormat与@DateTimeFormat注解
失意渔翁
05-05 2533
问题描述: 前台有个时间类型的表单项,后台的controller用的是Date()类型的参数接收, 发现运行报400错误–也就是Date类型的参数没映射上,为null了… 原因:前台传的date是String类型的,后台用的是Date接收的, 解决:String 的@DateTimeFormat可解决入参的时间映射问题, json的@JsonFormat可解决出参的时间映射问题… ...
fastjson报NoSuchMethodError诡异
u010002517的博客
01-04 418
一个神奇的bug，2017年的一个工程A依赖fastjson1.2.7编译出了一个jar包，fastjson中有一个类SerializeConfig，这个类继承了一个put(Object k,Object v)的方法，所以编译出的jar包字节码里写的方法签名就是descriptor: (Ljava/lang/Object;Lja...
JSON序列化/反序列化，指定自定义字段名key转换注解配置
日常记录
01-13 7326
输出结果： 可以看到直接输出key也是自定义的，但这里用的是alibaba.fastjson注解完成的，和上面使用场景不一样，因为springboot使用fastjson序列化对象。在springboot请求接口返回对象得到的结果：(因为springboot使用fastjson序列化对象)实体类属性上增加@JSONField(name = “属性名”)注解(alibaba.fastjson)实体类的属性上面增加@JsonProperty(“字段名”)注解(fastjson)
Mybatis自定义Handler实现Json数组转List对象
Mistra的博客
06-10 3310
先定义一个ListTypeHandler 泛型为需要Json转换为的目标实体对象
Spring MVC：自定义注解控制json返回字段
在Spring MVC开发中，处理...总结来说，本文教会了开发者如何利用Spring MVC的自定义注解来实现JSON响应的灵活过滤，从而简化接口设计，提高代码的复用性和可读性。这在构建RESTful API时是非常实用的一种技术手段。
自定义spring mvc的json视图实现思路解析
10-18
在本文中，将深入解析如何在Spring MVC环境下自定义JSON视图，以便解决多端数据接口对接的问题。具体来说，文章首先介绍了与多端数据接口对接相关的背景知识，然后详细阐述了实现自定义JSON视图的具体步骤，并重点...
Spring mvc Json处理实现流程代码实例
10-14
更简洁的方式是使用`@RequestBody`注解，该注解告诉Spring MVC使用合适的HttpMessageConverter将请求体中的JSON数据自动转换为指定类型的Java对象。例如： ```java @RequestMapping("/addbook3") @ResponseBody...
Spring Boot实现全局序列化配置（Jackson、FastJson）
旭东怪的博客
10-01 4718
1JsonConfig 序列化配置类。 package com.config; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.databind..
SpringMVC学习之Jackson和fastJson将后端数据转换成前端JSON字符串
qq_43880100的博客
09-15 931
学习SpringMVC时候的JSON相关知识笔记
fastjson实体转换异常问题
凌飞安
09-14 1883
com.alibaba.fastjson转实体遇到的一个大坑问题描述问题原因解决方案 问题描述 项目中使用fastjson将json字符串转换为对应的实体，某天因为业务需要，实体需要增加两个属性，然后就出问题了，具体的错误日记如下所示 at java.awt.EventDispatchThread.run(Unknown Source) Exception in thread "AWT-EventQueue-0" java.lang.VerifyError: (class: com/alibaba/fas
自定义json数据的对象转换器
最新发布
weixin_74004976的博客
06-01 743
对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]从Java对象生成JSON的过程称为 [序列化Java对象到JSON]在上面的基础我们只需注释掉@JsonFormat以排除对这次操作的影响。首先编写JacksonObjectMapper对象转换器。
Spring MVC使用注解格式化数据
实践求真知
08-29 614
一领域模型 package org.fkit.domain; import java.io.Serializable; import java.util.Date; import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.NumberF...
LeetCode刷题（七）——递归思维+滑动窗口
Eve12345678的博客
07-31 808
Day10 2020.07.31 1.reverse-string 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。 解法一：双指针 class Solution{ public: void reverseString(vector<char>& s) {
Alibaba FastJson支持对象中私有属性的json解析
热门推荐
魔力鸟的专栏
10-15 1万+
项目中需要使用fastjson做数据处理，而且部分对象中的属性很多都是非public的，且没有getter/setter方法，找了很久没有找到fastjson对这个问题的解决。 所以自己动手，基于fastjson的源代码构造了单独的javabean的序列化器。 使用方式：直接使用封装好的MetaJsonUtil的工具方法即可。 fastjson版本为1.2.7 MetaJs
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值