Maven插件

星辰

2018-05-23

2100

人

人评论

人举报

[TOC]

# 什么是 Maven 的插件？
Maven 是一个执行插件的框架，每一个任务实际上是由插件完成的。Maven 插件通常用于：
* 创建 jar 文件
* 创建 war 文件
* 编译代码文件
* 进行代码单元测试
* 创建项目文档
* 创建项目报告

一个插件通常提供了一组目标，可使用以下语法来执行：
`mvn [plugin-name]:[goal-name]`
例如，一个 Java 项目可以使用 Maven 编译器插件来编译目标，通过运行以下命令编译
`mvn compiler:compile`

# maven的生命周期有哪些阶段？
```
[validate,
initialize,
generate-sources,
process-sources,
generate-resources,
process-resources,
compile,
process-classes,
generate-test-sources,
process-test-sources,
generate-test-resources,
process-test-resources,
test-compile,
process-test-classes,
test,
prepare-package,
package,
pre-integration-test,
integration-test,
post-integration-test,
verify,
install,
deploy]
```

# 插件类型
Maven 提供以下两种类型插件：

类型|描述
--|--
构建插件|在生成过程中执行，并在 pom.xml 中的`<build/>` 元素进行配置
报告插件|在网站生成期间执行，在 pom.xml 中的 `<reporting/>` 元素进行配置
以下是一些常见的插件列表：

# 例子
我们使用 maven-antrun-plugin 插件在例子中来在控制台打印数据。现在在 C:\MVN\project 文件夹 创建一个 pom.xml 文件，内容如下：
```
<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.0
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
   <plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-antrun-plugin</artifactId>
   <version>1.1</version>
   <executions>
      <execution>
         <id>id.clean</id>
         <phase>clean</phase>
         <goals>
            <goal>run</goal>
         </goals>
         <configuration>
            <tasks>
               <echo>clean phase</echo>
            </tasks>
         </configuration>
      </execution>     
   </executions>
   </plugin>
</plugins>
</build>
</project>
```
接下来，打开命令控制台，并转到包含 pom.xml 的文件夹并执行以下命令 mvn 命令。
`C:\MVN\project>mvn clean`
Maven 将开始处理并显示清洁周期/阶段，如下图中输出：
```
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO]    task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
     [echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------
```
上面的例子说明了以下关键概念：
* 插件可在 pom.xml 使用的 plugin 元素来指定； 
* 每个插件可以有多个目标；
* 从插件应使用它的相位元素开始处理定义阶段。这里已经使用 clean 阶段；
* 可以通过将它们绑定到插件的目标来执行配置任务。这里已经绑定 echo 任务到 maven-antrun-plugin 的运行目标；
* 就这样，Maven将处理其余部分。如果没有可用的本地存储库，它会下载这个插件；

# 常用插件介绍
## 常用打包插件
| plugin                  | function                                       |
| ----------------------- | ---------------------------------------------- |
| `maven-jar-plugin`      | maven 默认打包插件，用来创建 project jar       |
| `maven-shade-plugin`    | 用来打可执行包，executable(fat) jar            |
| `maven-assembly-plugin` | 支持定制化打包方式，例如 apache 项目的打包方式 |

### maven-jar-plugin
暂未测试，改天有空再测试下
打成jar时，设定manifest的参数，比如指定运行的Main class，还有依赖的jar包，加入classpath中
```
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifest>
				
                <addClasspath>true</addClasspath>
				
                <classpathPrefix>/data/lib</classpathPrefix>
				
                <mainClass>com.zhang.spring.App</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

# maven插件把依赖的所有jar包找出来
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-rar-plugin</artifactId>
    <version>2.4</version>
</plugin>
```

### maven-shade-plugin
暂未测试过
用于把多个jar包，打成1个jar包
一般Java项目都会依赖其他第三方jar包，最终打包时，希望把其他jar包包含在一个jar包里。
与assembly类似，使用assembly即可。以下详解assembly。

