maven的简单使用（应用）

maven的简单使用（应用）

一、安装

Apache Maven是个项目管理和自动构建工具，基于项目对象模型（POM）的概念。作用：完成项目的相关操作，如：编译，构建，单元测试，安装，网站生成和基于Maven部署项目。

1. maven安装

   下载maven地址：https://maven.apache.org/download.cgi
   解压缩后配置环境变量
   maven -version查看版本
   

2. nexus安装

   #下载nexus-3.31.1-01-unix.tar.gz
   tar -zxvf nexus-3.31.1-01-unix.tar.gz -C /opt
   vi /opt/nexus-3.31.1-01/bin/nexus
   #修改run_as_root=false
   ./nexus start启动
   #登录ip:8081  账号admin，密码admin123，修改密码为admin
   #点击设置--Repositories--Create repository按钮--maven2(proxy)创建阿里仓库代理
   name：aliyun
   Remote storage：http://maven.aliyun.com/nexus/content/groups/public/
   #点击Create repository保存
   #返回到Repositories页面，点击maven-public
   将Available中左侧aliyun移动到右侧，点击保存
   #修改settings.xml，仓库地址修改为
     <mirrors>
       <mirror>
             <id>nexus</id>
             <name>naxus maven</name>
             <url>http://192.168.186.106:8081/repository/maven-public/</url>
             <mirrorOf>central</mirrorOf>
           </mirror>
     </mirrors>
   #配置npm私服
   #点击设置--Repositories--Create repository按钮--npm(hosted)本地仓库
   #输入Name：npm-hosted点击保存
   #点击设置--Repositories--Create repository按钮--npm(proxy)阿里代理仓库
   #输入
   Name：npm-ali 
   Remote storage：https://registry.npm.taobao.org/
   勾选Auto blocking enabled
   点击保存
   #点击设置--Repositories--Create repository按钮--npm(group)仓库组
   #输入
   Name：npm-group
   将Available中左侧npm-hosted和npm-ali移动到右侧，点击保存
   #设置npm仓库地址
   npm config set registry http://192.168.186.106:8081/repository/npm-group/
   

二、配置文件

1. settings.xml

   settings.xml文件中的包含一系列用于配置Maven执行方式的元素，如本地仓库位置、远程仓库服务器和身份验证信息等，类似pom.xml，但不捆绑到任何特定项目。 settings.xml文件一般位于以下两个位置： ${maven.home}/conf/settings.xml ${user.home}/.m2/settings.xml（没有改变settings.xml中本地仓库位置情况下此目录） 前面位置的settings.xml文件为全局配置文件，后面的为用户配置文件。如果两个配置文件都存在，则以用户配置文件为主合并其内容。

   <?xml version="1.0" encoding="UTF-8"?>
   <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
   #配置系统本地仓库的路径。默认值是${user.home}/.m2/repository目录。此元素特用于允许所有已登录到主服务器的用户共用公共本地仓库。          
     <localRepository>D:\repository</localRepository>
   #Maven尝试与用户交互，需用户输入，否则设置为false，默认为 true  
     <interactiveMode/>
   #Maven使用 ${user.home}/.m2/plugin-registry.xml 来管理插件版本, 否则false。默认值为 false 
     <usePluginRegistry/>
   #构建系统在离线模式运行，否则false。默认值为false  
     <offline/>
   #此元素包含一组<pluginGroup />元素，每个<pluginGroup />都包含一个groupId，当你使用插件并且在命令行中未提供groupId时，查询此列表。列表自动包含org.apache.maven.plugins和org.codehaus.mojo  
     <pluginGroups></pluginGroups>
   #代理配置  
     <proxies></proxies>
   #POM文件中 <repositories />和<distributionManagement />元素配置用于下载和发布的仓库。安全考虑，某些配置如用户名和密码，不应在pom.xml中设置，这种类型的信息应该存在于构建服务器上的settings.xml文件中  
     <servers></servers>
   #镜像仓库地址  
     <mirrors>
       <mirror>  
   	  <id>alimaven</id>  
   	  <name>aliyun maven</name>  
   	  <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
   	  <!--mirrorOf的值为central表示该配置为中央仓库的镜像，任何对于中央仓库的请求都会转至该镜像-->
   	  <!--mirrorOf值为*星号，表示该配置是所有Maven仓库的镜像，任何对于远程仓库的请求都会-->
   	  <mirrorOf>central</mirrorOf>          
   	</mirror>
   	    <mirror>  
   	  <id>jeecg</id>  
   	  <name>jeecg maven</name>  
   	  <url>http://maven.jeecg.org/nexus/content/repositories/jeecg/</url>
   	  <mirrorOf>central</mirrorOf>          
   	</mirror>
     </mirrors>
   #Maven中的<properties />是值占位符，通过${X}在POM文件中的任何地方可以访问它们的值（X为属性）。   
     <profiles>
   	  <profile>    
   		 <id>jdk-1.8</id>    
   		  <activation>    
   			   <activeByDefault>true</activeByDefault>    
   			   <jdk>1.8</jdk>    
   			</activation>    
   	      <properties>    
   	          <maven.compiler.source>1.8</maven.compiler.source>    
   	          <maven.compiler.target>1.8</maven.compiler.target>    
   	          <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>    
   	     </properties>    
        </profile> 
    </profiles>
   #包含一组activeProfile元素，每个activeProfile元素都包含一个profile id。任何在activeProfile元素中设置的profile id所对应的profile将处于激活状态 
    <activeProfiles/>
   </settings>
   

