maven实战笔记_maven configuration includes-CSDN博客

maven实战笔记

1. What is maven?
2. 配置文件
3. 入门
4. Archetype
5. 坐标
6. 依赖
- 依赖解调
- 依赖排除
- 依赖归类
- 依赖优化
7. maven仓库
- 在pom中配置远程仓库
- 远程仓库认证
- 部署到远程仓库
8. 镜像
9. 生命周期
- 三套周期
10. 插件
- 插件目标
- 插件配置
- 插件的仓库
- 解析插件版本
11. 聚合与继承
- 聚合
- 继承
- 可继承的pom元素
- dependencyManagement
- 插件管理 pluginManagement 类似
- 约定优于配置
- reactor反应堆
12. maven测试
- 跳过测试
- 指定某个测试
- 包含与排除
- 测试覆盖率报告
- 重用测试代码
13. maven构建web项目
- jetty-maven-plugin
- Cargo自动化部署
14. 版本管理和版本控制
- 管理
- 标签
- maven RELEASE plugin
- GPG GunPG是pretty good privacy PGP标准的一个实现
- maven gpg plugin
15. 灵活构建：属性、profile、资源过滤
- 属性
- 构建环境的差异
- profile的激活方式
- web资源过滤
16. 生成项目站点
17. maven-archetype-plugin
- 生成本地仓库的catalog
- 编写archetype
18. 编写maven插件
- Mojo标注
- Mojo参数
- 插件的集成测试maven-invoker-plugin

1. What is maven?

Maven主要服务于基于java平台的项目构建、依赖管理和项目信息管理。
最大化消除了构建的重复，抽象了构建生命周期
大量成熟插件

2. 配置文件

<proxy>
        <id>proxy</id>
        <active>true</active>
        <protocol>http</protocol>
        <username></username>
        <password></password>
        <host>proxy.zte.com.cn</host>
        <port>80</port>
        <nonProxyHosts>proxy.zte.com.cn:80|192.168.*.*|*.zte.com.cn|10.*.*.*|*.*.zte.intra</nonProxyHosts>
        //哪些主机名不需要代理
  </proxy>

<modelVersion>4.0.0</modelVersion> 指定了当前POM模型的版本

3. 入门

scope : test，默认compile
mvn clean compile
mvn clean test

插件配置：
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