### 推荐使用的打包插件 maven-assembly-plugin
```
 <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
              <execution>
              <id>make-assembly</id>
                <phase>package</phase>
                (1)
                <goals>
				  
                  <goal>single</goal>
                </goals>
                (2)
                <configuration>
                  <finalName>${project.name}</finalName>
                  
                  ...
				  
                  <descriptor>src/main/assembly/assembly.xml</descriptor>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
     </build>
```

**两个主要的参数设置（上述中的（1）（2））**

* I）Assembly插件的goals
single
help
可以执行如下命令完成动作：
`mvn assembly:single`
或者是，绑定到package生命周期阶段上（见上配置）触发。后续可以直接执行：
`mvn package`
这也是最常见的Assembly插件配置方式。
* II）Assembly descriptor
Assembly Descriptor可以使用内置的，或者定制的。
##### (1) 使用内置的Assembly Descriptor

要使用maven-assembly-plugin，需要指定至少一个要使用的assembly descriptor 文件。默认情况下，maven-assembly-plugin内置了几个可以用的assembly descriptor：

- bin ： 类似于默认打包，会将bin目录下的文件打到包中；
- jar-with-dependencies ： 会将所有依赖都解压打包到生成物中；
- src ：只将源码目录下的文件打包；
- project ： 将整个project资源打包。

使用 descriptorRefs来引用(官方提供的定制化打包方式)【不建议使用】

```
<plugin>  
    <artifactId>maven-assembly-plugin</artifactId>  
    <configuration>  
    
        <descriptorRefs>  
            <descriptorRef>jar-with-dependencies</descriptorRef>  
        </descriptorRefs>  
    </configuration>  
</plugin>
```

上述直接配置`jar-with-dependencies`打包方式。不需要引入额外文件。实际上，上述4中预定义的assembly descriptor有对应的xml。要查看它们的详细定义，可以到maven-assembly-plugin.jar里去看，例如对应 bin 的assembly descriptor 原始文件如下：

```
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>bin</id>
    <formats>
        <format>tar.gz</format>
        <format>tar.bz2</format>
        <format>zip</format>
    </formats>
    <fileSets>
        <fileSet>
            <directory>${project.basedir}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>README*</include>
                <include>LICENSE*</include>
                <include>NOTICE*</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}/site</directory>
            <outputDirectory>docs</outputDirectory>
        </fileSet>
    </fileSets>
</assembly>
```

(2) 自定义Assembly Descriptor

一般来说，内置的assembly descriptor都不满足需求，这个时候就需要写自己的assembly descriptor的实现了。
使用 `descriptors`，指定打包文件 `src/assembly/assembly.xml`，即在配置文件内指定打包操作要使用这个自定义assembly descriptor(自定义的xml中配置)，需要如下配置，即要引入描述文件：

```
<configuration>  
    <finalName>demo</finalName>  
    <descriptors>
        
        <descriptor>src/assembly/assembly.xml</descriptor>  
    </descriptors>  
    <outputDirectory>output</outputDirectory>
</configuration> 
```

示例：
`src/assembly/assembly.xml`:

```
<?xml version='1.0' encoding='UTF-8'?>
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0  
                    http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>demo</id>
    
    <formats>
        <format>jar</format>
    </formats>
    
    <includeBaseDirectory>false</includeBaseDirectory>
    
    <fileSets>
        <fileSet>
        
            <directory>${project.build.directory}/classes</directory>
            
            <outputDirectory>/</outputDirectory>
            
        </fileSet>
    </fileSets>
</assembly>
```

这个定义很简单：

- format：指定打包类型；
- includeBaseDirectory：指定是否包含打包层目录（比如finalName是output，当值为true，所有文件被放在output目录下，否则直接放在包的根目录下）；
- fileSets：指定要包含的文件集，可以定义多个fileSet；
- directory：指定要包含的目录；
- outputDirectory：指定当前要包含的目录的目的地。

