mybatis配置加载阶段源码之XMLMapperBuilder

最新推荐文章于 2023-04-27 17:53:26 发布
最新推荐文章于 2023-04-27 17:53:26 发布
阅读量535 收藏 1
点赞数 1
分类专栏： mybatis 文章标签： XMLMapper resultMap mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39654841/article/details/115103097
版权

文章目录

作用

主要负责解析*Mpper.xml映射文件。

构造方法

XMLMapperBuilder 也是同样继承于BaseBuilder，它有以下四个构造方法，最终调用的还是最后一个构造方法来初始化XMLMapperBuilder 对象。

@Deprecated
  public XMLMapperBuilder(Reader reader, Configuration configuration, String resource, Map<String, XNode> sqlFragments, String namespace) {
    this(reader, configuration, resource, sqlFragments);
    this.builderAssistant.setCurrentNamespace(namespace);
  }

  @Deprecated
  public XMLMapperBuilder(Reader reader, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
    this(new XPathParser(reader, true, configuration.getVariables(), new XMLMapperEntityResolver()),
        configuration, resource, sqlFragments);
  }

  public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments, String namespace) {
    this(inputStream, configuration, resource, sqlFragments);
    this.builderAssistant.setCurrentNamespace(namespace);
  }

  public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
    this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()),
        configuration, resource, sqlFragments);
  }

XMLMapperBuilder 对象的创建是在XMLConfigBuilder#mapperElement方法中

if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
              mapperParser.parse();
            }
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            try(InputStream inputStream = Resources.getUrlAsStream(url)){
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
              mapperParser.parse();
            }
          }

方法

parse

parse方法是*Mapper.xml 解析的开始

public void parse() {
    //判断是否已经加载该配置文件
    if (!configuration.isResourceLoaded(resource)) {
      //处理mapper节点
      configurationElement(parser.evalNode("/mapper"));
      //将mapper文件添加到configuration.loadedResources中
      configuration.addLoadedResource(resource);
      //注册mapper接口
      bindMapperForNamespace();
    }
    //处理解析失败的ResultMap节点
    parsePendingResultMaps();
    //处理解析失败的CacheRef节点
    parsePendingCacheRefs();
    //处理解析失败的Sql语句节点
    parsePendingStatements();
  }

解析步骤分两种情况：
一、资源已加载
如果资源已加载就直接处理失败的节点，这一步比较简单。
二、资源未加载
如果资源未加载，分四个步骤：
1、解析mapper标签
2、资源加载到configuration对象的loadedResources的set集合中
3、注册mapper接口
4、处理解析失败的节点

configurationElement

1、解析mapper标签
mapper的解析在configurationElement方法中，在该方法中会对*Mapper.xml内的节点进行解析并将解析到的结果填充到configuration对象中。

/**
   *  解析*mapper.xml文件
   * @param context
   */
  private void configurationElement(XNode context) {
    try {
      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"));

      // parameterMap 标签已过时
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));

      // 解析resultMap
      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);
    }
  }

标签

映射文件各个标签具体介绍可看官网XML 映射器，这里只关注几个重要的节点

resultMap

resultMap节点的解析是在resultMapElements方法中进行的，经过层层调用最终调用
ResultMap resultMapElement(XNode resultMapNode, List additionalResultMappings, Class<?> enclosingType) 方法，重点要看的就是这个方法

resultMapElements

private void resultMapElements(List<XNode> list) {
    for (XNode resultMapNode : list) {
      try {
        resultMapElement(resultMapNode);
      } catch (IncompleteElementException e) {
        // ignore, it will be retried
      }
    }
  }

