Maven 工程之间的继承

最新推荐文章于 2024-05-07 16:55:53 发布
最新推荐文章于 2024-05-07 16:55:53 发布
阅读量2.3k 收藏 9
点赞数 1
分类专栏： Maven 文章标签： maven spring java
原文链接：https://www.wolai.com/arAiYJYCr6Kkfi2kZ8HxE8
版权

Maven 工程之间的继承

文章目录

1. 概念

Maven工程之间，A 工程继承 B 工程

  • B 工程：父工程
  • A 工程：子工程

本质上是 A 工程的 pom.xml 中的配置继承了 B 工程中 pom.xml 的配置。

2. 作用

在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。

它的背景是：

  • 对一个比较大型的项目进行了模块拆分。
  • 一个 project 下面，创建了很多个 module。
  • 每一个 module 都需要配置自己的依赖信息。

它背后的需求是：

  • 在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
  • 使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
  • 使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。

通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

3. 举例

在一个工程中依赖多个 Spring 的 jar 包

[INFO] +- org.springframework:spring-core:jar:4.0.0.RELEASE:compile
[INFO] | \- commons-logging:commons-logging:jar:1.1.1:compile
[INFO] +- org.springframework:spring-beans:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-context:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-expression:jar:4.0.0.RELEASE:compile
[INFO] +- org.springframework:spring-aop:jar:4.0.0.RELEASE:compile
[INFO] | \- aopalliance:aopalliance:jar:1.0:compile

使用 Spring 时要求所有 Spring 自己的 jar 包版本必须一致。为了能够对这些 jar 包的版本进行统一管理，我们使用继承这个机制，将所有版本信息统一在父工程中进行管理。

继承的版本管理的注意点：

  1. 所继承的父工程的包方式：一定要为：<packaging>pom</packaging> 才能管理其他工程。
  2. 子工程当中的 依赖的jar不要写明版本，才会继承父工程当中的版本信息配置。如果子工程写明了对应的jar的版本，则不会继承父工程的版本信息配置，而是根据子工程自己的版本信息配置的。

4. 操作

①创建父工程

创建的过程和前面创建 pro01-maven-java 一样。

工程名称：pro03-maven-parent

如下：

E:\Maven_workspane\spaceVideo>mvn archetype:generate

在这里插入图片描述

在这里插入图片描述

工程创建好之后，要在pom.xml配置文件当中修改， 它的打包方式：为 pom 才能作为父工程，管理其他的工程。

在这里插入图片描述

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.rainbowSea.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--当前工程作为父工程,要去管理其他工程:打包方式必须为 pom 才行-->
  <packaging>pom</packaging>

  <name>pro03-maven-parent</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

只有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。

②创建模块工程

模块工程类似于 IDEA 中的 module，所以需要进入 pro03-maven-parent 工程的根目录，然后运行 mvn archetype:generate 命令来创建模块工程。

就是把 pr03-maven-parent 作为父工程，在其下面创建其子工程：

假设，我们创建三个模块工程：

在这里插入图片描述

这里我们就简单的创建两个子工程吧：分别为：pro04-maven-module，pro05-maven-module

执行如下创建 Mavne 工程命令

mvn archetype:generate

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

③查看被添加新内容的父工程 pom.xml

当我们在 pro03-maven-parent 父工程下创建了，两个子工程的时候。

我们在回到 pro03-maven-parent父工程下，查看其 pom.xml 发生了什么要的改变。

我们可以看到在 该 pro03-maven-parent父工程下的 pom.xml 配置文件当中，多添加了，如下：信息：

在这里插入图片描述

下面 modules 和 module 标签是聚合功能的配置

<modules>  
    <module>pro04-maven-module</module>
    <module>pro05-maven-module</module>
</modules>

④解读子工程的pom.xml

而我们再，看看，我们对应之下的，pro04-maven-module，pro05-maven-module 的 pom.xml的配置文件信息，有存在着一个怎样的变化。

在这里插入图片描述

在这里插入图片描述

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
  <!-- 通过：指定父工程的坐标，找到父工程 -->
  <groupId>com.rainbowSea.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>

<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.rainbowSEa.maven</groupId> -->