2. pom.xml

   <!--xml文件版本-->
   <?xml version="1.0" encoding="UTF-8"?>
   <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">
       <!--指定pom模型的版本-->
       <modelVersion>4.0.0</modelVersion>
       <!--打包方式：java项目打包为jar，web项目打包为war-->
       <pacagking>jar</pacagking>
       <!--父工程依赖坐标--> 
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.2.1.RELEASE</version>
       </parent>
       <!--本工程坐标-->
       <groupId>com.yyb</groupId>
       <artifactId>redis-springboot</artifactId>
       <!--RELEASE为正式版本，SNAPSHOT为开发版本-->
       <version>1.0-SNAPSHOT</version>
   	<!-- 通过自定义属性，统一指定版本，通过<version>${spring.version}</version>使用 -->
       <properties>
       	<!-- 解决maven控制台中文乱码 -->
       	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <maven.compiler.source>11</maven.compiler.source>
           <maven.compiler.target>11</maven.compiler.target>
           <spring.version>5.3.19</spring.version>
       </properties>
       <!--依赖-->
       <dependencies>
       	<!-- import实现依赖多个父工程，例如Spring IO Platform是一个依赖维护平台，该平台将相关依赖汇聚到一起，针对每个依赖，都提供了一个版本号，这些版本对应的依赖都是经过测试的，可以保证一起正常使用 ，相关依赖包可以参照https://docs.spring.io/platform/docs/current/reference/html/appendix-dependency-versions.html-->
           <dependency>
   			<groupId>io.spring.platform</groupId>
   			<artifactId>platform-bom</artifactId>
   			<version>Athens-SR2</version>
   			<type>pom</type>
   			<scope>import</scope>
   		</dependency>
           <dependency>
           	<!-- 公司或组织的 id -->
               <groupId>org.springframework.boot</groupId>
               <!-- 一个项目或者是项目中的一个模块的 id -->
               <artifactId>spring-boot-starter-web</artifactId>
               <!-- 依赖范围compile（默认）、test、provided、runtime、system本地系统jar文件路径 -->
               <scope>compile</scope>
               <!-- 隐藏依赖 -->
               <optional>true</optional>
               <!-- 排除依赖 -->
               <exceptions>
                   <exception>
                       <groupId>...</groupId>
                       <artifactId>...</artifactId>
                   <exception>
               </exceptions>
           </dependency>
           <dependency>  
       		<groupId>net.sf.json-lib</groupId>   
       		<artifactId>json-lib</artifactId>   
       		<version>2.2.2</version>  
       		<!-- 在相同版本下针对不同的环境或者jdk使用的jar -->
       		<classifier>jdk15</classifier>    
   		</dependency>  
       </dependencies>
       <!--插件-->
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
   </project>
   

三、maven使用

1. 命令

   mvn  compile  编译
   mvn  clean   清理
   mvn  package   打包
   mvn  test   测试
   mvn  install  安装到本地仓库
   mvn deploy 布署到本地maven仓库和远程maven私服仓库
   

2. compile依赖范围

   依赖范围	编译	测试	运行时	是否会被打入jar包
   compile	√	√	√	√
   provided	√	√	×	×
   runtime	×	√	√	√
   test	×	√	×	×
   system	√	√	×	√

3. compile依赖补充

   1.管理依赖最基本的办法是继承父工程是单继承的。如果不同体系的依赖信息封装在不同 POM 中了，可以使用 import
   2.import 依赖范围使用要求：
   1)打包类型必须是 pom
   2)必须放在 dependencyManagement 中
   

4. 版本管理

   1.release 正式发布版  snapshot 快照版本
   版本号约定：
   <主版本>.<次版本>.<增量版本>.<里程碑版本>
   主版本：项目架构有重大变化
   次版本：有较大的功能新增或变化，或全面系统的修复漏洞
   增量版本：修复重大漏洞
   里程碑版本：测试功能，与下一个正式版本相比，不是很稳定，有待更多地测试。
   
   2.mvn install 会将项目生成的构件安装到本地Maven仓库，mvn deploy 用来将项目生成的构件分发到远程Maven仓库
   <distributionManagement>
   	<repository>
   		<id>qf</id>
   		<name>qf Repository</name>
   		<url>http://maven.qf.com:8090/nexus/content/repositories/qf</url>
   	</repository>
   	<snapshotRepository>
   		<id>qf-snapshots</id>
   		<name>qf Snapshot Repository</name>
   		<url>http://maven.qf.com:8090/nexus/content/repositories/snapshots/</url>
   	</snapshotRepository>
   </distributionManagement>
   

5. repositories远程仓库配置

   <repositories>
   	<repository>
   		<id>aliyun</id>
   		<name>aliyun Repository</name>
   		<url>https://maven.aliyun.com/repository/public</url>
   		<snapshots>
   			<enabled>false</enabled>
   		</snapshots>
   	</repository>
   	<repository>
   		<id>oss-snapshots</id>
   		<name>oss-snapshots Repository</name>
   		<url>https://oss.sonatype.org/content/repositories/snapshots</url>
   		<releases>
   			<enabled>false</enabled>
   		</releases>
   		<snapshots>
   			<enabled>true</enabled>
   		</snapshots>
   	</repository>
   </repositories>
   

