Maven入门

最新推荐文章于 2023-03-07 08:14:58 发布

yangsiyuan0

最新推荐文章于 2023-03-07 08:14:58 发布

阅读量584

点赞数

分类专栏： java 文章标签： java maven

本文链接：https://blog.csdn.net/yangsiyuan0/article/details/88747735

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一. 导语

1. Maven：项目管理工具

Maven在美国是一个口语化的词语，代表专家、内行的意思，约等于北京话中的老炮儿，包含：
    - 一个项目对象模型(POM)：Project Object Model
    - 一组标准集合
    - 一个项目生命周期(Project Lifecycle)
    - 一个依赖管理系统(Dependency Management System)
    - 用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑

2. Gradle：基于Groovy语言的项目自动化构建工具

综合了maven+ant的特性

3. gradle VS maven

3.1 依赖管理系统
- maven坐标(Coordination)：groupId、artifactId、version
- maven作用域(scope)：complie(默认)、provided、runtime、test、system、import
- gradle坐标：可以依赖文件、工程、还可以排除传递依赖
- gradle作用域：compile、runtime、testCompile、testRuntime

configurations {
    compile.exclude module: 'commons'
    all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
}
dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared'
    }
}

3.2 多模块构建

maven
- 需要定义个parent POM作为一组module的聚合POM
- 在该POM中可以使用<modules>标签来定义一组子模块
- parent POM不会有什么实际构建产出,而parent POM中的build配置以及依赖配置都会自动继承给子module
Gradle
- 在parent的build.gradle中可以使用allprojects和subprojects代码块来分别定义里面的配置是应用于所有项目还是子项目
- 对于子模块的定义是放置在setttings.gradle文件中的

3.3 一致的项目结构

Gradle也沿用了Maven标准的目录结构,在此基础上也同时支持groovy、scala等源代码的构建

3.4一致的构建模型

maven
- 串行的构建周期
gradle
- 在Gradle世界里可以轻松创建一个task，并随时通过depends语法建立与已有task的依赖关系
- Gradle本身直接与项目构建周期是解耦的(Gradle是通过名为java的插件来包含了一个对Java项目的构建周期)

3.5 插件机制

maven
- 基于xml进行配置
gradle
- 更简洁
task dropDB(type: Exec) {
 commandLine ‘curl’,’-s’,’s’,’-x’,’DELETE’,"http://${db.server}:{db.port}/db_name"
}

二. 生命周期

maven有三套相互独立的生命周期,每套生命周期都由一组阶段(Phase)组成,我们平时在命令行输入的命令总会对应于一个特定的阶段【在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行】

1. CleanLifecycle

进行真正的构建之前进行一些清理工作

pre-clean：执行一些需要在clean之前完成的工作
clean：移除所有上一次构建生成的文件
post-clean：执行一些需要在clean之后立刻完成的工作

2. DefaultLifecycle

构建的核心部分：编译/测试/打包/部署(共22个阶段),核心的如下

process-resources：复制并处理资源文件至目标目录，准备打包
compile：编译项目的源代码
process-test-resources：复制并处理测试资源文件至测试目标目录
test：使用合适的单元测试框架运行测试。这些测试应该不需要代码被打包或发布
package：将编译好的代码打包成可分发的格式，如JAR，WAR，或者EAR
install：安装包至本地仓库，以备本地的其它项目作为依赖使用
deploy：复制最终的包至远程仓库，共享给其它开发人员和项目（通常和一次正式的发布相关）

3. SiteLifecycle

生成项目报告/站点/发布站点

pre-site：执行一些需要在生成站点文档之前完成的工作
site：生成项目的站点文档
post-site：执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy：将生成的站点文档部署到特定的服务器上

三. Maven插件

Maven本质上是一个插件框架，它的核心并不执行任何具体的构建任务，所有这些任务都交给插件来完成

1. 分类

主要分为生成过程中执行的构建插件()、网站生成期间执行的报告插件()

2. 核心插件

<plugins>
      <plugin>
             <!-- 编译插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <version>2.3.2</version>
             <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
             </configuration>
      </plugin>
      <plugin>
             <!-- 发布插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-deploy-plugin</artifactId>
             <version>2.5</version>
      </plugin>
      <plugin>
             <!-- 打包插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-jar-plugin</artifactId>
             <version>2.3.1</version>
      </plugin>
      <plugin>
             <!-- 安装插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-install-plugin</artifactId>
             <version>2.3.1</version>
      </plugin>
      <plugin>
             <!-- 单元测试插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <version>2.7.2</version>
             <configuration>
                    <skip>true</skip>
             </configuration>
      </plugin>
      <plugin>
             <!-- 源码插件 -->
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-source-plugin</artifactId>
             <version>2.1</version>
             <!-- 发布时自动将源码同时发布的配置 -->
             <executions>
                <execution>
                       <id>attach-sources</id>
                             <goals>
                                   <goal>jar</goal>
                            </goals>
                      </execution>
                 </executions>
      </plugin>
