Maven简介（二）——使用Maven

使用Maven

目录：

 

 

3.1     使用maven建立自己的项目

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

   (2)执行如下指令：

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

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

        -DgroupId=com.company.app 组id

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

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

      以下是一个示例：

Cmd代码  

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

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

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

Cmd代码  

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项目的指令写完整的话就应该是:

Cmd代码  

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本地仓库，那么我们可以在命令窗口执行以下命令：

Cmd代码  

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项目中引用该依赖类型了。如：

Xml代码  

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。如下示例：

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.   
5.   <groupId>com.tiantian.mavenApp</groupId>  
6.   <artifactId>mavenApp</artifactId>  
7.   <version>1.0-SNAPSHOT</version>  
8.   <packaging>jar</packaging>  
9.   
10.   <name>mavenAppTest</name>  
11.   <url>http://maven.apache.org</url>  
12.   
13.   <properties>  
14.    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
15.   </properties>  
16.   
17.   <dependencies>  
18.    <dependency>  
19.      <groupId>junit</groupId>  
20.      <artifactId>junit</artifactId>  
21.      <version>3.8.1</version>  
22.      <scope>test</scope>  
23.    </dependency>  
24.   </dependencies>  
25.    
26.   <build>  
27.    <resources>  
28.      <resource>  
29.         <directory>src/main/resources</directory>  
30.         <filtering>true</filtering>  
31.      </resource>  
32.    </resources>  
33.   </build>  
34. </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

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

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文件的内容：

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文件的内容：

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的值来指定的。

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.    
5.   <groupId>com.tiantian.mavenApp</groupId>  
6.   <artifactId>mavenApp</artifactId>  
7.   <version>1.0-SNAPSHOT</version>  
8.   <packaging>jar</packaging>  
9.    
10.   <name>mavenAppTest</name>  
11.   <url>http://maven.apache.org</url>  
12.    
13.   <properties>  
14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
15.   </properties>  
16.    
17.   <dependencies>  
18.     <dependency>  
19.       <groupId>junit</groupId>  
20.       <artifactId>junit</artifactId>  
21.       <version>3.8.1</version>  
22.       <scope>test</scope>  
23.     </dependency>  
24.   </dependencies>  
25.    
26.   <build>  
27.    <filters>  
28.       <filter>src/main/filters/testFilter.properties</filter>  
29.    </filters>  
30.    <resources>  
31.       <resource>  
32.         <directory>src/main/resources</directory>  
33.         <filtering>true</filtering>  
34.       </resource>  
35.    </resources>  
36.   </build>  
37. </project>  

 

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

Properties代码  

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

 

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

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文件中看到如下内容：

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文件会是这个样子：

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.    
5.   <groupId>com.tiantian.mavenApp</groupId>  
6.   <artifactId>mavenApp</artifactId>  
7.   <version>1.0-SNAPSHOT</version>  
8.   <packaging>jar</packaging>  
9.    
10.   <name>mavenAppTest</name>  
11.   <url>http://maven.apache.org</url>  
12.    
13.   <properties>  
14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
15.    <myFilter.maven.username>super</myFilter.maven.username>  
16.   </properties>  
17.    
18.   <dependencies>  
19.     <dependency>  
20.       <groupId>junit</groupId>  
21.       <artifactId>junit</artifactId>  
22.       <version>3.8.1</version>  
23.       <scope>test</scope>  
24.     </dependency>  
25.   </dependencies>  
26.    
27.   <build>  
28.    <filters>  
29.       <filter>src/main/filters/testFilter.properties</filter>  
30.    </filters>  
31.    <resources>  
32.       <resource>  
33.         <directory>src/main/resources</directory>  
34.         <filtering>true</filtering>  
35.       </resource>  
36.    </resources>  
37.   </build>  
38. </project>  

 

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

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的文件内容如下：

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文件修改为如下内容：

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的内容为：

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如下：

