`
lianhua
  • 浏览: 21561 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Maven的安装

阅读更多

 1.Maven的安装

 安装Maven之前要确保已经安装好了jdk，并且配置好了环境变量JAVA_HOME。具体安装步骤如下：

1.从apache网上下载maven项目的压缩包。下载地址为：http://maven.apache.org/download.html。比如现在最新的Maven版本是3.0.4，那么我下载好的安装文件就是apache-maven-3.0.4.zip。

2.将下载后的压缩包解压到Maven的安装目录，比如说是D:\\develop，那么解压后就是D:\\develop\\apache-maven-3.0.4。

3.添加环境变量M2_HOME，其值为Maven的家目录，如D:\\develop\\apache-maven-3.0.4。

4.添加环境变量M2，其值将为maven安装目录的bin目录，即D:\\develop\\apache-maven-3.0.4\\bin，对于windows系统也可以使用%M2_HOME%\\bin，对于linux系统也可以使用$M2_HOME/bin。

5.将环境变量M2加入到PATH变量中，对于windows系统，可以在PATH变量的值后面加上“;%M2%”，对于linux系统，可以使用“export path=$path:$M2”

6.还有一个可选的环境变量MAVEN_OPTS，该环境变量主要是配置Maven在使用jdk的时候指定JVM属性的。如指定其值为“-Xms256m -Xmx512m”。

经过以上几步之后Maven就安装成功了。接下来我们可以在命令窗口使用mvn --version来验证一下Maven是否安装成功。如能正确输出Maven的安装版本，则表示它安装成功了。

2.配置Maven的环境信息 

先来看一个基本的settings.xml的样子：

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <localRepository>D:\\develop\\mavenRepository</localRepository>
  <interactiveMode>true</interactiveMode>
  <offline>false</offline>
  <pluginGroups>
  </pluginGroups>
  <proxies>
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
  </proxies>
   <servers>
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
  </servers>
   <mirrors>
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
  </mirrors>
   <profiles>
    <profile>
      <id>jdk-1.5</id>
      <activation>
        <jdk>1.5</jdk>
      </activation>
      <repositories>
        <repository>
          <id>jdk15</id>
          <name>jdk1.5</name>
          <url>http://www.myhost.com/maven/jdk15</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
  </profiles>
  <activeProfiles>
    <activeProfile>jdk-1.5</activeProfile>
  </activeProfiles>
</settings>

 settings.xml中主要包括以下元素：

 localRepository：表示Maven用来在本地储存信息的本地仓库的目录。默认是用户家目录下面的.m2/repository目录。

 interactiveMode：表示是否使用交互模式，默认是true；如果设为false，那么当Maven需要用户进行输入的时候，它会使用一个默认值。

 offline：表示是否离线，默认是false。这个属性表示在Maven进行项目编译和部署等操作时是否允许Maven进行联网来下载所需要的信息。

 pluginGroups：在pluginGroups元素下面可以定义一系列的pluginGroup元素。表示当通过plugin的前缀来解析plugin的时候到哪里寻找。pluginGroup元素指定的是plugin的groupId。默认情况下，Maven会自动把org.apache.maven.plugins和org.codehaus.mojo添加到pluginGroups下。

 proxies：其下面可以定义一系列的proxy子元素，表示Maven在进行联网时需要使用到的代理。当设置了多个代理的时候第一个标记active为true的代理将会被使用。

下面是一个使用代理的例子：

<proxies>
  <proxy>
      <id>xxx</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>用户名</username>
      <password>密码</password>
      <host>代理服务器地址</host>
      <port>代理服务器的端口</port>
      <nonProxyHosts>不使用代理的主机</nonProxyHosts>
  </proxy>
</proxies>

   servers：其下面可以定义一系列的server子元素，表示当需要连接到一个远程服务器的时候需要使用到的验证方式。这主要有username/password和privateKey/passphrase这两种方式。

以下是一个使用servers的示例：

  <servers>
    <server>
      <id>id</id>
      <username>用户名</username>
      <password>密码</password>
    </server>
  </servers>

 mirrors：用于定义一系列的远程仓库的镜像。我们可以在pom中定义一个下载工件的时候所使用的远程仓库。但是有时候这个远程仓库会比较忙，所以这个时候人们就想着给它创建镜像以缓解远程仓库的压力，也就是说会把对远程仓库的请求转换到对其镜像地址的请求。每个远程仓库都会有一个id，这样我们就可以创建自己的mirror来关联到该仓库，那么以后需要从远程仓库下载工件的时候Maven就可以从我们定义好的mirror站点来下载，这可以很好的缓解我们远程仓库的压力。在我们定义的mirror中每个远程仓库都只能有一个mirror与它关联，也就是说你不能同时配置多个mirror的mirrorOf指向同一个repositoryId。

    下是一个使用mirrors的例子：   

<mirrors>
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>定义一个容易看懂的名称 </name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
</mirrors>

 id：是用来区别mirror的，所有的mirror不能有相同的id

 mirrorOf：用来表示该mirror是关联的哪一个仓库，其值为其关联仓库的id。当要同时关联多个仓库时，这多个仓库之间可以用逗号隔开；当要关联所有的仓库时，可以使用“*”表示；当要关联除某一个仓库以外的其他所有仓库时，可以表示为“*,!repositoryId”；当要关联不是localhost或用file请求的仓库时，可以表示为“external:*”。

 url：表示该镜像的url。当Maven在建立系统的时候就会使用这个url来连接到我们的远程仓库。

profiles：用于指定一系列的profile。profile元素由activation、repositories、pluginRepositories和properties四个元素组成。当一个profile在settings.xml中是处于活动状态并且在pom.xml中定义了一个相同id的profile时，settings.xml中的profile会覆盖pom.xml中的profile。

 （1）activation：这是profile中最重要的元素。跟pom.xml中的profile一样，settings.xml中的profile也可以在特定环境下改变一些值，而这些环境是通过activation元素来指定的。

<property>
       <name>hello</name>
       <value>world</value>
</property>

        看下面一个例子：      

<profiles>
    <profile>
      <id>test</id>
      <activation>
        <activeByDefault>false</activeByDefault>
        <jdk>1.6</jdk>
        <os>
          <name>Windows 7</name>
          <family>Windows</family>
          <arch>x86</arch>
          <version>5.1.2600</version>
        </os>
        <property>
          <name>mavenVersion</name>
          <value>2.0.3</value>
        </property>
        <file>
          <exists>${basedir}/file2.properties</exists>
          <missing>${basedir}/file1.properties</missing>
        </file>
      </activation>
     </profile>
  </profiles>

 在上面这段代码中，当所有的约束条件都满足的时候就会激活这个profile。

   jdk：表示当jdk的版本满足条件的时候激活，在这里是1.6。这里的版本还可以用一个范围来表示，如

    <jdk>[1.4,1.7)</jdk>表示1.4、1.5和1.6满足；

    <jdk>[1.4,1.7]</jdk>表示1.4、1.5、1.6和1.7满足；

 os：表示当操作系统满足条件的时候激活。

property：property是键值对的形式，表示当Maven检测到了这样一个键值对的时候就激活该profile。

 (1)下面的示例表示当存在属性hello的时候激活该profile。  

<property>  
     <name>hello</name>  
</property>

 (2)下面的示例表示当属性hello的值为world的时候激活该profile。

<property>
       <name>hello</name>
       <value>world</value>
</property>

   这个时候如果要激活该profile的话，可以在调用Maven指令的时候加上参数hello并指定其值为world，如： mvn compile –Dhello=world

  file：表示当文件存在或不存在的时候激活，exists表示存在，missing表示不存在。如下面的例子表示当文件hello/world不存在的时候激活该profile。 

<profile>
       <activation>
              <file>
                     <missing>hello/world</missing>
              </file>
       </activation>
</profile>

（1）activeByDefault：当其值为true的时候表示如果没有其他的profile处于激活状态的时候，该profile将自动被激活。

（2）properties：用于定义属性键值对的。当该profile是激活状态的时候，properties下面指定的属性都可以在pom.xml中使用。

（3）repositories：用于定义远程仓库的，当该profile是激活状态的时候，这里面定义的远程仓库将作为当前pom的远程仓库。  

      <repositories>
        <repository>
          <id>codehausSnapshots</id>
          <name>Codehaus Snapshots</name>
          <releases>
            <enabled>false</enabled>
            <updatePolicy>always</updatePolicy>
            <checksumPolicy>warn</checksumPolicy>
          </releases>
          <snapshots>
            <enabled>true</enabled>
            <updatePolicy>never</updatePolicy>
            <checksumPolicy>fail</checksumPolicy>
          </snapshots>
          <url>http://snapshots.maven.codehaus.org/maven2</url>
          <layout>default</layout>
        </repository>
      </repositories>

       releases、snapshots：这是对于工件的类型的限制。

    enabled：表示这个仓库是否允许这种类型的工件

    updatePolicy：表示多久尝试更新一次。可选值有always、daily、interval:minutes（表示每多久更新一次）和never。

    checksumPolicy：当Maven在部署项目到仓库的时候会连同校验文件一起提交，checksumPolicy表示当这个校验文件缺失或不正确的时候该如何处理，可选项有ignore、fail和warn。

（4）pluginRepositories：在Maven中有两种类型的仓库，一种是存储工件的仓库，另一种就是存储plugin插件的仓库。pluginRepositories的定义和repositories的定义类似，它表示Maven在哪些地方可以找到所需要的插件。

activeProfiles：底包含一系列的activeProfile元素，表示对于所有的pom都处于活跃状态的profile。如：  

  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>

3 maven介绍

3.1 使用maven建立自己的项目

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

   (2)执行如下指令：      

mvn archetype:generate

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

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

        -DgroupId=com.company.app 组id

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

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

      以下是一个示例：     

mvn archetype:generate -DgroupId=com.tiantian -DartifactId=jxc -DinteractiveMode=false
         运行上面的代码就会在d:\\develop\\apps下面新建一个名为jxc的maven项目。上面建立的只是一个简单的java应用，那如果我要建立一个web应用该如何呢？以下是一个示例： 
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项目的指令写完整的话就应该是: 
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本地仓库，那么我们可以在命令窗口执行以下命令：

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

    <dependency>  
        <groupId>com.tiantian</groupId>  
        <artifactId>abc</artifactId>  
        <version>1.0</version>  
    </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。如下示例：

    <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.tiantian.mavenApp</groupId>  
      <artifactId>mavenApp</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>jar</packaging>  
      <name>mavenAppTest</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>  
      <build>  
       <resources>  
         <resource>  
            <directory>src/main/resources</directory>  
            <filtering>true</filtering>  
         </resource>  
       </resources>  
      </build>  
    </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

project_name=${pom.name}  
project_version=${pom.version}  
project_modelVersion=${pom.modelVersion}  
project_artifactId=${pom.artifactId}  
settings_localRepository=${settings.localRepository}
    文件test.txt
project_version=${pom.version}  
project_modelVersion=${pom.modelVersion}  
project_artifactId=${pom.artifactId}  
settings_localRepository=${settings.localRepository}

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

   application.properties文件的内容：  

project_name=mavenAppTest  
project_version=1.0-SNAPSHOT  
project_modelVersion=4.0.0  
project_artifactId=mavenApp  
settings_localRepository=D:\\develop\\mavenRepository

    test.txt文件的内容：   

project_version=1.0-SNAPSHOT  
project_modelVersion=4.0.0  
project_artifactId=mavenApp  
settings_localRepository=D:\\develop\\mavenRepository

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

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

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

    <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.tiantian.mavenApp</groupId>  
      <artifactId>mavenApp</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>jar</packaging>  
      <name>mavenAppTest</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>  
       
      <build>  
       <filters>  
          <filter>src/main/filters/testFilter.properties</filter>  
       </filters>  
       <resources>  
          <resource>  
            <directory>src/main/resources</directory>  
            <filtering>true</filtering>  
          </resource>  
       </resources>  
      </build>  
    </project>
   在上面代码中我们通过build下面的filters下面的filter元素指定了一个外部用于资源文件过滤的属性文件src/main/filters /testFilter.properties，接着我们在src/main/filters下面建立testFilter.properties文件， 其内容如下： 
myFilter.maven.test=test  
myFilter.maven.username=andy
 然后我们在resources目录下面定义一个application.properties文件，内容如下： 
project_name=${pom.name}  
project_version=${pom.version}  
project_modelVersion=${pom.modelVersion}  
project_artifactId=${pom.artifactId}  settings_localRepository=${settings.localRepository}  
filter_username=${myFilter.maven.username}
  接下来我们执行mvn process-resources指令来处理资源文件，将在target/classes下面对应的application.properties文件中看到如下内容： 
project_name=mavenAppTest  
project_version=1.0-SNAPSHOT  
project_modelVersion=4.0.0  
project_artifactId=mavenApp  
settings_localRepository=D:\\develop\\mavenRepository  
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文件会是这个样子： 
    <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.tiantian.mavenApp</groupId>  
      <artifactId>mavenApp</artifactId>  
      <version>1.0-SNAPSHOT</version>  
      <packaging>jar</packaging>  
      <name>mavenAppTest</name>  
      <url>http://maven.apache.org</url>  
      <properties>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
       <myFilter.maven.username>super</myFilter.maven.username>  
      </properties>  
       
      <dependencies>  
        <dependency>  
          <groupId>junit</groupId>  
          <artifactId>junit</artifactId>  
          <version>3.8.1</version>  
          <scope>test</scope>  
        </dependency>  
      </dependencies>  
       
      <build>  
       <filters>  
          <filter>src/main/filters/testFilter.properties</filter>  
       </filters>  
       <resources>  
          <resource>  
            <directory>src/main/resources</directory>  
            <filtering>true</filtering>  
          </resource>  
       </resources>  
      </build>  
    </project>

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

project_name=mavenAppTest  
project_version=1.0-SNAPSHOT  
project_modelVersion=4.0.0  
project_artifactId=mavenApp  
settings_localRepository=D:\\develop\\mavenRepository  
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的文 件内容如下：

project_name=mavenAppTest  
project_version=1.0-SNAPSHOT  
project_modelVersion=4.0.0  
project_artifactId=mavenApp  
settings_localRepository=D:\\develop\\mavenRepository  
filter_username=super  
filter_fileType=text

 3.10.3使用系统属性

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

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

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

project_name=mavenAppTest  
java_version=1.7.0_07  
user_home=C:\\Users\\andy  
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如下：

<groupId>com.tiantian.projectA</groupId>  
<artifactId>projectA</artifactId>  
<version>1.0</version>

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

<dependency>  
      <groupId>com.tiantian.projectA</groupId>  
      <artifactId>projectA</artifactId>  
      <version>1.0</version>  
      <scope>running</scope>  
</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的时候，我们就可以这样用：

mvn –Dmaven.artifact.threads=3 install
      如果需要这个参数永久生效的话我们就可以把这个参数定义到环境变量MAVEN_OPTS中。

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

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

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应该是如下这样:

<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/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.tiantian</groupId>  
  <artifactId>myArchetype</artifactId>  
  <packaging>jar</packaging>  
  <version>1.0</version>  
  <name>myArchetype</name>  
  <url>http://maven.apache.org</url>  
  <dependencies>  
    <dependency>  
      <groupId>junit</groupId>  
      <artifactId>junit</artifactId>  
      <version>3.8.1</version>  
      <scope>test</scope>  
    </dependency>  
  </dependencies>  
</project>
   关于这段代码我们可以把里面无关紧要的内容删掉，那么最简单是形式应该是如下所示： 
<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/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.tiantian</groupId>  
  <artifactId>myArchetype</artifactId>  
  <version>1.0</version>  
</project>

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

    <archetype xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
      xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype/1.0.0 http://maven.apache.org/xsd/archetype-1.0.0.xsd">  
      <id>myArchetype</id>  
      <sources>  
        <source>src/main/java/Hello.java</source>  
      </sources>  
      <resources>  
           <resource>src/main/resources/jdbc.properties</resource>  
           <resource>src/main/webapp/WEB-INF/web.xml</resource>  
           <resource>src/main/webapp/WEB-INF/application.xml</resource>  
           <resource>src/main/webapp/index.jsp</resource>  
      </resources>  
      <testSources>  
        <source>src/test/java/Hello.java</source>  
      </testSources>  
    </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 version="1.0" encoding="UTF-8"?>  
    <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
           http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
           <welcome-file-list>  
                  <welcome-file>index.do</welcome-file>  
           </welcome-file-list>  
           <listener>  
                  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
           </listener>  
           <filter>  
                  <filter-name>encodingFilter</filter-name>  
                  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
                  <init-param>  
                         <param-name>encoding</param-name>  
                         <param-value>GBK</param-value>  
                  </init-param>  
           </filter>  
           <filter-mapping>  
                  <filter-name>encodingFilter</filter-name>  
                  <url-pattern>*.do</url-pattern>  
           </filter-mapping>  
           <servlet>  
                  <servlet-name>${artifactId}</servlet-name>  
                  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
                  <init-param>  
                         <param-name>contextConfigLocation</param-name>  
                         <param-value>classpath:${artifactId}-servlet.xml</param-value>  
                  </init-param>  
                  <load-on-startup>1</load-on-startup>  
           </servlet>  
           <servlet-mapping>  
                  <servlet-name>${artifactId}</servlet-name>  
                  <url-pattern>*.do</url-pattern>  
           </servlet-mapping>  
    </web-app>
        从上面这段代码我们可以看出，我们已经把一些针对特定项目要特定配置的项给参数化了。这样当我们建立项目的时候给定的参数会自动覆盖这些变量。接下来就是定义我们生成的pom.xml文件的内容了。这里我们如下定义： 
  <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/maven-v4_0_0.xsd">  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>${groupId}</groupId>  
      <artifactId>${artifactId}</artifactId>  
      <packaging>war</packaging>  
      <version>${version}</version>  
      <dependencies>  
        <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-context</artifactId>  
          <version>3.0.0.RELEASE</version>  
          <scope>runtime</scope>  
       </dependency>  
      </dependencies>  
    </project>

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

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

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

 

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

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



  

其中web.xml的内容变为：

 

    <?xml version="1.0" encoding="UTF-8"?>  
    <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
           http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
            <welcome-file-list>  
                  <welcome-file>index.do</welcome-file>  
           </welcome-file-list>  
           <listener>  
                  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
           </listener>  
            <filter>  
                  <filter-name>encodingFilter</filter-name>  
                  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
                  <init-param>  
                         <param-name>encoding</param-name>  
                         <param-value>GBK</param-value>  
                  </init-param>  
           </filter>  
           <filter-mapping>  
                  <filter-name>encodingFilter</filter-name>  
                  <url-pattern>*.do</url-pattern>  
           </filter-mapping>  
            <servlet>  
                  <servlet-name>myapp</servlet-name>  
                  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
                  <init-param>  
                         <param-name>contextConfigLocation</param-name>  
                         <param-value>classpath:myapp-servlet.xml</param-value>  
                  </init-param>  
                  <load-on-startup>1</load-on-startup>  
           </servlet>  
           <servlet-mapping>  
                  <servlet-name>myapp</servlet-name>  
                  <url-pattern>*.do</url-pattern>  
           </servlet-mapping>  
    </web-app>

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

       
    <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/maven-v4_0_0.xsd">  
      <modelVersion>4.0.0</modelVersion>  
      <groupId>com.myhost</groupId>  
      <artifactId>myapp</artifactId>  
      <packaging>war</packaging>  
      <version>1.0</version>  
      <dependencies>  
        <dependency>  
          <groupId>org.springframework</groupId>  
          <artifactId>spring-context</artifactId>  
          <version>3.0.0.RELEASE</version>  
          <scope>runtime</scope>  
       </dependency>  
      </dependencies>  
    </project>
    以上就是自己构建Maven的archetype的基本步骤。其实这些东西如果全部需要自己去建好的话还是比较麻烦的。针对于构建自己的 archetype，Maven也给我们提供了一个建立自己的archetype的archetype，那就是3.1节里面提过的maven- archetype-archetype。下面就简单介绍一下利用Maven提供的maven-archetype-archetype来建立我们自己的 archetype。 
mvn archetype:generate  
–DarchetypeGroupId=org.apache.maven.archetypes  
–DarchetypeArtifactId=maven-archetype-archetype  
–DgroupId=com.tiantian  –DartifactId=myArchetype  
 –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可以下载对应依赖包的源码。

4   profile介绍

4.1 profile简介

profile可以让我们定义一系列的配置信息，然后指定其激活条件。这样我们就可以定义多个profile，然后每个profile对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果。比如说，我们可以通过profile定义在jdk1.5以上使用一套配置信息，在jdk1.5以下使用另外一套配置信息；或者有时候我们可以通过操作系统的不同来使用不同的配置信息，比如windows下是一套信息，linux下又是另外一套信息，等等。具体的激活条件有哪些我在后文会讲到。

4.2     profile的定义位置

对于使用Maven3，我们可以有多个地方定义profile。定义的地方不同，它的作用范围也不同。

（1）针对于特定项目的profile配置我们可以定义在该项目的pom.xml中。

（2）针对于特定用户的profile配置，我们可以在用户的settings.xml文件中定义profile。该文件在用户家目录下的“.m2”目录下。

（3）全局的profile配置。全局的profile是定义在Maven安装目录下的“conf/settings.xml”文件中的。

4.3     profile中能定义的信息

profile中能够定义的配置信息跟profile所处的位置是相关的。以下就分两种情况来讨论，一种是定义在settings.xml中，另一种是定义在pom.xml中。

4.3.1  profile定义在settings.xml中

当profile定义在settings.xml中时意味着该profile是全局的，它会对所有项目或者某一用户的所有项目都产生作用。因为它是全局的，所以在settings.xml中只能定义一些相对而言范围宽泛一点的配置信息，比如远程仓库等。而一些比较细致一点的需要根据项目的不同来定义的就需要定义在项目的pom.xml中。具体而言，能够定义在settings.xml中的信息有<repositories>、<pluginRepositories>和<properties>。定义在<properties>里面的键值对可以在pom.xml中使用。

4.3.2  profile定义在pom.xml中

定义在pom.xml中的profile可以定义更多的信息。主要有以下这些：

   <repositories>

   <pluginRepositories>

   <dependencies>

   <plugins>

   <properties>

   <dependencyManagement>

   <distributionManagement>

 还有build元素下面的子元素，主要包括：

   <defaultGoal>

   <resources>

   <testResources>

   <finalName>

4.4     profile的激活方式

      Maven给我们提供了多种不同的profile激活方式。比如我们可以使用-P参数显示的激活一个profile，也可以根据环境条件的设置让它自动激活等。下面将对它们一一进行介绍：

4.4.1  使用activeByDefault设置激活

先看下面一个配置

     

 <profiles>
         <profile>
              <id>profileTest1</id>
              <properties>
                     <hello>world</hello>
              </properties>
              <activation>
                     <activeByDefault>true</activeByDefault>
              </activation>
         </profile>
         <profile>
              <id>profileTest2</id>
              <properties>
                     <hello>andy</hello>
              </properties>
         </profile>
  </profiles>
       我们可以在profile中的activation元素中指定激活条件，当没有指定条件，然后指定activeByDefault为true的时候就表示当没有指定其他profile为激活状态时，该profile就默认会被激活。所以当我们调用mvn package的时候上面的profileTest1将会被激活，但是当我们使用mvn package –P profileTest2的时候将激活profileTest2，而这个时候profileTest1将不会被激活。

4.4.2  在settings.xml中使用activeProfiles指定处于激活状态的profile

我们可以在settings.xml中使用activeProfiles来指定需要激活的profile，这种方式激活的profile将所有情况下都处于激活状态。比如现在我们定义了如下两个profile

   

  <profiles>
         <profile>
              <id>profileTest1</id>
              <properties>
                     <hello>world</hello>
              </properties>
         </profile>
         
         <profile>
              <id>profileTest2</id>
              <properties>
                     <hello>andy</hello>
              </properties>
         </profile>
  </profiles>
     这里的profile可以是定义在settings.xml中的，也可以是定义在pom.xml中的。这个时候如果我们需要指定profileTest1为激活状态，那么我们就可以在settings.xml中定义activeProfiles，具体定义如下： 
  <activeProfiles>
       <activeProfile>profileTest1</activeProfile>
  </activeProfiles>

   考虑这样一种情况，我们在activeProfiles下同时定义了多个需要激活的profile。这里还拿上面的profile定义来举例，我们定义了同时激活profileTest1和profileTest2。  

<activeProfiles>
    <activeProfile>profileTest1</activeProfile>
    <activeProfile>profileTest2</activeProfile>
</activeProfiles>
    从profileTest1和profileTest2我们可以看出它们共同定义了属性hello。那么这个时候我在pom.xml中使用属性hello的时候，它到底取的哪个值呢？是根据activeProfile定义的顺序，后面的覆盖前面的吗？根据我的测试，答案是非也，它是根据profile定义的先后顺序来进行覆盖取值的，然后后面定义的会覆盖前面定义的。

4.4.3  使用-P参数显示的激活一个profile

假设我们现在有如下定义的profiles  

<profiles>
       <profile>
              <id>profileTest1</id>
              <properties>
                     <hello>world</hello>
              </properties>
       </profile>
       <profile>
              <id>profileTest2</id>
              <properties>
                     <hello>andy</hello>
              </properties>
       </profile>
<profiles>
    那么当我们在进行Maven操作时就可以使用-P参数显示的指定当前激活的是哪一个profile了。比如我们需要在对项目进行打包的时候使用id为profileTest1的profile，我们就可以这样做： 
mvn package –P profileTest1
      当我们使用activeByDefault或settings.xml中定义了处于激活的profile，但是当我们在进行某些操作的时候又不想它处于激活状态，这个时候我们可以这样做： 
Mvn package –P !profileTest1
      这里假设profileTest1是在settings.xml中使用activeProfile标记的处于激活状态的profile，那么当我们使用“-P !profile”的时候就表示在当前操作中该profile将不处于激活状态。

4.4.4据环境来激活profile

    profile一个非常重要的特性就是它可以根据不同的环境来激活，比如说根据操作系统的不同激活不同的profile，也可以根据jdk版本的不同激活不同的profile，等等。

4.4.4.1根据jdk来激活profile

<profiles>
       <profile>
              <id>profileTest1</id>
              <jdk>1.5</jdk>
       </profile>
<profiles>
 上面情况表示在jdk为1.5版本系列的时候激活profileTest1 
<profiles>
       <profile>
              <id>profileTest1</id>
              <jdk>[1.4,1.7)</jdk>
       </profile>
<profiles>

 4.4.4.2根据操作系统来激活profile

  <profiles>
         <profile>
              <id>profileTest1</id>
              <activation>
                <os>
                     <name>Windows XP</name>
                     <family>Windows</family>
                     <arch>x86</arch>
                     <version>5.1.2600</version>
                </os>
              </activation>
         </profile>
  </profiles>

 上面的情况就是根据操作系统的类型来激活profileTest1。

4.4.4.3根据系统属性来激活profile

    <profiles>  
           <profile>  
                <id>profileTest1</id>  
                <activation>  
                  <property>  
                       <name>hello</name>  
                       <value>world</value>  
                  </property>  
                </activation>  
           </profile>  
    </profiles>
     上面的profileTest1将在提供了系统属性hello，并且其值为world的时候激活。下面的做法可以激活profileTest1。 
mvn package –Dhello=world

       当是下面的这种定义形式时，profileTest1将在指定了系统属性hello，且其值为任意值的时候被激活。

    <profiles>  
           <profile>  
                <id>profileTest1</id>  
                <activation>  
                  <property>  
                       <name>hello</name>  
                  </property>  
                </activation>  
           </profile>  
    </profiles>

 4.4.4.4根据文件是否存在激活profile

    <profiles>  
           <profile>  
                <id>profileTest1</id>  
                <activation>  
                  <file>  
                       <exists>target</exists>  
                  </file>  
                </activation>  
           </profile>  
    </profiles>

上面的定义表示当存在target文件时激活profileTest1。

    <profiles>  
           <profile>  
                <id>profileTest1</id>  
                <activation>  
                  <file>  
                       <missing>target</missing>  
                  </file>  
                </activation>  
           </profile>  
    </profiles>

       上面的定义表示当不存在target文件时激活profileTest1。

4.5     查看当前处于激活状态的profile

    我们可以同时定义多个profile，那么在建立项目的过程中，到底激活的是哪一个profile呢？Maven为我们提供了一个指令可以查看当前处于激活状态的profile都有哪些，这个指定就是mvn help:active-profiles。

现在假设我们的settings.xml文件中有如下profile的定义：

    <profiles>  
           <profile>  
                <id>profileTest1</id>  
                <activation>  
                  <file>  
                       <missing>target</missing>  
                  </file>  
                </activation>  
           </profile>  
    </profiles>  
      
    <activeProfiles>  
         <activeProfile>profileTest1</activeProfile>  
    </activeProfiles>
        这个时候我们可以看到，我们已经定义了profileTest1始终为激活状态，这个时候我们使用mvn help:active-profiles查看处于激活状态的profile时，就会打印出如下内容：

 

 

 

 

分享到：
合并多列为一行
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics