swagger2.9.2 报错：java.lang.NumberFormatException: empty String

最新推荐文章于 2024-08-19 00:15:00 发布
最新推荐文章于 2024-08-19 00:15:00 发布
阅读量1.5k 收藏 2
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23539167/article/details/108846574
版权

swagger2.9.2 报错：java.lang.NumberFormatException: empty String
原因：通过对比1.5.20与2.9.2源码，发现2.9.2源码缺失部分判断信息

在这里插入图片描述
解决方案：
1.降低版本自1.5.20；
2.对实体勒种Integer，BigDecimal，Long等类型，增加默认值example
在这里插入图片描述
3.推荐，重写
创建：io.swagger.models.parameters包，同时重写AbstractSerializableParameter.java
在这里插入图片描述

package io.swagger.models.parameters;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import io.swagger.models.properties.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
* @description   修改io.swagger.models.parameters源码(通过对比1.5.20与2.9.2源码，发现2.9.2源码缺失部分判断信息)
*                解决：Integer，BigDecimal，Long等类型，没有默认值example的报错问题
* @author        plj
* @date          2020/9/27 9:42
* @version       V1.0
**/
@JsonPropertyOrder({ "name", "in", "description", "required", "type", "items", "collectionFormat", "default", "maximum",
        "exclusiveMaximum", "minimum", "exclusiveMinimum", "maxLength", "minLength", "pattern", "maxItems", "minItems",
        "uniqueItems", "multipleOf" })