Xml代码  

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中定义的保持一致，具体代码如下：

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/中进行搜索寻找对应的依赖包。

 

 

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

 进入到项目的pom.xml文件所在的目录后，使用mvn dependency:tree指令可以查看当前项目的依赖关系。

 

 

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

默认情况下，Maven同时下载artifact的数量是5，这个可以通过参数maven.artifact.threads。比如如果我们希望一次只下载3个artifact的时候，我们就可以这样用：

Cmd代码  

1. mvn –Dmaven.artifact.threads=3 install  

       如果需要这个参数永久生效的话我们就可以把这个参数定义到环境变量MAVEN_OPTS中。

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

有时候我们连不上网或者我们需要在不访问网络的情况下进行某些操作，这个时候我们就可以在执行Maven指令的时候使用-o参数，比如：

Cmd代码  

1. mvn –o package  

 

3.15        构建自己的archetype

正如前面内容所介绍的那样，archetype就是Maven给我们提供的一种建立Maven项目的模板，它可以为我们建立我们自己想要的项目的初始目录结构和内容。但是Maven本身为我们提供的那些archetype在实际应用中是远远不够的，这就需要我们来扩展构建自己的archetype。archetype实际上也是一个Maven工件，所以当我们需要构建自己的archetype的时候也是通过对Maven项目的定义来构建的。下面将以一个示例来谈一下我们该如何构建属于自己的archetype，这个例子只是用于介绍如何构建自己的archetype的，其中文档结构和内容等不合理的地方我们在这里就不做深究了。假设我们开发的都是web项目，然后经常使用spring进行开发，然后我们需要创建一个目录结构如下的archetype。

 

 

第一步：创建一个简单的Maven项目，定义好它的groupId、artifactId和version，这三个属性就对应了我们需要建立的archetype的三个主要属性，在我们以后使用该archetype的时候会用到。这里我们使用“mvn archetype:generate –DgroupId=com.tiantian –DartifactId=myArchetype –Dversion=1.0 –DinteractiveMode=false”指令建立一个简单的Maven项目。这个时候myArchetype的pom.xml应该是如下这样:

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/maven-v4_0_0.xsd">  
3.   <modelVersion>4.0.0</modelVersion>  
4.   <groupId>com.tiantian</groupId>  
5.   <artifactId>myArchetype</artifactId>  
6.   <packaging>jar</packaging>  
7.   <version>1.0</version>  
8.   <name>myArchetype</name>  
9.   <url>http://maven.apache.org</url>  
10.   <dependencies>  
11.     <dependency>  
12.       <groupId>junit</groupId>  
13.       <artifactId>junit</artifactId>  
14.       <version>3.8.1</version>  
15.       <scope>test</scope>  
16.     </dependency>  
17.   </dependencies>  
18. </project>  
19. 关于这段代码我们可以把里面无关紧要的内容删掉，那么最简单是形式应该是如下所示：  
20. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
21.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
22.   <modelVersion>4.0.0</modelVersion>  
23.   <groupId>com.tiantian</groupId>  
24.   <artifactId>myArchetype</artifactId>  
25.   <version>1.0</version>  
26. </project>  

 

第二步：建立一个archetype.xml文件，用于描述需要构建的archetype，主要是描述该archetype建立的项目将包含哪些文件。这个文件必须放在“src/main/resources/META-INF/maven”下面。在这里我们这个archetype.xml的内容会如下所示：

Xml代码  

1. <archetype xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
2.   xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype/1.0.0 http://maven.apache.org/xsd/archetype-1.0.0.xsd">  
3.   <id>myArchetype</id>  
4.   <sources>  
5.     <source>src/main/java/Hello.java</source>  
6.   </sources>  
7.   <resources>  
8.        <resource>src/main/resources/jdbc.properties</resource>  
9.        <resource>src/main/webapp/WEB-INF/web.xml</resource>  
10.        <resource>src/main/webapp/WEB-INF/application.xml</resource>  
11.        <resource>src/main/webapp/index.jsp</resource>  
12.   </resources>  
13.   <testSources>  
14.     <source>src/test/java/Hello.java</source>  
15.   </testSources>  
16. </archetype>  

 

