maven GroupID和ArtifactID

时间：2022-05-30 02:41:46
GroupID是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。

ArtifactID就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称。
一般GroupID就是填com.leafive.test这样子。

groupid和artifactId被统称为“坐标”是为了保证项目唯一性而提出的，如果你要把你项目弄到maven本地仓库去，你想要找到你的项目就必须根据这两个id去查找。
　　groupId一般分为多个段，这里我只说两段，第一段为域，第二段为公司名称。域又分为org、com、cn等等许多，其中org为非营利组织，com为商业组织。举个apache公司的tomcat项目例子：这个项目的groupId是org.apache，它的域是org（因为tomcat是非营利项目），公司名称是apache，artigactId是tomcat。
　　比如我创建一个项目，我一般会将groupId设置为cn.zr，cn表示域为中国，zr是我个人姓名缩写，artifactId设置为testProj，表示你这个项目的名称是testProj，依照这个设置，你的包结构最好是cn.zr.testProj打头的，如果有个StudentDao，它的全路径就是cn.zr.testProj.dao.StudentDao、

http://elim.iteye.com/blog/1860128

使用Maven

目录：

3.1       使用maven建立自己的项目

3.2       使用mvc compile进行源码编译

3.3       使用mvc test-compile编译测试源码

3.4       使用mvc test编译源码和测试源码进行测试

3.5       使用mvn package进行项目打包

3.6       使用mvn install安装jar包到maven的本地仓库

3.7       使用mvn deploy可以安装当前项目到远程仓库

3.8       使用mvn clean可以清除存放临时文件的target目录

3.9       把资源文件一并打到jar包中

3.10       过滤资源文件

3.10.1          使用pom.xml和settings.xml中的元素element作为属性

3.10.2          使用外部文件的属性关联

3.10.3          使用系统属性

3.11           在pom.xml中定义project的外部依赖包

3.12           使用mvn dependency:tree可以查看一个项目的依赖关系

3.13           修改Maven同时下载artifact的最大数

3.14           在断开网络的情况下执行Maven指令

3.15           构建自己的archetype

3.16    使用mvn javadoc:jar生成javadoc

3.17    使用mvn dependency:sources下载源码

3.1     使用maven建立自己的项目

(1)切换到项目所在的目录，如：d:\\develop\\apps

(2)执行如下指令：

mvn archetype:generate 这样就可以根据提示来建立一个maven项目

后面可以接很多参数，常用的有：

-DgroupId=com.company.app 组id

-DartifactId=app 项目名称，maven会根据这个名称在当前目录下新建一个名为该名称的目录用于建立项目

-DinteractiveMode=false  是否已交互模式进行，如果是false的话就会采用默认设置建立项目

以下是一个示例：

  1. mvn archetype:generate -DgroupId=com.tiantian -DartifactId=jxc -DinteractiveMode=false

运行上面的代码就会在d:\\develop\\apps下面新建一个名为jxc的maven项目

上面建立的只是一个简单的java应用，那如果我要建立一个web应用该如何呢？以下是一个示例：

  1. mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=com.myhost.myapp -DartifactId=myapp

其实使用Maven建立简单项目时是省略了参数archetypeArtifactId，当没有指定该参数时默认将使用maven-archetype-quickstart。所以要把上面建立一个普通java应用的Maven项目的指令写完整的话就应该是:

  1. Mvn archetype:generate –DarchetypeGroupId=org.apache.maven.archetypes –DarchetypeArtifactId=maven-archetype-quickstart –DgroupId=com.tiantian –DartifactId=jxc –DinteractiveMode=false

从上面我们可以看出要建立什么样的项目就需要使用什么样的archetype，archetype就是Maven定义好的项目类型的模板，一个对应项目的目录架构。archetype是通过参数archetypeArtifactId来指定的。除了上面介绍的两种archetype之外，Maven还为我们提供了以下几种archetype。

archetypeArtifactId

描述

maven-archetype-archetype

包含一个archetype的例子，主要用于当我们要建立自己的archetype的时候

maven-archetype-j2ee-simple

包含一个简单的j2ee应用的例子

maven-archetype-plugin

包含一个Maven plugin的例子

maven-archetype-plugin-site

包含一个Maven plugin site的例子

Maven-archetype-portlet

包含一个portlet的例子

Maven-archetype-simple

包含一个简单maven项目

Maven-archetype-site

包含一个maven site的例子，它能够展示一些支持的文档类型，包括APT、XDoc和FML

Maven-archetype-site-simple

包含一个maven site的例子

在后续的内容中将介绍关于如何构建自己的archetype的内容。

3.2     使用mvc compile进行源码编译

在目录d:\\develop\\apps下面建立了项目jxc之后，我们就可以进入目录d:\\develop\\apps\\jxc执行指令mvn compile进行编译了。编译后的文件将放在项目根目录下的target目录中。