</plugins>

3. Mybatis插件(逆向工程)

自动生成mapper配置文件以及DAO层接口模板(还需定义generatorConfig.xml配置文件)

<plugin>
   <groupId>org.mybatis.generator</groupId>
   <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.2</version>
    <configuration>
       <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
        <verbose>true</verbose>
        <overwrite>true</overwrite>
    </configuration>
    <executions>
        <execution>
           <id>Generate MyBatis Artifacts</id>
            <goals>
               <goal>generate</goal>
            </goals>
        </execution>
    </executions>
    <dependencies>
        <dependency>
           <groupId>org.mybatis.generator</groupId>
           <artifactId>mybatis-generator-core</artifactId>
           <version>1.3.2</version>
        </dependency>
    </dependencies>
</plugin>

四. Maven命令

1. 命令格式

mvn [plugin-name]:[goal-name]

plugin-name：插件名称
goal-name：动作

命令	含义
mvn –version	显示版本信息
mvn clean	清理项目生产的临时文件,一般是模块下的target目录
mvn compile	编译源代码，一般编译模块下的src/main/java目录
mvn package	项目打包工具,会在模块下的target目录生成jar或war等文件
mvn test	测试命令,或执行src/test/java/下junit的测试用例.
mvn install	将打包的jar/war文件复制到你的本地仓库中,供其他模块使用
mvn deploy	将打包的文件发布到远程参考,提供其他人员进行下载依赖
mvn site	生成项目相关信息的网站
mvn eclipse:eclipse	将项目转化为Eclipse项目
mvn dependency:tree	打印出项目的整个依赖树
mvn archetype:generate	创建Maven的普通java项目
mvn tomcat:run	在tomcat容器中运行web应用
mvn jetty:run	调用 Jetty 插件的 Run 目标在 Jetty Servlet 容器中启动 web 应用

2. 命令参数

-D 传入属性参数

//打包的时候跳过单元测试
mvn package -Dmaven.test.skip=true
//部署项目并跳过单元测试
mvn deploy-Dmaven.test.skip=true

-P 使用指定的Profile配置

项目开发需要有多个环境，一般为开发，测试，预发，正式4个环境
- profiles定义了各个环境的变量id
- filters中定义了变量配置文件的地址
- 地址中的环境变量就是上面profile中定义的值
- resources中是定义哪些目录下的文件会被配置文件中定义的变量替换
//以开发环境配置打包
mvn package -P dev
--------------------------------------------------------------------------------
<profiles>
      <profile>
             <id>dev</id>
             <properties>
                    <env>dev</env>
             </properties>
             <activation>
                    <activeByDefault>true</activeByDefault>
             </activation>
      </profile>
      <profile>
             <id>qa</id>
             <properties>
                    <env>qa</env>
             </properties>
      </profile>
      <profile>
             <id>pre</id>
             <properties>
                    <env>pre</env>
             </properties>
      </profile>
      <profile>
             <id>prod</id>
             <properties>
                    <env>prod</env>
             </properties>
      </profile>
</profiles>
......
<build>
      <filters>
             <filter>config/${env}.properties</filter>
      </filters>
      <resources>
             <resource>
                    <directory>src/main/resources</directory>
                    <filtering>true</filtering>
             </resource>
      </resources>
      ......
</build>

-e 显示maven运行出错的信息
-o 离线执行命令,即不去远程仓库更新包
-X 显示maven允许的debug信息
-U 强制去远程更新snapshot的插件或依赖，默认每天只更新一次

五. Maven仓库

1. 本地仓库

2. 远程仓库

中央仓库

中央仓库是默认的远程仓库，其还有不少镜像仓库

私服
其他公共库

3. 仓库配置

核心两个目的：本地仓库在哪里？？远程仓库在哪里？？

设置镜像

- <mirrors>下面可以配置多个镜像
- <mirrorOf>用于指明是哪个仓库的镜像
- 使用通配符“*”表明该私服是所有仓库的镜像
------------------------------------------------------------------------
<mirrors>
    <mirror>
       <!--该镜像的唯一标识符。id用来区分不同的mirror元素。 -->
       <id>nexus</id>
       <!-- 镜像名，起注解作用，应做到见文知意。可以不配置  -->
       <name>Human Readable Name </name>
       <!--  所有仓库的构件都要从镜像下载  -->
       <mirrorOf>*</mirrorOf>
       <!-- 私服的局域网地址-->
       <url>http://192.168.0.1:8081/nexus/content/groups/public/</url>
    </mirror>
</mirrors>

设置远程仓库

远程仓库的设置是在<profile>节点下面
------------------------------------------------------------------------
<repositories>
<repository>
   <!--仓库唯一标识 -->
  <id>repoId </id>
   <!--远程仓库名称  -->
  <name>repoName</name>
<!--远程仓库URL，如果该仓库配置了镜像，这里的URL就没有意义了，因为任何下载请求都会交由镜像仓库处理，前提是镜像（也就是设置好的私服）需要确保该远程仓库里的任何构件都能通过它下载到  -->
  <url>http://……</url>
   <!--如何处理远程仓库里发布版本的下载-->
  <releases>
      <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启-->
    <enabled>false</enabled>
<!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是-->
      <!-- always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）-->
    <updatePolicy>always</updatePolicy>
      <!--当Maven验证构件校验文件失败时该怎么做:-->
      <!--ignore（忽略），fail（失败），或者warn（警告）。 -->
    <checksumPolicy>warn</checksumPolicy>
  </releases>
   <!--如何处理远程仓库里快照版本的下载，与发布版的配置类似 -->
  <snapshots>     
    <enabled/>
    <updatePolicy/>
    <checksumPolicy/>      
  </snapshots>
</repository>    
</repositories>

设置发布权限

- 私服的作用除了可以给全公司的人提供maven构件的下载，还有一个非常重要的功能，就是开发者之间的资源共享
- 在开发过程中，在pom中声明的构件版本一般是快照版

六. setting.xml

1. localRepository

2. servers

3. mirrors

4. profiles

profile是maven的一个重要特性,profile节点包含了激活(activation)，仓库(repositories)，插件仓库(pluginRepositories)和属性(properties)共四个子元素元素

常见激活条件(activation):os、jdk、property、file

七 pom.xml

1. 基础配置

定义项目的基本属性
有时候引用某个jar包，classifier不写的话会报错

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<!-- 模型版本。maven2.0必须是这样写，现在是maven2唯一支持的版本 -->
	<modelVersion>4.0.0</modelVersion>
	<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.winner.trade，maven会将该项目打成的jar包放本地路径：/com/winner/trade -->
	<groupId>com.winner.trade</groupId>
	<!-- 本项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
	<artifactId>trade-core</artifactId>
	<!-- 本项目目前所处的版本号 -->
	<version>1.0.0-SNAPSHOT</version>
	<!-- 打包的机制，如pom,jar, maven-plugin, ejb, war, ear, rar, par，默认为jar -->
	<packaging>jar</packaging>
	<!-- 帮助定义构件输出的一些附属构件,附属构件与主构件对应，有时候需要加上classifier才能唯一的确定该构件 不能直接定义项目的classifer,因为附属构件不是项目直接默认生成的，而是由附加的插件帮助生成的 -->
	<classifier>...</classifier>
	<!-- 定义本项目的依赖关系 -->
	<dependencies>
		<!-- 每个dependency都对应这一个jar包 -->
		<dependency>
			<!--一般情况下，maven是通过groupId、artifactId、version这三个元素值（俗称坐标）来检索该构件， 然后引入你的工程。如果别人想引用你现在开发的这个项目（前提是已开发完毕并发布到了远程仓库），--> 
			<!--就需要在他的pom文件中新建一个dependency节点，将本项目的groupId、artifactId、version写入， maven就会把你上传的jar包下载到他的本地 -->
			<groupId>com.winner.trade</groupId>
			<artifactId>trade-test</artifactId>
			<version>1.0.0-SNAPSHOT</version>
			<!-- maven认为，程序对外部的依赖会随着程序的所处阶段和应用场景而变化，所以maven中的依赖关系有作用域(scope)的限制。 -->
			<!--scope包含如下的取值：compile（编译范围）、provided（已提供范围）、runtime（运行时范围）、test（测试范围）、system（系统范围） -->
			<scope>test</scope>
			<!-- 设置指依赖是否可选，默认为false,即子项目默认都继承:为true,则子项目必需显示的引入，与dependencyManagement里定义的依赖类似  -->
			<optional>false</optional>
			<!-- 屏蔽依赖关系。 比如项目中使用的libA依赖某个库的1.0版，libB依赖某个库的2.0版，现在想统一使用2.0版，就应该屏蔽掉对1.0版的依赖 -->
			<exclusions>
				<exclusion>
					<groupId>org.slf4j</groupId>
					<artifactId>slf4j-api</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>
	<!-- 为pom定义一些常量，在pom中的其它地方可以直接引用 使用方式 如下 ：${file.encoding} -->
	<properties>
		<file.encoding>UTF-8</file.encoding>
		<java.source.version>1.5</java.source.version>
		<java.target.version>1.5</java.target.version>
	</properties>
	...
</project>

2. 构建配置

pom里面的仓库与setting.xml里的仓库功能是一样的,主要的区别在于-pom里的仓库是个性化的

<build>
	<!-- 产生的构件的文件名，默认值是${artifactId}-${version}。 -->
	<finalName>myPorjectName</finalName>
	<!-- 构建产生的所有文件存放的目录,默认为${basedir}/target，即项目根目录下的target -->
	<directory>${basedir}/target</directory>
	<!--当项目没有规定目标（Maven2叫做阶段（phase））时的默认值， -->
	<!--必须跟命令行上的参数相同例如jar:jar，或者与某个阶段（phase）相同例如install、compile等 -->
	<defaultGoal>install</defaultGoal>
	<!--当filtering开关打开时，使用到的过滤器属性文件列表。 -->
	<!--项目配置信息中诸如${spring.version}之类的占位符会被属性文件中的实际值替换掉 -->
	<filters>
		<filter>../filter.properties</filter>
	</filters>
	<!--项目相关的所有资源路径列表，例如和项目相关的配置文件、属性文件，这些资源被包含在最终的打包文件里。 -->
	<resources>
		<resource>
			<!--描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。 -->
			<!--举个例子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven/messages。 -->
			<!--然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。 -->
			<targetPath>resources</targetPath>
			<!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。 -->
			<filtering>true</filtering>
			<!--描述存放资源的目录，该路径相对POM路径 -->
			<directory>src/main/resources</directory>
			<!--包含的模式列表 -->
			<includes>
				<include>**/*.properties</include>
				<include>**/*.xml</include>
			</includes>
			<!--排除的模式列表 如果<include>与<exclude>划定的范围存在冲突，以<exclude>为准 -->
			<excludes>
				<exclude>jdbc.properties</exclude>
			</excludes>
		</resource>
	</resources>
	<!--单元测试相关的所有资源路径，配制方法与resources类似 -->
	<testResources>
		<testResource>
			<targetPath />
			<filtering />
			<directory />
			<includes />
			<excludes />
		</testResource>
	</testResources>
	<!--项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
	<sourceDirectory>${basedir}\src\main\java</sourceDirectory>
	<!--项目脚本源码目录，该目录和源码目录不同， <!-- 绝大多数情况下，该目录下的内容会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。 -->
	<scriptSourceDirectory>${basedir}\src\main\scripts
	</scriptSourceDirectory>
 	<!--项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
	<testSourceDirectory>${basedir}\src\test\java</testSourceDirectory>
	<!--被编译过的应用程序class文件存放的目录。 -->
	<outputDirectory>${basedir}\target\classes</outputDirectory>
	<!--被编译过的测试class文件存放的目录。 -->
	<testOutputDirectory>${basedir}\target\test-classes
	</testOutputDirectory>
	<!--项目的一系列构建扩展,它们是一系列build过程中要使用的产品，会包含在running bulid‘s classpath里面。 -->
	<!--他们可以开启extensions，也可以通过提供条件来激活plugins。 -->
	<!--简单来讲，extensions是在build过程被激活的产品 -->
	<extensions>
		<!--例如，通常情况下，程序开发完成后部署到线上Linux服务器，可能需要经历打包、 -->
		<!--将包文件传到服务器、SSH连上服务器、敲命令启动程序等一系列繁琐的步骤。 -->
		<!--实际上这些步骤都可以通过Maven的一个插件 wagon-maven-plugin 来自动完成 -->
		<!--下面的扩展插件wagon-ssh用于通过SSH的方式连接远程服务器， -->
		<!--类似的还有支持ftp方式的wagon-ftp插件 -->
		<extension>
			<groupId>org.apache.maven.wagon</groupId>
			<artifactId>wagon-ssh</artifactId>
			<version>2.8</version>
		</extension>
	</extensions>
	<!--使用的插件列表 。 -->
	<plugins>
		<plugin>
			<groupId></groupId>
			<artifactId>maven-assembly-plugin</artifactId>
			<version>2.5.5</version>
			<!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->
			<executions>
				<execution>
 				<!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 -->
					<id>assembly</id>
 				<!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 -->
					<phase>package</phase>
					<!--配置的执行目标 -->
					<goals>
						<goal>single</goal>
					</goals>
					<!--配置是否被传播到子POM -->
					<inherited>false</inherited>
				</execution>
			</executions>
			<!--作为DOM对象的配置,配置项因插件而异 -->
			<configuration>
				<finalName>${finalName}</finalName>
				<appendAssemblyId>false</appendAssemblyId>
				<descriptor>assembly.xml</descriptor>
			</configuration>
			<!--是否从该插件下载Maven扩展（例如打包和类型处理器）， -->
			<!--由于性能原因，只有在真需要下载时，该元素才被设置成true。 -->
			<extensions>false</extensions>
			<!--项目引入插件所需要的额外依赖 -->
			<dependencies>
				<dependency>...</dependency>
			</dependencies>
			<!--任何配置是否被传播到子项目 -->
			<inherited>true</inherited>
		</plugin>
	</plugins>
	<!--主要定义插件的共同元素、扩展元素集合，类似于dependencyManagement， -->
	<!--所有继承于此项目的子项目都能使用。该插件配置项直到被引用时才会被解析或绑定到生命周期。 -->
	<!--给定插件的任何本地配置都会覆盖这里的配置 -->
	<pluginManagement>
		<plugins>...</plugins>
	</pluginManagement>