6. plugins和pluginManagement的区别

   plugins和pluginManagement 的区别，与dependencies和dependencyManagement的区别是非常类似的。plugins下的 plugin 是真实使用的，而pluginManagement下的plugins下的plugin则仅仅是一种声明，子项目中可以对pluginManagement下的plugin进行信息的选择、继承、覆盖等。
   

7. 聚合与继承

   1、聚合：
   在一个模块中管理其他模块。
   聚合模块通常是空模块，没有src文件夹，只有pom.xml文件，打包方式为pom
   <packaging>pom</packaging>
   <modules>
       <module>...</module>
       <module>...</module>
       <module>...</module>    
   </modules>
   打包方式有： jar（java项目）、war（web项目）、pom（聚合项目）
   普通模块默认为jar，聚合模块为pom
   2、继承：
   子工程继承父工程，父工程管理子工程
   在父工程的pom.xml中对依赖进行统一管理，在dependencesManager中声明依赖，而不是引入依赖。
   <dependencesManager>
       <dependences>
           <dependence>
               <groupId>...</groupId>
               <arifactid>...</arifactid>
               <version>...</version>
           </dependence>
           <dependence>
               <groupId>...</groupId>
               <arifactid>...</arifactid>
               <version>...</version>
           </dependence>        
       </dependences>
   <dependencesManager>
   在子工程的pom.xml中，实质地引入依赖，可以不写依赖的版本号，使用父工程pom.xml中指定的版本号，如果在子工程中指定版本号，则使用子工程的版本号
   3.依赖循环问题
   如果 A 工程依赖 B 工程，B 工程依赖 C 工程，C 工程又反过来依赖 A 工程，那么在执行构建操作时会报下面的错误：
   DANGER
   [ERROR] [ERROR] The projects in the reactor contain a cyclic reference:
   这个错误的含义是：循环引用。
   

8. 依赖排除

   maven的依赖调节原则： 1，第一原则：路径近者优先原则 A→B→C→X（1.1） D→E→X（1.2） 使用X（1.2），因为其路径更近 2，第二原则：第一声明者优先原则 A→B→X（1.1） C→D→X（1.2） 使用X（1.1），因为其先声明 maven会先根据第一原则判断，若路径相等，再根据第二原则判断

   为了避免因为maven自动筛选的jar包版本错误，所以需要解决所有依赖冲突问题

   1)使用IDEA的Maven Show Dependency插件
   
   

   标红色线的是冲突的jar包，需要找到合适的jar包版本，其他版本jar包需要排除，选中需要排除的jar包后点击shift+delete键即可修改pom文件排除依赖

   2)使用Maven Helper插件

   打开pom文件后，点击下方的Dependency Analyzer按钮，即可查看pom依赖关系，标红色的为存在依赖冲突的jar包，选择需要排除的jar包右键点击Exclude，即可修改pom文件排除jar包

   
   

   3)使用mvn clean install dependency:tree命令（maven-dependency-plugin插件）打印依赖关系，如果存在WARNING日志内容，则为冲突jar包，可以通过Jenkins集成OWASP Dependency-Check Plugin+sonar-dependency-check-plugin实现自动生成检测报告

   

   4)使用maven-enforcer-plugin插件进行预校验，执行命令mvn clean package enforcer:enforce，在WARNING日志内容中会显示冲突包信息

   

   <build>
       <pluginManagement>
           <plugins>
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-enforcer-plugin</artifactId>
                   <version>1.4.1</version>
                   <executions>
                       <execution>
                           <id>enforce-dependencies</id>
                           <phase>validate</phase>
                           <goals>
                               <goal>display-info</goal>
                               <goal>enforce</goal>
                           </goals>
                       </execution>
                   </executions>
                   <dependencies>
                       <dependency>
                           <groupId>org.codehaus.mojo</groupId>
                           <artifactId>extra-enforcer-rules</artifactId>
                           <version>1.0-beta-4</version>
                       </dependency>
                   </dependencies>
                   <configuration>
                       <rules>
                           <banDuplicateClasses>
                               <findAllDuplicates>true</findAllDuplicates>
                           </banDuplicateClasses>
                       </rules>
                   </configuration>
               </plugin>
           </plugins>
       </pluginManagement>
   </build>
   

9. maven内置属性

   1.内置属性（maven预定义，用户可以直接使用的）
   ${project.basedir}同${basedir}表示项目根目录，即包含pom.xml文件的目录;  
   ${version}表示项目版本。
   2.POM属性(使用pom属性可以引用到pom.xml文件对应的元素的值)
   ${project.build.sourceDirectory}:项目的主源码目录，默认为src/main/java/.
   ${project.build.testSourceDirectory}:项目的测试源码目录，默认为/src/test/java/.
   ${project.build.directory}:项目构建输出目录，默认为target/.
   ${project.outputDirectory}:项目主代码编译输出目录，默认为target/classes/.
   ${project.testOutputDirectory}:项目测试代码编译输出目录，默认为target/testclasses/.
   ${project.groupId}:项目的groupId.
   ${project.artifactId}:项目的artifactId.
   ${project.version}:项目的version,于${version}等价 
   ${project.build.finalName}:项目打包输出文件的名称，默认 为${project.artifactId}${project.version}.
   3.在pom.xml文件的<properties>标签下定义的maven属性
   4.setting.xml文件属性（与pom属性同理，用户可以用以settings.开头的属性引用setting.xml文件的XML元素值）${settings.localRepository}表示本地仓库的地址
   java系统属性（所有的java系统属性都可以用env,开头的maven属性引用），使用mvn help:system命令可查看所有环境变量；${env.JAVA_HOME}表示JAVA_HOME环境变量的值；
   