3.3     使用mvc test-compile编译测试源码

在目录d:\\develop\\apps下建立了项目jxc之后，我们就可以在cmd中切换目录到d:\\develop\\apps\\jxc，然后执行指令mvc test-compile进行测试源码编译。

3.4     使用mvc test编译源码和测试源码进行测试

在目录d:\\develop\\apps\\jxc下面执行指令mvc test将先编译源码，再编译测试源码，然后执行测试代码。

3.5     使用mvn package进行项目打包

在项目所在的目录执行指令mvn package可以进行项目打包，打包方式是在项目根目录下的pom.xml文件中的packaging元素定义的，如果定义为jar则打为jar包，如果是war则打为war包，如果是ear则为ear包。如果pom.xml中没有定义packaging元素，则会使用默认值jar。打包后的文件将会放在项目根目录下的target目录下。打包后的文件名将是在pom.xml文件中定义的artifactId-version的形式，比如在pom.xml中定义的artifactId是hello，定义的version是1.0，则打包后生成的文件的名称将是hello-1.0。

3.6     使用mvn install安装jar包到maven的本地仓库

使用mvn install可以把mvn package打包好的jar安装到maven的本地仓库。本地仓库默认是在~/.m2/repository，可以在maven安装目录下的conf/settings文件中的localRepository标签中定义本地仓库的路径。

当我们需要安装一个本地jar包到本地资源库的时候我们可以使用“mvn install:install-file”指令，使用该指令时有几个参数需要指定。file：表示本地jar包所在的路径；groupId：表示jar包被安装到本地仓库之后的groupId；artifactId：表示jar包被安装到本地仓库之后的artifactId；version：表示安装到本地仓库之后对应的版本；packging：表示当前组件被引用的类型，既然我们是安装jar包则这里对应的自然是jar了。示例，假如现在我们需要安装一个jar包“c:\jars\abc.jar”到我们的Maven本地仓库，那么我们可以在命令窗口执行以下命令：

  1. mvn install:install-file -Dfile=c:\jars\abc.jar -DgroupId=com.tiantian -DartifactId=abc -Dversion=1.0 -Dpackaging=jar

这样就会把我们的“c:\jars\abc.jar”以groupId为“com.tiantian”，artifactId为“abc”，version为“1.0”，packaging类型为jar安装到我们的本地仓库，之后我们就可以直接在我们本地的Maven项目中引用该依赖类型了。如：

  1. <dependency>
  2. <groupId>com.tiantian</groupId>
  3. <artifactId>abc</artifactId>
  4. <version>1.0</version>
  5. </dependency>

3.7     使用mvn deploy可以安装当前项目到远程仓库

3.8     使用mvn clean可以清除存放临时文件的target目录

3.9     把资源文件一并打到jar包中

如果需要把一些资源文件也一并打包到jar包里面的话，需要在${basedir}/src/main下新建一个resources目录，然后把所有的资源文件都放到这个目录中，这样这些文件都会放到类路径下面。如果需要在测试代码中访问到对应的资源，那么相对的就需要在${basedir}/src/test下新建一个resources目录，然后把相应的资源文件放在这个目录下。

3.10        过滤资源文件

有的时候有些资源文件中的值我们需要在编译的时候动态的指定，maven允许我们在建立文件的时候以${property_name}的方式指定，这样当我们进行编译的时候就会自动的把property_name对应的值替换${property_name}。这个property可以是pom.xml中定义的值，也可以是settings.xml中定义的值，也可以是定义在外部属性文件中的值，还可以是系统属性。maven这种动态替换属性值的功能默认是关闭的，如果要打开的话需要在项目的pom.xml文件中指定filtering的值为true，默认是false。如下示例：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.tiantian.mavenApp</groupId>
  5. <artifactId>mavenApp</artifactId>
  6. <version>1.0-SNAPSHOT</version>
  7. <packaging>jar</packaging>
  8. <name>mavenAppTest</name>
  9. <url>http://maven.apache.org</url>
  10. <properties>
  11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12. </properties>
  13. <dependencies>
  14. <dependency>
  15. <groupId>junit</groupId>
  16. <artifactId>junit</artifactId>
  17. <version>3.8.1</version>
  18. <scope>test</scope>
  19. </dependency>
  20. </dependencies>
  21. <build>
  22. <resources>
  23. <resource>
  24. <directory>src/main/resources</directory>
  25. <filtering>true</filtering>
  26. </resource>
  27. </resources>
  28. </build>
  29. </project>

从上面的文件我们可以看出，filtering这个参数是针对于特定的资源文件目录的，而且我们还可以使用directory来指定资源文件的存放位置，默认是src/main/resources。这个build元素是有默认值的，因为我们需要改变filtering的值，所以需要重新定义build，然后覆盖里面的默认值。