如果没有指定打包类型，默认为jar，mvn clean package
其他maven项目如果需要直接引用的话，还需要install，将项目输出的jar安装到本地仓库 mvn clean install
默认打包生成的jar是不能直接运行的，带有main方法的类信息不会加载到manifest中，生成可执行jar需要借助

        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-shade-plugin</artifactId>  
            <version>1.4</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <filters>  
                            <filter>  
                                <artifact>*:*</artifact>  
                                <excludes>  
                                    <exclude>META-INF/*.SF</exclude>  
                                    <exclude>META-INF/*.DSA</exclude>  
                                    <exclude>META-INF/*.RSA</exclude>  
                                </excludes>  
                            </filter>  
                        </filters>  
                        <transformers>  
                            <transformer  
                                implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.lcifn.Application</mainClass>  
                            </transformer>  
                            <transformer  
                                implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.handlers</resource>  
                            </transformer>  
                            <transformer  
                                implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.schemas</resource>  
                            </transformer>  
                        </transformers>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>

4. Archetype

骨架：基本的目录结构和pom的文件内容
mvn archetype:generate
完全可以自己开发骨架

5. 坐标

为各种构件引入了秩序，groupId artifactId version packaging classifier(不能直接指定)

6. 依赖

依赖范围控制与三种classpath（编译、测试、运行的classpath）的关系

compile: 对三种都有效，默认（spring-core)
test：测试classpath（junit）
provided：编译和测试（servlet-core）
runtime：测试和运行（JDBC，编译时只需要接口，运行才要实现）
system：关系与provided一致，一定要指定systemPath，不是通过maven仓库解析的，谨慎使用，可引用环境变量（${java.home}）
import: 不会对三种classpath产生实际影响

依赖范围也影响依赖的传递性：

	compile	test	provided	runtime
compile	compile	-	-	runtime
test	test	-	-	test
provided	provided	-	provided	provided
runtime	runtime	-	-	runtime

依赖解调

两个版本：路径最近优先
路径一样，第一声明者优先
可选依赖：<optional>标签，依赖不会被传递

依赖排除

利用<exclusions> <exclusion>

依赖归类

有些依赖来自同一项目的不同模块，版本会一起升级，应该在一个唯一的地方定义版本。如：

<properties>
  <springframework.version>2.5.6</springframework>
</properties>
引用 ${springframework.version}

依赖优化

查看已解析依赖：mvn dependency:list``````mvn dependecny:tree
还有mvn dependency:analyse分析当前项目依赖

7. maven仓库

实际的项目不再各自存储依赖文件，统一位置是仓库，需要的时候maven会根据坐标找到并使用
仓库的路径：groupId/artifactId/version/artifactId-version-classifier.packaging

本地仓库
中央仓库
私服（私服软件：如Nexus）
其他公共库

在pom中配置远程仓库

<repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <enabled>false</enabled>
      </releases>
      <layout>default</layout> 表示是maven2或3的默认布局
    </repository>
  </repositories>``

<snapshots>
  <enabled>true</enabled>
  <updatePolicy>daily</updatePolicy> daily/never/always/interval:分钟
  <checksumPolicy>ignore</checksumPolicy>
</snapshots>

默认值是daily mvn clean install -U 强制下载最新快照

checksumPolicy：构建部署到仓库时会同时部署校验和文件，下载构建会验证校验和文件，如果失败？warn/fail/ignore

远程仓库认证

在settings文件中的’’’ ‘’'中配置用户名密码，其中的id必须和pom中仓库id对上

部署到远程仓库

<!-- 在POM中配置构件部署地址 -->
    <distributionManagement>
        <!-- 发布版本的构件的仓库 -->
        <repository>
            <id>proj-release</id>
            <name>proj release repository</name>
            <url>http://192.168.1.100/content/repositories/proj-release</url>
        </repository>
        <!-- 快照版本的仓库-->
        <snapshotRepository>
            <id>proj-snapshots</id>
            <name>proj snapshot repository</name>
            <url>http://192.168.1.100/content/repositories/proj-snapshots</url>
        </snapshotRepository>
    </distributionManagement>

如果不指定插件的版本，maven以RELEASE策略，自动解析最新的发布版本构建(不是快照)

8. 镜像

仓库X可以提供仓库Y的所有存储内容，认为X是Y的一个镜像，在settings中可以使用镜像代替中央仓库

<mirrors>
     <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/mvn/view</url>
        <mirrorOf>central</mirrorOf>
    </mirror>
    <mirror>
        <id>jboss-public-repository-group</id>
        <mirrorOf>central</mirrorOf>
        <name>JBoss Public Repository Group</name>
        <url>http://repository.jboss.org/nexus/content/groups/public</url>
    </mirror>
</mirrors>

mirrorOf：

*所有远程仓库
external:* 所有远程，localhost除外，使用file://协议除外
repo1，repo2 仓库repo1,repo2
*，！repo1repo1除外

镜像需要权限也在<server>配置

在settings.xml中配置远程仓库
<settings>  
  ...  
  <profiles>  
    <profile>  
      <id>dev</id>  
      <!-- repositories and pluginRepositories here-->   把上面的内容粘贴到这里。。。
    </profile>  
  </profiles>  
  <activeProfiles>  
    <activeProfile>dev</activeProfile>  
  </activeProfiles>  
  ...  
</settings>  
这里我们定义一个id为dev的profile，将所有repositories以及pluginRepositories元素放到这个profile中，然后，使用<activeProfiles>元素自动激活该profile。这样，你就不用再为每个POM重复配置仓库。

使用profile为settings.xml添加仓库提供了一种用户全局范围的仓库配置。

9. 生命周期

生命周期抽象了构建的各个步骤，定义了次序，没提供具体实现。谁实现？插件
maven提供了默认插件简化和稳定构建，用户可通过配置现有插件或自己编写插件自定义构建行为。

三套周期

clean周期： 后一个步骤会顺序执行前面所有步骤

pre-clean: clean之前要完成的工作
clean ：清理上一次构建生成的文件
post-clean：clean之后要完成的工作

default周期：

验证（validate）验证项目是正确的，所有必要的信息可用。
初始化（initialize）初始化构建状态，例如设置属性或创建目录。
产生来源（generate-sources）生成包含在编译中的任何源代码。
流程源（process-sources）处理源代码，例如过滤任何值。
生成资源（generate-resources）生成包含在包中的资源。
流程资源（process-resources）将资源复制并处理到目标目录中，准备打包。
编译（compile）编译项目的源代码。
工艺类（process-classes）从编译后处理生成的文件，例如对Java类进行字节码增强。
生成测试来源（generate-test-sources）生成包含在编译中的任何测试源代码。
流程测试来源（process-test-sources）处理测试源代码，例如过滤任何值。
生成测试资源（generate-test-resources）创建测试资源。
流程测试资源（process-test-resources）将资源复制并处理到测试目标目录中。
测试编译（test-compile）将测试源代码编译到测试目标目录中
流程检验类（process-test-classes）从测试编译中处理生成的文件，例如对Java类进行字节码增强。对于Maven 2.0.5及以上版本。
测试（test）使用合适的单元测试框架运行测试。这些测试不应该要求代码被打包或部署。
制备包（prepare-package）在实际包装之前，执行必要的准备包装的操作。这通常会导致打包的处理版本的包。（Maven 2.1及以上）
打包（package）采取编译的代码，并以其可分发的格式（如JAR）进行打包。
预集成测试（pre-integration-test）在执行集成测试之前执行所需的操作。这可能涉及诸如设置所需环境等。
集成测试（integration-test）如果需要，可以将该包过程并部署到可以运行集成测试的环境中。
整合后的测试（post-integration-test）执行集成测试后执行所需的操作。这可能包括清理环境。
校验（verify）运行任何检查以验证包装是否有效并符合质量标准。
安装（install）将软件包安装到本地存储库中，以作为本地其他项目的依赖关系。
部署（deploy）在集成或发布环境中完成，将最终软件包复制到远程存储库，以与其他开发人员和项目共享。

site周期： 处理你的项目站点文档的创建。

预网站（pre-site）在实际的项目现场生成之前执行所需的进程
网站（site）生成项目的站点文档
后网站（post-site）执行完成站点生成所需的进程，并准备站点部署
网站部署（site-deploy）将生成的站点文档部署到指定的Web服务器

10. 插件

插件目标

一个插件会聚合多种功能，每个功能就是一个目标

dependency: analyze、dependency:tree、dependency:list
compiler:compile、surefire:test

生命周期绑定了插件目标。
多个目标绑到一个阶段，按照插件声明的先后顺序决定执行顺序

插件配置

从命令行配置插件：如 mvn install -Dmaven.test.skip = true
pom中配置插件：

<build>  
      <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-compiler-plugin</artifactId>  
            <version>2.3.2</version>  
            <configuration>  
                <source>1.6</source>  
                <target>1.6</target>  
            </configuration>  
        </plugin>  
      </plugins>  
    </build>

　<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1.1</version>
    <configuration>
      <webResources>
        <resource>
          <directory>src/main/webapp</directory>
          <excludes>
            <exclude>**/*.jpg</exclude>
          </excludes>
        </resource>
      </webResources>
    </configuration>
  </plugin>

