Mybatis占位符#和$的区别？源码解读

最新推荐文章于 2024-09-01 06:45:00 发布
最新推荐文章于 2024-09-01 06:45:00 发布
阅读量342 收藏 1
点赞数 1
分类专栏： java mybatis源码 文章标签： mybatis spring java 源码软件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wayn111/article/details/128956953
版权

Mybatis 作为国内开发中常用到的半自动 orm 框架，相信大家都很熟悉，它提供了简单灵活的xml映射配置，方便开发人员编写简单、复杂SQL，在国内互联网公司使用众多。

本文针对笔者日常开发中对 Mybatis 占位符 #{} 和 ${} 使用时机结合源码，思考总结而来

  • Mybatis 版本 3.5.11
  • Spring boot 版本 3.0.2
  • mybatis-spring 版本 3.0.1
  • github地址：https://github.com/wayn111， 欢迎大家关注，点个star

一. 启动时，mybatis-spring 解析xml文件流程图

Spring 项目启动时，mybatis-spring 自动初始化解析xml文件核心流程
流程图 (2).jpg
Mybatis 在 buildSqlSessionFactory() 会遍历所有 mapperLocations（xml文件） 调用 xmlMapperBuilder.parse()解析，源码如下
image.png
在 parse() 方法中， Mybatis 通过 configurationElement(parser.evalNode("/mapper")) 方法解析xml文件中的各个标签

public class XMLMapperBuilder extends BaseBuilder {
  ...
  private final MapperBuilderAssistant builderAssistant;
  private final Map<String, XNode> sqlFragments;
  ...
  
    public void parse() {
      if (!configuration.isResourceLoaded(resource)) {
        // xml文件解析逻辑
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        bindMapperForNamespace();
      }

      parsePendingResultMaps();
      parsePendingCacheRefs();
      parsePendingStatements();
    }


    private void configurationElement(XNode context) {
      try {
        // 解析xml文件内的namespace、cache-ref、cache、parameterMap、resultMap、sql、select、insert、update、delete等各种标签
        String namespace = context.getStringAttribute("namespace");
        if (namespace == null || namespace.isEmpty()) {
          throw new BuilderException("Mapper's namespace cannot be empty");
        }
        builderAssistant.setCurrentNamespace(namespace);
        cacheRefElement(context.evalNode("cache-ref"));
        cacheElement(context.evalNode("cache"));
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        sqlElement(context.evalNodes("/mapper/sql"));
        buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
      } catch (Exception e) {
        throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
      }
    }
}

最后会把 namespace、cache-ref、cache、parameterMap、resultMap、select、insert、update、delete等标签内容解析结果放到 builderAssistant 对象中，将sql标签解析结果放到sqlFragments对象中，其中 由于 builderAssistant 对象会保存select、insert、update、delete标签内容解析结果我们对 builderAssistant 对象进行深入了解

public class MapperBuilderAssistant extends BaseBuilder {
...
}

public abstract class BaseBuilder {
  protected final Configuration configuration;
  ...
}  

public class Configuration {
  ...
  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
      .conflictMessageProducer((savedValue, targetValue) ->
          ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
  protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
  protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
  protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
  protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
  protected final Set<String> loadedResources = new HashSet<>();
  protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");
  ...
}

builderAssistant 对象继承至 BaseBuilder，BaseBuilder 类中包含一个 configuration 对象属性， configuration 对象中会保存xml文件标签解析结果至自身对应属性mappedStatements、caches、resultMaps、sqlFragments。

这里有个问题上面提到的sql标签结果会放到 XMLMapperBuilder 类的 sqlFragments 对象中，为什么 Configuration 类中也有个 sqlFragments 属性？

这里回看上文 buildSqlSessionFactory() 方法最后
image.png
原来 XMLMapperBuilder 类中的 sqlFragments 属性就来自Configuration类😂

回到主题，在 buildStatementFromContext(context.evalNodes("select|insert|update|delete")) 方法中会通过如下调用

buildStatementFromContext(List<XNode> list, String requiredDatabaseId) 
-> parseStatementNode()
-> createSqlSource(Configuration configuration, XNode script, Class<?> parameterType)
-> parseScriptNode()
-> parseDynamicTags(context)

最后通过parseDynamicTags(context) 方法解析 select、insert、update、delete 标签内容将结果保存在 MixedSqlNode 对象中的 SqlNode 集合中

public class MixedSqlNode implements SqlNode {
  private final List<SqlNode> contents;

