BlogJava-lcs868-文章分类-maven2http://www.blogjava.net/lcs868/category/36668.htmlzh-cnMon, 15 Dec 2008 23:23:24 GMTMon, 15 Dec 2008 23:23:24 GMT60用maven搭建struts2+spring+hibernatehttp://www.blogjava.net/lcs868/articles/246467.htmllcs868lcs868Mon, 15 Dec 2008 09:50:00 GMThttp://www.blogjava.net/lcs868/articles/246467.htmlhttp://www.blogjava.net/lcs868/comments/246467.htmlhttp://www.blogjava.net/lcs868/articles/246467.html#Feedback0http://www.blogjava.net/lcs868/comments/commentRss/246467.htmlhttp://www.blogjava.net/lcs868/services/trackbacks/246467.html
今天抽空练习下用maven2+myeclipse搭建一个ssh框架，把搭建过程简单记录一下，以便以后方便查阅
1.准备工作：jdk1.6，maven2.0.9，myeclipse6.0.1，mysql数据库

2.jdk的安装配置，以及maven2在eclipse里的配置网上的例子很多就不在重复

3.用m2搭建主项目工程s2shdemo，在myeclipse中点击new-other-maven project-create a simple project输入groupId,ArtifactId,在这里别的地方都可以根据自己的爱好填写，但打包方式packaging必须选择pom选项。点下一步后点击完成即可。

4.完成web层：我在这里用的是m2的命令行搭建一个web工程，进入cmd运行如下命令：
mvn archetype:create -DgroupId=com.lcsssh.web.action -DartifactId=s2shdemo -DarchetypeGroupId=org.apache.struts -DarchetypeArtifactId=struts2-archetype-starter -DarchetypeVersion=2.0.11.2-SNAPSHOT -DremoteRepositories=http://people.apache.org/repo/m2-snapshot-repository 
其中有标志的地方可以根据自己需要修改，这样一个struts2和spring的web工程就搭建成功。
5.完成service层：在myeclipse中选择file-other-maven module填写module name并选择父工程，也就是第3部你所建立起来的工程。进入下一步就如第三步一样填写所需选项，记住这里packaging应选择jar或其他不能用pom。

6.如第五步搭建dao层。

7.整合：以上步骤完成后开始配置，我把配置有关的文件全部放到web模块下的resources目录下
    配置web.xml文件，加入如下代码