</build>

3. 分发配置

<!--项目分发信息，在执行mvn deploy后表示要发布的位置。 -->
<!--有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。 -->
<distributionManagement>
	<!--部署项目产生的构件到远程仓库需要的信息 -->
	<repository>
		<!--是分配给快照一个唯一的版本号（由时间戳和构建流水号），还是每次都使用相同的版本号 -->
		<!--参见repositories/repository元素 -->
		<uniqueVersion>true</uniqueVersion>
		<id> repo-id </id>
		<name> repo-name</name>
		<url>file://${basedir}/target/deploy </url>
		<layout />
	</repository>
	<!--构件的快照部署到哪里,如果没有配置该元素，默认部署到repository元素配置的仓库 -->
	<snapshotRepository>
		<uniqueVersion />
		<id />
		<name />
		<url />
		<layout />
	</snapshotRepository>
	<!--部署项目的网站需要的信息 -->
	<site>
		<!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 -->
		<id> site-id </id>
		<!--部署位置的名称 -->
		<name> site-name</name>
		<!--部署位置的URL，按protocol://hostname/path形式 -->
		<url>scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web </url>
	</site>
	<!--项目下载页面的URL。如果没有该元素，用户应该参考主页。 -->
	<!--使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。 -->
	<downloadUrl />
	<!--如果构件有了新的groupID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。 -->
	<relocation>
		<!--构件新的group ID -->
		<groupId />
		<!--构件新的artifact ID -->
		<artifactId />
		<!--构件新的版本号 -->
		<version />
		<!--显示给用户的，关于移动的额外信息，例如原因。 -->
		<message />
	</relocation>
	<!--给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。 -->
	<!--有效的值有：none（默认），converted（仓库管理员从Maven 1 POM转换过来）， -->
	<!--partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部署），verified（被核实时正确的和最终的）。 -->
	<status />
</distributionManagement>

4. 仓库配置

<!--发现依赖和扩展的远程仓库列表。 -->
<repositories>
	<!--包含需要连接到远程仓库的信息 -->
	<repository>
		<!--如何处理远程仓库里发布版本的下载 -->
		<releases>
			<!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 -->
			<enabled />
			<!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。 -->
			<!--这里的选项是：always（一直），daily（默认，每日）， -->
			<!--interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
			<updatePolicy />
			<!--当Maven验证构件校验文件失败时该怎么做： -->
			<!--ignore（忽略），fail（失败），或者warn（警告）。 -->
			<checksumPolicy />
		</releases>
		<!--如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置， -->
		<!--POM就可以在每个单独的仓库中，为每种类型的构件采取不同的策略。 -->
		<!--例如，可能有人会决定只为开发目的开启对快照版本下载的支持 -->
		<snapshots>
			<enabled />
			<updatePolicy />
			<checksumPolicy />
		</snapshots>
		<!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 -->
		<id> repo-id </id>
		<!--远程仓库名称 -->
		<name> repo-name</name>
		<!--远程仓库URL，按protocol://hostname/path形式 -->
		<url>http://192.168.1.169:9999/repository/ </url>
		<!--用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。 -->
		<!--Maven 2为其仓库提供了一个默认的布局； -->
		<!--然而，Maven1.x有一种不同的布局。 -->
		<!--我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。 -->
		<layout> default</layout>
	</repository>