id是必须配置的，而且必须和我们定义的archetype的artifactId一致。sources用于定义java源码对应的目录，其下可以定义一系列的source元素。testSources用于定义测试源码对应的目录，其下也是可以定义一系列的source元素。resources、testResources和siteResources下面可以定义一系列的resource元素，表示资源文件所处的位置。

第三步：在archetype.xml中定义了该archetype将包含哪些文件之后我们就需要定义这些文件。那么这些文件是定义在哪里的呢？这些文件的位置都是当前项目的resources/archetype-resources目录下面对应的位置。即“src/main/resources/archetype-resources /src/main/java/Hello.java”、

“src/main/resources/archetype-resources /src/main/resources/jdbc.properties”、

“src/main/resources/archetype-resources /src/main/webapp/WEB-INF/web.xml”、

“src/main/resources/archetype-resources /src/main/webapp/WEB-INF/application.xml”、

“src/main/resources/archetype-resources /src/main/webapp/index.jsp”、

“src/main/resources/archetype-resources /src/test/java/Hello.java”。

这其中当然也包括pom.xml文件的定义。其目录结构大概如下图所示：

 

 

这个时候我们也可以指定上述文件的初始内容，比如web.xml的内容为：

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
5.        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
6.         
7.        <welcome-file-list>  
8.               <welcome-file>index.do</welcome-file>  
9.        </welcome-file-list>  
10.         
11.        <listener>  
12.               <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
13.        </listener>  
14.         
15.        <filter>  
16.               <filter-name>encodingFilter</filter-name>  
17.               <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
18.               <init-param>  
19.                      <param-name>encoding</param-name>  
20.                      <param-value>GBK</param-value>  
21.               </init-param>  
22.        </filter>  
23.        <filter-mapping>  
24.               <filter-name>encodingFilter</filter-name>  
25.               <url-pattern>*.do</url-pattern>  
26.        </filter-mapping>  
27.    
28.        <servlet>  
29.               <servlet-name>${artifactId}</servlet-name>  
30.               <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
31.               <init-param>  
32.                      <param-name>contextConfigLocation</param-name>  
33.                      <param-value>classpath:${artifactId}-servlet.xml</param-value>  
34.               </init-param>  
35.               <load-on-startup>1</load-on-startup>  
36.        </servlet>  
37.        <servlet-mapping>  
38.               <servlet-name>${artifactId}</servlet-name>  
39.               <url-pattern>*.do</url-pattern>  
40.        </servlet-mapping>  
41. </web-app>  

 

       从上面这段代码我们可以看出，我们已经把一些针对特定项目要特定配置的项给参数化了。这样当我们建立项目的时候给定的参数会自动覆盖这些变量。

接下来就是定义我们生成的pom.xml文件的内容了。这里我们如下定义：

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/maven-v4_0_0.xsd">  
3.   <modelVersion>4.0.0</modelVersion>  
4.   <groupId>${groupId}</groupId>  
5.   <artifactId>${artifactId}</artifactId>  
6.   <packaging>war</packaging>  
7.   <version>${version}</version>  
8.   <dependencies>  
9.     <dependency>  
10.       <groupId>org.springframework</groupId>  
11.       <artifactId>spring-context</artifactId>  
12.       <version>3.0.0.RELEASE</version>  
13.       <scope>runtime</scope>  
14.    </dependency>  
15.   </dependencies>  
16. </project>  

 

从上面的定义中我们可以看出这里的groupId、artifactId和version都是使用的参数形式，而packaging和dependency就是我们直接写好的。这是因为我们需要使用这个archetype来建立同一类型的不同的artifact。

第四步：使用“mvn install”安装该新建的archetype工件到本地仓库。