  public MixedSqlNode(List<SqlNode> contents) {
    this.contents = contents;
  }

  @Override
  public boolean apply(DynamicContext context) {
    contents.forEach(node -> node.apply(context));
    return true;
  }
}

SqlNode 是一个接口，有10个实现类如下
image.png
可以看出我们的 select、insert、update、delete 标签中包含的各个文本（包含占位符 #{} 和 ${}）、子标签都有对应的 SqlNode 实现类，后续运行中， Mybatis 对于 select、insert、update、delete 标签的 sql 语句处理都与这里的 SqlNode 各个实现类相关。自此我们 mybatis-spring 初始化流程中相关的重要代码都过了一遍。

二. 运行中，sql语句占位符 #{} 和 ${} 的处理

这里直接给出xml文件查询方法标签内容

<select id="findNewBeeMallOrderList" parameterType="Map" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List"/>
    from tb_newbee_mall_order
    <where>
        <if test="orderNo!=null and orderNo!=''">
            and order_no = #{orderNo}
        </if>
        <if test="userId!=null and userId!=''">
            and user_id = #{userId}
        </if>
        <if test="payType!=null and payType!=''">
            and pay_type = #{payType}
        </if>
        <if test="orderStatus!=null and orderStatus!=''">
            and order_status = #{orderStatus}
        </if>
        <if test="isDeleted!=null and isDeleted!=''">
            and is_deleted = #{isDeleted}
        </if>
        <if test="startTime != null and startTime.trim() != ''">
            and create_time &gt; #{startTime}
        </if>
        <if test="endTime != null and endTime.trim() != ''">
            and create_time &lt; #{endTime}
        </if>
    </where>
    <if test="sortField!=null and order!=null">
        order by ${sortField} ${order}
    </if>
    <if test="start!=null and limit!=null">
        limit #{start},#{limit}
    </if>
</select>

运行时 Mybatis 动态代理 MapperProxy 对象的调用流程，如下：

-> newBeeMallOrderMapper.findNewBeeMallOrderList(pageUtil);
-> MapperProxy.invoke(Object proxy, Method method, Object[] args)
-> MapperProxy.invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession)
-> MapperMethod.execute(SqlSession sqlSession, Object[] args)
-> MapperMethod.executeForMany(SqlSession sqlSession, Object[] args)
-> SqlSessionTemplate.selectList(String statement, Object parameter)
-> SqlSessionInterceptor.invoke(Object proxy, Method method, Object[] args)
-> DefaultSqlSession.selectList(String statement, Object parameter)
-> DefaultSqlSession.selectList(String statement, Object parameter, RowBounds rowBounds)
-> DefaultSqlSession.selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler)
-> CachingExecutor.query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)
-> MappedStatement.getBoundSql(Object parameterObject)
-> DynamicSqlSource.getBoundSql(Object parameterObject)
-> MixedSqlNode.apply(DynamicContext context) // ${} 占位符处理
-> SqlSourceBuilder.parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) // #{} 占位符处理

Mybatis 通过 DynamicSqlSource.getBoundSql(Object parameterObject) 方法对 select、insert、update、delete 标签内容做 sql 转换处理，代码如下：

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
  }

2.1 ${} 占位符处理

在 rootSqlNode.apply(context) -> MixedSqlNode.apply(DynamicContext context) 中会将 SqlNode 集合拼接成实际要执行的 sql 语句
保存在 DynamicContext 对象中。这里给出 SqlNode 集合的调试截图
image.png
可以看出我们的 ${} 占位符文本的 SqlNode 实现类为 TextSqlNode，apply方法相关操作如下

public class TextSqlNode implements SqlNode {
    ...
    @Override
    public boolean apply(DynamicContext context) {
      GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
      context.appendSql(parser.parse(text));
      return true;
    }
    private GenericTokenParser createParser(TokenHandler handler) {
        return new GenericTokenParser("${", "}", handler);
    }