</repositories>
<!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
<pluginRepositories>
	<!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->
	<pluginRepository />
</pluginRepositories>

5. profile配置

<!--在列的项目构建profile，如果被激活，会修改构建处理 -->
<profiles>
	<!--根据环境参数或命令行参数激活某个构建处理 -->
	<profile>
		<!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。 -->
		<activation>
			<!--profile默认是否激活的标识 -->
			<activeByDefault>false</activeByDefault>
			<!--activation有一个内建的java版本检测，如果检测到jdk版本与期待的一样，profile被激活。 -->
			<jdk>1.7</jdk>
			<!--当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。 -->
			<os>
				<!--激活profile的操作系统的名字 -->
				<name>Windows XP</name>
				<!--激活profile的操作系统所属家族(如 'windows') -->
				<family>Windows</family>
				<!--激活profile的操作系统体系结构 -->
				<arch>x86</arch>
				<!--激活profile的操作系统版本 -->
				<version>5.1.2600</version>
			</os>
			<!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。 -->
			<!-- 如果值字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 -->
			<property>
				<!--激活profile的属性的名称 -->
				<name>mavenVersion</name>
				<!--激活profile的属性的值 -->
				<value>2.0.3</value>
			</property>
			<!--提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活profile。 -->
			<!--另一方面，exists则会检查文件是否存在，如果存在则激活profile。 -->
			<file>
				<!--如果指定的文件存在，则激活profile。 -->
				<exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>
				<!--如果指定的文件不存在，则激活profile。 -->
				<missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>
 
			</file>
		</activation>
		<id />
		<build />
		<modules />
		<repositories />
		<pluginRepositories />
		<dependencies />
		<reporting />
		<dependencyManagement />
		<distributionManagement />
		<properties />
	</profile>

6. 报表配置

<!--描述使用报表插件产生报表的规范,特定的maven 插件能输出相应的定制和配置报表. -->
<!--当用户执行“mvn site”，这些报表就会运行,在页面导航栏能看到所有报表的链接。 -->
<reporting>
	<!--true，则网站不包括默认的报表。这包括“项目信息”菜单中的报表。 -->
	<excludeDefaults />
	<!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->
	<outputDirectory />
	<!--使用的报表插件和他们的配置。 -->
	<plugins>
		<plugin>
			<groupId />
			<artifactId />
			<version />
			<inherited />
			<configuration>
				<links>
					<link>http://java.sun.com/j2se/1.5.0/docs/api/</link>
				</links>
			</configuration>
			<!--一组报表的多重规范，每个规范可能有不同的配置。 -->
			<!--一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。 -->
			<!--1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标 -->
			<reportSets>
 
				<!--表示报表的一个集合，以及产生该集合的配置 -->
				<reportSet>
					<!--报表集合的唯一标识符，POM继承时用到 -->
					<id>sunlink</id>
					<!--产生报表集合时，被使用的报表的配置 -->
					<configuration />
					<!--配置是否被继承到子POMs -->
					<inherited /
					<!--这个集合里使用到哪些报表 -->
					<reports>
						<report>javadoc</report>
					</reports>
				</reportSet>
			</reportSets>
		</plugin>
	</plugins>
</reporting>

7. 环境配置

<!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira -->
<issueManagement>
	<!--问题管理系统（例如jira）的名字， -->
	<system> jira </system>
	<!--该项目使用的问题管理系统的URL -->
	<url> http://jira.clf.com/</url>
</issueManagement>
<!--项目持续集成信息 -->
<ciManagement>
	<!--持续集成系统的名字，例如continuum -->
	<system />
	<!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->
	<url />
	<!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->
	<notifiers>
		<!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->
		<notifier>
			<!--传送通知的途径 -->
			<type />
			<!--发生错误时是否通知 -->
			<sendOnError />
			<!--构建失败时是否通知 -->
			<sendOnFailure />
			<!--构建成功时是否通知 -->
			<sendOnSuccess />
			<!--发生警告时是否通知 -->
			<sendOnWarning />
			<!--不赞成使用。通知发送到哪里 -->
			<address />
			<!--扩展配置项 -->
			<configuration />
		</notifier>
	</notifiers>
 
</ciManagement>

8. 项目信息配置

