maven cargo

使用Maven Cargo 插件管理Tomcat6的部署
文章分类:软件开发管理



一、引言

      朋友，也许你也已经使用Maven有一段时间了，你已得益于Maven优美的管理方式，但是常常因为构建webapp而需手动发布到Tomcat而发愁。当然，你也有想到过通过脚本、FTP或者SSH的方式发布一个的最新WAR快照到Tomcat，对，这么做也不失为一种解决办法。但你也可能会想有没有更优雅的通过Maven插件来做到这一点吗？答案是肯定的，我找到了两个相关的插件-----Tomcat Maven plugin和 Cargo plugin。

     我首先试用了Tomcat Maven plugin，但我发现它实际上把项目部署到自己的Tomcat实例，而我想要的通过嵌入式的方式把项目发布到我本地的Tomcat，而不需要一个新的实例，所以我放弃了它。

      所以我回来来找 Cargo plugin，发现它正是我想要的，但是它的帮助文档让我抓狂，去看过的朋友估计和我有一样感同深受。不过，通过看它的文档，也锻炼我的耐心，经过一番周折，我部署成功了，所以我把它们贡献出来，和大家一起分享。



二、教程必需条件

      环境：Windows XP SP2及以上

      工具要求：apache-maven-3.0-beta-2、Tomcat6.0.29

      插件要求：cargo-maven2-plugin(Maven)

      本文章将引导你如何通过使用Maven Cargo 插件把一个Web应用程序发布到Tomcat6。Cargo是一个基于标准方式发布Web应用程序到Java EE容器的瘦包装器，它能发布到多种Web服务器，如Geronimo、Glassfish、JBoss、Tomcat、Jetty、WebLogic等。

      Cargo包含如下工具和API：
 
  启动/停止/配置Java容器和部署模块到Java容器的API。
解析/创建/合并Java EE模块的API。
  Ant 任务, Maven 1、 Maven 2 插件。
  以插件形式集成在Intellij IDEA 和Netbeans中。

      你可以通过配置您的pom.xml来决定您是否需要本地或者远程部署到您的tomcat服务器。

      我的用例很简单，就是把一个Web项目发布到本地或者远程Tomcat环境。

             下面包含了我本次教程的结构示例(呵呵，不算标准哟，大家自己扩充)：
 

cargosample-parent
pom.xml 1
cargosample-webapp
pom.xml 2
cargosample-deployer-local
pom.xml 3
cargosample-deployer-remote
pom.xml 4



        1、这是根pom，这里不会做有关于Cargo的操作，但是它包含了所有的子模块和Cargo所要用到的公共属性。

        下面是该文件中关于跟Cargo有关的自定义属性的描述：

Xml代码 
<properties>  
        <org.springframework.version>3.0.3.RELEASE</org.springframework.version>  
        <org.slf4j.version>1.5.10</org.slf4j.version>  
        <!-- 跟Cargo发布项目相关-->  
        <myproject.name>cargosample</myproject.name>  
        <cargo.project.groupid>${project.groupId}</cargo.project.groupid>  
        <cargo.project.artifactid>cargosample-webapp</cargo.project.artifactid>  
        <!--可单独提取并配置到profiles文件来激活 -->  
        <catalina.home>${env.CATLINA_HOME}</catalina.home><!--D:\hudson_ci\hudson_dep_tools\Tomcat6.0-->  
        <cargo.tomcat.manager.protocol>http</cargo.tomcat.manager.protocol>  
        <cargo.tomcat.manager.hostname>127.0.0.1</cargo.tomcat.manager.hostname>  
        <cargo.tomcat.manager.port>8080</cargo.tomcat.manager.port>  
        <cargo.tomcat.manager.ajp.port>8009</cargo.tomcat.manager.ajp.port>  
        <cargo.tomcat.manager.username>admin</cargo.tomcat.manager.username>  
        <cargo.tomcat.manager.password>1234</cargo.tomcat.manager.password>  
</properties> 
 





            2、这个pom包含web应用模块的描述和依赖关系。

       3、这个pom包含发布项目到本地Tomcat，是本实例的重点之一。

       4、这个pom包含发布项目到远程Tomcat。

值得一提注意的是，本次示例我使用的是同一个Tomcat来让Cargo模拟本地和远程两种方式来发布war。

因为我们需要部署sample-webapp的快照，把它作为以Cargo方式部署必需的依赖。所以我们在3和4中间都首先要添加对它的依赖。