    // 划重点，${}占位符替换逻辑在就handleToken(String content)方法中
    @Override
    public String handleToken(String content) {
          Object parameter = context.getBindings().get("_parameter");
          if (parameter == null) {
            context.getBindings().put("value", null);
          } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
            context.getBindings().put("value", parameter);
          }
          Object value = OgnlCache.getValue(content, context.getBindings());
          String srtValue = value == null ? "" : String.valueOf(value); // issue #274 return "" instead of "null"
          checkInjection(srtValue);
          return srtValue;
    }
}

public class GenericTokenParser {
    public String parse(String text) {
        ...
        do {
            ...
            if (end == -1) {
              ...
            } else {
              builder.append(handler.handleToken(expression.toString()));
              offset = end + closeToken.length();
            }
          }
          ...
        } while (start > -1);
        ...
        return builder.toString();
    }
}

划重点，${} 占位符处理如下

handleToken(String content) 方法中， Mybatis 会通过 ognl 表达式将 ${} 的结果直接拼接在 sql 语句中，由此我们得知 ${} 占位符拼接的字段就是我们传入的原样字段，有着 Sql 注入风险

2.2 #{} 占位符处理

#{} 占位符文本的 SqlNode 实现类为 StaticTextSqlNode，查看源码

public class StaticTextSqlNode implements SqlNode {
  private final String text;

  public StaticTextSqlNode(String text) {
    this.text = text;
  }

  @Override
  public boolean apply(DynamicContext context) {
    context.appendSql(text);
    return true;
  }

}

StaticTextSqlNode 会直接将节点内容拼接在 sql 语句中，也就是说在 rootSqlNode.apply(context) 方法执行完毕后，此时的 sql 语句如下

select order_id, order_no, user_id, total_price, 
pay_status, pay_type, pay_time, order_status, 
extra_info, user_name, user_phone, user_address, 
is_deleted, create_time, update_time 
from tb_newbee_mall_order
order by create_time desc
limit #{start},#{limit}

Mybatis 会通过上面提到 getBoundSql(Object parameterObject) 方法中的
image.png
sqlSourceParser.parse() 方法完成 #{} 占位符的处理，代码如下：

public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
  ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
  GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
  String sql;
  if (configuration.isShrinkWhitespacesInSql()) {
    sql = parser.parse(removeExtraWhitespaces(originalSql));
  } else {
    sql = parser.parse(originalSql);
  }
  return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

看到了熟悉的 #{ 占位符没有，哈哈😁， Mybatis 对于 #{} 占位符的处理就在 GenericTokenParser类的 parse() 方法中，代码如下：

public class GenericTokenParser {
    public String parse(String text) {
        ...
        do {
            ...
            if (end == -1) {
              ...
            } else {
              builder.append(handler.handleToken(expression.toString()));
              offset = end + closeToken.length();
            }
          }
          ...
        } while (start > -1);
        ...
        return builder.toString();
    }
}

public class SqlSourceBuilder extends BaseBuilder {
    ... 
    // 划重点，#{}占位符替换逻辑在就SqlSourceBuilder.handleToken(String content)方法中
    @Override
    public String handleToken(String content) {
      parameterMappings.add(buildParameterMapping(content));
      return "?";
    }
}

划重点，#{} 占位符处理如下

handleToken(String content) 方法中， Mybatis 会直接将我们的传入参数转换成问号（就是 jdbc 规范中的问号），也就是说我们的 sql 语句是预处理的。能够避免 sql 注入问题

三. 总结

由上经过源码分析，我们知道 Mybatis 对 #{} 占位符是直接转换成问号，拼接预处理 sql。 ${} 占位符是原样拼接处理，有sql注入风险，最好避免由客户端传入此参数。

源码阅读不易，欢迎大家点赞，转发，评论，加我的qq技术讨论群：862416125