<!--项目的名称, Maven产生的文档用 -->
<name>banseon-maven </name>
<!--项目主页的URL, Maven产生的文档用 -->
<url>http://www.clf.com/ </url>
<!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时 -->
<!--（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签），不鼓励使用纯文本描述。 -->
<!-- 如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->
<description>A maven project to study maven. </description>
<!--描述了这个项目构建环境中的前提条件。 -->
<prerequisites>
	<!--构建该项目或使用该插件所需要的Maven的最低版本 -->
	<maven />
</prerequisites>
<!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
<inceptionYear />
<!--项目相关邮件列表信息 -->
<mailingLists>
	<!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->
	<mailingList>
		<!--邮件的名称 -->
		<name> Demo </name>
		<!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
		<post> clf@126.com</post>
		<!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
		<subscribe> clf@126.com</subscribe>
		<!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
		<unsubscribe> clf@126.com</unsubscribe>
		<!--你可以浏览邮件信息的URL -->
		<archive> http:/hi.clf.com/</archive>
	</mailingList>
</mailingLists>
<!--项目开发者列表 -->
<developers>
	<!--某个项目开发者的信息 -->
	<developer>
		<!--SCM里项目开发者的唯一标识符 -->
		<id> HELLO WORLD </id>
		<!--项目开发者的全名 -->
		<name> banseon </name>
		<!--项目开发者的email -->
		<email> banseon@126.com</email>
		<!--项目开发者的主页的URL -->
		<url />
		<!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
		<roles>
			<role> Project Manager</role>
			<role>Architect </role>
		</roles>
		<!--项目开发者所属组织 -->
		<organization> demo</organization>
		<!--项目开发者所属组织的URL -->
		<organizationUrl>http://hi.clf.com/ </organizationUrl>
		<!--项目开发者属性，如即时消息如何处理等 -->
		<properties>
			<dept> No </dept>
		</properties>
		<!--项目开发者所在时区， -11到12范围内的整数。 -->
		<timezone> -5</timezone>
	</developer>
</developers>
 
<!--项目的其他贡献者列表 -->
<contributors>
	<!--项目的其他贡献者。参见developers/developer元素 -->
	<contributor>
		<name />
		<email />
		<url />
		<organization />
		<organizationUrl />
		<roles />
		<timezone />
		<properties />
	</contributor>
</contributors>
<!--该元素描述了项目所有License列表。应该只列出该项目的license列表，不要列出依赖项目的license列表。 -->
<!--如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->
<licenses>
	<!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->
	<license>
		<!--license用于法律上的名称 -->
		<name> Apache 2 </name>
		<!--官方的license正文页面的URL -->
		<url>http://www.clf.com/LICENSE-2.0.txt </url>
		<!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->
		<distribution> repo</distribution>
		<!--关于license的补充信息 -->
		<comments> Abusiness-friendly OSS license </comments>
	</license>
</licenses>
<!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。 -->
<scm>
	<!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。 -->
	<connection>scm:svn:http://svn.baidu.com/banseon/maven/</connection>
	<!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->
	<developerConnection>scm:svn:http://svn.baidu.com/banseon/maven/
	</developerConnection>
	<!--当前代码的标签，在开发阶段默认为HEAD -->
	<tag />
	<!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->
	<url> http://svn.baidu.com/banseon</url>
</scm>
<!--描述项目所属组织的各种属性。Maven产生的文档用 -->
<organization>
	<!--组织的全名 -->
	<name> demo </name>
	<!--组织主页的URL -->
	<url> http://www.clf.com/</url>
</organization>

八约定优于配置

1. 文件目录

2. 版本规范

一般定义： ..-

SNAPSHOT：开发中的版本
LATEST：某个特定构件的最新发布版
RELEASE：最后一个发布版

3. Maven变量

除了在setting.xml以及pom.xml当中用properties定义的常量，maven还提供了一些隐式的变量，用来访问系统环境变量

类别	例子header 2
内置属性	${basedir}表示项目根目录,即包含pom.xml文件的目录</br>$ {basedir}表示项目根目录,即包含pom.xml文件的目录 ${version}表示项目版本</br>$ {project.basedir}同 ${basedir}</br>$ {project.baseUri}表示项目文件地址${maven.build.timestamp}表示项目构件开始时间
setting属性	${settings.localRepository }表示本地仓库路径
POM属性	${project.build.directory}表示主源码路径</br>$ {project.build.sourceEncoding}表示主源码的编码格式 ${project.build.sourceDirectory}表示主源码路径</br>$ {project.build.finalName}表示输出文件名称 ${project.version}表示项目版本,与$ {version}相同
Java系统属性	${user.home}表示用户目录</br>$ {java.version}表示Java版本
环境变量属性	${env.JAVA_HOME}表示JAVA_HOME环境变量的值</br>$ {env.HOME }表示用户目录
上级工程变量	上级工程的pom中的变量用前缀 ${project.parent} 引用，上级工程的版本也可以这样引用$ {parent.version }