Xml代码 
<dependencies>  
    <dependency>  
        <groupId>org.jdonee.cargosample</groupId>  
        <artifactId>cargosample-webapp</artifactId>  
        <version>0.0.1-SNAPSHOT</version>  
        <type>war</type>  
    </dependency>  
  </dependencies> 
 





三、部署项目到本地环境

接下来是在<build>节点下配置Cargo：

1)首先配置的是<container>节点，详细描述如下：

 


Xml代码 
<configuration>  
                    <wait>true</wait>  
                    <!--以下标记将详细描述你想要部署的容器-->  
                    <container>  
                        <!--   
                        指定"tomcat6x"这个名称非常的重要!因为它是Cargo中一个完整的标识符,如果你把"x"去掉的话,  
                        而只用"tomcat6"的话,它就不能在Tomcat 6.x下正常工作.   
                        -->  
                        <containerId>tomcat6x</containerId>  
                        <type>installed</type><!-- 本地已安装Tomcat时设置 -->  
                        <home>${catalina.home}</home><!--本地Tomcat安装目录 -->  
                    </container> 
 



2)接下来配置容器的属性，详细描述如下：

    


Xml代码 
<!-- 容器的属性 -->  
                    <configuration>  
                        <!-- 如果你在容器属性中指定类型为"installed"的话,你就必须在如下配置type==existing和重配一次安装目录-->  
                        <type>existing</type>  
                        <home>${catalina.home}</home>  
                        <properties>  
                            <cargo.tomcat.manager.url>  
                            ${cargo.tomcat.manager.protocol}://${cargo.tomcat.manager.hostname}:${cargo.tomcat.manager.port}/manager  
                            </cargo.tomcat.manager.url>  
                            <cargo.remote.username>${cargo.tomcat.manager.username}</cargo.remote.username>  
                            <cargo.remote.password>${cargo.tomcat.manager.password}</cargo.remote.password>  
                            <cargo.tomcat.ajp.port>${cargo.tomcat.manager.ajp.port}</cargo.tomcat.ajp.port> <!-- ajp端口,默认8009 -->  
                        </properties>  
                    </configuration> 
 





    当然这里的属性还有很多，如果您想获知更多的参数定义，请点击Tomcat+6x。

3)Cargo有部署的概念，详细操作如下：

  


Xml代码 
<!-- 准备执行部署 -->  
                    <deployer>  
                        <!-- 类型设置必须跟容器一致 -->  
                        <type>installed</type>  
                        <deployables>  
                             <!--在deployable中指定你要部署的webapp -->  
                            <deployable>  
                                 <groupId>${cargo.project.groupid}</groupId>   
                                 <artifactId>${cargo.project.artifactid}</artifactId>  
                                 <type>war</type>  
                                 <!--如果你想重新定义Web应用的名称时设置,大多数情况下你都会定义此属性-->  
                                 <properties>  
                                 <context>${myproject.name}</context>  
                                 </properties>  
                            </deployable>  
                        </deployables>  
                    </deployer>  
                </configuration> 
 





   注：<deployalbe>中的<groupId>、<artifactId>和<type>必须定义。

4)Cargo除了可以运行"mvn cargo:deploy"这样的插件目标外，也可执行如clean、install这样的标准阶段目标，大多数时候我们也希望如此，详细操作如下：

  


Xml代码 
<!--运行构建的各个阶段时定义需执行的目标,每个阶段可执行多个目标 -->  
                <executions>  
                <execution>  
                    <id>init-container</id><!--初始化容器时先关闭,避免JVM端口被绑定-->  
                    <phase>validate</phase>  
                    <goals><goal>stop</goal></goals>  
                </execution>  
                <!--如下的两个阶段主要用于集成测试，如果你只是部署到环境可以忽略它们 -->  
                <execution>  
                    <id>start-container</id>  
                    <phase>pre-integration-test</phase>  
                    <goals><goal>deployer-deploy</goal><!--等同于deploy,本地不支持redeploy  --></goals>  
                </execution>  
                <execution>  
                    <id>stop-container</id>  
                    <phase>post-integration-test</phase>  
                    <goals><goal>deployer-undeploy</goal><!--等同于undeploy,本地不支持redeploy  --></goals>  
                </execution>  
                <execution><!-- 通过"install"目标部署到容器并运行-->  
                    <id>verify-deploy</id>  
                    <phase>install</phase>  
                    <goals><goal>deployer-deploy</goal><goal>start</goal>  
                    </goals>  
                </execution>   
                <execution><!--通过"pre-clean"目标取消部署并关闭容器-->  
                    <id>clean-undeploy</id>  
                    <phase>pre-clean</phase>  
                    <goals><goal>deployer-undeploy</goal><goal>stop</goal>  
                    </goals>  
                </execution>   
            </executions> 
 





  本地配置完成，你在根pom项目下运行"mvn install"就可以把最新WAR快照部署到Tomcat中运行。

  这里有两个值得注意的地方：

  (1)<wait>参数,  如果你设为"true"的话,它会告知你把Tomcat作为Maven构建过程的一部分，然后提示可通过快捷键Ctrl-C或者设置属性wait为false来关闭Session。但是这实际上只是把Tomcat脱离出Maven构建过程而没有真正关闭Tomcat进程。所以你必须再执行"pre-clean"或者"clean"目标来真正关闭它。

  (2)validate目标，我这里首先执行stop操作，如果不定义这个目标的话，重复执行"install"目标会出现JVM端口绑定错误。