resultMapElement

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());

    /**
     * 获取resultMap 映射的类
     * javaType、resultType、ofType、type 优先级顺序是
     * type > ofType > resultType >javaType,
     * 解析的时候按先从优先级最低的javaType属性开始，type的优先级最高，只要type属性存在，不管其他三个有没有最终都会用type，
     * 如果type属性没有获取到才会按照顺序依次往下获取并使用结果
     */
    String javaType = resultMapNode.getStringAttribute("javaType");
    String resultType = resultMapNode.getStringAttribute("resultType", javaType);
    String ofType = resultMapNode.getStringAttribute("ofType", resultType);
    String type = resultMapNode.getStringAttribute("type", ofType);

    // 从别名注册表中获取entity 的class对象
    Class<?> typeClass = resolveClass(type);
    if (typeClass == null) {
      // 别名注册中如果没找到entity的class对象，
      typeClass = inheritEnclosingType(resultMapNode, enclosingType);
    }

    Discriminator discriminator = null;
    List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
    List<XNode> resultChildren = resultMapNode.getChildren();
    for (XNode resultChild : resultChildren) {
      if ("constructor".equals(resultChild.getName())) {
        //constructor 节点解析
        processConstructorElement(resultChild, typeClass, resultMappings);
      } else if ("discriminator".equals(resultChild.getName())) {
        //discriminator 节点解析
        discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
      } else {
        List<ResultFlag> flags = new ArrayList<>();
        if ("id".equals(resultChild.getName())) {
          // 将id节点添加到ResultFlag 集合中
          flags.add(ResultFlag.ID);
        }
        // 创建resultMapping对象并加入到resultMappings 集合中
        resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
      }
    }

    //获取基于值的标识符  拼接成mapper_resultMap[BaseResultMap] 这样的字段，mapper 代表文件夹名, [ ]中间是resultMap节点的id属性值，这里id=BaseResultMap
    String valueBasedIdentifier = resultMapNode.getValueBasedIdentifier();
    String id = resultMapNode.getStringAttribute("id", valueBasedIdentifier);
    String extend = resultMapNode.getStringAttribute("extends");
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    // resultMap解析器
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
      // 返回resultMap对象
      return resultMapResolver.resolve();
    } catch (IncompleteElementException e) {
      configuration.addIncompleteResultMap(resultMapResolver);
      throw e;
    }
  }

解析步骤：
1、解析resultMap节点的属性找到映射类并从typeAliasRegistry类型别名注册表中找到对应的映射类的class对象。
2、循环解析resultMap的子节点。
2.1 解析constructor节点，解析步骤在processConstructorElement方法中。解析调用ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List flags)方法。

/**
   * constructor节点解析
   * @param resultChild 节点
   * @param resultType 映射类
   * @param resultMappings ResultMapping结果映射集合
   */
  private void processConstructorElement(XNode resultChild, Class<?> resultType, List<ResultMapping> resultMappings) {
    List<XNode> argChildren = resultChild.getChildren();
    for (XNode argChild : argChildren) {
      List<ResultFlag> flags = new ArrayList<>();
      flags.add(ResultFlag.CONSTRUCTOR);
      // idArg 类的id属性
      if ("idArg".equals(argChild.getName())) {
        flags.add(ResultFlag.ID);
      }
      resultMappings.add(buildResultMappingFromContext(argChild, resultType, flags));
    }
  }

2.2 解析discriminator节点，解析步骤在processDiscriminatorElement方法中。discriminator鉴别器会根据value的结果值来决定最终调用哪个resultMap。

private Discriminator processDiscriminatorElement(XNode context, Class<?> resultType, List<ResultMapping> resultMappings) {
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String typeHandler = context.getStringAttribute("typeHandler");
    Class<?> javaTypeClass = resolveClass(javaType);
    Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    Map<String, String> discriminatorMap = new HashMap<>();
    for (XNode caseChild : context.getChildren()) {
      // 取值
      String value = caseChild.getStringAttribute("value");
      // 获取嵌套的resultMap节点 id属性
      String resultMap = caseChild.getStringAttribute("resultMap", processNestedResultMappings(caseChild, resultMappings, resultType));
      // 根据结果获取对应的resultMap
      discriminatorMap.put(value, resultMap);
    }
    // 构建一个Discriminator 对象返回
    return builderAssistant.buildDiscriminator(resultType, column, javaTypeClass, jdbcTypeEnum, typeHandlerClass, discriminatorMap);
  }