3.10.1使用pom.xml和settings.xml中的元素element作为属性

我们可以使用pom.xml文件中的element对应的值来作为属性值。在maven中，使用pom来表示pom.xml中的根元素project，所以我们可以使用${pom.name}来表示project元素下面的name元素，使用${pom.version}来表示project元素下面的version元素。有些元素在pom.xml文件中是没有明确定义的，但是那不代表它们不存在，这是因为它们有一个默认值，像这种元素我们也可以直接拿来使用。同样的我们需要使用settings.xml中的元素的时候可以使用settings前缀来关联，如${settings.localRepository}就是在settings.xml中定义的localRepository元素的值。下面是一组示例，文件都是定义在resources目录下的：

文件application.properties

  1. project_name=${pom.name}
  2. project_version=${pom.version}
  3. project_modelVersion=${pom.modelVersion}
  4. project_artifactId=${pom.artifactId}
  5. settings_localRepository=${settings.localRepository}

文件test.txt

  1. project_version=${pom.version}
  2. project_modelVersion=${pom.modelVersion}
  3. project_artifactId=${pom.artifactId}
  4. settings_localRepository=${settings.localRepository}

在resources目录下定义了上面两个文件之后，在命令行模式下进入pom.xml文件所在的那一级目录，也就是项目的根目录，之后使用mvn compile进行编译，编译后可以到target/classes目录下找到对应的资源文件，打开可以看到如下内容：

application.properties文件的内容：

  1. project_name=mavenAppTest
  2. project_version=1.0-SNAPSHOT
  3. project_modelVersion=4.0.0
  4. project_artifactId=mavenApp
  5. settings_localRepository=D:\\develop\\mavenRepository

test.txt文件的内容：

  1. project_version=1.0-SNAPSHOT
  2. project_modelVersion=4.0.0
  3. project_artifactId=mavenApp
  4. settings_localRepository=D:\\develop\\mavenRepository

如果我们只需要对资源文件进行处理的话也可以使用mvn process-resources指令，该指令是专门用于处理资源文件的，而mvn compile是在编译的时候处理了资源文件。

3.10.2使用外部文件的属性关联

要使用外部文件的属性来关联资源文件里面定义的属性值，那么我们就需要告诉maven应该去哪里找这个属性文件，这是通过在pom.xml中指定filter的值来指定的。

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.tiantian.mavenApp</groupId>
  5. <artifactId>mavenApp</artifactId>
  6. <version>1.0-SNAPSHOT</version>
  7. <packaging>jar</packaging>
  8. <name>mavenAppTest</name>
  9. <url>http://maven.apache.org</url>
  10. <properties>
  11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12. </properties>
  13. <dependencies>
  14. <dependency>
  15. <groupId>junit</groupId>
  16. <artifactId>junit</artifactId>
  17. <version>3.8.1</version>
  18. <scope>test</scope>
  19. </dependency>
  20. </dependencies>
  21. <build>
  22. <filters>
  23. <filter>src/main/filters/testFilter.properties</filter>
  24. </filters>
  25. <resources>
  26. <resource>
  27. <directory>src/main/resources</directory>
  28. <filtering>true</filtering>
  29. </resource>
  30. </resources>
  31. </build>
  32. </project>

在上面代码中我们通过build下面的filters下面的filter元素指定了一个外部用于资源文件过滤的属性文件src/main/filters/testFilter.properties，接着我们在src/main/filters下面建立testFilter.properties文件，其内容如下：

  1. myFilter.maven.test=test
  2. myFilter.maven.username=andy

然后我们在resources目录下面定义一个application.properties文件，内容如下：

  1. project_name=${pom.name}
  2. project_version=${pom.version}
  3. project_modelVersion=${pom.modelVersion}
  4. project_artifactId=${pom.artifactId}
  5. settings_localRepository=${settings.localRepository}
  6. filter_username=${myFilter.maven.username}

接下来我们执行mvn process-resources指令来处理资源文件，将在target/classes下面对应的application.properties文件中看到如下内容：

  1. project_name=mavenAppTest
  2. project_version=1.0-SNAPSHOT
  3. project_modelVersion=4.0.0
  4. project_artifactId=mavenApp
  5. settings_localRepository=D:\\develop\\mavenRepository
  6. filter_username=andy