<artifactId>pro05-maven-module</artifactId>

<!-- <version>1.0-SNAPSHOT</version> -->

⑤在父工程中配置依赖的统一管理子工程

**注意：**即使在父工程配置了对依赖的管理，子工程需要使用依赖时，依旧是要指明/写明具体哪一个依赖的配置的，而不是不用写依赖的配置了，只是可以不用写依赖的版本号了而已。不然子工程当中的所支持的依赖的版本与父工程的版本不一致，子工程还是要指明所对应可以支持的版本号的，因为父工程所继承而来的版本号，自己子工程不支持吗，所以需要自己写明。

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 
注意：即使在父工程配置了对依赖的管理，子工程需要使用依赖时，依旧是要指明/写明具体哪一个依赖的配置的，而不是不用写依赖了。-->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
  </dependencies>
</dependencyManagement>

pro03-maven-parent 父工程下的 pom.xml 的全部信息

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.rainbowSea.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--当前工程作为父工程,要去管理其他工程:打包方式必须为 pom 才行-->
  <packaging>pom</packaging>

  <name>pro03-maven-parent</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 
注意：即使在父工程配置了对依赖的管理，子工程需要使用依赖时，
依旧是要指明/写明具体哪一个依赖的配置的，而不是不用写依赖了。-->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
  </dependencies>
 </dependencyManagement>
  
  <modules>  
    <module>pro04-maven-module</module>
    <module>pro05-maven-module</module>
  </modules>
</project>

⑥子工程中引用那些被父工程管理的依赖

关键点：省略版本号，如果没有省略版本号，则不会继承父工程下的版本号，而是沿用自己子工程配置的版本号信息。

**注意：**即使在父工程配置了对依赖的管理，子工程依旧需要自己配置要使用的依赖信息，只是省略了版本号而已，其他的还是要子工程自己配置哪个依赖的，父工程的依赖并不会被子工程所继承的

如下是：pr04-maven-module 的配置：

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。  -->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的 <dependencyManagement>来决定。 -->
<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.rainbowSea.maven</groupId>
    <artifactId>pro03-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <groupId>com.rainbowSea.maven</groupId>
  <artifactId>pro04-maven-module</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>pro04-maven-module</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

<!--即使在父工程配置了对依赖的管理，子工程依旧需要自己配置要使用的依赖信息，只是省略了
版本号而已，其他的还是要子工程自己配置哪个依赖的，父工程的依赖并不会被子工程所继承的-->
	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
    </dependency>

  </dependencies>
</project>

如下是：pr05-maven-module 的配置：

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>com.rainbowSea.maven</groupId>
    <artifactId>pro03-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>

  <groupId>com.rainbowSea.maven</groupId>

  <artifactId>pro05-maven-module</artifactId>

  <version>1.0-SNAPSHOT</version>

  <name>pro05-maven-module</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
    </dependency>
  </dependencies>
</project>

运行：mvn dependency:list命令查看：父工程和子工程的依赖信息配置。

如下是：父工程的
在这里插入图片描述

如下是：pro04-maven-module 子工程的

在这里插入图片描述

如下是：pro05-maven-module 子工程的：

在这里插入图片描述

⑦在父工程中升级依赖信息的版本

将其中的版本修改为 ： 4.1.4 版本在运行看看：

在这里插入图片描述

……
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.1.4.RELEASE</version>
      </dependency>
……

父工程下的：

在这里插入图片描述

子工程下的：

在这里插入图片描述

在这里插入图片描述

然后在子工程中运行mvn dependency:list，效果如下：

[INFO] org.springframework:spring-aop:jar:4.1.4.RELEASE:compile  
[INFO] org.springframework:spring-core:jar:4.1.4.RELEASE:compile  
[INFO] org.springframework:spring-context:jar:4.1.4.RELEASE:compile  
[INFO] org.springframework:spring-beans:jar:4.1.4.RELEASE:compile  
[INFO] org.springframework:spring-expression:jar:4.1.4.RELEASE:compile

⑧在父工程中声明自定义属性

我们可以通过父工程当中声明自定义属性：真正实现“一处修改，处处生效”。

就是将父工程的当的各个版本信息配置为一个变量：使用:在 标签当中，配置自定义标签。