九. 依赖关系

项目的依赖关系主要分为三种：依赖，继承，聚合

1. 依赖

<dependency>    
    <!--坐标-->
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.11</version>
   <!--作用域：
        - compile(默认)：编译时
        - provided：已提供范围
        - runtime：运行时
        - test：测试时
        - system：系统范围
   -->
   <scope>test</scope>
   <!--默认为jar，为pom时表示引用-->
   <type >jar</ type >
   <optional >true</optional>
 </dependency>

2. 继承

父项目的必须为pom
顶层父类用管理统一版本号，声明依赖，但是并不实际引入，子项目中还需要显式地引入依赖，并且不指定版本(若子项目中指定版本，则会使用指定的版本)

<project>  
	  <modelVersion>4.0.0</modelVersion>  
	  <groupId>org.clf.parent.son</groupId>  
	  <artifactId>my-son</artifactId>  
	  <version>1.0</version> 
	  <!-- 声明将父项目的坐标 -->
	  <parent>
		  <groupId>org.clf.parent</groupId>  
		  <artifactId>my-parent</artifactId>  
		  <version>2.0</version>  
		  <!-- 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。 -->
		  <!--	默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom， -->
		  <!--	其次在文件系统的这个位置（relativePath位置）， -->
		  <!--	然后在本地仓库，最后在远程仓库寻找父项目的pom。 -->
		  <relativePath>../parent-project/pom.xml</relativePath>
	  </parent> 
	  
	  <!-- 声明父项目dependencyManagement的依赖，不用写版本号 -->
	  <dependencies>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-web</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-beans</artifactId>
          </dependency>
      </dependencies>
	   
</project>

3. 聚合

maven要求同一个工程的所有模块都放置到同一个目录下，每一个子目录代表一个模块

总项目的配置

<project> 
   <modelVersion>4.0.0</modelVersion> 
   <groupId>org.clf.parent</groupId> 
   <artifactId>my-parent</artifactId> 
   <version>2.0</version> 
   <!-- 打包类型必须为pom -->
   <packaging>pom</packaging>
   <!-- 声明了该项目的直接子模块 -->
   <modules>
       <!-- 这里配置的不是artifactId，而是这个模块的目录名称-->
        <module>module-1</module>
        <module>module-2</module>
        <module>module-3</module>
   </modules>
   <!-- 聚合也属于父子关系，总项目中的dependencies与dependencyManagement、pluginManagement用法与继承关系类似 -->
   <dependencies>
    ......
   </dependencies>
   <dependencyManagement>
    ......
   </dependencyManagement>
   <pluginManagement> 
   ......
   </pluginManagement>
</project>

子模块的配置

<project> 
   <modelVersion>4.0.0</modelVersion> 
   <groupId>org.clf.parent.son</groupId> 
   <artifactId>my-son</artifactId> 
   <version>1.0</version>
   <!-- 声明将父项目的坐标 -->
   <parent>
          <groupId>org.clf.parent</groupId> 
          <artifactId>my-parent</artifactId> 
          <version>2.0</version> 
   </parent>
</project>

4. 继承VS聚合

在实际项目中，一个 POM往往既是聚合POM，又是父 POM，它继承了某个项目，本身包含几个子模块，同时肯定会存在普通的依赖关系，就是说，依赖、继承、聚合这三种关系是并存的

相同点：都是父子关系、父pom的packaging都必须是pom
不同点:聚合模块知道有哪些被聚合模块，反之不行；子模块知道父模块，反正不行

Maven可继承的POM 元素列表如下：
- groupId ：项目组 ID ，项目坐标的核心元素；
- version ：项目版本，项目坐标的核心元素；
- description ：项目的描述信息；
- organization ：项目的组织信息；
- inceptionYear ：项目的创始年份；
- url ：项目的 url 地址
- develoers ：项目的开发者信息；
- contributors ：项目的贡献者信息；
- distributionManagerment：项目的部署信息；
- issueManagement ：缺陷跟踪系统信息；
- ciManagement ：项目的持续继承信息；
- scm ：项目的版本控制信息；
- mailingListserv ：项目的邮件列表信息；
- properties ：自定义的 Maven 属性；
- dependencies ：项目的依赖配置；
- dependencyManagement：醒目的依赖管理配置；
- repositories ：项目的仓库配置；
- build ：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等；
- reporting ：包括项目的报告输出目录配置、报告插件配置等。