回到pom的配置中，自定义的configuration配置后，将会生成一个`demo-demo.jar` 文件在目录 `output` 下，其中前一个`demo`来自`finalName`，后一个`demo`来自assembly descriptor中的`id`，其中的内容和默认的打包出来的jar类似。

如果只想有finalName，则增加配置：

```
<appendAssemblyId>false</appendAssemblyId>  
```

对于描述文件的元素，即assembly.xml中的配置节点的详细配置，在此稍作总结，见下。

**assembly.xml节点配置**

在配置assembly.xml之前，我们先看一下pom中引入插件的结构。

```
<project>
  [...]
  <build>
    [...]
    <plugins>
      <plugin>
 ------------（1）坐标-----------
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.0.0</version>
        <configuration>
 ------------（2）入口-----------
          <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <mainClass>com.***.startup.BootStrap</mainClass> 
            </manifest>
          </archive>
 ------------（3）描述-----------  
          <descriptors>
            <descriptor>src/assembly/assembly.xml</descriptor>
          </descriptors>
        </configuration>
        [...]
</project>
```

**archive说明**
上面的`mainClass`标签中的内容替换成自己的`main`函数所在的类，前面要包含`package`名字，也就是`package_name.MainClassName`。

assembly.xml文件的主要结构如下。

**id**

```
<id>distribution</id>
```

id 标识符，添加到生成文件名称的后缀符。如果指定 id 的话，目标文件则是 `${artifactId}-${id}.tar.gz`

**formats**

maven-assembly-plugin 支持的打包格式有zip、tar、tar.gz (or tgz)、tar.bz2 (or tbz2)、jar、dir、war，可以同时指定多个打包格式

```
<formats>
    <format>dir</format>
  </formats>
```

**dependencySets**

用来定制工程依赖 jar 包的打包方式，核心元素如下表所示。

| 元素            | 类型         | 作用                                 |
| --------------- | ------------ | ------------------------------------ |
| outputDirectory | String       | 指定包依赖目录，该目录是相对于根目录 |
| includes        | List<String> | 包含依赖                             |
| excludes        | List<String> | 排除依赖                             |

```
    <dependencySets>
        <dependencySet>
            <outputDirectory>/lib</outputDirectory>
            <excludes>
                <exclude>${project.groupId}:${project.artifactId}</exclude>
            </excludes>
        </dependencySet>
        <dependencySet>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>${project.groupId}:${project.artifactId}</include>
            </includes>
        </dependencySet>
    </dependencySets>
```

**fileSets**

管理一组文件的存放位置，核心元素如下表所示。

| 元素            | 类型         | 作用                                                         |
| --------------- | ------------ | ------------------------------------------------------------ |
| outputDirectory | String       | 指定文件集合的输出目录，该目录是相对于根目录                 |
| includes        | List<String> | 包含文件                                                     |
| excludes        | List<String> | 排除文件                                                     |
| fileMode        | String       | 指定文件属性，使用八进制表达，分别为(User)(Group)(Other)所属属性，默认为 0644 |

```
    <fileSets>
        <fileSet>
            <directory>shell</directory>
            <outputDirectory>/shell</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>cluster_config</directory>
            <outputDirectory>/cluster_config</outputDirectory>
        </fileSet>
    </fileSets>
```

**其他**

其他的，如files节点基本类似fileSets。不常用的暂不介绍。

至此，即可按打包成功。下边给出具体示例。

## 编译插件 maven-compiler-plugin
编译Java源码，一般只需设置编译的jdk版本
```
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.6.0</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
		<encoding>UTF-8</encoding>
    </configuration>
</plugin>
```
或者在properties设置jdk版本
```
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
 </properties>
```