四、部署项目到远程环境

       同样，远程部署同样是在<build>节点下配置Cargo：

        1)首先配置的是<container>节点，详细描述如下：


Xml代码 
<configuration>  
                    <wait>true</wait>  
                    <container>  
                        <containerId>tomcat6x</containerId>  
                        <type>remote</type><!-- 远程部署类型必须是remote -->  
                    </container> 
 





  2)接下来配置容器的属性，详细描述如下：     

    


Xml代码 
<configuration>  
                        <!-- 如果你在容器属性中指定类型为"remote"的话,那么你必须在如下配置type==runtime -->  
                        <type>runtime</type>  
                        <properties>  
                            <cargo.hostname>${cargo.tomcat.manager.hostname}</cargo.hostname> <!--主机名,默认localhost -->  
                            <cargo.servlet.port>${cargo.tomcat.manager.port}</cargo.servlet.port> <!-- 端口号,默认值 8080 -->  
                            <cargo.tomcat.manager.url>  
                                ${cargo.tomcat.manager.protocol}://${cargo.tomcat.manager.hostname}:${cargo.tomcat.manager.port}/manager  
                            </cargo.tomcat.manager.url>  
                            <cargo.remote.username>${cargo.tomcat.manager.username}</cargo.remote.username>  
                            <cargo.remote.password>${cargo.tomcat.manager.password}</cargo.remote.password>  
                            <cargo.tomcat.ajp.port>${cargo.tomcat.manager.ajp.port}</cargo.tomcat.ajp.port>  
                        </properties>  
                    </configuration> 
 



  3)Cargo远程部署，详细操作如下：


Xml代码 
<deployer>  
                        <!-- 类型设置必须跟容器一致 -->  
                        <type>remote</type>  
                        <deployables>  
                            <!--在deployable中指定你要部署的webapp -->  
                            <deployable>  
                                <!--可选项,Ping目标地址判断项目地址发布成功或者失败 -->  
                                <pingURL>  
                                    ${cargo.tomcat.manager.protocol}://${cargo.tomcat.manager.hostname}:${cargo.tomcat.manager.port}/${myproject.name}  
                                 </pingURL>  
                                <!--可选项,Ping目标地址的响应时间,默认20000毫秒 -->  
                                <pingTimeout>300000</pingTimeout>  
                                <groupId>${cargo.project.groupid}</groupId>  
                                <artifactId>${cargo.project.artifactid}</artifactId>  
                                <type>war</type>  
                                <properties>  
                                    <context>${myproject.name}</context>  
                                </properties>  
                            </deployable>  
                        </deployables>  
                    </deployer>  
                </configuration> 
 







        4)Cargo执行阶段和目标:


Xml代码 
<executions>  
                    <execution>  
                        <id>start-container</id>  
                        <phase>pre-integration-test</phase>  
                        <goals>  
                            <goal>deployer-redeploy</goal><!--等同于redeploy,本地不支持redeploy -->  
                        </goals>  
                    </execution>  
                    <execution>  
                        <id>stop-container</id>  
                        <phase>post-integration-test</phase>  
                        <goals>  
                            <goal>deployer-undeploy</goal>  
                        </goals>  
                    </execution>  
                    <execution>  
                        <id>verify-deploy</id>  
                        <phase>install</phase>  
                        <goals>  
                            <goal>deployer-redeploy</goal>  
                        </goals>  
                    </execution>  
                    <execution>  
                        <id>clean-undeploy</id>  
                        <phase>pre-clean</phase>  
                        <goals>  
                            <goal>deployer-undeploy</goal>  
                        </goals>  
                    </execution>  
                </executions> 
 





         这里需要注意的是执行目标中我使用了redeploy，而不是deploy。这是因为重复执行"install"构建步骤使用deploy会报项目已存在的错误，不利于重复部署，当然你使用"clean install"就没有问题。

          远程配置大体如此，你在根pom项目下运行"mvn install"就可以把最新WAR快照部署到远程Tomcat中运行。