任务配置：

<plugin>
67             <groupId>org.apache.maven.plugins</groupId>
68             <artifactId>maven-clean-plugin</artifactId>
69             <version>${plugin.version}</version>
70             <executions>
71                 <execution>
72                     <id>auto-clean</id>
73                     <!-- clean生命周期clean阶段 -->
74                     <phase>clean</phase>
75                     <goals>
76                         <!-- 执行clean插件的clean目标 -->
77                         <goal>clean</goal>
78                     </goals>
79                 </execution>
80             </executions>
81         </plugin>

从命令行调用插件，因为有些插件不适合绑定在生命周期

插件的仓库

插件的远程仓库用<pluginRepository>配置
在pom中配置插件时，如果是maven官方插件，可省略groupId

解析插件版本

maven在超级pom中为所有核心插件指定了版本，如果不属于核心插件，会检查仓库中可用版本，maven3默认的是RELEASE
可以在settings中配置<pluginGroups>这样除了扫描org.apahce.maven.plugins和org.codehaus.mojo外，还会扫描配置的

11. 聚合与继承

聚合

maven聚合特性：把多模块聚合在一起构建；继承：抽取模块相同的依赖和配置，统一管理。

额外的tip：测试用例测试接口而不是实现，测试代码不能引入实现类

父类结构：多模块的maven项目，必须有一个额外的模块来聚合所有的模块，packaging为pom，否则无法构建；<modules>实现模块的聚合，每一个值是一个当前pom的相对目录。一般与artifactId一致（模块存放的目录）
平行结构： pom需要改动 <module>../account-email</module>

继承

创建parent模块，packaging还是为pom，继承的时候子模块用<parent>来继承

<relativePath>默认是../pom.xml，默认父pom在上一层目录
<relativePath>../account-parent/pom/xml表示在与子模块平行的parent目录下

maven会根据relativePath查找父模块，没找到会到本地仓库找

可继承的pom元素

子模块会默认继承父的groupId和version，一样的话就不需要再配置了
description ：项目的描述信息；
organization ：项目的组织信息；
inceptionYear ：项目的创始年份；
url ：项目的 url 地址
develoers ：项目的开发者信息；
contributors ：项目的贡献者信息；
distributionManagerment ：项目的部署信息；
issueManagement ：缺陷跟踪系统信息；
ciManagement ：项目的持续继承信息；
scm ：项目的版本控制信息；
mailingListserv ：项目的邮件列表信息；
properties ：自定义的 Maven 属性；
dependencies ：项目的依赖配置；
dependencyManagement ：醒目的依赖管理配置；
repositories ：项目的仓库配置；
build ：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置 等；
reporting ：包括项目的报告输出目录配置、报告插件配置等。

dependencyManagement

dependencyManagement能让子模块继承到依赖配置，但只是对版本进行管理，不会实际引入jar，约束dependencies依赖使用。在子模块只要配置简单的groupId和artifactId就能获得对应的依赖信息

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.test.sample</groupId>
            <artifactid>base-parent1</artifactId>
            <version>1.0.0-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

import依赖范围，可以将目标pom中的dependencyManagement引入，提供了除复制和继承外的第三种方法，注意：打包类型必须是pom

插件管理 pluginManagement 类似

简化：一个POM既是聚合pom又是继承pom也没关系

约定优于配置

maven有一些固定的项目组织结构，减少交流成本，如非必要不要改，比如<sourceDirectory>src/java</sourceDirectory>

这些约定来自于超级pom

reactor反应堆

依次读取pom，如果没有依赖，构建，有依赖，先构建依赖的模块，不允许出现依赖循环。

反应堆裁剪命令：

-am，–also-make：同时构建所列模块的依赖模块
-amd，-also-make-dependents：同时构建依赖于所列模块的模块
-pl，–projects：构建指定的模块，模块间用逗号分隔
-rf，-resume-from：在完整的反应堆构建顺序基础上指定从哪个模块开始构建

举例：使用-pl来指定构建某几个模块，并增加 -am 参数同时构建依赖的模块，mvn clean -pl account-service -am; 使用 -amd 选项可以同时构建依赖于所列模块的模块, mvn clean -pl account-email -amd; 使用 -rl 选项可以在完整的反应堆构建顺序基础上指定从哪个模块开始构建，mvn clean -rf account-email

12. maven测试