## tomcat 运行插件 tomcat7-maven-plugin
部署Java Web项目
```
# 远程部署，还需要测试下
<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <configuration>
        <url>http://59.110.162.178:8080/manager/text</url>
        <username>itnoteshare</username>
        <password>itnoteshare</password>
    </configuration>
</plugin>
# 本地部署
<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <configuration>
        <port>8080</port>
        <path>/gld</path>
        <uriEncoding>UTF-8</uriEncoding>
		
        <contextFile>src/main/resources/context.xml</contextFile>
    </configuration>
</plugin>
```

## Maven SCM Plugin
http://maven.apache.org/scm/maven-scm-plugin/index.html

## flatten-maven-plugin ： 处理版本占位符
https://blog.csdn.net/sayyy/article/details/103994302
https://my.oschina.net/liyuj/blog/874929

## Maven 配置 Jacoco 插件，查看代码覆盖率
https://blog.csdn.net/oschina_41790905/article/details/82627728

## 测试插件 maven-surefire-plugin
```
# 测试测试用例
mvn test
或
mvn surefire:test
# 打包过程中会自动进行测试用例测试
mvn package
# 运行单元测试并生成报告
mvn test surefire-report:report

# 关闭测试用例测试方法 命令加参数发 -Dmaven.test.skip=true
# 或 插件添加配置
<configuration>
	<skipTests>true</skipTests>
</configuration>
# 添加属性法
<properties>
    <maven.test.skip>true</maven.test.skip>
</properties>
或
<properties>
    <skipTests>true</skipTests>
</properties>
```
更详细信息
https://www.cnblogs.com/qyf404/archive/2004/01/13/5013694.html

## spring-boot-starter-test

## spring-boot-maven-plugin

```
<!--
功能介绍
This plugin has 6 goals:

spring-boot:build-info
  Generate a build-info.properties file based the content of the current
  MavenProject.

spring-boot:help
  Display help information on spring-boot-maven-plugin.
  Call mvn spring-boot:help -Ddetail=true -Dgoal=<goal-name> to display
  parameter details.

spring-boot:repackage
  Repackages existing JAR and WAR archives so that they can be executed from the
  command line using java -jar. With layout=NONE can also be used simply to
  package a JAR with nested dependencies (and no main class, so not executable).

spring-boot:run
  Run an executable archive application.

spring-boot:start
  Start a spring application. Contrary to the run goal, this does not block and
  allows other goal to operate on the application. This goal is typically used
  in integration test scenario where the application is started before a test
  suite and stopped after.

spring-boot:stop
  Stop a spring application that has been started by the 'start' goal. Typically
  invoked once a test suite has completed.

中文说明：
spring-boot:repackage，默认goal。在mvn package之后，再次打包可执行的jar/war，同时保留mvn package生成的jar/war为.origin（使用其打包后的jar可以直接运行）
spring-boot:run，运行Spring Boot应用
spring-boot:start，在mvn integration-test阶段，进行Spring Boot应用生命周期的管理
spring-boot:stop，在mvn integration-test阶段，进行Spring Boot应用生命周期的管理
spring-boot:build-info，生成Actuator使用的构建信息文件build-info.properties
-->
<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

mvn package spring-boot:repackage

# 涉及到的属性配置 properties中配置，一般不用配置，配置了可能会导致一些问题
<start-class>eurekademo.EurekaApplication</start-class>
# 插件里面的配置
<configuration>
    <mainClass>${start-class}</mainClass>
</configuration>
```
更详细介绍
https://www.cnblogs.com/jpfss/p/11098740.html

## 其他插件
maven scm 、checkstyle、maven-gpg-plugin、maven-javadoc-plugin、maven-source-plugin、maven-checkstyle-plugin、
flatten-maven-plugin、maven-surefire-plugin、maven-eclipse-plugin、jacoco-maven-plugin
https://www.cnblogs.com/qyf404/archive/2004/01/13/5013694.html
Asciidoctor Maven插件使用
https://segmentfault.com/a/1190000015497599

所有评论列表