五、运用反应堆模式灵活部署项目

          细心的朋友马上就会发现，为什么在单独执行"mvn clean"或者"mvn install"有时候会出错，而且我们使用测试错误的主要原因很多，但是使用同一个Tomcat或者远程Tomcat关闭的时候就会构建就会出现很多问题。

如果我们希望两个模块相处融洽的话，那么最好加入反应堆控制。

比如我想只需要执行本地部署：

clean install -pl cargosample-deployer-local/ -am

同样只执行远程部署：

clean install -pl cargosample-deployer-remote/ -am

关于反应堆的更过信息，请点击按需构建多模块，玩转Maven反应堆。



六、通过定义profile文件的方式部署

         如果涉及团队开发的话，parent pom文件中的属性不见得都适用，让每个成员灵活定义自己的属性就显得尤为重要。

         剪切父pom文件中关于cargo 配置的部分，并在settings中定义一个属于Cargo的profile文件添加如下文本并自动激活它，当然你也可已选择手动激活，关于手动激活请参阅激活Maven profile的方式。


Xml代码 
<profile>    
      <id>cargo</id>    
   <activation>    
          <activeByDefault>true</activeByDefault>    
      </activation>   
      <properties>    
       <!--可单独提取并配置到profiles文件来激活 -->  
    <catalina.home>${env.CATLINA_HOME}</catalina.home><!--D:\hudson_ci\hudson_dep_tools\Tomcat6.0-->  
    <cargo.tomcat.manager.protocol>http</cargo.tomcat.manager.protocol>  
    <cargo.tomcat.manager.hostname>127.0.0.1</cargo.tomcat.manager.hostname>  
    <cargo.tomcat.manager.port>8080</cargo.tomcat.manager.port>  
    <cargo.tomcat.manager.ajp.port>8009</cargo.tomcat.manager.ajp.port>  
    <cargo.tomcat.manager.username>admin</cargo.tomcat.manager.username>  
    <cargo.tomcat.manager.password>1234</cargo.tomcat.manager.password>  
      </properties>    
lt;/profile>  
 



不要忘了激活它。


Xml代码 
<activeProfiles>  
      <activeProfile>cargo</activeProfile>    
</activeProfiles>   
 



再执行"clean install"，同样大功告成。



关于通过Cargo部署项目到Tomcat就暂时写到这里，如果您有什么好的建议，欢迎指出。

下一部分，将写到如何利用Hudson持续部署项目。

        

七、其它参考资料



1、http://www.waltercedric.com/java-j2ee-mainmenu-53/361-maven-build-system/1555-deploy-to-tomcat-6-using-maven.html

2、http://dpillay.wordpress.com/2009/04/12/maven-cargo-tomcat-auto-deployment/



在tomcat 7的deploy

在pom.xml中加上:

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>tomcat-maven-plugin</artifactId>
<configuration>
<url>http://localhost:8080/manager/html</url>
<username>${tomcat.manager.username}</username>
<password>${tomcat.manager.password}</password>
</configuration >
</plugin>

另在tomcat 7.x conf/tomcat-users.xml中加上username和password的设置。注意：
   <user username="XXX" password="XXXXXX" roles="manager-gui,manager-status,manager-script" />

后remote deploy成功。

谢谢你前面的文章。


在tomcat 7的deploy

在pom.xml中加上:

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>tomcat-maven-plugin</artifactId>
<configuration>
<url>http://localhost:8080/manager/html</url>
<username>${tomcat.manager.username}</username>
<password>${tomcat.manager.password}</password>
</configuration >
</plugin>

另在tomcat 7.x conf/tomcat-users.xml中加上username和password的设置。注意：
   <user username="XXX" password="XXXXXX" roles="manager-gui,manager-status,manager-script" />

后remote deploy成功。

谢谢你前面的文章。








在多模块Maven项目中，反应堆（Reactor）是一个包含了所有需要构建模块的抽象概念，对于Maven用户来说，主要关心的是两点：


哪些模块会被包含到反应堆中？
反应堆中所有模块的构建顺序是什么？



例如有这样的一个多模块项目:







plexus-security包含了8个子模块，其中security-realms还包括了更进一层的两个子模块。