maven重要职责之一是自动运行单元测试，插件为maven-surefire-plugin，test目标会自动执行测试源码路径（默认为src/test/java）下所有符合一组命名模式的测试类：

**/Test*.java: 任何子目录下以Test开头的类
**/*Test.java: 任何子目录下以Test结尾的类
**/*TestCase.java: 任何子目录下以TestCase结尾的类

以Tests结尾的类不会自动执行

跳过测试

-DskipTests可跳过测试运行，-Dmaven.test.skip = true跳过测试代码的编译和运行

指定某个测试

mvn test -Dtest=测试用例类名
mvn test -Dtest=Random*Test 模糊匹配
mvn test -Dtest=Random*Test，类名2 指定多个
但如果没有匹配到任何测试类，会报错，可以mvn test -Dtest -DfailIfNoTests=false

包含与排除

<build>
   <plugins>
     <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-surefire-plugin</artifactId>
       <version>2.20</version>
       <configuration>
         <!-- 包含 -->
         <includes>
           <include>**/*Tests.java</include>
         </includes>
         <!-- 排除 -->
         <excludes>
           <exclude>**/Abstract*.java</exclude>
         </excludes>
       </configuration>
     </plugin>
   </plugins>
</build>

测试覆盖率报告

cobertura是一个开源测试覆盖率统计软件 mvn cobertura:cobertura

重用测试代码

