`

Maven入门--较复杂的实例

阅读更多
本文将使用一个较复杂的实例,讲述如何定制目录布局(即不使用Maven标准目录布局),以及讲述一些关键插件的使用(配置)。为了方便其它朋友能够方便地使用该实例,后台数据库使用开源的面向对象数据库--db4o,该数据库无需安装,已包含在与本文配套的实例中,文末附有该实例的下载链接。(2007.01.02最后更新)
注:转载时请注明原作者(jiangshachina)及出处(http://www.blogjava.net/jiangshachina)!
1 实例的构想
文章开头的摘要已经讲述了,本文仍然将以一个实例描述如何使用Maven, 该实例将使用非Maven标准的目录结构,并将呈现一些关键的Maven插件的配置与应用。 该实例是一个基于db4o的数据库Web应用。该应用本身十分简单,即从db4o数据库中查询出若干记录并将它们显现在Web页面中。
    该实例仍然由一个普通应用工程(demo-app)与一个Web应用工程(demo-web),以及这两个工程的父工程(demo)构成,最终的目标是将Web应用工程制作成war文件,并部署到JBoss服务器中。启动服务器后,能够在页面中看到正确的查询结果。
    该实例使用Eclipse3.2 + JDK1.5.0_10 + Windows2000开发。当然这仅仅只是我个人的开发平台,但该实例并不受限于此平台;由于我选择使用db4o针对JDK1.5的产品包,所以该实例只能运行在JDK1.5.0或更高版本的JDK/JRE中; 该工程中的所有文件都使用UTF-8编码方式。
2 demo工程
demo工程是其它两个工程的父工程,它的主要职责是预定义子工程所需要依赖的jar文件(artifact),以及针对子工程所使用的插件进行通用配置。该工程完整的POM文件如下所示:
js 代码
 
  1. <project>   
  2.     <modelVersion>4.0.0</modelVersion>   
  3.     <groupId>mvn.demo</groupId>   
  4.     <artifactId>demo</artifactId>   
  5.     <packaging>pom</packaging>   
  6.     <version>1.0-SNAPSHOT</version>   
  7.     <description>Maven Demo Project</description>   
  8.     <modules>   
  9.         <module>demo-app</module>   
  10.         <module>demo-web</module>   
  11.     </modules>   
  12.     <dependencyManagement>   
  13.         <dependencies>   
  14.             <dependency>   
  15.                 <groupId>mvn.demo</groupId>   
  16.                 <artifactId>demo-app</artifactId>   
  17.                 <version>${project.version}</version>   
  18.             </dependency>   
  19.             <dependency>   
  20.                 <groupId>mvn.demo</groupId>   
  21.                 <artifactId>demo-web</artifactId>   
  22.                 <version>${project.version}</version>   
  23.             </dependency>   
  24.             <dependency>   
  25.                 <groupId>com.db4o</groupId>   
  26.                 <artifactId>db4o-java5</artifactId>   
  27.                 <version>5.5</version>   
  28.             </dependency>   
  29.             <dependency>   
  30.                 <groupId>javax.servlet</groupId>   
  31.                 <artifactId>servlet-api</artifactId>   
  32.                 <version>2.4</version>   
  33.                 <scope>provided</scope>   
  34.             </dependency>   
  35.             <dependency>   
  36.                 <groupId>commons-configuration</groupId>   
  37.                 <artifactId>commons-configuration</artifactId>   
  38.                 <version>1.2</version>   
  39.                 <exclusions>   
  40.                     <exclusion>   
  41.                         <groupId>dom4j</groupId>   
  42.                         <artifactId>dom4j</artifactId>   
  43.                     </exclusion>   
  44.                     <exclusion>   
  45.                         <groupId>xml-apis</groupId>   
  46.                         <artifactId>xml-apis</artifactId>   
  47.                     </exclusion>   
  48.                     <exclusion>   
  49.                         <groupId>xalan</groupId>   
  50.                         <artifactId>xalan</artifactId>   
  51.                     </exclusion>   
  52.                     <exclusion>   
  53.                         <groupId>xerces</groupId>   
  54.                         <artifactId>xercesImpl</artifactId>   
  55.                     </exclusion>   
  56.                 </exclusions>   
  57.             </dependency>   
  58.         </dependencies>   
  59.     </dependencyManagement>   
  60.     <dependencies>   
  61.         <dependency>   
  62.         <groupId>junit</groupId>   
  63.          <artifactId>junit</artifactId>   
  64.            <version>3.8.1</version>   
  65.       <scope>test</scope>   
  66.     </dependency>   
  67.     </dependencies>   
  68.     <build>   
  69.         <plugins>   
  70.             <plugin>   
  71.                 <groupId>org.apache.maven.plugins</groupId>   
  72.                 <artifactId>maven-resources-plugin</artifactId>   
  73.                 <configuration>   
  74.                     <encoding>UTF-8</encoding>   
  75.                 </configuration>   
  76.             </plugin>   
  77.             <plugin>   
  78.                 <groupId>org.apache.maven.plugins</groupId>   
  79.                 <artifactId>maven-compiler-plugin</artifactId>   
  80.                 <configuration>   
  81.                     <source>1.5</source>   
  82.                     <target>1.5</target>   
  83.                     <encoding>UTF-8</encoding>   
  84.                 </configuration>   
  85.             </plugin>   
  86.             <plugin>   
  87.                 <groupId>org.apache.maven.plugins</groupId>   
  88.                 <artifactId>maven-jar-plugin</artifactId>   
  89.                 <configuration>   
  90.                     <archive>   
  91.                         <addMavenDescriptor>false</addMavenDescriptor>   
  92.                     </archive>   
  93.                 </configuration>   
  94.             </plugin>   
  95.             <plugin>   
  96.                 <groupId>org.apache.maven.plugins</groupId>   
  97.                 <artifactId>maven-war-plugin</artifactId>   
  98.                 <configuration>   
  99.                     <archive>   
  100.                         <addMavenDescriptor>false</addMavenDescriptor>   
  101.                     </archive>   
  102.                 </configuration>   
  103.             </plugin>   
  104.             <plugin>   
  105.                 <groupId>org.apache.maven.plugins</groupId>   
  106.                 <artifactId>maven-javadoc-plugin</artifactId>   
  107.                 <configuration>   
  108.                     <charset>UTF16</charset>   
  109.                 </configuration>   
  110.             </plugin>   
  111.         </plugins>   
  112.     </build>   
  113. </project>   

    预定义工程的依赖关系,就是把会被子工程依赖的artifact的详细信息(groupId,artifactId,version,...)先声明到<dependencyManagement>中。然后子工程只需要声明使用某个artifact就可以了,即那时只需要设置groupId和artifactId(甚至更少)就可以了。 <dependencyManagement>中声明的artifact并不一定真的会被使用到。
2.1 声明依赖关系
    根据实际情况, 该实例 需要使用db4o针对java5的产品包(jar文件)。由于该jar文件并不存在于Maven的中央仓库中,所以我们不能直接通过Maven获得该jar文件。我们只能另外下载db4o-5.5(Java版)的压缩包,然后从压缩包内获得db4o-java5.jar。得到该jar后,必须先将它安装到Maven的本地仓库中(安装方法参见资源[1],主题"向本地仓库安装文件时要生成POM文件"),以备后面的使用。此处将该artifact的groupId定义为com.db4o,artifactId定义为db4o-java5,version自然就是5.5了(请见上述POM脚本)。
    由于该实例最终是一个Web应用,所以它至少需要依赖Servlet的包(servlet-api-2.4.jar),还需要commons-configuration-1.2.jar。这两个artifact都已经存在于Maven中央仓库中,所以我查找到它们后,按照Maven中央仓库的命名将它们声明到了<dependencyManagement>中(请见上述POM脚本)。junit是进行单元测试时使用的artifact,(假设)它肯定会被每个工程使用,所以没有将它设置到 <dependencyManagement>中,而直接设置到了 <dependency>中。
    细心的朋友肯定已经发现了,针对 commons-configuration的依赖声明处多了一些语句。从表面上看,应该是排除了4个artifact(dom4j, xml-apis , xalan 和 xerces )。不错,就是排除了这4个jar文件(artifact)。如果有兴趣的话,可以将整个<exclusions>元素删除,然后再尝试一下制作war文件。你会发现在WEB-INF/lib目录下存在着这4个artifact对应的jar文件。那我为什么要将它们“排除”呢?因为,它们是多余的!即,它们对于我的这个Web应用来说,根本就是无用的!
    Maven2加入了一个很好的特性:自动加载“依赖的依赖(Transitive Dependency)”。以commons-configuration为例。为了能够让它运行正常,我们实际上还需要其它一些jar(artifact),如commons-collections,commons-lang,...。但这些artifact我都没有“显示”地声明需要依赖它们,但Maven会自动加载,因为 commons-configuration的POM文件将它们声明为了dependency 。
    既然那个4个artifact是commons-configuration的依赖,为什么会认为它们是无用的呢?实际上,它们就不应该被声明到commons-configuration的依赖关系中。这是commons-configuration开发者的失误,他们没有将依赖关系整理清晰,而将一些确实既不是runtime,更不是compile-time需要的artifact放入到了依赖关系中。在Maven中央仓库中存在着很多这种情况,所以我们有时需要弄清楚“哪些文件是我们真正需要的,哪些是可以被清除的”。但有时候,很难做到一个不漏。正是由于这一原因,自动加载Transitive Dependency这一极好的特性,有时让人十分无奈 ^_^
2.2 对插件进行基本配置
我们可以把对插件的全局性(如针对整个项目的)设置放到较高层次的POM文件中,因为它们被设置后,子工程们就会自然遵守它们,而且可以使每个子工程的情况都是一样的。
    在第1节中,已经表明该工程使用JDK1.5平台,并且所有文件都使用UTF-8的编码方式。而Maven默认使用JDK1.3级别的javac编译器;默认使用本地编码方式(简体中文Windows操作系统默认使用GBK编码方式)处理文件。这样就必须对Maven进行适当设置,以满足工程的实际需要。
    针对资源文件的处理,Maven使用maven-resources-plugin插件,需要将它的编码方式设置为UTF-8。编译Java源文件,是使用maven-compiler-plugin插件,需要将它的source(Java源文件)与target(class文件)的级别都设置为1.5,另外还要将它的encoding方式设置为UTF-8。(详细设置请见POM脚本)
3 demo-app工程
demo-app工程是一个普通应用程序工程,它用于处理和数据库相关的操作,如针对数据库的增、删、改、查等基本功能。该工程POM文件的主要内容如下所示:
js 代码
 
  1. <project>   
  2.     ......   
  3.     <build>   
  4.         <finalName>app</finalName>   
  5.         <directory>target</directory>   
  6.         <sourceDirectory>src/java</sourceDirectory>   
  7.         <outputDirectory>target/classes</outputDirectory>   
  8.         <resources>   
  9.             <resource>   
  10.                 <directory>src/java</directory>   
  11.                 <excludes>   
  12.                     <exclude>**/*.java</exclude>  
  13.                 </excludes>  
  14.             </resource>  
  15.         </resources>  
  16.         <testSourceDirectory>src/test/java</testSourceDirectory>  
  17.         <testOutputDirectory>target/test-classes</testOutputDirectory>  
  18.         <testResources>  
  19.             <testResource>  
  20.                 <directory>src/test/java</directory>  
  21.                 <excludes>  
  22.                     <exclude>**/*.java</exclude>   
  23.                 </excludes>   
  24.             </testResource>   
  25.         </testResources>   
  26.     </build>   
  27. </project>   

    文章的开头已经提到,本实例将会使用定制的目录结构,但在前面却一字不提此事,现在将描述如何定制目录结构。Maven的标准目录结构其实是在Super POM中设置的,由于任何POM都会继承该POM,所以所有的工作都会默认使用标准目录结构。要定制目录,其实就是需要重新设置相关参数的值,即用新值覆盖Super POM中的值。
[1]<finalName>,该元素指定了工程输出的artifact的名称,默认值为${artifactId}-${version},此处修改为app。
[2]<directory>,该元素指定了工程输出的目标目录。默认值为target,此处未修改变。
[3]<sourceDirectory>,该元素指定了Java源文件所在的目录。默认值为src/main/java,此处修改为src/java。
[4]<outputDirectory>,该元素指定了编译后的class文件的放置目录。默认值为target/classes,此处未作改变。
[5]<resources> <resource>,该元素指定了Java源文件使用的资源文件的存放目录。默认值为src/main/resources,此处修改为src/java。由于在编码Java源文件时,Maven会将资源路径中的文件全部拷贝到classes目录。而此时将Java资源文件目录与Java源文件目录,设置为同一目录,所以需要将.java文件排除在资源文件的范畴之外( <exclude>**/*.java</exclude> )。
[6] <testSourceDirectory>,该元素指定了单元测试Java源文件的放置目录。默认值为src/test/java,此处未作修改。
[7] <testOutputDirectory>,该元素指定了单元测试Java源文件编译后的class文件放置目录。默认值为 target/test-classes,此处未作改变。
[8] <testResources> <testResource>,该元素指定了单元测试Java源文件所使用的资源文件的放置目录。默认值为src/test/resources,此处修改为 src/test/java。并且也做了与 设置<resources> <resource>时相同的处理(排除Java源文件)。
    通过上述设置后,就可以拥有一个定制的Maven工程目录结构了。
4 demo-web工程
demo-web工程是整个应用最终的目标输出,因为此处的目的就是制作一个war文件,然后将它部署到JBoss服务器中。与demo-app工程相比,demo-web工程的POM文件主要有如下不同内容:
xml 代码
 
  1. <project >  
  2.     ......   
  3.     <build>  
  4.         ......   
  5.         <plugins>  
  6.             <plugin>  
  7.                 <groupId>org.apache.maven.plugins</groupId>  
  8.                 <artifactId>maven-war-plugin</artifactId>  
  9.                 <version> 2.0.1 </version>  
  10.                 <configuration>  
  11.                     <webappDirectory>target/${artifactId}</webappDirectory>  
  12.                     <warSourceDirectory>src/webapp</warSourceDirectory>  
  13.                 </configuration>  
  14.             </plugin>  
  15.             <plugin>  
  16.                 <groupId>org.codehaus.mojo</groupId>  
  17.                 <artifactId>jboss-maven-plugin</artifactId>  
  18.                 <version> 1.3.1 </version>  
  19.                 <configuration>  
  20.                     <jbossHome>E:/jboss- 4.0.2 </jbossHome>  
  21.                     <serverName>default</serverName>  
  22.                     <fileName>  
  23.                         ${project.build.directory}/${project.build.finalName}.${project.packaging}   
  24.                     </fileName>  
  25.                 </configuration>  
  26.             </plugin>  
  27.         </plugins>  
  28.     </build>  
  29. </project>   

可以看出不同之处就在于对maven-war-plguin及jboss-maven-plugin插件的配置与使用。
    Maven使用maven-war-plugin插件对Web工程制作war文件。由于本文使用了定制目录结构,这样则会使maven-war-plugin无法找到Web工程的Web Root目录(默认是src/main/webapp),所以需要对该插件进行适当地配置。<warSourceDirectory>就是Web工程的Web Root目录,此处设置为;<webappDirectory>是制作war文件之前,相当于是一个被打开(exploded)的war文件的根目录(默认是target/artifactId-version)。
    该工程的脚本中,还使用了一个JBoss插件。该插件可以将制作好的war文件部署(实质上是拷贝)到指定的JBoss部署目录中。<jbossHome>是JBoss的安装根目录,<serverName>指JBoss Server的名称,<fileName>是被部署war文件的名称。
参考资源
[1]Maven入门--概念与实例. http://www.blogjava.net/jiangshachina/archive/2006/09/01/67080.html
[2]Maven + Continuum Weed. http://www.blogjava.net/jiangshachina/archive/2006/09/11/68944.aspx
[3]Maven POM Reference. http://maven.apache.org/pom.html
[3]db4o. http://www.db4objects.com
本文实例下载地址--http://www.blogjava.net/files/jiangshachina/mvn-demo.rar
分享到:
评论

相关推荐

    Maven入门--概念与实例.doc

    Maven入门--概念与实例.doc

    Maven入门--概念与实例

    Maven 的缺点则可能包括对非标准项目结构的适应性较差,以及大型项目可能需要复杂的 POM 配置。 总的来说,Maven 提供了一种强大而灵活的方式来管理 Java 项目,促进了开发团队的协作和项目的可维护性。学习并熟练...

    maven + springmvc 入门实例

    **SpringMVC与Maven入门实例详解** 在Java Web开发中,SpringMVC和Maven是两个非常重要的工具。SpringMVC是Spring框架的一部分,它提供了模型-视图-控制器(MVC)架构,用于构建可维护、高性能的Web应用程序。而...

    maven-thrift-client

    通过这种方式,`maven-thrift-client` 提供了一个快速入门的模板,帮助开发者高效地创建和管理基于 Thrift 的客户端应用程序。它使得在 Maven 项目中使用 Thrift 变得简单,降低了跨语言服务开发的门槛。

    Maven+SpringMVC的入门级HelloWorld实例

    在IT行业中,Maven和SpringMVC是两个非常重要的组件,它们分别是项目管理和Web应用程序开发的核心...通过这个入门级的HelloWorld实例,我们可以快速理解这两个工具的基本用法,为进一步深入学习和实践打下坚实的基础。

    J2EE JNDI配置原理详解 JBOSS安装配置 Maven入门 Ant使用入门

    1.13 Maven入门--概念与实例 1.14 Subversion 1.15 jar war ear区别 1.16 如何在Eclipse中调试JBoss应用 1.17 JBoss 5.0 安装与配置详解 1.18 JBOSS安装配置 1.19 Oracle,MySql,SQL server分页 1.20 Jboss...

    Maven入门到精通

    **Maven入门到精通** Maven,一个强大的Java项目管理工具,由Apache软件基金会...阅读提供的文档,如《Maven入门-概念与实例》、《Maven 参考文档》和《Maven2完全使用手册》,将有助于你更全面地掌握Maven的使用。

    poi的maven项目代码

    【标题】"poi的maven项目代码"是一个关于Apache POI库的 Maven 项目示例,主要用于演示如何利用POI库来操作Excel文件。Apache POI 是一个流行的开源Java API,它允许开发者创建、修改和显示Microsoft Office格式的...

    maven入门整合SpringMVC登录+调用天气接口实例

    **maven入门** Maven是Java开发中的一个项目管理和构建工具,它简化了构建过程,通过定义项目的构建配置,管理依赖关系,自动化构建任务。在本项目中,Maven被用来整合SpringMVC和实现接口调用。Maven的POM...

    Spring Security 新手入门级maven实例

    **Spring Security新手入门级Maven实例详解** Spring Security是一个强大且高度可定制的身份验证和访问控制框架,用于Java和Java EE应用。它为应用程序提供了全面的安全解决方案,包括用户认证、授权以及安全配置。...

    两个基于Maven+SpringBoot的实例

    总结来说,"两个基于Maven+SpringBoot的实例"是针对初学者的实践教程,通过这两个实例,学习者可以了解到如何使用Maven管理项目,以及如何利用SpringBoot快速构建Web应用。这些实例涵盖了从项目初始化、依赖配置到...

    JFinal+Maven+FreeMarker入门实例

    在"JFinal+Maven+FreeMarker入门实例"中,我们将看到如何配置和使用这些工具。首先,我们需要在项目根目录下创建一个`pom.xml`文件,这是Maven项目的配置文件。在这里,我们需要列出所有依赖项,包括JFinal和...

    Dubbo入门---搭建一个最简单的Demo框架

    【描述】:这篇博客通过一个简单的实例,引导读者了解如何入门Dubbo框架的使用。它可能是以创建一个包含服务提供者和服务消费者的基本项目为背景,逐步讲解了Dubbo的配置与运行流程。 【标签】:“源码”和“工具”...

    kafka java maven例子

    这个“kafka java maven例子”提供了一个完整的Kafka入门实践,包括创建和配置生产者与消费者,处理消息发送和接收。通过深入研究和运行这个实例,开发者能够快速理解Kafka的基本工作原理和Java API的用法,为后续的...

    CXF入门 -- 第一个简单webService

    【CXF入门 -- 第一个简单webService】 Apache CXF 是一款强大的开源服务框架,它用于构建和开发服务,包括Web服务。本篇文章将带你入门CXF,通过创建一个简单的Web服务来理解其基本概念和工作流程。 1. **CXF简介*...

    jdeps-maven-plugin-0.3.1.zip

    在使用SDK时,你需要提供API key、secret key和passphrase来创建`Coinbase`实例。 2. **异步和同步调用**:SDK提供了同步和异步两种调用方式,以适应不同场景的需求。异步调用适用于不希望阻塞主线程的情况,而同步...

    maven学习指南java(经典,实例)

    Apache Maven是一个开源的项目管理和综合工具,...以上内容不仅会为初学者提供Maven入门的全面指导,还会通过实际例子帮助开发者深入理解并掌握Maven的高级特性,为他们今后在项目开发中解决实际问题提供了强大的工具。

    Maven+Struts2+Hibernate入门实例

    【标题】"Maven+Struts2+Hibernate入门实例"是一个综合性的开发教程,旨在帮助初学者理解并掌握这三个核心技术在Java Web开发中的应用。这个实例项目通过集成Maven、Struts2和Hibernate,展示了如何构建一个功能完备...

Global site tag (gtag.js) - Google Analytics