2.3 解析其他节点，其他节点的解析步骤在buildResultMappingFromContext方法中

/**
   *  解析 result 节点 并封装为ResultMapping 返回
   * @param context
   * @param resultType
   * @param flags
   * @return
   */
  private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) {
    String property;
    // 如果是构造方法节点
    if (flags.contains(ResultFlag.CONSTRUCTOR)) {
      property = context.getStringAttribute("name");
    } else {
      property = context.getStringAttribute("property");
    }
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String nestedSelect = context.getStringAttribute("select");
    String nestedResultMap = context.getStringAttribute("resultMap", () ->
        processNestedResultMappings(context, Collections.emptyList(), resultType));
    String notNullColumn = context.getStringAttribute("notNullColumn");
    String columnPrefix = context.getStringAttribute("columnPrefix");
    String typeHandler = context.getStringAttribute("typeHandler");
    String resultSet = context.getStringAttribute("resultSet");
    String foreignColumn = context.getStringAttribute("foreignColumn");
    // 是否懒加载
    boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
    Class<?> javaTypeClass = resolveClass(javaType);
    // 类型处理器
    Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
    //jdbcType 枚举类型获取
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    // 创建resultMapping对象
    return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
  }

3、解析resultMap节点的id、extends、autoMapping等属性，然后构建一个ResultMapResolver
4、调用ResultMapResolver对象的resolve方法，解析并返回一个resultMap对象。resolve方法会调用MapperBuilderAssistant#addResultMap方法把解析到各种参数设值到resultMap对象中并返回，实际设值的方法是ResultMap#build方法，build方法中就是对ResultMap属性的各种赋值。
MapperBuilderAssistant#addResultMap

public ResultMap addResultMap(String id, Class<?> type,String extend, Discriminator discriminator, List<ResultMapping> resultMappings, Boolean autoMapping) {
    id = applyCurrentNamespace(id, false);
    extend = applyCurrentNamespace(extend, true);

    // 如果resultMap有继承一个resultMap，解析继承的resultMap
    if (extend != null) {
      if (!configuration.hasResultMap(extend)) {
        throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
      }
      ResultMap resultMap = configuration.getResultMap(extend);
      List<ResultMapping> extendedResultMappings = new ArrayList<>(resultMap.getResultMappings());
      extendedResultMappings.removeAll(resultMappings);
      // Remove parent constructor if this resultMap declares a constructor.
      boolean declaresConstructor = false;
      for (ResultMapping resultMapping : resultMappings) {
        if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
          declaresConstructor = true;
          break;
        }
      }
      if (declaresConstructor) {
        extendedResultMappings.removeIf(resultMapping -> resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR));
      }
      // 继承的resultMap也添加到resultMappings中
      resultMappings.addAll(extendedResultMappings);
    }
    // 构建一个resultMap对象
    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
        .discriminator(discriminator).build();
    // 把resultMap添加到configuration对象的resultMaps中
    configuration.addResultMap(resultMap);
    return resultMap;
  }

sql

sql节点可以用来定义可重用的 SQL 代码片段，以便在其它语句中使用。 参数可以静态地（在加载的时候）确定下来，并且可以在不同的 include 元素中定义不同的参数值.
解析是在sqlElement(List list, String requiredDatabaseId)方法中,最终会把sql节点对象放到configuration#sqlFragments对象中的

private void  sqlElement(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
      String databaseId = context.getStringAttribute("databaseId");
      String id = context.getStringAttribute("id");
      id = builderAssistant.applyCurrentNamespace(id, false);
      if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
        sqlFragments.put(id, context);
      }
    }
  }

select|insert|update|delete

select|insert|update|delete节点解析是在buildStatementFromContext(List list, String requiredDatabaseId)，在buildStatementFromContext中会引出配置解析节点的第三个重要的类XMLStatementBuilder，在XMLStatementBuilder#parseStatementNode方法中。

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }

能力有限，水平一般，如有错误，请多指出。