<?xml version="1.0" encoding="UTF-8"?>  
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
 <display-name>s2shdemo</display-name>  
 <distributable />  
 <context-param>  
  <param-name>contextConfigLocation</param-name>  
  <param-value>classpath:applicationContext.xml</param-value>  
 </context-param>  
 <listener>  
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
 </listener>  
 <filter>  
  <filter-name>struts</filter-name>  
  <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
  <init-param>  
   <param-name>actionPackages</param-name>  
   <param-value>cn.allwap.backend.action</param-value>  
  </init-param>  
 </filter>  
 <servlet>  
  <servlet-name>dwr</servlet-name>  
  <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>  
  <init-param>  
   <param-name>debug</param-name>  
   <param-value>true</param-value>  
  </init-param>  
 </servlet>    
 <filter>  
  <filter-name>openSession</filter-name>  
  <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>  
  <init-param>  
   <param-name>singleSession</param-name>  
   <param-value>false</param-value>  
  </init-param>  
 </filter>  
 <filter>  
  <filter-name>struts-cleanup</filter-name>  
  <filter-class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-class>  
 </filter>  
 <filter>  
  <filter-name>encodingFilter</filter-name>  
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  <init-param>  
   <param-name>encoding</param-name>  
   <param-value>UTF-8</param-value>  
  </init-param>  
 </filter>  
 <filter-mapping>  
  <filter-name>encodingFilter</filter-name>  
  <url-pattern>/*</url-pattern>  
 </filter-mapping>  
 <filter-mapping>  
  <filter-name>openSession</filter-name>  
  <url-pattern>/*</url-pattern>  
 </filter-mapping>  
 <servlet-mapping>  
  <servlet-name>dwr</servlet-name>  
  <url-pattern>/dwr/*</url-pattern>  
 </servlet-mapping>  
 <filter-mapping>  
  <filter-name>struts-cleanup</filter-name>  
  <url-pattern>/*</url-pattern>  
 </filter-mapping>  
 <filter-mapping>  
  <filter-name>struts</filter-name>  
  <url-pattern>/*</url-pattern>  
 </filter-mapping>  
   <!-- Spring 刷新Introspector防止内存泄露 -->  
    <listener>  
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
    </listener>  
  
       
    <!-- session超时定义,单位为分钟 -->  
    <session-config>  
        <session-timeout>10</session-timeout>  
    </session-config>
 <welcome-file-list>  
  <welcome-file>index.jsp</welcome-file>  
  <welcome-file>default.jsp</welcome-file>  
  <welcome-file>index.html</welcome-file>  
 </welcome-file-list>  
</web-app>  
配置web action applicationContext-action.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

     <bean id="helloWorldAction" class="com.lcsssh.web.action.HelloWorldAction"  scope="prototype"/>
      <bean id="adminInfoAction" class="com.lcsssh.web.action.AdminInfoAction"  scope="prototype">
       <property name="adminInfoServiceImpl" ref="adminInfoServiceImpl"/>
      </bean>
</beans>

配置业务层applicationContext-service.xml文件
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xmlns:lang="http://www.springframework.org/schema/lang"  
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd"  
 default-autowire="byName">  
  <bean id="adminInfoServiceImpl" class="com.lcsssh.service.impl.AdminInfoServiceImpl" scope="prototype">
   <property name="adminInfoDAO" ref="adminInfoDAO"></property>
  </bean> 
</beans>    
配置dao 层applicationContext-dao.xml文件
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xmlns:lang="http://www.springframework.org/schema/lang"  
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd"  
 default-autowire="byName">    
  <bean id="adminInfoDAO" class="com.lcsssh.dao.impl.AdminInfoDAO">
   <property name="sessionFactory">
    <ref bean="sessionFactory"/>
   </property>
  </bean>
</beans>
配置application.xml
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xmlns:lang="http://www.springframework.org/schema/lang"  
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">  
 
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  <property name="driverClassName">  
   <value>com.mysql.jdbc.Driver</value>  
  </property>  
  <property name="url">  
   <value>jdbc:mysql://localhost/test</value>  
  </property>  
  <property name="username">  
   <value>user</value>  
  </property>  
  <property name="password">  
   <value>123456</value>  
  </property>  
  <property name="maxActive">  
   <value>20</value>  
  </property>  
  <property name="maxIdle">  
   <value>5</value>  
  </property>  
  <property name="maxWait">  
   <value>-1</value>  
  </property>  
  <property name="defaultAutoCommit">  
   <value>true</value>  
  </property>  
 </bean>  
  
    
  
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  <property name="dataSource">  
   <ref local="dataSource" />  
  </property>     
  <property name="mappingDirectoryLocations">  
   <list>  
    <value>classpath:com/lcsssh/bo</value>  
   </list>  
  </property>     
  <property name="hibernateProperties">  
   <props>  
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
    <prop key="hibernate.show_sql">false</prop>  
    <prop key="hibernate.cglib.use_reflection_optimizer">true</prop>  
    <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
    <prop key="hibernate.cache.use_query_cache">true</prop>  
   </props>  
  </property>  
 
 </bean>  
  <!-- dao object defintions -->
  <import resource="applicationContext-dao.xml"></import>
  <!-- business object defintions -->
  <import resource="applicationContext-service.xml"></import>
  <!-- web action object defintions -->
  <import resource="applicationContext-action.xml"></import>  
 <bean id="transactionManager"  
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  <property name="sessionFactory">  
   <ref bean="sessionFactory" />  
  </property>  
 </bean>  
  
 <bean id="transactionInterceptor"  
  class="org.springframework.transaction.interceptor.TransactionInterceptor">  
  <property name="transactionManager" ref="transactionManager"></property>  
  <property name="transactionAttributes">  
   <props>  
    <prop key="save*">PROPAGATION_REQUIRED</prop>  
    <prop key="add*">PROPAGATION_REQUIRED</prop>  
    <prop key="set*">PROPAGATION_REQUIRED</prop>  
    <prop key="update*">PROPAGATION_REQUIRED</prop>  
    <prop key="delete*">PROPAGATION_REQUIRED</prop>  
    <prop key="register">PROPAGATION_REQUIRED</prop>          
    <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
    <prop key="valid*">PROPAGATION_REQUIRED,readOnly</prop>  
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
   </props>  
  </property>  
 </bean>   
 <bean  
  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
  <property name="beanNames">  
   <value>*Service</value>  
  </property>  
  <property name="interceptorNames">  
   <value>transactionInterceptor</value>  
  </property>  
 </bean>   
 <bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">  
  <property name="transactionInterceptor" ref="transactionInterceptor">  
  </property>  
 </bean>   
</beans> 
所有配置文件配置完成。然后在父工程pom.xml下加入第4步创建的web模块工程，主要代码如下所示
<modules>
  <module>webProject</module>
  <module>serviceProject</module>
  <module>daoProject</module>
 </modules>
好了，到此为止所有的配置完成

8.根据数据库表生成dao 层代码，用myeclipse的生成工具生成即可。另外工程中所有依赖包都在web工程下的pom.xml中
为了节省篇幅，没有截图，希望大家体谅，本人水平有限，有不当之处敬请包含！！！
代码下载地址：http://www.blogjava.net/Files/lcs868/s2shdemo.zip

lcs868 2008-12-15 17:50 发表评论
]]>Maven2 的新特性http://www.blogjava.net/lcs868/articles/245924.htmllcs868lcs868Fri, 12 Dec 2008 05:05:00 GMThttp://www.blogjava.net/lcs868/articles/245924.htmlhttp://www.blogjava.net/lcs868/comments/245924.htmlhttp://www.blogjava.net/lcs868/articles/245924.html#Feedback0http://www.blogjava.net/lcs868/comments/commentRss/245924.htmlhttp://www.blogjava.net/lcs868/services/trackbacks/245924.html 
本文主要阐述 Maven2 的新特性，这些新特性可以大大地缩短了开发管理中的工作量，使得开发人员将精力集中在实际的业务问题上。

Maven 出现到现在也有很长时间了，初识它的感觉至今仍清晰的印在脑海中。现在想来，当时从 Ant 移情 Maven 的想法其实很朴素，就是因为 Maven 可以以网站的形式展现与项目相关的信息，如开发人员列表、各种 Report。这种方式为项目的构建带来了极大的方便，尤其是 Report 的。试想对于产生的 Junit-Report、JavaDoc、CheckStyle、PMD 等报告，如果没有一个统一的入口，每次切换目录是多么令人厌烦的事情！

Maven 无疑是相当成功的，这一点从越来越多的开源项目开始使用 Maven 就可以看出。Maven 取得成功的原因很简单：在简化构建脚本的同时，功能并没有缩水，反而有所增强；提供汇集项目信息的工具，并以相当友好的方式呈现；丰富的插件简化了工作。如此有力的工具出现，自然是争相使用。

新特性

如今 Maven2 已经推出，Maven 的官方网站称，Maven2 相对于 Maven1 是一个相当大的转变，甚至不惜牺牲兼容性来达到这一目的。（为了 Maven1 的用户着想，Maven1 仍在继续他的使命。）如此大的变动到底换来了什么样的结果？

1． 更快、更简单

比起 Maven1 那不急不慢的运行速度，Maven2在速度上有了质的飞跃，甚至与Ant相比也毫不逊色（当然，下载不算）。除此之外，"简化工作，使用业界公认的最佳实践"也是是 Maven2 的另一大主题，其他的新特性无处不在体现 Maven2 为简化工作而做出的努力。

2． 更少的配置文件

Maven1 和 Maven2 主要配置文件的对比：

  • Maven1：project.xml、maven.xml、project.properties和build.properties。
  • Maven2：pom.xml和settings.xml。

POM是Maven的核心对象模型，在Maven2中POM已由project.xml转移到pom.xml中使用，版本也由3升级为4。对于项目，一般只需要pom.xml就行了。

在Maven2中不需要也不提倡使用maven.xml，原因如下：

  • plugin的易用性的增强。
  • 散布于maven.xml中的内容难以在不同项目间共享，也不利于维护。在Maven2中建议使用自定义的plugin来封装这些内容。

如果仍期望能够使用类似maven.xml的功能，如<preGoal>，请参考Inserting non-standard build steps using preGoals and postGoals。

在Maven2中，配置使用settings.xml，它取代了原有的project.properties和build.properties。配置在Maven2中存在两种级别：

  • 用户级，针对操作系统登录用户而言。一般在$home/.m2/，对于windows用户，就是目录：C:\Documents and Settings\用户名\.m2\settings.xml。
  • 全局级：一般在%M2_HOME%/conf/settings.xml，M2_HOME是Maven2的根目录环境变量名。

在settings.xml中可以配置，如本地Repository、proxy等等，关于settings.xml的结构可以从Maven的官方网站上获取。

3． Plugin语言更换

在Maven2中，编写plugin的语言由jelly变更为Java和BeanShell。Java在速度上更有优势，而且开发人员的熟悉程度更高。对于其他的流行脚本，如groovy，Maven的官方网站的意见是，等待其更成熟时再考虑

。

4． 提供预定义的目录模板

好的目录结构可以使开发人员更容易理解项目，为以后的维护工作也打下良好的基础。Maven2根据业界公认的最佳目录结构，为开发者提供了缺省的标准目录模板。Maven2的标准目录结构如下：



使用目录模板，可以使pom.xml更简洁。因为Maven2已经根据缺省目录，预定义了相关的动作，而无需人工的干预。以resources目录为例：

  • src/main/resources，负责管理项目主体的资源。在使用Maven2执行compile之后，这个目录中的所有文件及子目录，会复制到target/classes目录中，为以后的打包提供了方便。
  • src/test/resources，负责管理项目测试的资源。在使用Maven2执行test-compile之后，这个目录中的所有文件及子目录，会复制到target/test-classes目录中，为后续的测试做好了准备。

这些动作在 Maven1 中，是需要在 maven.xml 中使用<preGoal>或<postGoal>来完成的。如今，完全不需要在pom.xml中指定就能够自动完成。在src和test都使用resources，方便构建和测试，这种方式本就已是前人的经验。通过使用Maven2，使这个经验在开发团队中得到普及。

创建标准目录模板，可以通过如下命令：


mvn archetype:create -DgroupId=com.codeline.commons -DartifactId=codelineCommons

groupId和artifactId的含义与Maven1中的含义一样，参数artifactId的值会作为项目根目录的名字。除了建立相应的目录之外，Maven2还会创建缺省的pom.xml。

Maven2也考虑到：不同类型的项目需要拥有不同的目录结构。如创建web项目，可以使用命令：


mvn archetype:create -DgroupId=com.mycompany.app
            -DartifactId=my-webapp
            -DarchetypeArtifactId=maven-archetype-webapp

5． 生命周期的引入

在Maven2中有了明确的生命周期概念，而且都提供与之对应的命令，使得项目构建更加清晰明了。主要的生命周期阶段：

  • validate，验证工程是否正确，所有需要的资源是否可用。
  • compile，编译项目的源代码。
  • test-compile，编译项目测试代码。
  • test，使用已编译的测试代码，测试已编译的源代码。
  • package，已发布的格式，如jar，将已编译的源代码打包。
  • integration-test，在集成测试可以运行的环境中处理和发布包。
  • verify，运行任何检查，验证包是否有效且达到质量标准。
  • install，把包安装在本地的repository中，可以被其他工程作为依赖来使用
  • deploy，在整合或者发布环境下执行，将最终版本的包拷贝到远程的repository，使得其他的开发者或者工程可以共享。
  • generate-sources，产生应用需要的任何额外的源代码，如xdoclet。

如果要执行项目编译，那么直接输入：mvn compile即可，对于其他的阶段可以类推。阶段之间是存在依赖关系（dependency）的，如test依赖test-compile。在执行mvn test时，会先运行mvn test-compile，然后才是mvn test。

6． 新增Dependency Scope

在POM 4中，<dependency>中还引入了<scope>，它主要管理依赖的部署。目前<scope>可以使用5个值：

  • compile，缺省值，适用于所有阶段，会随着项目一起发布。
  • provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
  • runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
  • test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
  • system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。

<scope>的使用举例：


<dependency>
            <groupId>hibernate</groupId>
            <artifactId>hibernate</artifactId>
            <version>3.0.3</version>
            <scope>test</scope>
            </dependency>

7． 传递依赖，简化依赖管理

在Maven1中，需要把依赖所需要的包也一并列出。这对于使用类似如Hibernate的用户来说所操的心太多了，而且也不方便。在Maven2中实现了传递依赖，如此对于Hibernate所依赖的包，Maven2会自动下载，开发人员只需关心Hibernate即可。

注意：只有得到Maven支持的依赖，通常是plugin形式出现，才能获得这个特性。而且对于一些老的plugin，可能由于时间的关系不支持传递依赖。如至少在Maven 2.0.1中，对于Hibernate 2.1.2，仍然需要显式列出Hibernate 2.1.2所依赖的包。


回页首


使用简介

安装Maven2的步骤非常简单：首先从Maven官方网站下载相应的软件包，目前是Maven 2.0.1；然后解压，并设置环境变量M2_HOME= Maven2的解压安装目录；最后将%M2_HOME%/bin添加到path中，方便Maven在任何目录下运行。

Maven2的运行命令是mvn，使用mvn -h可以获得相关的帮助信息。常用情形：

  • 创建Maven项目：mvn archetype:create
  • 编译源代码：mvn compile
  • 编译测试代码：mvn test-compile
  • 运行测试：mvn test
  • 产生site：mvn site
  • 打包：mvn package
  • 在本地Repository中安装jar：mvn install
  • 清除产生的项目：mvn clean

或许是由于刚刚推出的缘故，Maven2目前还是有一些不尽如人意的地方。尤其是Report部分的plugin，有的是因为目前还没有，如junit-report。有的则是一些莫名其妙的问题，如checktyle和pmd，在本地locale下都无法正常工作。以pmd举例，在产生PMD报告时会抛出如下异常：


java.util.MissingResourceException: Can't find bundle for base name pmd-report,
            locale zh_CN
            at java.util.ResourceBundle.throwMissingResourceException(ResourceBundle
            .java:839)
            at java.util.ResourceBundle.getBundleImpl(ResourceBundle.java:808)
            at java.util.ResourceBundle.getBundle(ResourceBundle.java:702)
            ……

幸运的是，Maven2一出现就备受关注，要不了多长时间，诸如此类的问题应该就会很快解决。

lcs868 2008-12-12 13:05 发表评论
]]>maven2使用手册http://www.blogjava.net/lcs868/articles/245923.htmllcs868lcs868Fri, 12 Dec 2008 04:57:00 GMThttp://www.blogjava.net/lcs868/articles/245923.htmlhttp://www.blogjava.net/lcs868/comments/245923.htmlhttp://www.blogjava.net/lcs868/articles/245923.html#Feedback0http://www.blogjava.net/lcs868/comments/commentRss/245923.htmlhttp://www.blogjava.net/lcs868/services/trackbacks/245923.html阅读全文

lcs868 2008-12-12 12:57 发表评论
]]>maven2完全使用手册http://www.blogjava.net/lcs868/articles/245920.htmllcs868lcs868Fri, 12 Dec 2008 04:51:00 GMThttp://www.blogjava.net/lcs868/articles/245920.htmlhttp://www.blogjava.net/lcs868/comments/245920.htmlhttp://www.blogjava.net/lcs868/articles/245920.html#Feedback0http://www.blogjava.net/lcs868/comments/commentRss/245920.htmlhttp://www.blogjava.net/lcs868/services/trackbacks/245920.html阅读全文

lcs868 2008-12-12 12:51 发表评论
]]>Maven使用手册http://www.blogjava.net/lcs868/articles/245919.htmllcs868lcs868Fri, 12 Dec 2008 04:48:00 GMThttp://www.blogjava.net/lcs868/articles/245919.htmlhttp://www.blogjava.net/lcs868/comments/245919.htmlhttp://www.blogjava.net/lcs868/articles/245919.html#Feedback0http://www.blogjava.net/lcs868/comments/commentRss/245919.htmlhttp://www.blogjava.net/lcs868/services/trackbacks/245919.html来自:http://www.jieesoft.com/modules.php?name=News&file=article&sid=155

Maven和ANT是Apache 推出的大名鼎鼎的Build和工程管理工具，国内有人将他做了汉化工作，并推出了maven手册汉化工作，其中手册已经完工，对广大程序员可是一大帮助。进入该网站
用户手册

  1. 关于手册
  2. 简介
  3. 项目对象模型
  4. POM 处理机制
    1. POM 插值机制
    2. POM 继承机制

  5. 使用插件
  6. maven.xml文件

    1. 简单的maven.xml例子
    2. project节点
    3. 目标
    4. Jelly编程

  7. Maven 配置

    1. 属性的处理机制
    2. 插件的属性
    3. 行为属性
    4. 使用代理
    5. 使用多个远程Repositories

  8. 项目设置

    1. 开始一个新项目

  9. 构建

    1. 构建生命周期
    2. 在CVS中存放jar文件
    3. 重载已声明的依赖包
    4. 使用SNAPSHOT依赖
    5. 多项目构建和Reactor
    6. 离线构建
    7. 命令行选项介绍

  10. 测试



    1. 测试资源
    2. 运行一个单独的测试

  11. 打包



    1. JAR 资源

  12. 部署



    1. 固化SNAPSHOT依赖
    2. 拷贝依赖JAR包

  13. 命名约定

    1. 规则和指南
    2. 项目
    3. 依赖
    4. 发布多个包的项目

  14. 远程Repository布局
  15. 本地Repository布局
  16. 生成项目站点

    1. 颜色
    2. 风格
    3. 报告





关于手册
这篇Maven使用手册意在通过提供完整的描述和例子，帮助开发人员了解Maven。 如果你有任何建议或者意见请在 Maven使用者邮件列表上发表.
感谢选择Maven!

简介
Maven最早始于Jarkarta Turbine项目，目的是为了简化构建过程。这个项目下面有 几个子项目，每个子项目都有自己的Ant文件，但是区别很小，而且生成的JAR 文件都要check in到CVS中。我们希望有一种标准的方式来构建这些项目，一种可以 清晰描述项目的方式，一种易于发布项目信息的方式，一种在多个项目之间共享JARs 的方式。
这个结果就是产生了一个可以用于构建、管理任何基于java的项目。我们希望我们创造 的这个工具可以让Java开发者的日常工作更加轻松，并有助于理解基于java的项目.

项目对象模型
Maven是基于项目对象模型(POM)的概念而创建的。在这个模型中，所有由Maven产生的 artifact都是清晰定义的项目模型的结果。构建，文档，源码度量，源码交叉引用和其他 任何由Maven plug-in提供的东西都是由POM来控制的。

POM 处理机制
这篇文档简单的描述了Maven执行过程中是如何处理POM的。这里有一些简单的POM例子 来展示继承机制和插值机制。

POM 插值机制
POM(通常以project.xml的名字出现)现在已经被当作Jelly脚本来处理了。大部分时 候，用户无须关心project.xml文件是不是真正的Jelly脚本，但是，如果需要的话， 也可以使用内置值。我也不愿看到逻辑控制语句出现在project.xml中，但是由于 project.xml实际上已经是一个隐含的jelly的脚本，所以它会有足够的灵活性:-)。 下面是一个简单的例子。
3
maven
maven
Maven
1.0-b5-dev

Apache Software Foundation
http://jakarta.apache.org/
/images/jakarta-logo-blue.gif

2001
org.apache.${pom.artifactId}
/images/${pom.artifactId}.jpg

Maven is a project that was created in ${pom.inceptionYear}.
${pom.name} is a Java Project Management Tool

POM 继承机制
现在有一种简单方式可以用于在POM中进行继承，下面是一个简单的例子：
project.xml
super-extendo
super-extendo
Super Extendo

**/*Test*.java