经过这几步之后我们就可以使用自己定义的myArchetype进行自己项目的建立了。如：

Cmd代码  

1. mvn archetype:generate –DarchetypeGroupId=com.tiantian –DarchetypeArtifactId=myArchetype –DarchetypeVersion=1.0 –DgroupId=com.myhost –DartifactId=myapp –Dversion=1.0  

 

使用该指令建立的项目的目录结构如下所示：

  

其中web.xml的内容变为：

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
5.        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
6.         
7.        <welcome-file-list>  
8.               <welcome-file>index.do</welcome-file>  
9.        </welcome-file-list>  
10.         
11.        <listener>  
12.               <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
13.        </listener>  
14.         
15.        <filter>  
16.               <filter-name>encodingFilter</filter-name>  
17.               <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
18.               <init-param>  
19.                      <param-name>encoding</param-name>  
20.                      <param-value>GBK</param-value>  
21.               </init-param>  
22.        </filter>  
23.        <filter-mapping>  
24.               <filter-name>encodingFilter</filter-name>  
25.               <url-pattern>*.do</url-pattern>  
26.        </filter-mapping>  
27.    
28.        <servlet>  
29.               <servlet-name>myapp</servlet-name>  
30.               <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
31.               <init-param>  
32.                      <param-name>contextConfigLocation</param-name>  
33.                      <param-value>classpath:myapp-servlet.xml</param-value>  
34.               </init-param>  
35.               <load-on-startup>1</load-on-startup>  
36.        </servlet>  
37.        <servlet-mapping>  
38.               <servlet-name>myapp</servlet-name>  
39.               <url-pattern>*.do</url-pattern>  
40.        </servlet-mapping>  
41.    
42. </web-app>  

 

使用myArchetype建立的Maven项目myapp中的pom.xml的内容如下：

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/maven-v4_0_0.xsd">  
3.   <modelVersion>4.0.0</modelVersion>  
4.   <groupId>com.myhost</groupId>  
5.   <artifactId>myapp</artifactId>  
6.   <packaging>war</packaging>  
7.   <version>1.0</version>  
8.   <dependencies>  
9.     <dependency>  
10.       <groupId>org.springframework</groupId>  
11.       <artifactId>spring-context</artifactId>  
12.       <version>3.0.0.RELEASE</version>  
13.       <scope>runtime</scope>  
14.    </dependency>  
15.   </dependencies>  
16. </project>  

 

       以上就是自己构建Maven的archetype的基本步骤。其实这些东西如果全部需要自己去建好的话还是比较麻烦的。针对于构建自己的archetype，Maven也给我们提供了一个建立自己的archetype的archetype，那就是3.1节里面提过的maven-archetype-archetype。下面就简单介绍一下利用Maven提供的maven-archetype-archetype来建立我们自己的archetype。

 

Cmd代码  

1.       mvn archetype:generate  
2. –DarchetypeGroupId=org.apache.maven.archetypes  
3. –DarchetypeArtifactId=maven-archetype-archetype  
4. –DgroupId=com.tiantian  –DartifactId=myArchetype  
5.  –Dversion=1.0 –DinteractiveMode=false  

 

       通过上面的指令可以建立简单的archetype的示例，接着我们就可以根据自己的需要修改需要建立的archetype的描述文件archetype.xml，然后在对应的archetype-resources目录下建立对应的文件即可。接下来的操作一样是通过“mvn install”指令安装该archetype工件到本地仓库，这样我们以后就可以通过该archetype来建立我们预定好的Maven项目了。

 

3.16        使用mvn javadoc:jar生成对应的javadoc

在Maven项目的根目录即pom.xml文件所在的目录下使用mvn javadoc:jar可以生成当前项目对应的java doc。

 

 

3.17        使用mvn dependency:sources下载对应的源码

在Maven项目的根目录即pom.xml文件所在的目录下使用mvn dependency:sources可以下载对应依赖包的源码。