10. 使用maven切换不同环境配置文件

    1.pom中定义环境变量
    <profiles>
    	<profile>
    		<!--id唯一，打包时可以通过 -P profile.id 指定profile-->
    		<id>dev</id>
    		<properties>
    			<!--自定义标签，等待被${}占位符引用-->
    			<profile.active>dev</profile.active>
    		</properties>
    		<activation>
    			<!--打包时不指定profile，默认使用-->
    			<activeByDefault>true</activeByDefault>
    		</activation>
    	</profile>
    	<profile>
    		<id>test</id>
    		<properties>
    			<profile.active>test</profile.active>
    		</properties>
    	</profile>
    	<profile>
    		<id>prod</id>
    		<properties>
    			<profile.active>prod</profile.active>
    		</properties>
    	</profile>
    </profiles>
    2.application.yml中配置使用变量，分别对应了application-{profile.active}.yml配置文件
    spring:
      profiles:
        active: '@profile.active@'
    3.maven打包的时候指定变量
    mvn clean package -P dev|test|prod
    4.Filtering 是 maven 的 resource 插件 提供的功能，作用是用环境变量、pom文件里定义的属性和指定配置文件里的属性替换属性(*.properties)文件里的占位符(例如${jdbc.url})
    <!-- 用pom里定义的属性做替换 -->
    <properties>
    	<pom.jdbc.url>jdbc:mysql://127.0.0.1:3306/dev</pom.jdbc.url>
    	<pom.jdbc.username>root</pom.jdbc.username>
    	<pom.jdbc.password>123456</pom.jdbc.password>
    </properties>
    <build>
    	<!-- 可以把属性写到文件里,用属性文件里定义的属性做替换 -->
    	<!-- filters.properties中可以定义jdbc.url=${pom.jdbc.url} -->
    	<filters>
    		<filter>src/main/filters.properties</filter>
    	</filters>
    	<resources>
    		<resource>
    			<directory>src/main/resources</directory>
    			<filtering>true</filtering>
    		</resource>
    	</resources>
    </build>    
    