**/TestAll.java
**/*Abstract*.java

目前对POM父对象的解析还相对较弱，现在对一层以上的继承还没有做过任何测试。尽管如此， 单层继承加上插值机制已经能够给带来很多好处。这些机制的意图在于简化构建的共用问题。
你可以这样定义主模板：

3
commons
commons-master
Commons Master Maven POM

Apache Software Foundation
http://www.apache.org

jakarta
http://jakarta.apache.org/commons/${pom.artifactId}.html
http://nagoya.apache.org/
jakarta.apache.org
/www/jakarta.apache.org/commons/${pom.artifactId}/
/www/jakarta.apache.org/builds/jakarta-commons/${pom.artifactId}/

scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-commons/${pom.artifactId}
http://cvs.apache.org/viewcvs/jakarta-commons/${pom.artifactId}/
...

子POM对象可以这样定义：
commons-betwixt
commons-betwixt
Betwixt
...

这样你就可以在父POM对象中，将子POM对象的${pom.artifactId}替换进去。有许多项目的 构建都以相似的方式进行构建，这样一来，对于项目的公共部分，你就可以使用一个主模板， 然后在子POM对象project.xml中定义有区别的部分，而这部分内容通常很少。
这种机制确实还可以简化那些需要产生多个JAR包的项目。由于project.xml和标准Ant构建 不会相互干扰，我计划在公共部分测试继承机制。
如果你对使用这种机制，DVSL报告会变成什么样感到疑惑，我要说，你很上路。我已经修改 了DVSL报告来适应POM本身，这就是说DVSL转换是基于java对象的。在使用继承和插值机制的 时候，为了正确的产生DVSL报告，这是很有必要的。象上面列出的子模板是无法工作的，我们 需要全面的解析POM。我能说的是，它可以工作了！我所使用的处理方式可能不是最有效率的 方式，但仍有提升的空间。因为POM只会被处理一次(不管怎么说，这就它的原理，我可能漏了 某些东西)，然后到处使用，至少这就是我以前试图做的事情，所以我们很有可能会取得平衡。
如果你不使用继承和插值，那么一切照常工作。maven站点本身一切ok，有几个刚部署的站点 已经使用了我昨晚提交的东西了。

使用插件
Maven是一个很紧凑的内核，围绕着它的是许许多多的插件。Maven所有的功能都是由插件来提供 的。

maven.xml文件
项目中的maven.xml文件是Maven在执行过程中要使用的“定制”文件。
在这个文件中，你可以加入Maven构建中需要的额外处理。或者在Maven的“目标”前后附加自己 的代码，如jar 或 test。
Maven使用Jelly 脚本语言, 任何合法的jelly标签都可以在maven.xml中使用。
Maven所采用的goal功能是由werkz标签库提供。更多的信息请看 wiki页面.

简单的maven.xml例子
注意由于Maven并未缺省的定义'compile'目标，下面这个例子没法运行。
这是一个简单的maven.xml例子

${goals}
Now attaining goal number ${goalNumber}, which is ${goal}

你可能会注意到这里一些有意思的东西，下面我们将逐一解释。

project节点
project节点, , 是任何 maven.xml 文件的根节点。
项目节点有一个缺省的属性：default="nightly-build"，如果用户只是简单键入 没有参数的maven命令，Maven就会用nightly-build 目标作为缺省目标。
接下来是几个名字空间的声明，如：

  1. xmlns:j="jelly:core"
    所有以j:作为前缀的节点，Jelly都会把它视为在core标识下 预定义的标签库。
  2. xmlns:u="jelly:util"
    所有以u:作为前缀的节点，Jelly都会把它视为在标识下 预定义的标签库。

    所有在maven.xml文件使用的Jelly标签库，都必须在project节点中定义，并且 分配一个名称空间前缀。
    Maven已经预先包含了jeez标签库作为空前缀。这个标签库在一个名称空间内包含了 ant 和 werkz 标签库。这样，任何werkz或ant标签都无须名称空间 即可使用，同时也简化了ant的迁移过程。

    目标
    goal是一个     werkz 标签，类似于Ant的target；它是包含了一系列可执行标签的容器。
    由于jeez 标签库已经由maven预先注册了，一个目标(goal)可以包含任何合法的 Ant 标签。
    为了执行在maven.xml中定义的目标，你只需要在命令行中为Maven指定目标名即可。要执行例子中定 义的nightly-build你只需执行命令:
    maven nightly-build

    Maven插件定义的目标需要在目标前加上插件名，这样一来，就不会和你自己的goal冲突，如 jar:jar就是 jar 插件定义的目标，用于创建项目的jar包。

    Jelly编程
    在每个目标里，由Jelly标签提供功能，让我们来看看例子里的这些代码。
    set

    这行就是一个jelly的core标签set，它使用了project节点中定义的前缀 j:
    set标签设置了一个由var属性定义的Jelly变量，值由 value 指定。和Ant的proerties不一样，Jelly变量在被赋值后仍可以改变。
    mkdir

    等同于Ant任务 mkdir, 用于创建目录，目录名由变量 ${maven.build.dir}指定。
    tokenize
    ${goals}
    这行执行的是Jelly tokenize 标签。这是Jelly util 标签库中标签， 这个标签库已经在项目节点中预先定义：u:
    tokenize标签在将节点中的内容分离成一个list，用于后续的处理。
  • var 属性就是将被于新list的变量。
  • delim 属性是用于分割字符串中的分隔符。
  • 在这个例子中，tokenize 标签中节点值是一个变量：goals, 在前几行中，这是一个由逗号分隔、compile 与 test 的字符串。



forEach

Now attaining goal number ${goalNumber}, which is ${goal}


forEach标签提供简单循环功能，节点值就是循环体。


  • items 属性是一个表达式，是在循环过程中需要遍历的值集合。
  • 集合中的值被逐个取出，存放在var 属性指定的变量中。你可以在 forEach 循环体访问这个变量。
  • indexVar 属性指定了一个计数器(起始基数为0)变量，用于在处理 过程中计数。



forEach 标签的节点值输出了一些在处理过程中的关于目标的文本，并使用 attainGoal werkz 标签来获得(执行?)这些目标。

Maven 配置

属性的处理机制
Maven按下面的顺序依次读入properties文件：

  • ${project.home}/project.properties
  • ${project.home}/build.properties
  • ${user.home}/build.properties


读入的属性遵循“最后的定义有效”原则。也就是说，Maven依次读入properties文件，以新的定义 覆盖旧的定义。${user.home}/build.properties是Maven最后处理的文件。我们把 这些文件称为Maven处理的标准属性文件集。
另外，上述properties文件处理完毕后，Maven才会开始处理系统属性。所以，如果在命令行中使用 象-Dproperty=value这样的形式来指定的属性，它会覆盖先前定义的同名属性。

插件的属性
上述属性文件处理完后，Maven才会开始调用插件，但是 PluginManager 会禁止插件 覆盖已经设置的属性值。这和Maven一般的属性处理方式是相反的，这是因为插件只能在Maven内部的 其他部分初始化完毕后才能处理，但是我们又希望以这样顺序去处理属性：

  • 处理Plug-in 缺省属性
  • 处理${project.home}/project.properties
  • 处理${project.home}/build.properties
  • 处理${user.home}/build.properties


这样一来，即使插件处于属性处理链的后端，也能覆盖插件的任何缺省属性。例如，Checkstyle插件 就定义了如下缺省属性：
maven.checkstyle.format = sun

你可能已经猜出来了，Checksytle插件把Sun的编码规范作为缺省的格式。但是我们仍然可以在标准属性 文件集的任何一个文件中覆盖这个属性。所以如果在${project.home}/project.properties 文件定义了如下属性值：
maven.checkstyle.format = turbine

Checkstyle就会使用Turbine的编码规范。

行为属性
下面的这些属性可以改变Maven的“行为方式”。

属性
描述
缺省值

maven.build.dest
目录名，存放编译生成的类
${maven.build.dir}/classes

maven.build.dir
存放构建结果的目录，如类文件，文档，单元测试报告等等。
注意： 在${user.home}/build.properties文件中改变maven.build.dir 的缺省值或许会得到一个 较为个性化的目录布局。但是，这会干扰Maven由从源码开始的编译工作，因为它假设jar包 会被创建到${basedir}/target/目录中。
${basedir}/target

maven.build.src
源码目录
${maven.build.dir}/src

maven.conf.dir
配置文件目录
${basedir}/conf

maven.docs.dest
html格式报告的输出目录
${maven.build.dir}/docs

maven.docs.omitXmlDeclaration
产生的文档所应包含的xml声明头，如：

false

maven.docs.outputencoding
生成文档的缺省编码
ISO-8859-1

maven.docs.src
用户提供的文档目录
${basedir}/xdocs

maven.gen.docs
xdocs文档转换成html后的输出目录
${maven.build.dir}/generated-xdocs

maven.home.local
maven用于写入用户信息的本机目录，如解开插件包、缓冲数据。
${user.home}/.maven

maven.mode.online
是否连接internet
true

maven.plugin.dir
插件的存放目录
${maven.home}/plugins

maven.plugin.unpacked.dir
用于展开安装插件的目录
${maven.home.local}/plugins

maven.repo.central
在进行dist:deploy处理的时候，发行包所要部署的目标机器
login.ibiblio.org

maven.repo.central.directory
在进行dist:deploy处理的时候，发行包所要部署的目标目录。
/public/html/maven

maven.repo.local
本机repository，用于存储下载的jar包。
${maven.home.local}/repository

maven.repo.remote
远程repository，如果本机repository没有的jar包，maven会从这里下载。
http://www.ibiblio.org/maven

maven.repo.remote.enabled
是否使用远程repository。
true

maven.scp.executable
用于安全拷贝的可执行程序
scp

maven.src.dir
基础源代码目录
${basedir}/src

maven.ssh.executable
远程命令可执行程序
scp

使用代理
如果你只能通过代理访问，不要紧，Maven为你提供了下列属性：

代理属性
描述

maven.proxy.host
代理的IP地址

maven.proxy.port
代理端口

maven.proxy.username
如果代理需要认证的话，在这里填写用户名。 User name if your proxy requires authentication.

maven.proxy.password
如果代理需要认证的话，在这里填写密码。
如果你实在需要代理，最好在${user.home}/build.properties文件中指定。
## ----------------------------------------------------------
## ${user.home}/build.properties
## ----------------------------------------------------------
.
.
maven.proxy.host = my.proxyserver.com
maven.proxy.port = 8080
maven.proxy.username = username
maven.proxy.password = password
.
.

使用多个远程Repositories
你可以在任何Maven可以处理的属性文件中指定使用多个远程Repositories，如：
maven.repo.remote = http://www.ibiblio.org/maven/,http://www.mycompany.com/maven/

项目设置

开始一个新项目
如果你是第一次使用Maven，或者开始一个新的项目，你可以使用GenApp来自动创建Maven项目树。
maven -Dpackage=com.mycompany.app genapp

执行该命令后，屏幕显示如下：
__ __
| / |__ Jakarta _ ___
| |/| / _ V / -_) ' ~ intelligent projects ~
|_| |___,_|_/___|_||_| v. 1.0-beta-9

[mkdir] Created dir: /genapp/src/java/com/mycompany/app
[copy] Copying 1 file to /genapp/src/java/com/mycompany/app
[mkdir] Created dir: /genapp/src/test/com/mycompany/app
[copy] Copying 3 files to /genapp/src/test/com/mycompany/app
[copy] Copying 2 files to /genapp
[copy] Copying 1 file to /genapp/src/conf
BUILD SUCCESSFUL
Total time: 3 seconds

执行完毕，即生成下面的完整项目目录树：
.
|-- project.properties
|-- project.xml
`-- src
|-- conf
| `-- app.properties
|-- java
| `-- com
| `-- mycompany
| `-- app
| `-- App.java
`-- test
`-- com
`-- mycompany
`-- app
|-- AbstractTestCase.java
|-- AppTest.java
`-- NaughtyTest.java

构建
Maven采用了集中管理库的理念。所有用于构建的jar包都是从集中管理的中心库上取出。目前， 我们的中心库放在这儿 Ibiblio. 在一个典型的Maven项目中，构建所需的 jar包会从中心库下载。Maven只会取回依赖链条上缺失的包。如果你使用Maven来构建几个项目， 这些项目可能会共享一些依赖包：Maven可以在任意个项目中共享同一个包，而无须在同一系统 中保持一个jar包的多个拷贝。

构建生命周期

在CVS中存放jar文件
我们不推荐你在CVS中存放jar包。Maven提倡在本机repository中存放用于构建共享的jar包或 和其他项目包。许多项目都依赖于诸如XML解析器、标准例程，这在Ant构建中，经常会被复制 多份。在Maven中，这些标准例程就存放在本地repository中，供任何项目构建使用。
重载已声明的依赖包
你可能会发现，在某些情况下允许重载POM中已经声明的依赖包会很方便，甚至很有必要。 你可能会希望使用文件系统中的某个JAR包，或者你希望简单重新指定某个包的版本。对于 这样的情况，Maven提供了一种简单的方式，允许你选择构建所需的jar包。我们严重建议;) 你设置本机repository，但是在简单至上，或在由ant构建迁移的情况下，JAR包重载特性 会显得非常方便。
为了使用JAR包重载特性，你必须将maven.jar.override 属性设置为 on。 只要设置了这个属性，就可以在任何maven处理的属性文件中重载JAR包。
关于JAR重载的指令有两种。第一种允许你指定某个特定的包的路径，作为JAR包；的二种 允许你指定某个特定的JAR包（这个jar包必须已经存在于本机repository）。下面是这两 种方式：
maven.jar.artifactId = [path]
maven.jar.artifactId = [version]

下面是一个使用JAR重载指令的属性文件例子：
# ------------------------------------------------------------------------
# M A V E N J A R O V E R R I D E
# ------------------------------------------------------------------------
maven.jar.override = on
# ------------------------------------------------------------------------
# Jars set explicity by path.
# ------------------------------------------------------------------------
maven.jar.a = ${basedir}/lib/a.jar
maven.jar.b = ${basedir}/lib/b.jar

# ------------------------------------------------------------------------
# Jars set explicity by version.
# ------------------------------------------------------------------------
maven.jar.classworlds = 1.0-beta-1

使用SNAPSHOT依赖
在Maven中，SNAPSHOP是某个特定项目的最新构建的jar包。如果你的项目依赖于另一个频繁变更 的项目，你可以在你的POM中声明SNAPSHOP依赖，以保持与那个项目的同步。例如，在你的POM中 这样写，你可以与Jelly保持 同步更新。
...
commons-jelly
commons-jelly
SNAPSHOT
...

上述语句的含义是：总是使用Maven repository中最新的Jelly构建包。SNAPSHOT依赖 总会导致依赖失败。在这种情况下，Maven就会去Maven repository取得一个SNAPSHOT 依赖包的拷贝。如果你正在离线工作，Maven就会发出警告：“SNAPSHO依赖包可能已经 过期”。

多项目构建和Reactor
在Maven中，Reactor是一个用于控制多项目构建的工具。Reactor用Werkz包,并根据每个项目 各自定义的依赖关系来安排构建顺序。Reactor的意图在于：鼓励创建/重构具有更小、更松散、 更有一致性单元的项目。r源于面向组件编程，在向组件编程中，整个系统由许多松散的个体 构成，这些个体需要聚合起来作为一个整体进行部署。
Reactor可以为某个项目集执行一个任意编排的目标列表。所以，如果使用Reactor的话，它 可以用来做项目站点生成，任意jar包生成这样的事情。
目前 db.apache.org 站点就是收集了其子项目的 丰富信息、并与一系列的Velocity 模板合成的。这一过程是由 Jelly Velocity 标签库来完成的。 这里是其中的机制，有兴趣可以看看。
Plexus(一个基于Avalon的容器)组件的manifest是遍历所有Plexus组件、并聚合而成的。这里 使用的还是Velocity模板和Jelly Volocity标签库。 这里是其中的机制，有兴趣可以看看。
这里是一个使用Reactor标签，遍历一系列组件，最后产生项目站点的例子：
... Do whatever you want with the harvested information ...

如果你需要聚合N个项目的文档，形成一个统一的视图，你可以参考 db.apache.org站点，它从所有的子项目中收集 信息，最终形成一个有导航条，邮件列表，开发者列表和源码repository统一的站点。这解决 了在收集子项目信息过程中的冗余、易于产生错误的问题。db.apache.org的子项目只需关注 自身的信息，却可以自动的集成到高层的项目站点中。

离线构建
如果你需要离线构建，你得在命令行中使用离线选项：
maven -o jar:jar

这等同于：
maven -Dmaven.mode.online=false jar:jar

或者你可以在属性文件中设置 maven.mode.online 属性为false。
在联机模式下，maven总是下载 SNAPSHOT 依赖包, 请参考 使用SNAPSHOT依赖。如果本机repository 上的当前版本比服务器上的还要新，你也许不想maven覆盖你的当前版本。如果不想下载，你可以 设置属性：
maven.repo.remote.enabled=false

在maven beta 9版本中，这个属性并没有起作用(新版本已经解决了这个问题)。可以这样来清空 maven.repo.remote 属性：
maven.repo.remote.enabled=

在命令行或属性文件中设置都一样。
在下面的情形中，你需要同时设置maven.repo.remote.enabled=false maven.mode.online=true：希望javadoc插件的"-link"选项起作用，而又不希望 下载任何(包括snapshot)包。

命令行选项介绍
如果你用命令行来构建，这里提供了一个关于命令行选项的快速参考。
Options:
-D,--define arg 定义一个系统属性
-E,--emacs 输出简洁的日志信息
-X,--debug 输出debug信息
-b,--nobanner 禁止 logo banner
-d,--dir arg 设置指定的工作目录
-e,--exception 输出异常堆栈信息
-f,--find arg 通过搜寻项目文件来确定执行的项目文件及其工作目录
-g,--goals 显示可用的目标
-h,--help 显示帮助信息
-i,--info 显示系统信息
-o,--offline 离线构建
-p,--pom arg 指定项目文件
-v,--version 显示版本号

测试

测试资源
通常情况下，你需要在测试类路径上为测试指定某些资源。你可以在POM中使用
下面的例子说明了如何递归的包含在${basedir}/src/test目录中所有以.xml和.properties为扩展名 的文件：
...
...
...

${basedir}/src/test
**/*.xml
**/*.properties

下面的例子说明了如何递归的包含在${basedir}/src/test目录中所有以.xml和.properties为扩展名 的文件，但naughty.properties文件除外。请注意增加的project/build/unitTest/resources/excludes 节点：
...
...
...

${basedir}/src/test
**/*.xml
**/*.properties

naughty.properties

运行一个单独的测试
下面的命令运行了一个单独的测试：
maven -Dtestcase=org.foo.bar.MyTest test:single-test

打包
JAR 资源
...

${basedir}/src/conf

*.xml
*.properties

${basedir}/src/messages
org/apache/maven/messages
messages*.properties

部署

固化SNAPSHOT依赖
在开发时使用SNAPSHOT依赖包非常方便，但是在部署的时候，你需要把所有的SNAPSHOT依赖包 固定下来，以便发布一个包含固定jar的版本。如果你发布了一个含SNAPSHOT依赖包的项目，而 这些SNAPSHOT在项目发布后发生了变更，你可能很快就会发现这个版本没法儿工作。
当SNAPSHOT以时间戳为版本号部署到Maven上时，Maven可以识别foo-SNAPSHOT.jar实际上相当 于foo-20030101.010101.jar。当部署的时刻来临，你可以用下面的命令，让Maven把SNAPSHOT 版本号变为时间戳版本号。
maven convert-snapshots

Maven会提供交互的方式让你选择哪个SNAPSHOPT依赖包应该固化下来。这一过程结束后，Maven 就会把刚才你的选择写会你的POM。
如果你希望Maven简单的、尽可能最好的固化SNAPSHOT依赖包，你可以用下面的命令：
maven convert-snapshots-auto

拷贝依赖JAR包
在maven.xml这样写下面的语句是最简单的拷贝依赖包的方法。
...
...

用deploy:copy-deps标签你就可以简单的把项目所有的依赖包拷贝到任何 目录，如果希望排除某个依赖包，需要给出一个依赖包的id列表，列表中依赖包就不会被拷贝。

...
...

命名约定
这部分将简要的描述项目对象模型(POM)中命名约定。本篇文档希望可以统一各式各样jar包命名 方法，这些jar包一般为java开发者社区广泛使用。

规则和指南
项目
一个项目必须由一个唯一的的标识，标识由a-z小写字母和连线号构成，其首字母必须以小写字母 开头。

bar
foo
...

所有项目间的引用都由组id和包id构成。到现在为止，在POM与此相关的是下面将要（上面提到的？）谈到的项目的 依赖声明。
项目的名称应该易于阅读，可用于文档。

bar
foo
The Grand Master Foo
...

项目应该有一个组标识，组标识是名称的基础部分。
bar
foo
The Grand Master Foo

...

所有项目发布的包都应基于项目唯一的标识，并且放在基于项目的组id的目录中。对于上面的 项目来说，假定发布的包是jar类型的包，我们就会有如下目录结构：
repository
|
+-- bar
|-- distribution
`-- jar
|-- foo-1.0.jar
`-- foo-2.0.jar


依赖
一个理想的典型依赖声明的例子可能会象这样：

yourProject
yourArtifact
Your Groovey Machine
...

bar
foo
1.0

这样一来，依赖于id为foo1.0 版本的bar项目 属于org.foo.bar组。这个依赖会被解析为本地repository中jar文件。上面 的情形假定发布的包是基于包id命名的。因此对于上述依赖，Maven就会采用 foo-1.0.jar作为jar名。
就像用户反映的那样，这种理想的方式并不能适应所有的项目。有几种情形我们必须考虑调整 理想的依赖机制：

  • 发布的jar包的并未使用项目作为基础名，如xercesImpl就是所有发布的jar包的基础名 它与gump id和maven中的id都不一样。
  • 发布的jar包没有使用任何版本声明，如许多commons组件并没有把版本号作为包名的一部分。
  • 有些项目即没有使用项目id作为基础名也没有版本声明。例如，最坏的情形是Java Activation Framework 的jar包，它没有遵循其他Sun的命名规则，也没有在jar包中声明 版本号，甚至在manifest中都没有任何版本信息。

    在多数情形下，任何例外的情况都可以用 (可选节点)、或者是重命名来解决。 现在，许多Jarkata的产品在repository已经被重命名，因为在不久的未来，绝大多数的Jarkarta的 项目将用maven进行构建。但这不是公司政策，我们不需要解决所有情况的问题。

    发布多个包的项目
    Maven的依赖机制完全支持任何形式的多项目包。 Maven's dependency mechanism completely supports multiple project artifacts of any given type.
    下面的代码包含了ant的主jar包和optional包加上hypothetical包。
    ant
    ant
    1.4.1

ant
ant-optional
1.4.1
ant
poorly-named
1.4.1

所以A), B) 和 C)实际上是指向属于同一组的单个包的指针，这就是说，一个单独的依赖就是对某个组中的某个 包的引用。目前artifact如果没有特别说明的话，一般指的是jar包。但是依赖也可能是一个war文件或一个 发行包。我们试图在提供多数情况下(构建大多需要jar包)使用的缺省方式的同时，也顾及灵活性。

远程Repository布局
这部分文档将对Maven的远程repositories做一个概要的说明。目前，主repository位于 Ibiblio，但是你也可以自己创建一 个远程repositories，其结果描述可以在这部分文档中找到。
任何独立的项目在repository都有自己的目录。每个项目有一个唯一的项目id和同名目录， 项目的发行包就放在这个目录中。
项目的目录中可以存放各种各样的artifacts，目前最为广泛使用的两种类型是jar包和发行包 下面是一个远程repository快照：
repository
|
|-- ant
| |-- distribution
| `-- jars
| |-- ant-1.4.1.jar
| `-- ant-optional-1.4.1.jar
+-- jsse
|-- distribution
`-- jars
|-- jsse.jar
|-- jcert.jar
`-- jnet.jar

本地Repository布局
应该有一个接口集合的紧凑实现使本地repository目录结构更加随意一些。现在我只使用 了一个类来实现，显得有些臃肿。我还是认为本地和远程repositories应保持相同的结构 但是为了使用更乐于使用，我开始设计一些接口，用于满足用户自己安排自己本地Repository 布局，相似的远程Repositor也在设计中。尽管目前本地repository仍与远程repository 完全一致，我希望听到更多的用户反馈，以促进这些接口的开发，或者完全抛弃它。

生成项目站点
Maven可以为项目产生一个完成的web站点。这个web站点将包含各种各样、由许多Maven插件 产生的报告，如javadocs，代码度量，单元测试，changlog，及其它... 本节文档接下来的 部分将阐述Maven支持的站点定制选项。

颜色
考虑到一致性，缺省情况下，所有Maven产生的站点都使用相似的外观。这使用户一眼就能 认出由Maven产生的站点，产生熟悉的感觉，更加方便信息的获取。当然，Maven开发组也 考虑到用户可能会希望定制他们的站点。修改Maven产生的站点，最简单的方法是指定你要 使用的颜色搭配。这只需要在project.properties简单的设置适当的属性 即可。下面是所有可用的属性描述在 xdoc plugin。

风格
如果你感觉颜色太过于简单，无法满足你的要求，你可以用自己的stylesheet。为了重载 在${basedir}/xdocs/stylesheets/中的maven.css stylesheet，你可以通过设置maven.javadoc.stylesheet 属性来指定你的 javadoc风格。

报告
最后，如果你希望定制哪些报告需要自动产生，你需要在你的项目描述中包含 reports 标签库。 到目前为止，如果没有reports标签指定，所有插件报告都会产生。这个标签 允许你选择产生哪些报告而排斥另外一些报告，而且允许你安排顺序。
目前的标准 报告集在xdoc中是硬编码实现的，它们是：
maven-changelog-plugin
maven-changes-plugin
maven-checkstyle-plugin
maven-developer-activity-plugin
maven-file-activity-plugin
maven-javadoc-plugin
maven-jdepend-plugin
maven-junit-report-plugin
maven-jxr-plugin
maven-license-plugin
maven-linkcheck-plugin
maven-pmd-plugin
maven-tasklist-plugin

如果你希望产生缺省的报告，但是还想增加或删除一两个，最好的方法是：给 xdoc:register-reports目标写一个前置目标(postGoal)。

排除所有Maven产生的内容
某些情况下，用户需要构建只有文档的站点，或是构建聚合许多子项目的站点，但不希望 在站点上有个整体“项目文档”导航条。设置 maven.xdoc.includeProjectDocumentation属性值为no 即可解决这一问题。缺省的，Maven会包含“项目文档”导航条，下面挂的是许多Maven 生成的报告。 "



lcs868 2008-12-12 12:48 发表评论
]]>