我们可以看到我们在application.properties文件中定义的${myFilter.maven.username}已经被指定的外部属性文件testFilter.properties的属性myFilter.maven.username对应的属性值andy所取代。像这种指定外部属性文件来过滤资源文件的方式也可以在pom.xml中的properties元素下指定对应的子元素作为属性名称的形式来达到相同的效果。在上面示例的基础上，我们先在pom.xml文件的properties元素下面加一个myFilter.maven.username元素，然后指定其值为super，这时候pom.xml文件会是这个样子：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.tiantian.mavenApp</groupId>
  5. <artifactId>mavenApp</artifactId>
  6. <version>1.0-SNAPSHOT</version>
  7. <packaging>jar</packaging>
  8. <name>mavenAppTest</name>
  9. <url>http://maven.apache.org</url>
  10. <properties>
  11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12. <myFilter.maven.username>super</myFilter.maven.username>
  13. </properties>
  14. <dependencies>
  15. <dependency>
  16. <groupId>junit</groupId>
  17. <artifactId>junit</artifactId>
  18. <version>3.8.1</version>
  19. <scope>test</scope>
  20. </dependency>
  21. </dependencies>
  22. <build>
  23. <filters>
  24. <filter>src/main/filters/testFilter.properties</filter>
  25. </filters>
  26. <resources>
  27. <resource>
  28. <directory>src/main/resources</directory>
  29. <filtering>true</filtering>
  30. </resource>
  31. </resources>
  32. </build>
  33. </project>

接着，我们再次运行mvn process-resources指令，然后查看target/classes目录下的application.properties文件的内容会是这个样子：

  1. project_name=mavenAppTest
  2. project_version=1.0-SNAPSHOT
  3. project_modelVersion=4.0.0
  4. project_artifactId=mavenApp
  5. settings_localRepository=D:\\develop\\mavenRepository
  6. filter_username=super

我们可以看到filter_username已经由src/main/filters/testFilter.properties中指定的属性myFilter.maven.username的值user变成了pom.xml中properties元素的子元素myFilter.maven.username的值super。由此我们也可以看出在pom.xml文件内部定义的属性值将具有更高的优先级，它会覆盖外部属性文件中相同的属性定义。

跟需要替换属性值的资源文件可以是不同的文件类型一样，用于关联属性的外部文件也可以是不同的文件类型。为了证明这个问题，我们先在pom.xml中新增一个filter元素，其值指向src/main/filters/testFilter.txt，然后在src/main/filters下新建文件内容为myFilter.maven.fileType=text的testFilter.txt文件，接着在资源文件application.properties中新增一行内容为filter_fileType=${myFilter.maven.fileType}，之后运行mvn process-resources指令，之后我们可以看到target/classes下的资源文件application.properties的文件内容如下：

  1. project_name=mavenAppTest
  2. project_version=1.0-SNAPSHOT
  3. project_modelVersion=4.0.0
  4. project_artifactId=mavenApp
  5. settings_localRepository=D:\\develop\\mavenRepository
  6. filter_username=super
  7. filter_fileType=text

3.10.3使用系统属性

过滤资源还可以使用来自系统属性的值，比如java.version，或者在命令行使用-D参数指定的参数。我们来做一下实验，先把我们的application.properties文件修改为如下内容：

  1. project_name=${pom.name}
  2. java_version=${java.version}
  3. user_home=${user.home}
  4. command.line.prop=${command.line.prop}

接下来，我们执行指令mvn process-resources –Dcommand.line.prop=hello，之后我们可以看到target/classes下文件application.properties的内容为：

  1. project_name=mavenAppTest
  2. java_version=1.7.0_07
  3. user_home=C:\\Users\\andy
  4. command.line.prop=hello

3.11        在pom.xml中定义project的外部依赖包

对于每一个外部依赖都有4个元素是必须定义的，它们是groupId、artifactId、version和scope。其中groupId、artifactId和version必须和依赖包中使用maven打包时定义的pom.xml中定义的相对应的元素的值相同。比如说我们有一个maven项目叫projectA，它的pom.xml中定义的groupId、artifactId和version如下：

  1. <groupId>com.tiantian.projectA</groupId>
  2. <artifactId>projectA</artifactId>
  3. <version>1.0</version>

之后我们用mvn package把projectA打包为一个jar包，然后使用mvn install把打好的jar包安装到本地仓库。这个时候有另一个项目projectB，它需要在它的pom.xml中定义对projectA的依赖，这个时候它的pom.xml中定义对projectA依赖的groupId、artifactId和version都应该和projectA的pom.xml中定义的保持一致，具体代码如下：

  1. <dependency>
  2. <groupId>com.tiantian.projectA</groupId>
  3. <artifactId>projectA</artifactId>
  4. <version>1.0</version>
  5. <scope>running</scope>
  6. </dependency>

元素scope的值表示引用的作用范围，主要取值有compile、test、provided、runtime和system。关于scope的更多介绍将在以后的文中作更多的介绍。对于pom.xml中使用dependency定义的引用信息，maven在需要使用的时候会先从本地仓库取，如果在本地仓库取不到的时候就会尝试从远程仓库下载。

当我们需要引用一个依赖包，而不知道其对应的groupId等信息的时候，我们可以在网站http://mvnrepository.com/中进行搜索寻找对应的依赖包。

相关文章