public abstract class AbstractSerializableParameter<T extends AbstractSerializableParameter<T>> extends AbstractParameter implements SerializableParameter {
    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractSerializableParameter.class);
    protected String type;
    protected String format;
    protected String collectionFormat;
    protected Property items;
    protected Boolean exclusiveMaximum;
    protected BigDecimal maximum;
    protected Boolean exclusiveMinimum;
    protected BigDecimal minimum;
    protected String example;
    private Integer maxItems;
    private Integer minItems;
    protected Boolean allowEmptyValue;

    @JsonIgnore
    protected List<String> _enum;

    /**
     * See http://json-schema.org/latest/json-schema-validation.html#anchor26
     */
    public Integer maxLength;
    /**
     * See http://json-schema.org/latest/json-schema-validation.html#anchor29
     */
    public Integer minLength;
    /**
     * See http://json-schema.org/latest/json-schema-validation.html#anchor33
     */
    public String pattern;
    /**
     * See http://json-schema.org/latest/json-schema-validation.html#anchor49
     */
    public Boolean uniqueItems;
    /**
     * See http://json-schema.org/latest/json-schema-validation.html#anchor14
     */
    public Number multipleOf;

    @JsonIgnore
    protected String defaultValue;

    public T property(Property property) {
        this.setProperty(property);
        return castThis();
    }

    public T type(String type) {
        this.setType(type);
        return castThis();
    }

    public T format(String format) {
        this.setFormat(format);
        return castThis();
    }

    public T description(String description) {
        this.setDescription(description);
        return castThis();
    }

    public T name(String name) {
        this.setName(name);
        return castThis();
    }

    public T required(boolean required) {
        this.setRequired(required);
        return castThis();
    }

    public T collectionFormat(String collectionFormat) {
        this.setCollectionFormat(collectionFormat);
        return castThis();
    }

    public T example(String example) {
        this.setExample(example);
        return castThis();
    }

    public T allowEmptyValue(Boolean allowEmpty) {
        this.setAllowEmptyValue(allowEmpty);
        return castThis();
    }

    public T readOnly(Boolean readOnly) {
        this.setReadOnly(readOnly);
        return castThis();
    }

    @JsonIgnore
    protected String getDefaultCollectionFormat() {
        return "csv";
    }

    public T items(Property items) {
        this.items = items;
        return castThis();
    }

    public T _enum(List<String> value) {
        this._enum = value;
        return castThis();
    }

    @JsonIgnore
    @Override
    public List<String> getEnum() {
        return _enum;
    }

    @Override
    public void setEnum(List<String> _enum) {
        this._enum = _enum;
    }

    @JsonProperty("enum")
    @Override
    public List<Object> getEnumValue() {
        if (_enum == null) return null;
        if (_enum.isEmpty()) return Collections.emptyList();
        List<Object> oList = new ArrayList<Object>(_enum.size());

        if (BaseIntegerProperty.TYPE.equals(type) || DecimalProperty.TYPE.equals(type)) {
            for (String s : _enum) {
                try {
                    if ("int32".equals(format)) {
                        oList.add(Integer.valueOf(s));
                    } else if ("int64".equals(format)) {
                        oList.add(Long.valueOf(s));
                    } else if ("double".equals(format)) {
                        oList.add(Double.valueOf(s));
                    } else if ("float".equals(format)) {
                        oList.add(Float.valueOf(s));
                    } else if (BaseIntegerProperty.TYPE.equals(type)) {
                        oList.add(Integer.valueOf(s));
                    } else if (DecimalProperty.TYPE.equals(type)) {
                        oList.add(Double.valueOf(s));
                    }
                } catch (NumberFormatException e) {
                    LOGGER.warn(String.format("Illegal enum value %s for parameter type %s", s, type), e);
                    oList.add(s);
                }
            }
        } else if ((type == null || "array".equals(type)) && items != null) {
            for (String s : _enum) {
                try {
                    if (items instanceof StringProperty) {
                        oList.add(s);
                    } else if (items instanceof IntegerProperty) {
                        oList.add(Integer.valueOf(s));
                    } else if (items instanceof LongProperty) {
                        oList.add(Long.valueOf(s));
                    } else if (items instanceof FloatProperty) {
                        oList.add(Float.valueOf(s));
                    } else if (items instanceof DoubleProperty) {
                        oList.add(Double.valueOf(s));
                    } else if (items instanceof BaseIntegerProperty) {
                        oList.add(Integer.valueOf(s));
                    } else if (items instanceof DecimalProperty) {
                        oList.add(Double.valueOf(s));
                    } else {
                        oList.add(s);
                    }
                } catch (NumberFormatException e) {
                    LOGGER.warn(String.format("Illegal enum value %s for parameter type %s", s, type), e);
                    oList.add(s);
                }
            }

        } else {
            for (String s: _enum) {
                oList.add(s);
            }
        }
        return oList;
    }

    @Override
    public void setEnumValue(List<?> enumValue) {
        if (enumValue == null) {
            this._enum = null;
            return;
        }
        if (enumValue.isEmpty()) {
            this._enum = Collections.emptyList();
            return;
        }
        List<String> sList = new ArrayList<String>(enumValue.size());
        for (Object item: enumValue) {
            sList.add(item.toString());
        }
        this._enum = sList;
    }

    @Override
    public Property getItems() {
        return items;
    }

    @Override
    public void setItems(Property items) {
        this.items = items;
    }

    @Override
    public String getFormat() {
        return format;
    }

    @Override
    public void setFormat(String format) {
        this.format = format;
    }

    @Override
    public String getType() {
        return type;
    }

    @Override
    public void setType(String type) {
        this.type = type;
        if(ArrayProperty.isType(type)) {
            if(getCollectionFormat() == null){
                setCollectionFormat(getDefaultCollectionFormat());
            }
        } else {
            setCollectionFormat(null);
        }
    }

    @Override
    public String getCollectionFormat() {
        return collectionFormat;
    }

    @Override
    public void setCollectionFormat(String collectionFormat) {
        this.collectionFormat = collectionFormat;
    }

    public void setProperty(Property property) {
        setType(property.getType());
        this.format = property.getFormat();
        if (property instanceof StringProperty) {
            final StringProperty string = (StringProperty) property;
            setEnum(string.getEnum());
        } else if (property instanceof IntegerProperty) {
            setEnumValue(((IntegerProperty) property).getEnum());
        } else if (property instanceof LongProperty) {
            setEnumValue(((LongProperty) property).getEnum());
        } else if (property instanceof FloatProperty) {
            setEnumValue(((FloatProperty) property).getEnum());
        } else if (property instanceof DoubleProperty) {
            setEnumValue(((DoubleProperty) property).getEnum());
        } else if (property instanceof ArrayProperty) {
            final ArrayProperty array = (ArrayProperty) property;
            setItems(array.getItems());
        }
    }

    public Object getDefaultValue() {
        if(defaultValue == null) {
            return null;
        }

        // don't return a default value if types fail to convert
        try {
            if ("integer".equals(this.type)) {
                return new Integer(defaultValue);
            }
            if ("number".equals(this.type)) {
                return new BigDecimal(defaultValue);
            }
        }
        catch (Exception e) {
            return null;
        }

        return defaultValue;
    }

    public void setDefaultValue(String defaultValue) {
        this.defaultValue = defaultValue;
    }

    public Object getDefault() {
        if (defaultValue == null || defaultValue.isEmpty()) {
            return null;
        }
        try {
            if (BaseIntegerProperty.TYPE.equals(type)) {
                return Long.valueOf(defaultValue);
            } else if (DecimalProperty.TYPE.equals(type)) {
                return Double.valueOf(defaultValue);
            } else if (BooleanProperty.TYPE.equals(type)) {
                if ("true".equalsIgnoreCase(defaultValue) || "false".equalsIgnoreCase(defaultValue)) {
                    return Boolean.valueOf(defaultValue);
                }
            }
        } catch (NumberFormatException e) {
            LOGGER.warn(String.format("Illegal DefaultValue %s for parameter type %s", defaultValue, type), e);
        }
        return defaultValue;
    }

    public void setDefault(Object defaultValue) {
        this.defaultValue = defaultValue == null ? null : defaultValue.toString();
    }

    @Override
    public void setExclusiveMaximum(Boolean exclusiveMaximum) {
        this.exclusiveMaximum = exclusiveMaximum;
    }

    @Override
    public BigDecimal getMaximum() {
        return maximum;
    }

    @Override
    public void setMaximum(BigDecimal maximum) {
        this.maximum = maximum;
    }

    @Override
    public Boolean isExclusiveMinimum() {
        return exclusiveMinimum;
    }

    @Override
    public void setExclusiveMinimum(Boolean exclusiveMinimum) {
        this.exclusiveMinimum = exclusiveMinimum;
    }

    @Override
    public BigDecimal getMinimum() {
        return minimum;
    }

    @Override
    public void setMinimum(BigDecimal minimum) {
        this.minimum = minimum;
    }

    @Override
    public Integer getMaxItems() {
        return maxItems;
    }

    @Override
    public void setMaxItems(Integer maxItems) {
        this.maxItems = maxItems;
    }

    @Override
    public Integer getMinItems() {
        return minItems;
    }

    @Override
    public void setMinItems(Integer minItems) {
        this.minItems = minItems;
    }

    @Override
    public Boolean getAllowEmptyValue() {
        return allowEmptyValue;
    }

    @Override
    public void setAllowEmptyValue(Boolean allowEmptyValue) {
        this.allowEmptyValue = allowEmptyValue;
    }

    @JsonProperty("x-example")
    public Object getExample() {
        /* 增加example.isEmpty()判断，修复Integer，BigDecimal，Long等类型，没有默认值example的报错问题
            if (example == null) {
                return null;
            }
        */
        if (example == null||example.isEmpty()) {
            return null;
        }
        try {
            if (BaseIntegerProperty.TYPE.equals(type)) {
                return Long.valueOf(example);
            } else if (DecimalProperty.TYPE.equals(type)) {
                return Double.valueOf(example);
            } else if (BooleanProperty.TYPE.equals(type)) {
                if ("true".equalsIgnoreCase(example) || "false".equalsIgnoreCase(defaultValue)) {
                    return Boolean.valueOf(example);
                }
            }
        } catch (NumberFormatException e) {
            LOGGER.warn(String.format("Illegal DefaultValue %s for parameter type %s", defaultValue, type), e);
        }
        return example;
    }

    @Override
    public Integer getMaxLength() {
        return maxLength;
    }

    @Override
    public void setMaxLength(Integer maxLength) {
        this.maxLength = maxLength;
    }

    @Override
    public Integer getMinLength() {
        return minLength;
    }

    @Override
    public void setMinLength(Integer minLength) {
        this.minLength = minLength;
    }

    @Override
    public String getPattern() {
        return pattern;
    }

    @Override
    public void setPattern(String pattern) {
        this.pattern = pattern;
    }

    @Override
    public Boolean isUniqueItems() {
        return uniqueItems;
    }

    @Override
    public void setUniqueItems(Boolean uniqueItems) {
        this.uniqueItems = uniqueItems;
    }

    @Override
    public Number getMultipleOf() {
        return multipleOf;
    }

    @Override
    public void setMultipleOf(Number multipleOf) {
        this.multipleOf = multipleOf;
    }

    @Override
    public Boolean isExclusiveMaximum() {
        return exclusiveMaximum;
    }

    public void setExample(String example) {
        this.example = example;
    }

    @JsonIgnore
    private T castThis() {
        @SuppressWarnings("unchecked")
        final T result = (T) this;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!super.equals(obj)) return false;
        if (getClass() != obj.getClass()) return false;
        AbstractSerializableParameter<?> other = (AbstractSerializableParameter<?>) obj;
        if (_enum == null) {
            if (other._enum != null) return false;
        } else if (!_enum.equals(other._enum)) return false;
        if (collectionFormat == null) {
            if (other.collectionFormat != null) return false;
        } else if (!collectionFormat.equals(other.collectionFormat)) return false;
        if (defaultValue == null) {
            if (other.defaultValue != null) return false;
        } else if (!defaultValue.equals(other.defaultValue)) return false;
        if (example == null) {
            if (other.example != null) return false;
        } else if (!example.equals(other.example)) return false;
        if (exclusiveMaximum == null) {
            if (other.exclusiveMaximum != null) return false;
        } else if (!exclusiveMaximum.equals(other.exclusiveMaximum)) return false;
        if (exclusiveMinimum == null) {
            if (other.exclusiveMinimum != null) return false;
        } else if (!exclusiveMinimum.equals(other.exclusiveMinimum)) return false;
        if (format == null) {
            if (other.format != null) return false;
        } else if (!format.equals(other.format)) return false;
        if (items == null) {
            if (other.items != null) return false;
        } else if (!items.equals(other.items)) return false;
        if (maxItems == null) {
            if (other.maxItems != null) return false;
        } else if (!maxItems.equals(other.maxItems)) return false;
        if (maxLength == null) {
            if (other.maxLength != null) return false;
        } else if (!maxLength.equals(other.maxLength)) return false;
        if (maximum == null) {
            if (other.maximum != null) return false;
        } else if (!maximum.equals(other.maximum)) return false;
        if (minItems == null) {
            if (other.minItems != null) return false;
        } else if (!minItems.equals(other.minItems)) return false;
        if (minLength == null) {
            if (other.minLength != null) return false;
        } else if (!minLength.equals(other.minLength)) return false;
        if (minimum == null) {
            if (other.minimum != null) return false;
        } else if (!minimum.equals(other.minimum)) return false;
        if (multipleOf == null) {
            if (other.multipleOf != null) return false;
        } else if (!multipleOf.equals(other.multipleOf)) return false;
        if (pattern == null) {
            if (other.pattern != null) return false;
        } else if (!pattern.equals(other.pattern)) return false;
        if (type == null) {
            if (other.type != null) return false;
        } else if (!type.equals(other.type)) return false;
        if (uniqueItems == null) {
            if (other.uniqueItems != null) {
                return false;
            }
        } else if (!uniqueItems.equals(other.uniqueItems)) {
            return false;
        }
        if (allowEmptyValue != null ? !allowEmptyValue.equals(other.allowEmptyValue) : other.allowEmptyValue != null) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + ((_enum == null) ? 0 : _enum.hashCode());
        result = prime * result + ((collectionFormat == null) ? 0 : collectionFormat.hashCode());
        result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
        result = prime * result + ((example == null) ? 0 : example.hashCode());
        result = prime * result + ((exclusiveMaximum == null) ? 0 : exclusiveMaximum.hashCode());
        result = prime * result + ((exclusiveMinimum == null) ? 0 : exclusiveMinimum.hashCode());
        result = prime * result + ((format == null) ? 0 : format.hashCode());
        result = prime * result + ((items == null) ? 0 : items.hashCode());
        result = prime * result + ((maxItems == null) ? 0 : maxItems.hashCode());
        result = prime * result + ((maxLength == null) ? 0 : maxLength.hashCode());
        result = prime * result + ((maximum == null) ? 0 : maximum.hashCode());
        result = prime * result + ((minItems == null) ? 0 : minItems.hashCode());
        result = prime * result + ((minLength == null) ? 0 : minLength.hashCode());
        result = prime * result + ((minimum == null) ? 0 : minimum.hashCode());
        result = prime * result + ((multipleOf == null) ? 0 : multipleOf.hashCode());
        result = prime * result + ((pattern == null) ? 0 : pattern.hashCode());
        result = prime * result + ((type == null) ? 0 : type.hashCode());
        result = prime * result + ((uniqueItems == null) ? 0 : uniqueItems.hashCode());
        result = prime * result + (allowEmptyValue != null ? allowEmptyValue.hashCode() : 0);
        return result;
    }
}
PLJ_
关注
Swagger报错：Caused by: java.lang.NullPointerException: null at springfox.documentation.spring.web
流楚丶格念的博客
11-18 1051
因为 Springfox 使用的路径匹配是基于AntPathMatcher 的，而 Spring Boot 2.6.X等低版本使用的是 PathPatternMatcher。在yml（yaml）里添加如下配置，重写匹配一下路径。
解决swagger报：java.lang.IllegalStateException: Ambiguous models equality when conditions is empty
hkl_Forever的博客
12-21 1195
（2）解决（1）问题，需要把当前类中引用的当前dto类型属性和引用当前dto类的其他dto中对应的类型属性隐藏掉（@ApiModelProperty(value = "xxx", hidden = true)）例如：aDto、bDto，aDto中引用aDto自己，bDto中也引用了aDto，就会出现出现本次所说的异常现象，此时把aDto中引用aDto自己这个属性隐藏掉，再把bDto中也引用的aDto属性隐藏掉即可。2、把循环引用的两个dto中swagger属性的文档标记为隐藏 hidden = true。
控制台报错For input string: ““、empty String
m0_54193189的博客
04-07 1289
通过修改swagger依赖版本，解决For input string: ""、empty String报错。
swagger2 一刷新就报 java.lang.NumberFormatException: empty String For input string: ““
CenZn的博客
05-15 493
默认 models 1.5.20 改为1.5.22就好了 <!--swagger ui依赖--> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version> <!-- 排除..
Swagger接口文档基本使用教程
最新发布
www.h y p e r p l a s m a.top
08-19 893
Swagger是一个针对RESTful Web服务的框架，旨在简化接口的生成、描述和测试，非常适合前后端分离的开发模式。它能够自动生成在线接口文档，减轻后端开发人员的文档编写负担。此外，Swagger与Spring框架高度兼容，通过引入Springfox组件，开发者可以轻松集成Swagger。Knife4j作为Swagger的增强解决方案，提供了更为便利的API文档生成工具，适合于Java MVC框架。
java.lang.NumberFormatException: empty String
康小超
01-02 4167
java.lang.NumberFormatException: empty String at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1842) at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110) at java....
java.lang.NumberFormatException: empty String 错误
dianman0220的博客
11-22 4968
原因：前台获取的字符串，后台类型转换，与之对应的实体类中却是Integer类型，所以会报错。 排错情况：1.先检查数据库与实体类中的类型是否一致 　　　　　2.检查类型转换代码，如果需要加入异常处理 转载于:https://www.cnblogs.com/doublesauce/p/4114985.html...
Swagger2异常:java.lang.NumberFormatException:For input string:""
weixin_42835717的博客
03-01 5520
Swagger2异常:java.lang.NumberFormatException:For input string:"" 最近在springboot2.x项目中整合swagger2.9.2版本时,在进行在线接口测试时,出现java.lang.NumberFormatException:For input string:""的异常，针对此问题，小紫也在度娘上寻找了许多方法，也进行了一系列的尝试...
swagger报错java.lang.NumberFormatException: For input string: ““，解决方法
Vicky_2020的博客
09-14 4068
1、问题出现 偶然发现有一天，运行swagger会报java.lang.NumberFormatException: For input string: ""错误，出错的原因呢是因为 空字符串""无法转成Number。 2、分析 查阅大量资料发现是swagger版本的问题，我使用的是io.springfox:springfox-swagger2:2.9.2的版本，而该版本依赖了swagger-models的1.5.20版本（会导致报此错），深挖原因是1.5.20版本中的...
报错解决：关于swagger的Caused by: java.lang.NullPointerException: null
快乐学习
04-26 978
在往springboot项目里面添加swagger时候，启动的时候就报了如下null了的错误。 Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled. Caused by: java.lang.NullPointerException: null
java lang NumberFormatException empty String
qq_43678480的博客
02-13 933
java lang NumberFormatException empty String
Eclipse运行项目报错java.lang.NumberFormatException: empty String
qq_44699157的博客
07-16 938
http协议不支持navigator.geolocation。
Java java.lang.NumberFormatException: empty String
weixin_30580341的博客
07-22 1598
卧槽，今天是真他娘的坑爹呀。。 错误百出啊，shit 、、、 又遇到了介个问题，哥纠结了半天。。 Java java.lang.NumberFormatException: empty String 查了一下，原来是 因为 在这条语句中Float.parseFloat(bookPrice)，bookPrice 接收的是文本框中的数据，而我在输入时 输入了字符。 看来这个地方需要注意一下，...
com.google.gson.JsonSyntaxException: java.lang.NumberFormatException:empty String
Aile
03-18 5152
问题: 某时后台给了一个账号,说app登陆不了,而其他账号可以,让帮忙看下什么原因 分析: 1,异常解释: json语法异常:数字格式化异常:空字符串 2,返回结果(其实很复杂,我删除很多字段,只保留重点): { "resultCode":200, "loginFlag":true, "rows":[ { "NM_STATE":85905, "DEPTORDER":8, "ST_MAJOR":"
swagger报java.lang.NumberFormatException
大造梦家的博客
05-17 279
原因: 在使用@ApiModelProperty的时候有个example属性,如果没设置默认值,会自动赋值""空字符串,导致整型数据赋值有问题 解决办法: 修改maven依赖: <dependency> <groupId>io.springfox</groupId> <artifactId>s...
关于spring boot在启动的时候报错: java.lang.Error: generate operation swagger failed, xxx.xxx.xxx...
06-11
这个问题可能是由于Swagger生成API文档时出现了问题导致的。您可以尝试以下解决方法： 1. 确认您的项目中是否已经引入了Swagger相关的依赖，如 springfox-swagger2 和 springfox-swagger-ui。 2. 检查您的代码中是否使用了Swagger相关的注解，如 @Api 和 @ApiOperation。 3. 检查您的Swagger配置是否正确，如是否指定了正确的扫描包路径。 4. 尝试升级您的Swagger版本，或者降级到稳定版本。 5. 如果以上方法都无法解决问题，可以尝试在启动程序时关闭Swagger的自动文档生成功能，如在 application.properties 文件中添加如下配置： springfox.documentation.swagger.v2.enabled=false 希望这些方法能够帮助您解决问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值