mybatis配置加载阶段源码之XMLMapperBuilder

最新推荐文章于 2024-01-18 17:47:52 发布
最新推荐文章于 2024-01-18 17:47:52 发布
阅读量536 收藏 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
    评论
专栏目录
MyBatis源码分析，三、XMLMapperBuilder
weixin_42875415的博客
03-13 813
（一）创建XMLMapperBuilder对象 文章二最后创建了一个XMLMapperBuilder对象。 XMLMapperBuilder其实和XmlConfigBuilder一样，里面内置了一个XPathParser，通过读取resource创建document属性。 因为XMLMapperBuilder和XmlConfigBuilder都是继承基类BaseBuilder，configuration是基类的属性，这里向configuration里添加属性，都是修改同一个configuration。
mybatis源码解读(三)：XMLMapperBuilder详解
qq_41063182的博客
06-07 3117
功能 在之前的工作中 XMLConfigBuilder 已经将 configuration 配置信息都解析过了，接下来就是mapper映射文件的解析。XMLMapperBuilder是专门负责解析mapper文件的。 第一步：首先根据你配置的mapper文件的路径，resouce、url或者是class、package来分别区分对待找到路径，如果是resource、url会有一个流资源的读取来解析，class与package则是另一种方式，通过MapperProxy代理来完成。 第二步：获取到资源，就是对常
XMLMapperBuilder解析*mapper.xml
weixin_46666822的博客
04-27 879
就是xml中每个方法定义的resultMap或实体类型的resultType。parse方法是被循环调用的，也就是每个mapper.xml都会执行一次。configuration关键属性。每个xml中定义的sql标签。
（源码解析）mybatis调用链之XMLMapperBuilder解析Mapper
超域的博客
01-02 1367
其次创建MapperBuilderAssistant对象，用于辅助XMLMapperBuilder和XMLStatementBuilder解析mapper.xml文件，完善属性信息，并注册到configuration对象。上述cache解析即为解析二级缓存，若是配置了二级缓存，则会通过builderAssistant创建缓存对象，并添加至configuration。parse方法中，首先判断判断是否已经加载该配置文件，若未加载，贼进入configurationElement方法，开始处理mapper节点。
2. XMLMapperBuilder如何解析mapper.xml文件
最新发布
aaaaaaaa23456的博客
01-18 819
我们在mybatis中写的很多mapper.xml文件就是通过XMLConfigurationBuilder中的mapperElement进行解析的，下面我们好好研究一下mapper.xml文件下面就是整个mapperElement方法中的内容，为了简化我只保留关于resource的内容。在mapperElement重要加载mapper.xml ，然后把解析工作交给了XMLMapperBuilder。
【自用】mybatis学习笔记-xmlMapperBuilder 解析映射文件（第三天）
qq_42765493的博客
04-26 1252
判断子标签是不是 package标签 老师说不让用包映射？？说是只能是注解才能用 可以有多种方法指定 现在只有resource 属性 resource url 和 class 只能指定一个 检测文件有没有错，语法之类的，原来可以写一个方法，我要学习一下 得到映射文件的流 又来个构造器，对映射文件解析的XMLMapperBuilder try { mapperParser = new XMLMapperBuilder(inputStream, this.configuration,
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系列四：XMLMapperBuilder解析XL配置文件
lemon
03-08 652
概述 在《Mybatis系列一：构建SqlSessionFactory》一文中了解了Mybatis配置文件的解析，其中对mappers元素解析使用到了XMLMapperBuilder这个类，现在分析下这个类是如何解析Mapper配置文件的。当然也调用了Configuration#addMappers方法，实际上调用的是MapperRegistry#addMappers方法。 <ma...
Mybatis学习（六）--- Xml的解析
weixin_37880711的博客
04-11 401
在实际mybatis的应用中，我们写好mapper接口之后，需要提供对应的xml文件，这次我们主要分析是如何解析xml文件的。 XmlMappedBuilder 解析的主要函数是： //是否加载过该映射文件 public void parse() { if (!configuration.isResourceLoaded(resource)) { //处理map...
手敲Mybatis(二)-Mapper的XML解析自动注册使用
dfBeautifulLive的博客
05-26 1117
上一章节实现了mapper注册器来将代理类进行注册，获取等，在测试时手动给与注册路径进行一系列操作，这章节采用自动注册方式，通过MapperFactoryBuilder进行解析xml的select标签、Sql、id、namespace等，解析完毕注册到MapperRegistry中，接下来就还是和上节一样的操作，代理对象使用及调用映射到自己需要调用的方法中 1.xml类图 1.SqlSessionFactoryBuilder 这次测试的入口，通过构建build方法调用XMLConfiBuilder
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...
mybatis 源码导读
a469517790的博客
03-30 118
1、mybatis 跟spring 整合的入口在哪？ 查看类：org.mybatis.spring.mapper.MapperScannerConfigurer 2、mybatis 使用接口Mapper，如何将Mapper 实例化成spring bean？ 查看 MapperFactoryBean -> MapperProxyFactory -> MapperProxy 3、Mapper 接口默认的select、insert 方法实现是在哪？ 查看 MapperProxy.invoke()
XMLMapperBuilder源码分析
二缺和傻宝宝的博客
07-26 635
XMLMapperBuilder这个类主要是用于解析mybatis中的标签里边的内容，怎么一步一步的引用，看下边的分析： 其实XMLMapperBuilder和XMLConfigBuilder的功能比较相似，只是XMLConfigBuilder的作用范围，或者说包括的范围比较大，其中标 签就是其中解析的一部分，看过源码的其实应该就知道。我接下来单独抽出来相关的部分代码做解释。 //通过X
XMLMapperBuilder类
weixin_33777877的博客
09-01 196
涉及到的类包括： MapperBuilderAssistant：Mapper文件解析辅助类，包括了解析各种节点的方法。 BaseBuilder：XMLMapperBuilder与MapperBuilderAssistant的父类，保存了Configuration、TypeAliasRegistry、TypeHandlerRegistry三个属性。 TypeAliasRegistry：别名对应...
@Deprecated注解
王洪展的博客
01-25 307
刚学到一个注解 @Deprecated 表示这个方法下个版本可能会被弃用 看个东西 /** @deprecated */ @Deprecated public static boolean isEmpty(@Nullable Object str) { return str == null || "".equals(str); } 这是 springframework 下的一个方法 StringUtils.isEmpty() 然后我们看调用
"Mybatis缓存配置与源码分析详解
本文主要讨论了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、付费专栏及课程。

余额充值