程序员wayn
关注
专栏目录
Springboot集成mybatis，解读SQL 映射语句mapper的路径配置的源码
qq1592的博客
11-05 3819
目录 一、背景 二、排查过程 2.1 Springboot的自动配置 2.2 Spring获取资源 2.3 AntPathMatcher，spring默认的路径匹配器 三、解决 四、小结 一、背景 最近在新项目中在用springboot结合mybatis，一开始采取全注解模式，即，sql语句也写到接口注解上。后来，考虑到复杂sql语句在注解上编写的可读性...
Mybatis源码解读 (入门篇）
Ernest’‘’的博客
09-15 190
认识MyBatis mybatis参考网址：http://www.mybatis.org/mybatis-3/zh/index.html Github源码地址：https://github.com/mybatis/mybatis-3 Mybatis是什么 MyBatis 是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis 避免了几乎 所有的 JDBC代码和手动设置参数以及获取结果集，它可以使用简单的XML或注解来配置和映射SQL信 息，将接口和 Jav...
ＭyBatis 中#与$的区别
x
01-22 2万+
今天在工作中有个点击排序的功能调试了许久，终寻因，总结之。 　　需求是这样的，页面有个table，有一列的上下箭头可点击并排序。对于这种需求，我的mybatis.xml的sql配置写成了如下：<if test="map.ColumnNameSort!=null and map.ColumnNameSort!=''"> 　　ORDER BY columnName #{map.ColumnNameS
mybatis中的#和$的区别?
gol_phing的博客
08-12 847
1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id". 　　 2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为
MyBatis中的#和$：深入解析与实战应用
最新发布
xycxycooo的博客
09-01 1178
MyBatis是一个持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis通过配置文件或注解实现数据库字段与Java对象属性之间的映射。MyBatis中的和占位符各有其适用场景。占位符用于预编译SQL语句，可以防止SQL注入攻击，性能较好；占位符用于直接替换SQL语句中的参数值，存在SQL注入风险，但在需要动态生成SQL语句的情况下是必需的。希望通过本文的详细解析和示例代码，大家能更好地理解和的区别，并在实际项目中正确使用它们。
mybatis 之 占位符#{} 和 ${}
weixin_33708432的博客
11-13 201
#{}占位符用来设置参数，参数的类型可以有3种，基本类型，自定义类型，map基本类型作为参数，参数与占位符中的名称无关。 &lt;select id="findById" parameterType="int" resultType="cn.wh.vo.Role"&gt; select * from t_role where id = #{xxxid} &lt;/sel...
MyBatis #{} ${}
weixin_43014205的博客
01-09 1393
#{} 表示一个占位符号 自动进行java类型和jdbc类型转换 可以有效防止SQL注入 可以接受简单类型或者pojo属性值 如果parameterType传输单个数据类型，#{}括号中可以是value或其他名称   SELECT * FROM `customer` where cust_name like '%#{value}%';  SELECT * FROM `custom...
Mybatis中的$和#
sillyyyy的博客
05-08 2682
在SQL语句执行时，Mybatis会将$占位符替换为对应的参数值，并将SQL语句发送到数据库执行。使用$占位符可以在某些情况下提高SQL语句的性能，因为在预编译时不需要处理参数占位符。#用于预编译，表示参数占位符，例如：#{username}。在SQL语句执行时，Mybatis会将占位符替换为对应的参数值，并将SQL语句发送到数据库执行。使用#占位符可以有效地防止SQL注入攻击，因为Mybatis会将参数值转义后再替换占位符。使用哪种占位符取决于具体的需求，如果需要防止SQL注入攻击，则应该使用#占位符；
第二章 MyBatis源码骨架分析笔记
hankin的博客
09-03 604
一、MyBatis 源码概述 1、怎么下载MyBatis源码？ MyBatis 源码下载地址：https://github.com/MyBatis/MyBatis-3建议直接用网盘里的源码包 源码包导入过程： 下载MyBatis的源码 检查 maven 的版本，必须是3.25以上，建议使用maven的最新版本 MyBatis 的工程是maven工程，在开发工具中导入，工程必须使用 jd...
mybatis源码解读：builder构建者(一)
qq_41063182的博客
05-29 1688
其实一个框架或者是系统要想运转，支撑他们运行的规则很重要，比如游戏如果没有游戏规则，那么就会变得毫无游戏体验，乃至一个社团或者公司可以健康高速的运转，也离不开一个强壮的并且必须要遵守的规则，如果没有奖罚措施，公司倒闭是迟早的事情。 对于mybatis来说，如何让一段xml配置可以识别为它自己可以理解的东西，这其实就是mybatis的开发团队定制好的一段规则，然后让大家来遵守，如果是你自己写框架，那么这个规则就是由你来定制了，哈哈。 builder builder下的类是mybatis解析xml的核心。 .
SpringBoot + Mybatis 增删改查 教程 (源码实例)
Bnana博客
07-02 802
SpringBoot + Mybatis 增删改查实例教程 SpringBoot + Mybatis 框架 SpringBoot + Mybatis 使用教程 SpringBoot + Mybatis 实例 SpringBoot + Mybatis 增删改查 代码 SpringBoot + Mybatis 增删改查 源码 SpringBoot + Mybatis 教程 SpringBoot + Mybatis 新手教程 SpringBoot + Mybatis 实现增删改查
mybatis中的#和$的区别
热门推荐
kobi521的专栏
11-25 11万+
1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id". 　　 2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的
mybatis中的#{}和${}
submorino的专栏
11-25 2462
mybatis中的#{}和${} 1、在MyBatis 的映射配置文件中，动态传递参数有两种方式： （1）#{}占位符 （2）${}拼接符 2、#{}和${}的区别 （1） 　　1）#{}为参数占位符?，即sql 预编译 　　2）${}为字符串替换，即sql 拼接 （2） 　　1）#{}：动态解析 ->预编译-> 执行 　　2）${}：动态解析 ->编译-> 执行 （3） 　　1）#{}的变量替换是在DBMS中 　　2）${}...
mybatis中的#和$
yangyou55的博客
06-02 626
#相当于对数据 加上 双引号，$相当于直接显示数据 1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id".　　2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如...
Mybatis ${}和#{}
WN-YoungKun的博客
06-19 336
Mybatis中传入参数会涉及到${}和#{}两种方式，但是什么时候用哪个，看过众多博客之后决定去官网看看。加上自己的试验之后总结如下：Parameters：#{}首先字面理解就是参数，可以指定类型。不指定类型，会默认为字符串类型，所以会在传入的值上面加''（单引号）。或者预编译的时候，参数不符合规则，直接无法预编译。String Substitution：${}先看看Mybatis是如何解释的：...
MyBatis 中 #{} 和 ${} 的区别
liuyuinsdu的专栏
03-12 1303
1、在MyBatis 的映射配置文件中，动态传递参数有两种方式： （1）#{}占位符 （2）${}拼接符 2、#{}和${}的区别 （1） 1）#{}为参数占位符?，即sql 预编译 2）${}为字符串替换，即sql 拼接 （2） 1）#{}：动态解析 ->预编译-> 执行 2）${}：动态解析 ->编译-> 执行 （3） 1）#{}的变量替换是在DBMS中 2）${}的变量替换是在DBMS外 （4） 1）变量替换后，...
占位符#{}和拼接符${}
weixin_30376323的博客
12-20 406
　　#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。#{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。 　　${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sq...
MyBatis中的#{}和${}的用法
heliuerya的博客
06-15 2607
在实际开发中有些数据量非常大，需要分表存储，然后分表查询，比如：日志信息表基本上是每天一张表，现有多张日志信息表：log_20230101、log_20230102、log_20230103…比如：在查询某班全体学生并按照姓名按照升序/降序排列的sql语句中，当需要传入关键字asc"或"desc"的时候需要使用${}而不能使用#{}，像这种需要传入。先进行sql语句拼接，然后再编译sql语句，底层是Statement实现。的sql语句需要使用${},其它情况需要使用#{}，用来防止出现sql注入现象。
一文解惑mybatis中的#{}和${}
一个菜鸡的博客
07-19 5826
{}先编译sql语句，再给占位符传值，底层是PreparedStatement实现。可以防止sql注入，比较常用。${}先进行sql语句拼接，然后再编译sql语句，底层是Statement实现。存在sql注入现象。只有在需要进行sql语句关键字拼接的情况下才会用到。
mybatis中使用#和$书写占位符有什么区别？
06-06
MyBatis中使用#和$书写占位符有什么区别？ 在MyBatis中，使用#和$书写占位符都是用来替换SQL语句中的参数，但是它们的功能和作用是不同的。#代表参数预处理，它会将传入的值自动封装成对应的Java类型，可以防止SQL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值