索码理
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Mybatis3源码分析(04)-加载Configuration-XMLMapperBuilder加载ResultMap
ashan
12-17 2765
XMLMapperBuilder.parse()方法 XMLConfigBuilder在解析过程中碰到mappers元素会交由XMLMapperBuilder.parse()方法来处理 public void parse() { if (!configuration.isResourceLoaded(resource)) { //真正解析 co
mybatis - XMLMapperBuilder
weixin_34194359的博客
05-27 205
2019独角兽企业重金招聘Python工程师标准>>> ...
MyBatis源码初识二 加载mapper.xml文件
死磕各种源码
03-23 285
mapper.xml源码流程图源码加载xml资源代码解析xml xmlParser.parse()解析mapper节点 configurationElement二级缓存cacheElement 解析二级缓存useNewCache 构造二级缓存解析resultMap解析sql节点解析select|insert|update|delete构造Statement将节点解析成Statement创建createSqlSource解析脚本真正开始解析 源码流程图 源码 加载xml资源代码 private void
Configuration--mappers--XMLMapperBuilder.parse(三-8-2)
XingTree的博客
08-22 907
上一篇我们讲了Configuration的addMappers方法,可以看出,这个方法的最终目的,是将我们定义的mapper接口最终转化为MappedStatement,然后加入Configuration中,并且我们从上一篇文章中可以看出,即使我们是使用了class去配置mapper,也会去默认路径下加载xml文件.本篇我们来看看当mapper标签加载的是一个xml文件时使用的XMLMapperBu
mybatis源码解读(三)：XMLMapperBuilder详解
qq_41063182的博客
06-07 3110
功能 在之前的工作中 XMLConfigBuilder 已经将 configuration 配置信息都解析过了，接下来就是mapper映射文件的解析。XMLMapperBuilder是专门负责解析mapper文件的。 第一步：首先根据你配置的mapper文件的路径，resouce、url或者是class、package来分别区分对待找到路径，如果是resource、url会有一个流资源的读取来解析，class与package则是另一种方式，通过MapperProxy代理来完成。 第二步：获取到资源，就是对常
Mybatis延迟加载的实现方式
08-25
在Mybatis中，延迟加载可以通过配置文件mybatis-config.xml来实现，主要有三种方式：直接加载、侵入式延迟加载和深度延迟加载。 直接加载是指执行完对主加载对象的select语句，马上执行对关联对象的select查询。...
mybatis配置及案列源码
10-20
在本案例中，"mybatis配置及案列源码"提供了关于如何在项目中安装和配置MyBatis的详细步骤，同时可能包含了相关示例代码以供学习和实践。 首先，了解MyBatis的基本概念是必要的。MyBatis消除了几乎所有的JDBC代码和...
mybatis 加载配置文件的方法（两种方式）
08-28
"MyBatis 加载配置文件的方法" MyBatis 是一个流行的持久层框架，它可以帮助开发者快速地实现数据访问层的开发。MyBatis 提供了多种方式来加载配置文件，在本篇文章中，我们将介绍 MyBatis 加载配置文件的两种方式...
mybatis教程之延迟加载详解
08-30
在本篇文章中，我们将详细介绍MyBatis延迟加载的意义、配置和实现。 延迟加载的意义 在进行数据查询时，为了提高数据库查询性能，尽量使用单表查询，因为单表查询比多表关联查询速度要快。如果查询单表就可以满足...
Mybatis懒加载的实现
08-18
在JavassistProxyFactory类中，createProxy方法是核心逻辑执行的入口，该方法将目标结果对象、延迟加载对象、配置、对象工厂、构造参数类型和构造参数值作为参数，返回一个代理对象。该代理对象实现了MethodHandler...
Mybatis源码解读-配置加载和Mapper的生成
王谷雨的博客
05-15 237
问题 Mybatis四大对象的创建顺序？ Mybatis插件的执行顺序？ 工程创建 环境：Mybatis(3.5.9) mybatis-demo，参考官方文档 简单示例 这里只放出main方法的示例，其余类请看demo工程。 public static void main(String[] args) throws Exception { // 配置文件路径 String resource = "mybatis-config.xml"; InputStream inputStre
Mybatis源码解读系列(三)-XMLConfigBuilder&XMLMapperBuilder对mybatis初始化文件的解析(对Configuration成员变量的初始化)
Feverasa的博客
12-18 275
上一篇我们介绍了Configuration类的成员变量，这一篇我们通过XMLMapperBuilder&XMLMapperBuilder类来看下对mybatis xml配置文件的解析。 一、XMLConfigBuilder基本介绍 1、基本结构&成员变量 public class XMLConfigBuilder extends BaseBuilder { private boolean parsed; private XPathParser parser; private S
【自用】mybatis学习笔记-xmlMapperBuilder 解析映射文件（第三天）
qq_42765493的博客
04-26 1252
判断子标签是不是 package标签 老师说不让用包映射？？说是只能是注解才能用 可以有多种方法指定 现在只有resource 属性 resource url 和 class 只能指定一个 检测文件有没有错，语法之类的，原来可以写一个方法，我要学习一下 得到映射文件的流 又来个构造器，对映射文件解析的XMLMapperBuilder try { mapperParser = new XMLMapperBuilder(inputStream, this.configuration,
Mybatis系列四：XMLMapperBuilder解析XL配置文件
lemon
03-08 650
概述 在《Mybatis系列一：构建SqlSessionFactory》一文中了解了Mybatis配置文件的解析，其中对mappers元素解析使用到了XMLMapperBuilder这个类，现在分析下这个类是如何解析Mapper配置文件的。当然也调用了Configuration#addMappers方法，实际上调用的是MapperRegistry#addMappers方法。 <ma...
Mybatis源码分析——mapper.xml解析
有米oooooooo
06-27 805
本系列的文章都是基于这个demo来分析的Mybatis入门，一个简单的demo 在源码分析过程中，会使用到一些额外的知识点，比如Mybatis中使用的spring接口Mybatis中使用的设计模式 Mybatis初始化配置文件分为两个阶段，如下 mybatis-config.xml解析 mapper.xml文件解析 本篇分析的是第二阶段。 上一篇讲到解析mapper.xml是在X...
XMLMapperBuilder解析*mapper.xml
最新发布
weixin_46666822的博客
04-27 878
就是xml中每个方法定义的resultMap或实体类型的resultType。parse方法是被循环调用的，也就是每个mapper.xml都会执行一次。configuration关键属性。每个xml中定义的sql标签。
mapper配置的几种方式
沐淼的博客
03-28 1304
方式一 方式二 方式三 方式四
Mybatis 分多个配置文, 重写org.mybatis.spring.SqlSessionFactoryBean支持多个mybatis-config.xml...
wu1g119的专栏
03-28 1576
现有版本的mybatis不支持多个mybatis-config.xml配置文件,但是实际应用中开发者希望它能与spring或struts一样支持多个配置文件,不同功能模块使用不同的配置文件以减少开发中代码检索的时间与维护成本. 下面,是我根据网上资料结合自己实际遇到的问题重写的 参考资料 http://www.xinglongjian.com/index.php/2012/09/15/my...
XMLMapperBuilder源码分析
二缺和傻宝宝的博客
07-26 634
XMLMapperBuilder这个类主要是用于解析mybatis中的标签里边的内容，怎么一步一步的引用，看下边的分析： 其实XMLMapperBuilder和XMLConfigBuilder的功能比较相似，只是XMLConfigBuilder的作用范围，或者说包括的范围比较大，其中标 签就是其中解析的一部分，看过源码的其实应该就知道。我接下来单独抽出来相关的部分代码做解释。 //通过X
Mybatis的缓存1
08-03
本文主要讨论了Mybatis的缓存机制，包括一级缓存和二级缓存的使用、配置、工作流程以及源码分析。下面是全文总结： Mybatis是一款流行的Java持久化框架，它通过提供ORM（对象关系映射）的功能，将Java对象与数据库...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

索码理

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值