测试代码默认是不打包的，插件maven-jar-plugin有两个目标，分别是jar和test-jar，前者内置绑定到package生命周期，后者默认绑定到package，但没有内置绑定，要显式声明

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.0.2</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>test-jar</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <excludes>
            <!--注意这玩意从编译结果目录开始算目录结构-->
            <exclude>/*.properties</exclude>
            <exclude>/*.xml</exclude>
        </excludes>
    </configuration>
</plugin>

测试被打成jar之后，可被其他模块的测试代码包含到dependency中，type test-jar

13. maven构建web项目

显式指定打包方式 war

+src

    ++main

     +++java(源代码)

     +++resources(资源文件)

     +++webapp(web应用目录)

       ++++WEB-INF
           web.xml
       ++++静态资源
    ++test

     +++java(测试源代码)

     +++resources(测试资源文件)

一个典型war文件有它固定的结构，maven规定的结构和war有一定的对应关系
web.xml中会配置多个sevlet对应不同的url，这是没有用jersey的一种url映射方式？用jersey的时候也有这些配置，有什么区别呢，jersey里的servlet干啥的

jetty-maven-plugin

详细的配置，用法以及需要修改settings.xml，这不是官方的默认插件，groupid不同。还可以设置很多web级的配置，比如context。
https://www.cnblogs.com/liupeizhi/articles/2701348.html

mvn jetty:run mvn jetty:run -Djetty.port = 9999
插件自动扫描到web的修改，热部署

Cargo自动化部署

自动化地将web应用部署至本地或远程的web容器中

cargo:start的生命周期依赖于maven实例的生命周期，也就是说，maven构建成功或者失败之后，cargo插件的生命周期也自动停止了；而cargo:run不同，不管maven是否构建成功或者失败，都必须手工去按Ctrl + C来停止。

部署到本地Web容器
standalone模式

在standalone模式，Cargo会从Web容器的安装目录复制一份配置到用户指定的目录，然后在此基础上部署应用，每次重新构建的时候，这个目录都会被清空，所有配置被重新生成

<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven2-plugin</artifactId>
<version>1.4.9</version>
<configuration>
  <container>
    <containerId>tomcat7x</containerId>
    <home>/usr/local/devtools/apache-tomcat-7.0.55</home>
  </container>
  <configuration>
    <type>standalone</type>
    <home>${project.build.directory}/tomcat7x</home>
    <properties>
      <!-- 更改监听端口 -->
      <cargo.servlet.port>8088</cargo.servlet.port>
    </properties>
  </configuration>
</configuration>
</plugin>

mvn cargo:run
2. 部署到本地Web容器

existing模式

在existing模式下，用户需要指定现有的web容器配置目录，然后Cargo会直接使用这些配置并将应用部署到其对应的位置

<plugin>
	<groupId>org.codehaus.cargo</groupId>
	<artifactId>cargo-maven2-plugin</artifactId>
	<version>1.4.9</version>
	<configuration>
		<container>
			<containerId>tomcat7x</containerId>
			<home>/usr/local/devtools/apache-tomcat-7.0.55</home>
		</container>
		<configuration>
			<type>existing</type>
			<home>/usr/local/devtools/apache-tomcat-7.0.55</home>
		</configuration>
	</configuration>
</plugin>

部署到远程正在运行的容器

更多配置详见插件解析，这里是最简单的

配置好之后就可以运行mvn cargo:redeploy 来部署应用了（必须保证tomcat是running状态，否则没法部署），如果容器中已经部署的当前应用，Cargo会先卸载掉原来的应用，然后再重新部署。

<plugin>
	<groupId>org.codehaus.cargo</groupId>
	<artifactId>cargo-maven2-plugin</artifactId>
	<version>1.4.9</version>
	<configuration>
		<container>
			<containerId>tomcat7x</containerId>
			<type>remote</type>
		</container>
		<configuration>
			<type>runtime</type>
			<properties>
				<cargo.tomcat.manager.url>http://localhost:8080/manager/text</cargo.tomcat.manager.url>
        <cargo.remote.username>admin</cargo.remote.username>
        <cargo.remote.password>password</cargo.remote.password>
      </properties>
		</configuration>
	</configuration>
</plugin>

14. 版本管理和版本控制

版本管理：项目整体版本的演变过程管理；版本控制：追踪代码的每一个变更

管理

发布的条件：

自动化测试全通过
没有配置任何快照版本依赖
没有配置任何快照版本插件
项目所包含的代码全部提交到版本控制系统中

命名的含义：<主版本>.<次版本>.<增量版本> - <里程碑版本>

主版本：重大架构变更
次版本：较大范围功能增加和变化
增量版本：重大bug修复
里程碑：通常表示与正式版本比不太稳定

后面两个是可选的

maven RELEASE plugin

该插件主要有三个目标：release: prepare, release: rollback, release: perform (什么是插件目标)，在介绍分支自己主动化的时候还会引入branch目标

release:prepare -DautoVersionSubmodules 准备版本号公布。依次运行下列操作

检查项目是否有未提交的代码
检查项目是否有快照版本号依赖
依据用户的输入将快照版本号升级为公布版
将POM中的SCM信息更新为标签地址
基于改动后的POM运行maven构建
提交POM变更
基于用户输入为代码打标签
将代码从公布版升级为新的快照版
提交POM变更

release: rollback

回退release: prepare所运行的操作。

将POM回退至release:prepare之前的状态。并提交。

注：该步骤不会删除release:prepare生成的标签，须要用户手动删除

release: perform

运行版本号公布

签出release:prepare生成的标签中的源码，并在此基础上运行mvn deploy命令打包并部署构件至仓库

pom中需要配置SCM信息，插件中要配置configuration告诉标签目录，需要知道版本控制系统的主干、标签等地址信息
超级pom中的profile会在特定情况下激活，可以在maven任何命令行指令指定属性为true，执行release:perform的时候，插件会自动成圣值为true的performRelease属性。
如果需要跳过单元测试，可以加入参数 -Darguments="-DskipTests"，直接使用-Dmaven.test.skip=true是无效的。

<project>
    <scm>
        <connection>scm:git:http://项目git地址</connection>
        <url>项目git地址（不加'.git后缀'）</url>
        <developerConnection>scm:项目git地址</developerConnection>
    </scm>
</project>


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-release-plugin</artifactId>
    <version>2.5.3</version>
    <configuration>
        <tagNameFormat>v@{project.version}</tagNameFormat>
        <autoVersionSubmodules>true</autoVersionSubmodules>
    </configuration>
</plugin>

release: branch

mvn release:branch -DbranchName=1.1.x -DupdateBranchVersions=true -DupdateWorkingCopyVersions=false

这是maven-release-plugin的branch目标，我们指定branch的名称为1.1.x，表示这里会有版本1.1.1, 1.1.2等等。updateBranchVersions=true的意思是在分支中更新版本，而updateWorkingCopyVersions=false是指不更改当前工作目录（这里是trunk）的版本。

在运行该命令后，我们会遇到这样的提示：

What is the branch version for “Unnamed - org.myorg:myapp:jar:1.1-SNAPSHOT”? (org.myorg:myapp) 1.1-SNAPSHOT: :

——“分支中的版本号是多少？默认为1.1-SNAPSHOT” 这时我们想要的版本是1.1.1-SNAPSHOT，因此输入1.1.1-SNAPSHOT，回车，maven继续执行直至结束。

接着，我们浏览svn仓库，会看到这样的目录：https://192.168.1.100:8443/svn/myapp/branches/1.1.x/，打开其中的POM文件，其版本已经是1.1.1-SNAPSHOT。

GPG GunPG是pretty good privacy PGP标准的一个实现

GPG是GNU Privacy Guard的缩写，是自由软件基金会的GNU计划的一部分。它是一种基于密钥的加密方式，使用了一对密钥对消息进行加密和解密，来保证消息的安全传输。一开始，用户通过数字证书认证软件生成一对公钥和私钥。任何其他想给该用户发送加密消息的用户，需要先从证书机构的公共目录获取接收者的公钥，然后用公钥加密信息，再发送给接收者。当接收者收到加密消息后，他可以用自己的私钥来解密，而私钥是不应该被其他人拿到的。

gpg --gen-key 生成密钥，生成的时候会做很多选择，以及添加口令保护私钥
最后，建议再生成一个撤销证书，以便以后密钥作废时，请求公钥服务器撤销你的公钥：gpg --ken-revoke [用户ID]
gpg --list-keys 列出密钥 gpg --list-secret-keys私钥
密钥服务器是用来发布你的公钥，并将其分发到其他人的服务器，这样其他用户可以轻松的根据你数据库中的名字（或者e-mail地址）来获取你的公钥，并给你发送加密信息。避免了把公钥直接拷贝给其他人 gpg --send-keys [your pubID] --keyserver [keyservers.address.com]
gpg --recv-keys [your pubID] --keyserver [keyservers.address.com]从服务器导入本地机器
删除密钥：gpg --delete-key [id]

签名，验证完整性： gpg -ab temp.java：-b创建一个独立的签名文件，-a创建AscII格式输出，生成temp.java.asc签名文件，将这两个文件一起发给用户，假设用户已导入你的公钥
gpg --verify temp.java.asc 验证原始文件
加密：

法一：gpg -o encrypted_file.gpg --encrypt -r key-id original.file

命令解释：

（1）-o encrypted_file.gpg = 指定输出文件

（2）–encrypt = 做加密

（3）-r = 接收者的KEY-ID，比如这里就填你朋友的KEY-ID。

（4）original.file = 指定要加密的文件

法二： gpg --recipient [your pubID]--output out.file --encrypt original.file

3. 解密：gpg --decrypt filename.gpg

maven gpg plugin

<plugin>
                       <groupId>org.apache.maven.plugins</groupId>
                       <artifactId>maven-gpg-plugin</artifactId>
                       <version>${maven-gpg-plugin.version}</version>
                       <executions>
                           <execution>
                               <id>sign-artifacts</id>
                               <phase>verify</phase>
                               <goals>
                                   <goal>sign</goal>
                               </goals>
                               <!-- <configuration> <executable>gpg</executable> <homedir>${gpg.homedir}</homedir>
                                   <keyname>${gpg.keyname}</keyname> <passphrase>${gpg.passphrase}</passphrase>
                                   </configuration> -->
                           </execution>
                       </executions>
                   </plugin>

执行mvn clean deploy -Dgpg.passphrase=yourpassphrase

若已经发布了，想签名，用插件的另一个goal：

mvn gpg:sign-and-deploy-file
> -DpomFile = target/myapp-1.0.pom
> -Dfile = target/myapp-1.0.jar
> -Durl = maven仓库地址
> -DrepositoryId = id

考虑一个问题：签名只有正式发布的时候才有必要，平常的快照构建是不需要的，profile标签设置触发条件

15. 灵活构建：属性、profile、资源过滤

属性

内置
${basedir}项目的根目录(包含pom.xml文件的目录)，$ {version}项目版本
pom属性，每一个都对应一个pom元素

${project.build.sourceDirectory}：项目的主源码目录，默认为 src/main/java

${project.build.testSourceDirectory}：项目的测试源码目录，默认为 src/test/java

${project.build.directory}：项目构件输出目录，默认为 target/

${project.outputDirectory}：项目主代码编译输出目录，默认为 target/classes/

${project.testOutputDirectory}：项目测试代码编译输出目录，默认为 target/test-classes/

${project.groupId}：项目的 groupId

${project.artifactId}：项目的 artifactId

${project.version}：项目的 version，与$ {version}等价

${project.build.fianlName}：项目打包输出文件的名称。默认为$ {project.artifactId}-${project.version}

自定义属性

用户可以在POM的元素下自定义Maven属性

settings属性

用户使用settings.开头的属性引用 settings.xml 文件中XML元素的值，如：${settings.localRepository}

java系统属性：可通过mvn help:system查看

所有Java系统属性都可以使用Maven属性引用，${user.home}

环境变量属性

所有环境变量都可以使用以env.开头的Maven属性引用 ${env.JAVA_HOME}

构建环境的差异

比如开发和测试和发布所用的数据库配置都不同！！

我们写变量值:maven 属性，然后在某个地方定义它

database.jdbc.driverClass = ${db.driver}

database.jdbc.connectionURL = ${db.url}

database.jdbc.username = ${db.username}

database.jdbc.password = ${db.password}

<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <db.driver>com.mysql.jdbc.Driver</db.driver>
            <db.url>jdbc:mysql://localhost:3360/test</db.url>
            <db.username>username</db.username>
            <db.password>password></db.password>
        </properties>
    </profile>
</profiles>

** 但是，maven默认属性只在pom中被解析，在资源文件中没有自动解析，资源文件处理是maven-resource-plugin做的事情，他默认的行为是将主资源和测试资源文件复制到编译输出目录，这个是在超级pom定义的**
开启filtering即可

<resources>
    <resource>
        <directory>${project.basedir}/src/main/resources</directory>
        <filtering>true</filtering>
    </resource>
</resources>

<testResources>
    <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
        <filtering>true</filtering>
    </testResource>
<testResources>

然后运行 mvn clean install -Pdev，-P参数表示激活一个profile，构建完成后输出目录中的配置就是开发环境的配置了

profile的激活方式

命令行，mvn … -P 加上profile的id，多个的话逗号隔开
settings文件中使某profile一直处于激活
系统属性激活
操作系统环境激活
文件存在与否激活
默认激活，<activeByDefault>true</activeByDefault>

<profile>  
  <id>dev</id>  
  <activation>  
    <activeByDefault>false</activeByDefault>  
    <jdk>1.5</jdk>  
    <os>  操作系统环境
      <name>Windows XP</name>  
      <family>Windows</family>  
      <arch>x86</arch>  
      <version>5.1.2600</version>  
    </os>  
    <property>  系统属性 在命令行可以声明哦 mvn install -Dtest=x
      <name>mavenVersion</name>  
      <value>2.0.5</value>  
    </property>  
    <file>  
      <exists>file2.properties</exists>  
      <missing>file1.properties</missing>  
    </file>  
  </activation>  
  ...  
</profile>

mvn help:active-profiles 列出当前激活的
mvn help:all-profiles列出当前所有的

pom跟项目一起发布，所以pom中的profile可修改的元素多

<project>  
    <profiles>  
        <profile>  
            <build>  
                <defaultGoal>...</defaultGoal>  
                <finalName>...</finalName>  
                <resources>...</resources>  
                <testResources>...</testResources>  
                <plugins>...</plugins>  
            </build>  
            <reporting>...</reporting>  
            <modules>...</modules>  
            <dependencies>...</dependencies>  
            <dependencyManagement>...</dependencyManagement>  
            <distributionManagement>...</distributionManagement>  
            <repositories>...</repositories>  
            <pluginRepositories>...</pluginRepositories>  
            <properties>...</properties>  
        </profile>  
    </profiles>  
</project>

pom外部的profile

<repositories>...</repositories>  
<pluginRepositories>...</pluginRepositories>  
<properties>...</properties>

web资源过滤

在Web项目中，资源文件位于src/main/resources/目录下，他们经处理后会位于WAR包的WEB-INF/classes目录下，即这类资源文件在打包过后位于应用程序的classpath中。Web项目中位于src/main/webapp目录，经打包后位于WAR包的根目录。这一类资源文件称作web资源文件，他们在打包过后不位于应用程序的classpath中。web资源默认不会被过滤，因此开启一般资源文件的过滤也不会影响到web资源文件

<profiles>
    <profile>
        <id>client-a</id>
        <properties>
            <client.logo>a.jpg</client.logo>
            <client.theme>red</client.theme>
        </properties>
    </profile>
    <profile>
        <id>client-b</id>
        <properties>
            <client.logo>b.jpg</client.logo>
            <client.theme>blue</client.theme>
        </properties>
    </profile>
</profiles>

需要配置maven-war-plugin对src/main/webapp这一web资源目录开启过滤

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1-beta-1</version>
    <configuration>
        <webResources>
            <resource>
                <filtering>true</filtering>
                <directory>src/main/webapp</directory>
                <includes>
                    <include>**/*.css</include>
                    <include>**/*.js</include>
                </includes>
            </resource>
        </webResources>
    </configuration>
</plugin>

profile不仅可以用来应对不同的构建环境以保持构建环境的可移植性，还可以用来分离构建的一些较耗时或耗资源的行为，给予更合适的构建频率

16. 生成项目站点

添加maven-site-plugin，mvn site，但是多模块的链接点不过去，那么可以在本地预发布到一个临时目录:
mvn site:stage -DstagingDirectory = D:\temp

pom中配置的信息越全，生成的站点信息越丰富
插件maven-project-info-reports-plugin可以配置选择生成哪些信息报告，maven3配置方法：

<plugin>  
  <groupId>org.apache.maven.plugins</groupId>  
  <artifactId>maven-site-plugin</artifactId>  
  <version>3.0-beta-3</version>  
  <configuration>  
    <reportPlugins>  
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-project-info-reports-plugin</artifactId>  
        <version>2.4</version>  
        <reports>  
          <report>license</report>  
          <report>mailing-list</report>  
          <report>dependencies</report>  
          <report>dependency-convergence</report>  
          <report>plugin-management</report>  
          <report>cim</report>  
          <report>issue-tracking</report>  
          <report>scm</report>  
          <report>summary</report>  
        </reports>  
      </plugin>  
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-surefire-report-plugin</artifactId>  
        <version>2.6</version>  
      </plugin>  
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-javadoc-plugin</artifactId>  
        <version>2.7</version>  
      </plugin>       
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-checkstyle-plugin</artifactId>  
        <version>2.6</version>  
      </plugin>  
      <plugin>  
        <groupId>org.codehaus.mojo</groupId>  
        <artifactId>jdepend-maven-plugin</artifactId>  
        <version>2.0-beta-2</version>  
      </plugin>  
      <plugin>  
        <groupId>org.codehaus.mojo</groupId>  
        <artifactId>cobertura-maven-plugin</artifactId>  
        <version>2.4</version>  
      </plugin>  
      <plugin>  
        <groupId>org.codehaus.mojo</groupId>  
        <artifactId>taglist-maven-plugin</artifactId>  
        <version>2.4</version>  
      </plugin>  
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-jxr-plugin</artifactId>  
        <version>2.1</version>  
      </plugin>  
      <plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-pmd-plugin</artifactId>  
        <version>2.5</version>  
        <configuration>  
          <linkXref>true</linkXref>  
          <minimumTokens>100</minimumTokens>  
          <minimumPriority>3</minimumPriority>                                  
          <targetJdk>1.6</targetJdk>  
        </configuration>  
      </plugin>  
    </reportPlugins>  
  </configuration>  
</plugin>

生成的站点web可以通过xml文件去自定义，修改menu，设置皮肤

17. maven-archetype-plugin

maven archetype:generate，我使用这个命令后出现了很多remote，不止internal，还有dexcloud的local，可以用-DarchetypeCatalog= 来筛选
来自于catalog，指定本机任一位置的catalog，file://、http协议远程catalog，http://
自动化方式，

mvn archetype:generate DarchetypeGroupId=  -DarchetypeArtifactId=maven-archetype-quickstart
 -DarchetypeVersion  -DinteractiveMode=false
-DgroupId=com.mycompany.app -DartifactId=myapp -Dversion=1.0-snap... -Dpackage

生成本地仓库的catalog

mvn archetype:crawl -Drepository = D:/java/reposiroty -Dcatalog = C:/archetype-catalog.xml

指定要遍历的仓库和要更新的文件，不提供会遍历settings中定义的localRepository，在仓库根目录生成archetype-catalog.xml

编写archetype

自身的pom
src/main/resources/archetype-resources/pom.xml基于该模板生成的项目的pom原型，注意在必要的地方使用可配置的属性代替硬编码
src/main/resources/META-INF/maven/archetype-metadata.xml描述符文件，一声明哪些目录和文件应该包含在archetype中，二是这个archetype使用哪些属性参数
src/main/resources/archetype-resources/** 其他需要包含在archetype中的内容

<?xml version="1.0" encoding="UTF-8"?>
<archetype-descriptor name="miuse-job-archetype">
    <fileSets>
        <fileSet filtered="true" encoding="UTF-8">
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.**</include>
            </includes>
        </fileSet>
        <fileSet filtered="true" encoding="UTF-8">
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.xml</include>
                <include>**/**</include>
            </includes>
        </fileSet>
        <fileSet filtered="true" encoding="UTF-8">
            <directory>src/test/java</directory>
            <includes>
                <include>**/*.**</include>
            </includes>
        </fileSet>
  </fileSets>
  <requiredProperties>
    <requiredProperty key="">
      <defaultValue></defaultValue>
    </requiredProperty>
  </requiredProperties>
</archetype-descriptor>

默认要求的参数group artifact version package，还可以要求额外参数,见上述代码

编写完成后，clean install 安装到本地库
https://blog.csdn.net/lff1991/article/details/76550363

18. 编写maven插件

建立一个maven项目，可以用命令行的方式建立如：mvn archetype：generate
然后选择：maven-archetype-plugin
pom的特殊之处：

<packaging>maven-plugin</packaging>    maven-plugin-api的依赖

继承AbstractMojo类，实现execute方法，提供@goal目标
提供用户配置点，@parameter
@parameter expression= 可以从系统属性读取字段的值，用户可以从命令行去配置，也可以在pom中配置
execute方法，可抛出异常MojoExecutionException, MojoFailureException，插件执行时遇到MojoExecutionException会显示“BUILD ERROR”; MojoFailureException----“BUILD FAILURE”
日志对象，getlog().info, getlog().error

Mojo标注

@goal <name>插件目标，唯一必须声明的标注
@phase <phase>绑定到生命周期，@phase test
@requiredDependencyResolution <scope>运行该Mojo前必须解析所有指定范围的依赖， compile,test,runtime,默认runtime
@requiredProject <true/false>该目标是否必须在一个maven项目中运行，默认为true
@requiredDirectInvocation <true/false>是否只能通过命令行调用，若true，在pom中尝试绑定到生命周期就报错，默认false
@requiredOnline <true/false>是否要求maven在线，默认false
@requiredReport <true/false>是否要求项目报告已生成，默认false
@aggregator多模块项目，该标注表示目标只会在顶层模块运行
@execute goal= "<goal>"运行该目标前，先运行另一目标；如果是本插件的目标，直接使用目标名称，否则用"prefix:goal"
@execute phase= "<phase>"运行该目标前，先让maven运行一个并行的生命周期，到指定的阶段为止
@execute lifecycle= "<lifecycle>" phase="<phase>"运行该目标前，先运行一个自定义的生命周期，到指定的阶段为止。自定义生命周期的配置文件lifecycle.xml

Mojo参数

boolean(boolean和Boolean)：

/**

*@parameter

*/