11. archetype模板

    1: appfuse-basic-jsf (创建一个基于Hibernate，Spring和JSF的Web应用程序的原型) 
    2: appfuse-basic-spring(创建一个基于Hibernate，Spring和Spring MVC的Web应用程序的原型) 
    3: appfuse-basic-struts(创建一个基于Hibernate，Spring和Struts 2的Web应用程序的原型) 
    4: appfuse-basic-tapestry(创建一个基于Hibernate，Spring 和 Tapestry 4的Web应用程序的原型) 
    5: appfuse-core(创建一个基于Hibernate，Spring 和 XFire的jar应用程序的原型) 
    6: appfuse-modular-jsf(创建一个基于Hibernate，Spring和JSF的模块化应用原型) 
    7: appfuse-modular-spring(创建一个基于Hibernate, Spring 和 Spring MVC 的模块化应用原型) 
    8: appfuse-modular-struts(创建一个基于Hibernate, Spring 和 Struts 2 的模块化应用原型) 
    9: appfuse-modular-tapestry (创建一个基于 Hibernate, Spring 和 Tapestry 4 的模块化应用原型) 
    10: maven-archetype-j2ee-simple(一个简单的J2EE的Java应用程序) 
    11: maven-archetype-marmalade-mojo(一个Maven的 插件开发项目 using marmalade) 
    12: maven-archetype-mojo(一个Maven的Java插件开发项目) 
    13: maven-archetype-portlet(一个简单的portlet应用程序) 
    14: maven-archetype-profiles() 
    15:maven-archetype-quickstart() 
    16: maven-archetype-site-simple(简单的网站生成项目) 
    17: maven-archetype-site(更复杂的网站项目) 
    18:maven-archetype-webapp(一个简单的Java Web应用程序) 
    19: jini-service-archetype(Archetype for Jini service project creation) 
    20: softeu-archetype-seam(JSF+Facelets+Seam Archetype) 
    21: softeu-archetype-seam-simple(JSF+Facelets+Seam (无残留) 原型) 
    22: softeu-archetype-jsf(JSF+Facelets 原型) 
    23: jpa-maven-archetype(JPA 应用程序) 
    24: spring-osgi-bundle-archetype(Spring-OSGi 原型) 
    25: confluence-plugin-archetype(Atlassian 聚合插件原型) 
    26: jira-plugin-archetype(Atlassian JIRA 插件原型) 
    27: maven-archetype-har(Hibernate 存档) 
    28: maven-archetype-sar(JBoss 服务存档) 
    29: wicket-archetype-quickstart(一个简单的Apache Wicket的项目) 
    30: scala-archetype-simple(一个简单的scala的项目) 
    31: lift-archetype-blank(一个 blank/empty liftweb 项目) 
    32: lift-archetype-basic(基本（liftweb）项目) 
    33: cocoon-22-archetype-block-plain([http://cocoapacorg2/maven-plugins/]) 
    34: cocoon-22-archetype-block([http://cocoapacorg2/maven-plugins/]) 
    35:cocoon-22-archetype-webapp([http://cocoapacorg2/maven-plugins/]) 
    36: myfaces-archetype-helloworld(使用MyFaces的一个简单的原型) 
    37: myfaces-archetype-helloworld-facelets(一个使用MyFaces和Facelets的简单原型) 
    38: myfaces-archetype-trinidad(一个使用MyFaces和Trinidad的简单原型) 
    39: myfaces-archetype-jsfcomponents(一种使用MyFaces创建定制JSF组件的简单的原型) 
    40: gmaven-archetype-basic(Groovy的基本原型) 
    41: gmaven-archetype-mojo(Groovy mojo 原型)
    

12. Maven项目的标准目录结构

    • src
    • • main
    • • • java 源文件
        • resources 资源文件
        • filters 资源过滤文件
        • config 配置文件
        • scripts 脚本文件
        • webapp web应用文件
    • • test
    • • • java 测试源文件
        • resources 测试资源文件
        • filters 测试资源过滤文件
    • • it 集成测试
      • assembly assembly descriptors
      • site Site
    • target
    • • generated-sources
      • classes
      • generated-test-sources
      • test-classes
      • xxx.jar
    • pom.xml
    • LICENSE.txt
    • NOTICE.txt
    • README.txt

13. idea中导入maven项目

    idea可以将需要打开的多个项目放置到同一个文件夹下，然后直接打开文件夹就可以在同一个窗口打开所有项目，在pom.xml文件上右键，可以将导入的项目转换成maven项目

    

    如果需要指定settings.xml文件及本地仓库路径，需要点击File->Build，Execution，Deployment->Build Tools->maven
    

    执行maven命令，点击右侧Maven->M按钮
    
    

    项目基本信息设置，点击File->Project Structure

    

四、maven插件

1. Maven整合JaCoCo用于检测测试覆盖率

   <plugin>
     <groupId>org.jacoco</groupId>
     <artifactId>jacoco-maven-plugin</artifactId>
     <version>${jacoco.version}</version>
     <configuration>
       <skip>${maven.test.skip}</skip>
       <destFile>${basedir}/target/coverage-reports/jacoco-unit.exec</destFile>
       <dataFile>${basedir}/target/coverage-reports/jacoco-unit.exec</dataFile>
       <output>file</output>
       <append>true</append>
       <excludes>
         <exclude>com/pkslow/basic/containsperformance/**</exclude>
         <exclude>com/pkslow/basic/ReadPropertiesFile</exclude>
       </excludes>
       <!-- 配置代码测试覆盖率规则 -->
       <rules>
         <rule implementation="org.jacoco.maven.RuleConfiguration">
           <element>BUNDLE</element>
           <limits>　　
             <limit implementation="org.jacoco.report.check.Limit">
               <counter>METHOD</counter>
               <value>COVEREDRATIO</value>
               <minimum>0.50</minimum>
             </limit>
             <limit implementation="org.jacoco.report.check.Limit">
               <counter>BRANCH</counter>
               <value>COVEREDRATIO</value>
               <minimum>0.50</minimum>
             </limit>
             <limit implementation="org.jacoco.report.check.Limit">
               <counter>CLASS</counter>
               <value>MISSEDCOUNT</value>
               <maximum>0</maximum>
             </limit>
           </limits>
         </rule>
       </rules>
     </configuration>
     <executions>
       <execution>
         <id>jacoco-initialize</id>
         <goals>
           <goal>prepare-agent</goal>
         </goals>
         <phase>test-compile</phase>
       </execution>
   
       <execution>
         <id>jacoco-site</id>
         <phase>verify</phase>
         <goals>
           <goal>report</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   

2. dependency-check-maven安全漏洞扫描工具，执行mvn dependency-check:check命令，在会在target目录下生成一个dependency-check-report.html

   <plugin>
       <groupId>org.owasp</groupId>
       <artifactId>dependency-check-maven</artifactId>
       <version>${dependency-check-maven.version}</version>
       <configuration>
           <autoUpdate>true</autoUpdate>
           <dataDirectory>D:\ProgramFiles\dependency-check\data</dataDirectory>
           <versionCheckEnabled>false</versionCheckEnabled>
           <retireJsForceUpdate>false</retireJsForceUpdate>
           <ossindexAnalyzerUseCache>true</ossindexAnalyzerUseCache>
           <skipRuntimeScope>true</skipRuntimeScope>
           <skipProvidedScope>true</skipProvidedScope>
           <skipSystemScope>true</skipSystemScope>
           <skipTestScope>true</skipTestScope>
       </configuration>
       <executions>
           <execution>
               <goals>
                   <goal>check</goal>
               </goals>
           </execution>
       </executions>
   </plugin>
   

3. maven-assembly-plugin将依赖文件打包到jar中

   <build>
   	<plugins>
   		<plugin>
   			<artifactId>maven-compiler-plugin</artifactId>
   			<configuration>
   				<source>1.8</source>
   				<target>1.8</target>
   				<encoding>${project.build.sourceEncoding}</encoding>
   			</configuration>
   		</plugin>
   		<plugin>
   			<artifactId>maven-assembly-plugin</artifactId>
   			<configuration>
   				<descriptorRefs>
   					<descriptorRef>jar-with-dependencies</descriptorRef>
   				</descriptorRefs>
   				<archive>
   					<manifest>
   						<mainClass>com.itsenlin.Helloworld</mainClass>
   					</manifest>
   				</archive>
   			</configuration>
   			<executions>
   				<execution>
   					<id>make-assembly</id> <!-- this is used for inheritance merges -->
   					<phase>package</phase> <!-- bind to the packaging phase -->
   					<goals>
   						<goal>single</goal>
   					</goals>
   				</execution>
   			</executions>
   		</plugin>
   	</plugins>
   </build>
   

4. 配置groovy 插件，支持java和groovy混合开发

   <build>
       <plugins>
       <!-- 增加 gmavenplus 插件 允许集成Groovy到Maven-->
         <plugin> 
           <groupId>org.codehaus.gmavenplus</groupId>  
           <artifactId>gmavenplus-plugin</artifactId>
           <version>1.7.1</version>
           <executions>
             <execution>
               <goals>
                 <goal>addSources</goal>
                 <goal>addTestSources</goal>
                 <goal>generateStubs</goal>
                 <goal>compile</goal>
                 <goal>generateTestStubs</goal>
                 <goal>compileTests</goal>
                 <goal>removeStubs</goal>
                 <goal>removeTestStubs</goal>
               </goals>
             </execution>
           </executions>
         </plugin>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
         </plugin>
       </plugins>
     </build>
     <dependencies>
       <dependency>
         <groupId>org.codehaus.groovy</groupId>
         <!-- groovy-all 包含所有groovy GDK 中的包,
          groovy 只包含基础 Groovy 编译需要的包-->
         <artifactId>groovy-all</artifactId>
         <!-- any version of Groovy \>= 1.8.2 should work here -->
         <version>2.5.7</version>
         <!--指定类型为 pom -->
         <type>pom</type>
       </dependency>
     </dependencies>
   

5. maven编译插件maven-compiler-plugin

   <build>
   	<plugins>
   		<!-- 指定JDK编译版本 -->
   		<plugin>
   			<groupId>org.apache.maven.plugins</groupId>
   			<artifactId>maven-compiler-plugin</artifactId>
   			<configuration>
   				<source>1.8</source>
   				<target>1.8</target>
   				<encoding>UTF-8</encoding>
   			</configuration>
   		</plugin>
   		<!-- 打包跳过测试 -->
   		<plugin>
   			<groupId>org.apache.maven.plugins</groupId>
   			<artifactId>maven-surefire-plugin</artifactId>
   			<configuration>
   			  <skipTests>true</skipTests>
   			</configuration>
   		</plugin>
   		 <!-- 避免font文件的二进制文件格式压缩破坏 -->
   		 <plugin>
   			<groupId>org.apache.maven.plugins</groupId>
   			<artifactId>maven-resources-plugin</artifactId>
   			 <version>3.1.0</version>
   			<configuration>
   				<nonFilteredFileExtensions>
   					<nonFilteredFileExtension>woff</nonFilteredFileExtension>
   					<nonFilteredFileExtension>woff2</nonFilteredFileExtension>
   					<nonFilteredFileExtension>eot</nonFilteredFileExtension>
   					<nonFilteredFileExtension>ttf</nonFilteredFileExtension>
   					<nonFilteredFileExtension>svg</nonFilteredFileExtension>
   				</nonFilteredFileExtensions>
   			</configuration>
   		</plugin>
   	</plugins>
   	<resources>
   		<resource>
   			<directory>src/main/resources</directory>
   			<filtering>true</filtering>
   		</resource>
   		<resource>
   			<directory>src/main/java</directory>
   			<includes>
   				<include>**/*.xml</include>
   				<include>**/*.json</include>
   				<include>**/*.ftl</include>
   			</includes>
   		</resource>
   	</resources>
   </build>
   

6. 多个项目关联自动化构建maven-invoker-plugin

   <build>
   	<plugins>
   		<plugin>
   			<artifactId>maven-invoker-plugin</artifactId>
   			<version>2.0.0</version>
   			<configuration>
   				<debug>true</debug>
   				<!-- 关联项目所在目录 -->
   				<projectsDirectory>C:\work\projects</projectsDirectory>
   				<cloneProjectsTo>${project.build.directory}</cloneProjectsTo>
   			</configuration>
   			<executions>
   				<execution>
   					<id>id-integration-test</id>
   					<goals>
   						<goal>run</goal>
   					</goals>
   				</execution>
   			</executions>
   		</plugin>
   	</plugins>
   </build>
   

7. 源码打包插件maven-source-plugin

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-source-plugin</artifactId>
               <version>2.1.2</version>
               <executions>
                   <execution>
                       <phase>package</phase>
                       <goals>
                           <goal>jar-no-fork</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
   

8. 自定义规则插件maven-enforcer-plugin

   创建一系列规则强制大家遵守，包括设定Java版本、设定Maven版本、禁止某些依赖、禁止 SNAPSHOT依赖。只要在一个父POM配置规则，然后让大家继承，当规则遭到破坏的时候，Maven就会报错。除了标准的规则之外，你还可以扩展该插 件，编写自己的规则。maven-enforcer-plugin的enforce目标负责检查规则，它默认绑定到生命周期的validate阶段。
   

9. maven辅助工具maven-help-plugin

   maven-help-plugin是一个小巧的辅助工具，最简单的help:system可以打印所有可用的环境变量和Java系统属性。help:effective-pom和help:effective-settings最 为有用，它们分别打印项目的有效POM和有效settings，有效POM是指合并了所有父POM（包括Super POM）后的XML，当你不确定POM的某些信息从何而来时，就可以查看有效POM。有效settings同理，特别是当你发现自己配置的 settings.xml没有生效时，就可以用help:effective-settings来验证。此外，maven-help-plugin的describe目标可以帮助你描述任何一个Maven插件的信息，还有all-profiles目标和active-profiles目标帮助查看项目的Profile。
   

10. 自动化版本发布插件maven-release-plugin

    是帮助自动化项目版本发布，它依赖于POM中的SCM信息。release:prepare用来准备版本发布，具体的工作包括检查是否有未提交代码、检查是否有SNAPSHOT依赖、升级项目的SNAPSHOT版本至RELEASE版本、为项目打标签等等。release:perform则 是签出标签中的RELEASE源码，构建并发布。版本发布
    

五、pom信息整理

1. pom.xml

   <?xml version="1.0" encoding="utf-8"?>
   <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/maven-v4_0_0.xsd">
       <!--父项目的坐标。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。 坐标包括group ID，artifact ID和 version。-->
       <parent>
           <!--被继承的父项目的构件标识符-->
           <artifactId/>
           <!--被继承的父项目的全球唯一标识符-->
           <groupId/>
           <!--被继承的父项目的版本-->
           <version/>
       </parent>
       <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。-->
       <modelVersion>4.0.0</modelVersion>
       <!--项目的全球唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app -->
       <groupId>cn.missbe.web</groupId>
       <!-- 构件的标识符，它和group ID一起唯一标识一个构件。换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个特定的group ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源码，二进制发布和WARs等。-->
       <artifactId>search-resources</artifactId>
       <!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型-->
       <packaging>war</packaging>
       <!--项目当前版本，格式为:主版本.次版本.增量版本-限定版本号-->
       <version>1.0-SNAPSHOT</version>
       <!--项目的名称, Maven产生的文档用-->
       <name>search-resources</name>
       <!--项目主页的URL, Maven产生的文档用-->
       <url>http://www.missbe.cn</url>
       <!-- 项目的详细描述, Maven 产生的文档用。  当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标 签），不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。-->
       <description>A maven project to study maven.</description>
       <!--描述了这个项目构建环境中的前提条件。-->
       <prerequisites>
           <!--构建该项目或使用该插件所需要的Maven的最低版本-->
           <maven/>
       </prerequisites>
       <!--构建项目需要的信息-->
       <build>
           <!--该元素设置了项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->
           <sourceDirectory/>
           <!--该元素设置了项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。-->
           <scriptSourceDirectory/>
           <!--该元素设置了项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->
           <testSourceDirectory/>
           <!--被编译过的应用程序class文件存放的目录。-->
           <outputDirectory/>
           <!--被编译过的测试class文件存放的目录。-->
           <testOutputDirectory/>
           <!--使用来自该项目的一系列构建扩展-->
           <extensions>
               <!--描述使用到的构建扩展。-->
               <extension>
                   <!--构建扩展的groupId-->
                   <groupId/>
                   <!--构建扩展的artifactId-->
                   <artifactId/>
                   <!--构建扩展的版本-->
                   <version/>
               </extension>
           </extensions>
           <!--这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。-->
           <resources>
               <!--这个元素描述了项目相关或测试相关的所有资源路径-->
               <resource>
                   <!-- 描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。举个例 子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven /messages。然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。-->
                   <targetPath/>
                   <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。-->
                   <filtering/>
                   <!--描述存放资源的目录，该路径相对POM路径-->
                   <directory/>
                   <!--包含的模式列表，例如**/*.xml.-->
                   <includes/>
                   <!--排除的模式列表，例如**/*.xml-->
                   <excludes/>
               </resource>
           </resources>
           <!--这个元素描述了单元测试相关的所有资源路径，例如和单元测试相关的属性文件。-->
           <testResources>
               <!--这个元素描述了测试相关的所有资源路径，参见build/resources/resource元素的说明-->
               <testResource>
                   <targetPath/>
                   <filtering/>
                   <directory/>
                   <includes/>
                   <excludes/>
               </testResource>
           </testResources>
           <!--构建产生的所有文件存放的目录-->
           <directory/>
           <!--产生的构件的文件名，默认值是${artifactId}-${version}。-->
           <finalName/>
           <!--当filtering开关打开时，使用到的过滤器属性文件列表-->
           <filters/>
           <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->
           <pluginManagement>
               <!--使用的插件列表 。-->
               <plugins>
                   <!--plugin元素包含描述插件所需要的信息。-->
                   <plugin>
                       <!--插件在仓库里的group ID-->
                       <groupId/>
                       <!--插件在仓库里的artifact ID-->
                       <artifactId/>
                       <!--被使用的插件的版本（或版本范围）-->
                       <version/>
                       <!--是否从该插件下载Maven扩展（例如打包和类型处理器），由于性能原因，只有在真需要下载时，该元素才被设置成enabled。-->
                       <extensions/>
                       <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。-->
                       <executions>
                           <!--execution元素包含了插件执行需要的信息-->
                           <execution>
                               <!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标-->
                               <id/>
                               <!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段-->
                               <phase/>
                               <!--配置的执行目标-->
                               <goals/>
                               <!--配置是否被传播到子POM-->
                               <inherited/>
                               <!--作为DOM对象的配置-->
                               <configuration/>
                           </execution>
                       </executions>
                       <!--项目引入插件所需要的额外依赖-->
                       <dependencies>
                           <!--参见dependencies/dependency元素-->
                           <dependency>......</dependency>
                       </dependencies>
                       <!--任何配置是否被传播到子项目-->
                       <inherited/>
                       <!--作为DOM对象的配置-->
                       <configuration/>
                   </plugin>
               </plugins>
           </pluginManagement>
           <!--使用的插件列表-->
           <plugins>
               <!--参见build/pluginManagement/plugins/plugin元素-->
               <plugin>
                   <groupId/>
                   <artifactId/>
                   <version/>
                   <extensions/>
                   <executions>
                       <execution>
                           <id/>
                           <phase/>
                           <goals/>
                           <inherited/>
                           <configuration/>
                       </execution>
                   </executions>
                   <dependencies>
                       <!--参见dependencies/dependency元素-->
                       <dependency>......</dependency>
                   </dependencies>
                   <goals/>
                   <inherited/>
                   <configuration/>
               </plugin>
           </plugins>
       </build>
       <!--模块（有时称作子项目）被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->
       <modules/>
       <!--发现依赖和扩展的远程仓库列表。-->
       <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就可以在每个单独的仓库中，为每种类型的构件采取不同的 策略。例如，可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素 -->
               <snapshots>
                   <enabled/>
                   <updatePolicy/>
                   <checksumPolicy/>
               </snapshots>
               <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库-->
               <id>banseon-repository-proxy</id>
               <!--远程仓库名称-->
               <name>banseon-repository-proxy</name>
               <!--远程仓库URL，按protocol://hostname/path形式-->
               <url>http://192.168.1.169:9999/repository/</url>
               <!-- 用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。Maven 2为其仓库提供了一个默认的布局；然 而，Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。-->
               <layout>default</layout>
           </repository>
       </repositories>
       <!--发现插件的远程仓库列表，这些插件用于构建和报表-->
       <pluginRepositories>
           <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->
           <pluginRepository>......</pluginRepository>
       </pluginRepositories>
       <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。
     它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。-->
       <dependencies>
           <dependency>
               <!--依赖的group ID-->
               <groupId>org.apache.maven</groupId>
               <!--依赖的artifact ID-->
               <artifactId>maven-artifact</artifactId>
               <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->
               <version>3.8.1</version>
               <!-- 依赖类型，默认类型是jar。它通常表示依赖的文件的扩展名，但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应，尽管这也有例外。一些类型的例子：jar，war，ejb-client和test-jar。如果设置extensions为 true，就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。-->
               <type>jar</type>
               <!-- 依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如，如果你想要构建两个单独的构件成 JAR，一个使用Java 1.4编译器，另一个使用Java 6编译器，你就可以使用分类器来生成两个单独的JAR构件。-->
               <classifier/>
               <!--依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。   
                         - compile ：默认范围，用于编译      
                         - provided：类似于编译，但支持你期待jdk或者容器提供，类似于classpath     
                         - runtime: 在执行时需要使用      
                         - test:    用于test任务时使用      
                         - system: 需要外在提供相应的元素。通过systemPath来取得      
                         - systemPath: 仅用于范围为system。提供相应的路径      
                         - optional:   当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用-->
               <scope>test</scope>
               <!--仅供system范围使用。注意，不鼓励使用这个元素，并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径，例如${java.home}。-->
               <systemPath/>
               <!--当计算传递依赖时， 从依赖构件列表里，列出被排除的依赖构件集。即告诉maven你只依赖指定的项目，不依赖项目的依赖。此元素主要用于解决版本冲突问题-->
               <exclusions>
                   <exclusion>
                       <artifactId>spring-core</artifactId>
                       <groupId>org.springframework</groupId>
                   </exclusion>
               </exclusions>
               <!--可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。-->
               <optional>true</optional>
           </dependency>
       </dependencies>
       <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述group ID和 artifact ID信息），如果group ID和artifact ID以外的一些信息没有描述，则通过group ID和artifact ID 匹配到这里的依赖，并使用这里的依赖信息-->
       <dependencyManagement>
           <dependencies>
               <!--参见dependencies/dependency元素-->
               <dependency>......</dependency>
           </dependencies>
       </dependencyManagement>
       <!--项目分发信息，在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库-->
       <distributionManagement>
           <!--部署项目产生的构件到远程仓库需要的信息-->
           <repository>
               <!--是分配给快照一个唯一的版本号（由时间戳和构建流水号）？还是每次都使用相同的版本号？参见repositories/repository元素-->
               <uniqueVersion/>
               <id>banseon-maven2</id>
               <name>banseon maven2</name>
               <url>file://${basedir}/target/deploy</url>
               <layout/>
           </repository>
           <!--构件的快照部署到哪里？如果没有配置该元素，默认部署到repository元素配置的仓库，参见distributionManagement/repository元素-->
           <snapshotRepository>
               <uniqueVersion/>
               <id>banseon-maven2</id>
               <name>Banseon-maven2 Snapshot Repository</name>
               <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>
               <layout/>
           </snapshotRepository>
           <!--部署项目的网站需要的信息-->
           <site>
               <!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置-->
               <id>banseon-site</id>
               <!--部署位置的名称-->
               <name>business api website</name>
               <!--部署位置的URL，按protocol://hostname/path形式-->
               <url>scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web</url>
           </site>
           <!--项目下载页面的URL。如果没有该元素，用户应该参考主页。使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。-->
           <downloadUrl/>
           <!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。有效的值有：none（默认），converted（仓库管理员从 Maven 1 POM转换过来），partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部 署），verified（被核实时正确的和最终的）。-->
           <status/>
       </distributionManagement>
       <!--以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml配置文件里activation元素的说明）。格式是<name>value</name>-->
       <properties/>
   </project>http://192.168.14.88:8081/zh/share/docker.html)