运行mvn clean install可以看到这样的输出：


Java代码 
[INFO] Scanning for projects...  
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Plexus Security Aggregator  
[INFO] Security: Parent  
[INFO] Security: Model  
[INFO] Security: XML Model  
[INFO] Security: Configuration  
[INFO] Security: System  
[INFO] Security: Realms Parent  
[INFO] Plexus XML Realm  
[INFO] Security: REST API  
[INFO] Plexus URL Realm  
[INFO] Security Legacy Adapter  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  



在默认情况下，Maven会根据多模块配置构建所有的模块，Maven还会根据模块间的依赖关系自动计算构建顺序，以确保被依赖的模块会先得以构建。值得一提的是，在这种情形下，Maven会将父模块看成是其子模块的依赖，因此该例中Security Parent会较先得以构建。



一般来说，我们要么构建整个项目，要么构建单个模块，但是有些时候，我们会想要仅仅构建这个完整的反应堆中的某些模块，换句话说，我们会需要裁剪反应堆。

例如说，我对模块security-configuration做了一些更改，而我知道在完整反应堆顺序中，security-model-xml和security-model在其之前，不会依赖它，因此就没必要构建他们。我们只需要构建security-configuration及其之后的项目。



Maven提供了很多命令行选项让我们自定义反应堆，输入mvn -h可以看到这样一些选项：


Java代码 
Options:  
-am,--also-make                        If project list is specified, also  
                                        build projects required by the  
                                        list  
-amd,--also-make-dependents            If project list is specified, also  
-pl,--projects <arg>                   Build specified reactor projects  
                                        instead of all projects. A project  
                                        can be specified by  
                                        [groupId]:artifactId or by its  
                                        relative path.  
-rf,--resume-from <arg>                Resume reactor from specified  
                                        project 
 



--resume-from 表示从该模块恢复，也就是说选择从哪里开始构建，等于剪掉了完整反应堆的前面一部分。

例如我运行 mvn clean install -rf security-configuration/ ，就会得到这样的一个反应堆：


Java代码 
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Security: Configuration  
[INFO] Security: System  
[INFO] Security: Realms Parent  
[INFO] Plexus XML Realm  
[INFO] Security: REST API  
[INFO] Plexus URL Realm  
[INFO] Security Legacy Adapter  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  
  

与完整反应堆相比，前面的四个模块不见了，只保留了security-system及其之后的模块。



--projects 表示手动选择需要构建的项目，项目间以逗号分隔。

例如我运行 mvn clean install -pl security-configuration/,security-realms/security-xml-realm/，会得到如下反应堆：


Java代码 
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Security: Configuration  
[INFO] Plexus XML Realm  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  



--also-make 的前提是--projects参数，表示同时构建所列模块依赖的其他模块。

例如我运行 mvn clean install -pl security-model-xml/ -am，会得到如下反应堆：


Java代码 
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Security: Parent  
[INFO] Security: Model  
[INFO] Security: XML Model  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  





这里security-model-xml依赖于security-model，而security-parent是security-model-xml的父项目，因此这两个模块都会得以构建。



--also-make-dependents 的前提是--projects参数，表示同时构建那些依赖于所列模块的模块。

例如我运行 mvn clean install -pl security-model-xml/ -amd，会得到如下反应堆：


Java代码 
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Security: XML Model  
[INFO] Plexus XML Realm  
[INFO] Security: REST API  
[INFO] Plexus URL Realm  
[INFO] Security Legacy Adapter  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  
 


除了security-model-xml本身，所有其他依赖于该模块的模块也会被加入到反应堆中。



除此之外，在-pl、-am或者-pl、-amd的基础上，还能应用-rf参数，紧接着上面的例子，再加上参数-rf -rf security-rest-api/，

如：mvn clean install -pl security-model-xml/ -amd -rf security-rest-api/，便可以得到如下的反应堆：


Java代码 
[INFO] ------------------------------------------------------------------------  
[INFO] Reactor Build Order:  
[INFO]   
[INFO] Security: REST API  
[INFO] Plexus URL Realm  
[INFO] Security Legacy Adapter  
[INFO]                                                                           
[INFO] ------------------------------------------------------------------------  





这个反应堆表示：计算所有security-model-xml及依赖于它的模块，在次基础上，从security-rest-api模块开始构建。



在开发过程中，灵活应用上述4个参数，可以帮助我们跳过那些无须构建的项目模块，从而加速构建，当项目庞大，模块特别多的时候，这种效果就异常明显。



最后提一下，Maven从2.1版本才加入了此功能。