private boolean sampleBoolean:对应配置<sampleBoolean>true</sampleBoolean>

int(Integer,long.Long,short,Short,byte,Byte)：

/**

*@parameter

*/

private int sampleInt:对应配置<sampleInt>8</sampleInt>

float(Float,Double,double)：

/**

*@parameter

*/

private float sampleFloat:对应配置<sampleFloat>8.2</sampleFloat>

String(StringBuffer,char,Character)：

/**

*@parameter

*/

private String sampleString:对应配置<sampleString>heoll</sampleString>

Date(yyyy-MM-dd HH:mm:ss.S a或yyyy-MM-dd HH:mm:ssa)：

/**

*@parameter

*/

private Date sampleDate:对应配置<sampleDate>2010-06-09 3:14:55.1 PM或2010-06-09 3:14:55 PM</sampleDate>

File

/**

*@parameter

*/

private File sampleFile:对应配置<sampleFile>c:tem</sampleFile>

URL

/**

*@parameter

*/

private URL sampleUrl:对应配置<sampleUrl>http;//www.baidu.com</sampleUrl>

数组

/**

*@parameter

*/

private String[] includes:对应配置<includes><include>ee</include><include>dd</include></includes>

Collection(任何实现Collection接口的类)

/**

*@parameter

*/

private List includes:对应配置<includes><include>ee</include><include>dd</include></includes>

Map

/**

*@parameter

*/

private Map includes:对应配置<includes><key1>ee</key1><key2>dd</include></key2></includes>

Properties

/**

*@parameter

*/

private Properties includes:对应配置

<includes>

<property>

<name>ee</name>

<value>22</value>

</property>

<property>

<name>dd</name>

<value>11</value>

</property>

</includes>





@parameter额外属性：

@parameter alias="<aliasName>":为mojo参数使用别名

@parameter expression="${aSystemProperty}":使用系统属性表达式对mojo参数进行赋值

@parameter defaultValue="aValue/${anExpression}":提供一个默认值

另外

@readonly:只读属性，不允许配置

@required:必需的属性，未配置，会报错