自定义的标签，没有特别的要求：不要使用中文，尽量与你配置的哪个 jar 有所关联，做到见明知其是依赖的是哪个 jar包的版本信息。如下：自定义标签，维护Spring版本数据

在这里插入图片描述

<!-- 通过自定义属性，统一指定Spring的版本 -->
<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  
  <!-- 自定义标签，维护Spring版本数据 -->
  <rainbowSea.spring.version>4.0.0.RELEASE</rainbowSea.spring.version>
</properties>

使用到该版本信息的的地方使用${}的形式来引用自定义的属性名：

      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${rainbowSea.spring.version}</version>
      </dependency>

在这里插入图片描述

真正实现“一处修改，处处生效”。

运行：mvn dependency:list命令查看：父工程和子工程的依赖信息配置。

父工程下的：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

5. 实际意义

在这里插入图片描述

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。

如上图所示，公司级的父工程中管理的就是成熟的依赖组合方案，各个新项目、子系统各取所需即可。

6. 最后：感谢

该文章参考了，如下博主的分享。我们再此，真诚的感谢博主的技术的热情的分享。

⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐感谢如下博主的分享 ⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐

【1】：兵器|代码重工

在这里插入图片描述

ChinaRainbowSea
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IntelliJ IDEA 构建maven多模块工程项目(详细多图)
08-19
4. 创建聚合工程 c：在 c 模块下新建一个 Maven 工程模块 c1，继承 c 模块配置 c1 工程路径，finish 完成 c1 模块创建。 5. 创建 c2 模块：依赖 c1 模块，c 工程模块依赖 b 工程模块。 项目结构 这种项目结构主要...
尚硅谷Java视频教程_Maven视频
02-17
第一个Maven工程的目录结构和文件内容　· 10.联网问题　· 11.几个常用Maven命令　· 12.POM　· 13.坐标　· 14.仓库　· 15.第二个Maven工程的目录结构和文件内容　· 16.依赖的基本操作　· 17.依赖的范围初步...
【Maven学习】maven继承和传递依赖
fxkcsdn的博客
07-28 9345
本篇我们将学习maven的继承机制、依赖之间的传递性以及maven是如何解决依赖冲突的。 maven继承 在maven中，子项目是可以继承父项目的依赖的，假设父项目引入了junit依赖，子项目继承父项目，虽然子项目没有引入junit依赖，但是子项目会继承父项目的依赖，从而使用junit依赖。请看例子：现在新建了一个父项目mavenParent，它的目录结构如下，有一个Hello.java和对应...
maven--继承
weixin_44239550的博客
01-07 339
其实这里就两块内容，一个是大家都可以用的坐标，一个是有些用不着的坐标。如果需要使用父的坐标，那子类得描述清楚父模块的位置，如果是定义可选择的坐标，那父模块必须的加一个标签。
【Java基础】Maven继承
最新发布
jayxiaoxionger的博客
05-07 425
Maven 在设计时，借鉴了 Java 面向对象中的继承思想，提出了 POM 继承思想。
七、Maven工程继承和聚合关系
青年有志
01-22 1102
Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。继承可以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作。
Maven高级6：继承；（使用maven中的【继承】手段，让子工程能够使用父工程中的配置（依赖和插件等），以解决不同子工程（或称模块），版本不一致的问题）
小枯林的博客
06-12 1623
目录一：继承引入：资源依赖的问题和解决；1.【多个工程，组成一个项目】时，资源依赖的问题； 2.解决策略二：继承演示；1.设置父工程和子工程：把【ssm_controller、ssm_service、ssm_dao、ssm_pojo】设为【ssm】的子工程；（1）把【ssm_pojo】设为【ssm】的子工程；（2）把【ssm_dao】设为【ssm】的子工程；（3）把【ssm_service】设为【ssm】的子工程；（4）把【ssm_controller】设为【ssm】的子工程；2.在【ssm】这个父工程的p
maven 继承
Mr_Wanter
02-02 989
系统整理一下用到的maven继承关系。 dependencyManagement、pluginManagement dependencies、scope ……
maven继承父工程统一版本号的实现
09-07
在大型项目中，多个模块之间通常会有共同的依赖和版本管理需求，这时可以使用 Maven 的继承机制来实现统一版本号的管理。本文将详细讲解如何通过 Maven 继承父工程来实现这一目标。 首先，我们需要创建一个父工程...
2018-05-22-Maven工程的拆分与聚合.docx
01-07
本篇文章将详细探讨如何使用IntelliJ IDEA（简称IDEA）对Maven工程进行拆分和聚合。 1. **Maven工程拆分** Maven工程拆分的目标是将项目按功能或层次结构划分为多个独立的模块。例如，通常我们会将项目分为三层：...
Maven依赖管理项目构建工具.pdf
12-24
七、Maven工程继承和聚合关系 1. Maven工程继承关系 一个父pom可以定义共享的依赖、插件、属性等，子项目通过元素继承这些配置。 2. Maven工程聚合关系 通过元素，一个父项目可以聚合多个子项目，方便进行整体构建...
Maven中依赖的聚合和继承的关系与实现
weixin_51220009的博客
08-25 230
依赖的聚合是用来统一管理模块依赖的，让依赖同时构建，防止一个模块依赖更新后整个项目出错的情况，依赖的继承是方便版本控制和依赖耦合的情况
Maven 父子工程
adozoo
05-16 444
Maven 父子工程 工程只能使用自己的内部资源 ，也可以和其他工程或者模块建立关系 模块不是独立的，模块天生是属于父工程的，父工程的资源都可以使用 子模块可以直接继承父模块一些资源 子模块和子模块之间没有任何关系 父子工程之间的传递依赖与直接依赖 1.首先在父工程导入所有需要jar包的坐标。 2.第二子工程可以直接使用父工程的资源，此时子工程与父工程是直接依赖。 3.但是子工程与父工程中的jar包都是间接依赖。 如下图所示（- 表示无法依赖），比如junit，在子工程（传递依赖）作用区为
MAVEN的继承详解
浅时光|初如梦
07-17 4256
1.前言 我们先来看一个应用场景,使用maven将一个项目分给多个人并行开发,最终多人开发的多个工程整合成一个项目系统使用,这时就需要考虑不同开发人员在开发过程中使用的资源版本问题,一旦出现版本不兼容会造成测试成本过高,项目不能及时上线的严重问题. 2. 继承 2.1继承的意义 为了统一一个项目多模块并行开发的资源版本,maven出现了继承的功能,可以将一个大型项目分为父工程和子工程,其中父工程的唯一作用就是定义所有子模块工程的资源版本（父工程不编写代码，只编辑pom.xml文件） 上图中
【IDEA】建立多个子模块依赖于一个父模块(maven)
'Ablaze 的专栏
05-20 1万+
第一步，建立父模块（在IDEA中就是工程） 第二步，选中父模块（也就是工程）右键New Module建立子模块 勾选创建模板原型并一般选择 maven-archetype-quickstart，当创建web模块时选择 maven-archetype-webapp 其他子模块都是类似这样创建~ packaging打包类型有： jar，默认类型 war ...
Maven项目子模块如何引用父模块的jar包
热门推荐
java_xxxx的博客
07-24 1万+
如果父pom中使用的是….方式，则子pom会自动使用pom中的jar包， 如果父pom使用….方式，则子pom不会自动使用父pom中的jar包，这时如果子pom想使用的话，就要给出groupId和artifactId，无需给出version...
maven创建父，子工程聚合与继承，及子工程依赖另一个子工程-demo
香帅的博客
04-12 1万+
maven创建父，子工程聚合与继承，及子工程依赖另一个子工程1. 创建父工程maven ---父工程打包方式必须为pow包 - -标签 &lt;packaging&gt;pow&lt;/packaging&gt;创建子工程a -- childrenA--选择创建maven moule 这样可以直接选择父工程选择父工程为parent2-demo打成jar包同样创建子工程 b-- childrenB ...
maven工程和maven archetype
09-27
maven工程是一种使用Maven构建的项目。Maven是一个用于项目管理和构建的工具，它可以自动化项目构建过程，包括编译、测试、打包和部署等。Maven通过一个中央仓库来管理项目所需的依赖关系，并提供了一套标准化的项目...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值