maven内置属性与打包相关插件

已于 2022-05-20 09:29:19 修改
阅读量1.2k 收藏 4
点赞数
分类专栏： maven 文章标签： maven java xml
于 2022-05-20 09:23:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46090394/article/details/124876749
版权

maven内置属性

内置属性

主要有两个常用内置属性：b a s e d i r 项 目 的 根 目 录 ( 包 含 p o m . x m l 文 件 的 目 录 ) ， {basedir}项目的根目录(包含pom.xml文件的目录)，basedir项目的根目录(包含pom.xml文件的目录)，{version}项目版本

POM属性

用户可以使用该属性引用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 ： 项 目 的 v e r s i o n ， 与 {project.version}：项目的 version，与project.version：项目的version，与{version}等价

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

自定义属性

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

Settings属性

用户使用settings.开头的属性引用 settings.xml 文件中XML元素的值

Java系统属性

所有Java系统属性都可以使用Maven属性引用

环境变量属性

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

在依赖中 使用pom变量

<dependencies>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>part-a</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>part-b</artifactId>
        <version>${project-version}</version>
    </dependency>
</dependencies>

在插件中使用pom变量

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.5</version>
    <configuration>
        <repositoryDirectory>${project.build.directory}/test-reports</repositoryDirectory>
    </configuration>
</plugin>

自定义变量

 <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>
</profiles>

Maven属性默认只有在POM中才会被解析，因此需要让Maven解析资源文件中的Maven属性。Maven用maven-resources-plugin处理资源文件。它默认的行为只是将项目主资源文件复制到主代码编译输出目录中，将测试资源文件复制到测试代码编译输出目录中。

Maven默认的主资源目录和测试资源目录的定义是在超级POM中，要为资源目录开启过滤，只要在此基础上添加一行filtering配置即可。

Filtering是maven resource插件的功能，作用是用环境变量，pom文件里定义的属性和指定文件里的属性替换属性文件的占位符。（超级pom在 apache-maven-3.3.9\lib\maven-model-builder-3.3.9.jar\org\apache\maven\model\pom-4.0.0.xml）

maven6大内置属性

Maven共有6类属性：

  1. 内置属性(Maven预定义,用户可以直接使用)
    ${basedir}表示项目根目录,即包含pom.xml文件的目录;
    ${version}表示项目版本;
    ${project.basedir}同 ${basedir};
    ${project.baseUri}表示项目文件地址;
    ${maven.build.timestamp}表示项目构件开始时间;
    ${maven.build.timestamp.format}表示属性 ${maven.build.timestamp}的展示格式,默认值为yyyyMMdd-HHmm,可自定义其格式,其类型可参考java.text.SimpleDateFormat。用法如下：
<properties>
	<maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format>
</properties>

  1. POM属性(使用pom属性可以引用到pom.xml文件对应元素的值)
    ${project.build.directory}表示主源码路径;
    ${project.build.sourceEncoding}表示主源码的编码格式;
    ${project.build.sourceDirectory}表示主源码路径;
    ${project.build.finalName}表示输出文件名称;
    ${project.version}表示项目版本,与 ${version}相同;

  2. 自定义属性(在pom.xml文件的标签下定义的Maven属性)

    <project>
  <properties>
    <my.project>abc</my.project>
  </properties>
</project>

    在其他地方使用${my.project}使用该属性值。

  3. settings.xml文件属性(与pom属性同理,用户使用以settings.开头的属性引用settings.xml文件中的XML元素值)

    • ${settings.localRepository}表示本地仓库的地址;

  4. Java系统属性(所有的Java系统属性都可以使用Maven属性引用)

    • 使用mvn help:system命令可查看所有的Java系统属性;

    • System.getProperties()可得到所有的Java属性;

    • ${user.home}表示用户目录;

  5. 环境变量属性(所有的环境变量都可以用以env.开头的Maven属性引用)

    • 使用mvn help:system命令可查看所有环境变量;

    • ${env.JAVA_HOME}表示JAVA_HOME环境变量的值;

maven插件

spring-boot-maven-plugin:

将应用程序及其依赖jar一起打包到一个独立的jar中,打出来的是fat jar,可以直接启动

<plugin>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-maven-plugin</artifactId>
           <executions>
               <execution>
                   <goals>
                       <goal>repackage</goal>
                   </goals>
               </execution>
           </executions>
</plugin>

maven-jar-plugin

maven打成jar包插件:默认的打包插件

只包括当前模块的jar,不包含依赖jar,无法直接启动（相当于打成一个可以依赖的jar包）

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-jar-plugin</artifactId>
	<version>2.4</version>
	<configuration>
		<archive>
			<!-- 生成的jar中，包含pom.xml和pom.properties这两个文件 -->
			<addMavenDescriptor>true</addMavenDescriptor>
			<!-- 生成MANIFEST.MF的设置 -->
			<manifest>
				<!--这个属性特别关键，如果没有这个属性，有时候我们引用的包maven库
				下面可能会有多个包，并且只有一个是正确的，其余的可能是带时间戳的，
				此时会在classpath下面把那个带时间戳的给添加上去，然后我们
				在依赖打包的时候，打的是正确的，所以两头会对不上，报错。-->
				<useUniqueVersions>false</useUniqueVersions>
				<!-- 为依赖包添加路径, 这些路径会写在MANIFEST文件的Class-Path下 -->	
				<addClasspath>true</addClasspath>
				<!-- 这个jar所依赖的jar包添加classPath的时候的前缀，如果这个
				jar本身和依赖包在同一级目录，则不需要添加-->
				<classpathPrefix>lib/</classpathPrefix>
                <!-- jar启动入口类：指定运行的主程序,会在META-INF/MANIFEST.MF 指定main-->
                <mainClass>com.test.Test</mainClass>
			</manifest>
			<manifestEntries>
				<!-- 在Class-Path下添加配置文件的路径 -->
				<Class-Path>../config/</Class-Path>
				<!-- 假如这个项目可能要引入一些外部资源，但是你打包的时候并不想把
				这些资源文件打进包里面，这个时候你必须在这边额外指定一些这些资源
				文件的路径，这个位置指定的话，要根据你预期的这些位置去设置，我这边
				所有jar都在lib下，资源文件都在config下，lib和config是同级的 -->
				<!-- 同时还需要注意另外一个问题，假如你的pom文件里面配置了
				<scope>system</scope>,就是你依赖是你本地的资源，这个时候使用
				这个插件，classPath里面是不会添加，所以你得手动把这个依赖添加进
				这个地方，用空格隔开就行-->
			</manifestEntries>
		</archive>
		<!-- jar包的位置-->
		<outputDirectory>${project.build.directory}/lib</outputDirectory>
		<includes>
			<!-- 打jar包时，只打包class文件 -->
			<!-- 有时候可能需要一些其他文件，这边可以配置，包括剔除的文件等等-->
			<include>**/*.class</include>
		</includes>
	</configuration>
</plugin>

maven-dependency-plugin

复制依赖：将项目依赖项从存储库复制到定义位置的目标。处理与依赖相关的插件。它有很多可用的goal，但是我们最常用到的是 dependency:copy，dependency:copy-dependencies及dependency:unpack,dependency:unpack-dependencies这四个。此处演示常用的dependency:copy和dependency:copy-dependencies.

dependency:copy: 将一系列在此插件内列出的artifacts ，将他们copy到一个特殊的地方，重命名或者去除其版本信息。这个可以解决远程仓库存在但是本地仓库不存在的依赖问题，copy操作可以用来将某个（些）maven artifact(s)拷贝到某个目录下。添加phase和goal如下:

比如把junit拷到libs目录下

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.8</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>copy</goal>
                    </goals>
                    <configuration>
                        <artifactItems>
                            <artifactItem>
                                <groupId>junit</groupId>
                                <artifactId>junit</artifactId>
                                <version>4.11</version>
                                <outputDirectory>${project.build.directory}/libs</outputDirectory>
                            </artifactItem>
                        </artifactItems>
                    </configuration>
                </execution>
            </executions>
        </plugin>

执行mvn package打包命令之后，会多出libs目录:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBPsKdsu-1653009649047)(图片.assets/image-20220519095402457.png)]

dependency:copy-dependencies: 将项目所有的依赖copy到指定的地方，

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-dependency-plugin</artifactId>
	<executions>
		<execution>
			<id>copy-dependencies</id>
			<phase>package</phase>
			<goals>
				<goal>copy-dependencies</goal>
			</goals>
			<configuration>
				<!-- 拷贝项目依赖包到lib/目录下 -->
				<outputDirectory>${project.build.directory}/lib</outputDirectory>
				<!-- 间接依赖也拷贝 -->
				<excludeTransitive>false</excludeTransitive>
				<!-- 带上版本号 -->
				<stripVersion>false</stripVersion>
                
                <outputDirectory>target/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
			</configuration>
		</execution>
	</executions>
</plugin>

maven-resources-plugin

maven中默认只能读取resources文件夹下的资源，如果要读取其他路径下的资源文件，那么就需要用到maven-resources-plugin这一插件

Maven区别对待Java代码文件和资源文件，maven-compiler-plugin用来编译Java代码，maven-resources-plugin则用来处理资源文件。

默认的主资源文件目录是src/main/resources，很多用户会需要添加额外的资源文件目录，这个时候就可以通过配置maven-resources-plugin来实现

方式1:

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-resources-plugin</artifactId>
	<version>2.6</version>
	<executions>
		<!-- 一个execution就是一个目标输入位置，如果想把各种资源拆开放的话，就
		可以创建多个execution，一个资源文件可以被拷贝多份 -->
		<execution>
			<id>copy-resources</id>
			<phase>package</phase>
			<goals>
				<goal>copy-resources</goal>
			</goals>
			<configuration>
				<encoding>UTF-8</encoding>
				<!-- 资源文件的输出目录 -->
				<outputDirectory>{project.build.directory}/config</outputDirectory>
				<resources>
					<!-- 资源文件的原始目录，有多个的话就多配几个 -->
					<resource>
						<!-- 原始目录 -->
						<directory>src/main/resources</directory>
						<!-- 是否使用过滤器，如果是的话，需要配置一下才行
						这个后续再研究，这边没有使用到 -->
						<filtering>true</filtering>
						<!-- 包含哪些文件以及去除调哪些文件等等 -->
						<includes>
							<include>**/*.*</include>
						</includes>
						<excludes>
							<exclude>**/*.json</exclude>
						</excludes>
					</resource>
				</resources>
			</configuration>
		</execution>
	</executions>
</plugin>

方式2：

pom.xml中导入

<plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-resources-plugin</artifactId>
          <version>2.6</version>
</plugin>

在build节点下面添加resource配置：

<resource>
		<!--从此目录下读取全部以.properties和.xml开头的文件-->
        <directory>src/main/resources/</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
</resource>
 <resource>
		 <!--从此目录下读取全部以.properties和.xml开头的文件-->
        <directory>src/main/java/</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
      </resource>
</resources>

maven-source-plugin

可以把我们的项目打包成源码包.

 <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <attach>true</attach>
                </configuration>
                <executions>
                    <execution>
                         <!-- 可以指定在哪个阶段打成源码包
               		package 在package阶段打源码包 -->
                        <phase>package</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
</plugin>

在这里插入图片描述

maven-assembly-plugin

maven-assembly-plugin : 是maven中针对打包任务而提供的标准插件,可以实现自定义打包。
主要提供如下功能：

  • 提供一个把工程依赖元素、模块、网站文档等其他文件存放到单个归档文件里
  • 打包成指定格式分发包，支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的
  • 能够自定义包含/排除指定的目录或文件

在pom.xml 文件里面的配置说明

<plugin>  
    <artifactId>maven-assembly-plugin</artifactId>  
    <executions>  <!--执行器 mvn assembly:assembly-->  
        <execution>  
            <id>make-zip</id><!--名字任意 -->    
        <phase>package</phase><!-- 绑定到package生命周期阶段上 -->    
        <goals>    
           <goal>single</goal><!-- 只运行一次 -->    
        </goals>    
        <configuration>  
             <descriptors> 
             <!--描述文件路径-->  
             <descriptor>build/assembly/assembly.xml</descriptor>  
             </descriptors>  
         </configuration>  
        </execution>  
    </executions>  
 </plugin>

assembly.xml描述文件：

<?xml version="1.0" encoding="UTF-8"?>
<assembly>
    <!--打包名称，唯一标识-->
    <id>assembly</id>
    <!--打包格式，可以手动修改-->
    <formats>
        <format>tar.gz</format>
    </formats>
    <!--根目录-->
    <baseDirectory>data-xxx-xxx</baseDirectory>
    <!--文件设置-->
    <fileSets>
        <fileSet>
            <!--目标目录,会处理目录里面的所有文件-->
            <directory>build/bin</directory>
            <!--相对于打包后的目录-->
            <outputDirectory>bin</outputDirectory>
            <!--文件过滤-->
            <includes>
                <include>*.*</include>
            </includes>
            <!--文件权限-->
            <fileMode>0755</fileMode>
            <!--如果是脚本，一定要改为unix.如果是在windows上面编码，会出现dos编写问题-->
            <lineEnding>unix</lineEnding>
        </fileSet>
        <fileSet>
            <directory>src/main/resources</directory>
            <outputDirectory>conf</outputDirectory>
        </fileSet>
 <!-- 指定输出target/classes中的配置文件到config目录中 -->
        <fileSet>
            <directory>${basedir}/target/classes</directory>
            <outputDirectory>config</outputDirectory>
            <fileMode>0644</fileMode>
            <includes>
                <include>*.xml</include>
                <include>*.properties</include>
                <include>*.keystore</include>
                <include>*.yaml</include>
            </includes>
        </fileSet>
             <!-- 将第三方依赖打包到lib目录中 -->
        <fileSet>
            <directory>${basedir}/target/lib</directory>
            <outputDirectory>lib</outputDirectory>
            <fileMode>0755</fileMode>
        </fileSet>
                <!-- 启动jar文件打包 -->
        <fileSet>
            <directory>${basedir}/target</directory>
            <outputDirectory>${file.separator}</outputDirectory>
            <fileMode>0755</fileMode>
            <includes>
                <include>${project.build.finalName}.jar</include>
            </includes>
        </fileSet>
    </fileSets>
	<dependencySets>
        <dependencySet>
            <!--是否把本项目添加到依赖文件夹下:-->
            <useProjectArtifact>false</useProjectArtifact>
            <!-- 将项目所有依赖包拷贝到发布包的lib目录下 ：-->
            <outputDirectory>lib</outputDirectory>
            <!-- 符合runtime作用范围的依赖会被打包进去： -->
            <scope>runtime</scope>
        </dependencySet>
	</dependencySets>
</assembly>

assembly标签

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

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

<formats> 
     <format>tar.gz</format> 
     <format>dir</format>
 </formats>
3. includeBaseDirectory标签

includeBaseDirectory标签指定打的包是否包含打包层目录（比如finalName是terminal-dispatch，当值为true，所有文件被放在包内的terminal-dispatch目录下，否则直接放在包的根目录下）

4. dependencySets标签

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

  • outputDirectory： 指定包依赖目录，该目录是相对于根目录
  • includes/include*：包含依赖
  • excludes/exclude*：排除依赖
  • useProjectArtifact：指定打包时是否包含工程自身生成的jar包
  • unpack：布尔值，false表示将依赖以原来的JAR形式打包，true则表示将依赖解成*.class文件的目录结构打包
  • scope：表示符合哪个作用范围的依赖会被打包进去。compile与provided都不用管，一般是写runtime
5. fileSets标签

fileSets标签用来设置一组文件在打包时的属性：

  • directory：源目录的路径。
  • includes/excludes：设定包含或排除哪些文件，支持通配符。
  • fileMode：指定该目录下的文件权限，采用Unix八进制描述法，(User Group Other)所属属性默认值是0644，Read = 4，Write = 2和Execute = 1
  • outputDirectory：指定文件集合的输出目录，生成目录的路径，该目录是相对于根目录
6. files标签

files标签可以指定目的文件名到指定目录，其他和 fileSets 相同，核心元素如下表所示：

  • source：源文件，相对路径或绝对路径
  • outputDirectory：输出目录
  • destName： 目标文件名
  • fileMode：文件权限

assembly.xml描述文件配置详解

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
    <!--
        设置此程序集的标识。这是来自此项目的特定文件组合的符号名称。此外，除了用于通过将生成的归档的值附加到组合包以明确命名组合包之外，该ID在部署时用作工件的分类器。
    -->
    <!--string-->
    <id/>
    <!--
        (许多） 指定程序集的格式。通过目标参数而不是在这里指定格式通常会更好。例如，允许不同的配置文件生成不同类型的档案。
        可以提供多种格式，装配体插件将生成每种所需格式的档案。部署项目时，所有指定的文件格式也将被部署。
        通过在<format>子元素中提供以下值之一来指定格式：
        “zip” - 创建一个ZIP文件格式
        “tar” - 创建一个TAR格式
        “tar.gz”或“tgz” - 创建一个gzip'd TAR格式
        “tar.bz2”或“tbz2” - 创建一个bzip'd TAR格式
        “tar.snappy” - 创建一个灵活的TAR格式
        “tar.xz”或“txz” - 创建一个xz'd TAR格式
        “jar” - 创建一个JAR格式
        “dir” - 创建分解的目录格式
        “战争” - 创建一个WAR格式
    -->
    <!--List<String>-->
    <formats/>
    <!--
        在最终归档中包含一个基本目录。例如，如果您正在创建一个名为“your-app”的程序集，则将includeBaseDirectory设置为true将创建一个包含此基本目录的归档文件。
        如果此选项设置为false，则创建的存档将其内容解压缩到当前目录。
        默认值是：true。
    -->
    <!--boolean-->
    <includeBaseDirectory/>
    <!--
        设置生成的程序集归档的基本目录。如果没有设置，并且includeBaseDirectory == true，则将使用$ {project.build.finalName}。（从2.2-beta-1开始）
    -->
    <!--string-->
    <baseDirectory/>
    <!--
        在最终档案中包含一个网站目录。项目的站点目录位置由Assembly Plugin的siteDirectory参数确定。
        默认值是：false。
    -->
    <!--boolean-->
    <includeSiteDirectory/>

    <!--
        （许多） 从常规归档流中过滤各种容器描述符的组件集合，因此可以将它们聚合然后添加。
    -->
    <!--List<ContainerDescriptorHandlerConfig>-->
    <containerDescriptorHandlers>
        <!--
            配置文件头部的过滤器，以启用各种类型的描述符片段（如components.xml，web.xml等）的聚合。
        -->
        <containerDescriptorHandler>
            <!--
                处理程序的plexus角色提示，用于从容器中查找。
            -->
            <!--string-->
            <handlerName/>
            <!--
                处理程序的配置选项。
            -->
            <!--DOM-->
            <configuration/>
        </containerDescriptorHandler>
    </containerDescriptorHandlers>
    <!--
        （许多） 指定在程序集中包含哪些模块文件。moduleSet是通过提供一个或多个<moduleSet>子元素来指定的。
    -->
    <!--List<ModuleSet>-->
    <moduleSets>
        <!--
            moduleSet表示一个或多个在项目的pom.xml中存在的<module>项目。这使您可以包含属于项目<modules>的源代码或二进制文件。
            注意：从命令行使用<moduleSets>时，需要先通过“mvn package assembly：assembly”来传递包阶段。这个bug计划由Maven 2.1解决。
        -->
        <moduleSet>
            <!--
                如果设置为true，则该插件将包含当前反应堆中的所有项目，以便在此ModuleSet中进行处理。这些将被 纳入/排除(includes/excludes) 规则。（从2.2开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useAllReactorProjects/>
            <!--
                如果设置为false，则该插件将从该ModuleSet中排除子模块的处理。否则，它将处理所有子模块，每个子模块都要遵守包含/排除规则。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <includeSubModules/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组包含的项目坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的项目工件坐标。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                当存在这个时，插件将在生成的程序集中包含这个集合中包含的模块的源文件。
                包含用于在程序集中包含项目模块的源文件的配置选项。
            -->
            <!--ModuleSources-->
            <sources>
                <!--
                    在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <useDefaultExcludes/>
                <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
                -->
                <!--string-->
                <outputDirectory/>
                <!--
                    （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
                <!--string-->
                <fileMode/>
                <!--
                    与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                -->
                <!--string-->
                <directoryMode/>
                <!--
                    （许多） 指定包含在程序集中的每个包含模块的哪些文件组。fileSet通过提供一个或多个<fileSet>子元素来指定。（从2.2-beta-1开始）
                -->
                <!--List<FileSet>-->
                <fileSets>
                    <!--
                        fileSet允许将文件组包含到程序集中。
                    -->
                    <fileSet>
                        <!--
                            在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useDefaultExcludes/>
                        <!--
                            设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
                        -->
                        <!--string-->
                        <outputDirectory/>
                        <!--
                            （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
                        -->
                        <!--List<String>-->
                        <includes/>
                        <!--
                            （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
                        -->
                        <!--List<String>-->
                        <excludes/>
                        <!--
                            与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0644转换为用户读写，组和其他只读。默认值是0644.
                        -->
                        <!--string-->
                        <fileMode/>
                        <!--
                            与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                        -->
                        <!--string-->
                        <directoryMode/>
                        <!--
                            设置模块目录的绝对或相对位置。例如，“src / main / bin”会选择定义这个依赖关系的项目的这个子目录。
                        -->
                        <!--string-->
                        <directory/>
                        <!--
                            设置此文件集中文件的行结束符。有效值：
                            “keep” - 保留所有的行结束
                            “unix” - 使用Unix风格的行尾（即“\ n”）
                            “lf” - 使用一个换行符结束符（即“\ n”）
                            “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                            “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                            “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
                        -->
                        <!--string-->
                        <lineEnding/>
                        <!--
                            是否在复制文件时过滤符号，使用构建配置中的属性。（从2.2-beta-1开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <filtered/>
                    </fileSet>
                </fileSets>
                <!--
                    指定模块的finalName是否应该添加到应用于它的任何fileSets的outputDirectory值。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <includeModuleDirectory/>
                <!--
                    指定是否应从应用于该模块的文件集中排除当前模块下方的子模块目录。如果仅仅意味着复制与此ModuleSet匹配的确切模块列表的源，忽略（或单独处理）当前目录下目录中存在的模块，这可能会很有用。（从2.2-beta-1开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <excludeSubModuleDirectories/>
                <!--
                    设置此程序集中包含的所有模块基本目录的映射模式。注意：只有在includeModuleDirectory == true的情况下才会使用此字段。
                    缺省值是在 2.2-beta-1中是$ {artifactId}，以及后续版本中是$ {module.artifactId}。（从2.2-beta-1开始）
                    默认值是：$ {module.artifactId}。
                -->
                <!--string-->
                <outputDirectoryMapping/>
            </sources>
            <!--
                    如果存在，插件将在生成的程序集中包含来自该组的所包含模块的二进制文件。
                    包含用于将项目模块的二进制文件包含在程序集中的配置选项。
            -->
            <!--ModuleBinaries-->
            <binaries>
                <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                -->
                <!--string-->
                <outputDirectory/>
                <!--
                    （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                    工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                    另外，可以使用通配符，如*：maven- *
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                    工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                    另外，可以使用通配符，如*：maven- *
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
                <!--string-->
                <fileMode/>
                <!--
                    与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                -->
                <!--string-->
                <directoryMode/>
                <!--
                    指定时，attachmentClassifier将使汇编器查看附加到模块的工件，而不是主工程工件。如果能够找到与指定分类符匹配的附件，则会使用它; 否则，会抛出异常。（从2.2-beta-1开始）
                -->
                <!--string-->
                <attachmentClassifier/>
                <!--
                    如果设置为true，插件将包含这里包含的项目模块的直接和传递依赖关系。否则，它将只包含模块包。
                    默认值是：true。
                -->
                <!--boolean-->
                <includeDependencies/>
                <!--List<DependencySet>-->
                <dependencySets>
                    <!--
                        依赖关系集允许在程序集中包含和排除项目依赖关系。
                    -->
                    <dependencySet>
                        <!--
                                设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                            -->
                        <!--string-->
                        <outputDirectory/>
                        <!--
                            （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                            工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                            另外，可以使用通配符，如*：maven- *
                        -->
                        <!--List<String>-->
                        <includes/>
                        <!--
                            （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                            工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                            另外，可以使用通配符，如*：maven- *
                        -->
                        <!--List<String>-->
                        <excludes/>
                        <!--
                            与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0644转换为用户读写，组和其他只读。默认值是0644
                        -->
                        <!--string-->
                        <fileMode/>
                        <!--
                            与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                            例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
                        -->
                        <!--string-->
                        <directoryMode/>
                        <!--
                            如果指定为true，那么在程序集创建过程中任何用于过滤实际构件的包含/排除模式都将导致构建失败，并显示错误。这是为了强调过时的包含或排除，或者表示程序集描述符配置不正确。（从2.2开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <useStrictFiltering/>
                        <!--
                            为此程序集中包含的所有依赖项设置映射模式。（从2.2-beta-2开始； 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）。
                            默认值是：$ {artifact.artifactId} - $ {artifact.version} $ {dashClassifier？}。$ {artifact.extension}。
                        -->
                        <!--string-->
                        <outputFileNameMapping/>
                        <!--
                            如果设置为true，则此属性将所有依赖项解包到指定的输出目录中。设置为false时，依赖关系将被包含为档案（jar）。只能解压jar，zip，tar.gz和tar.bz压缩文件。
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <unpack/>
                        <!--
                            允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
                        -->
                        <unpackOptions>
                            <!--
                                （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                            -->
                            <!--List<String>-->
                            <includes/>
                            <!--
                                （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                            -->
                            <!--List<String>-->
                            <excludes/>
                            <!--
                                是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                                默认值是：false。
                            -->
                            <!--boolean-->
                            <filtered/>
                            <!--
                                设置文件的行尾。（从2.2开始）有效值：
                                “keep” - 保留所有的行结束
                                “unix” - 使用Unix风格的行结尾
                                “lf” - 使用单个换行符结束符
                                “dos” - 使用DOS风格的行尾
                                “ crlf ” - 使用Carraige返回，换行符结束
                            -->
                            <!--string-->
                            <lineEnding/>
                            <!--
                                在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                                默认值是：true。
                            -->
                            <!--boolean-->
                            <useDefaultExcludes/>
                            <!--
                                允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                            -->
                            <!--string-->
                            <encoding/>
                        </unpackOptions>
                        <!--
                            为此dependencySet设置依赖项范围。
                            默认值是：runtime。
                        -->
                        <!--string-->
                        <scope/>
                        <!--
                            确定当前项目构建过程中产生的工件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useProjectArtifact/>
                        <!--
                            确定当前项目构建过程中产生的附件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                            默认值是：false。
                        -->
                        <!--boolean-->
                        <useProjectAttachments/>
                        <!--
                            确定是否将传递依赖项包含在当前依赖项集的处理中。如果为true，那么include / excludes / useTransitiveFiltering将应用于传递依赖项构件以及主项目依赖项构件。
                            如果为false，则useTransitiveFiltering无意义，并且包含/排除仅影响项目的直接依赖关系。
                            默认情况下，这个值是真的。（从2.2-beta-1开始）
                            默认值是：true。
                        -->
                        <!--boolean-->
                        <useTransitiveDependencies/>
                        <!--
                            确定此依赖项集中的包含/排除模式是否将应用于给定工件的传递路径。
                            如果为真，并且当前工件是由包含或排除模式匹配的另一个工件引入的传递依赖性，则当前工件具有与其相同的包含/排除逻辑。
                            默认情况下，此值为false，以保持与2.1版的向后兼容性。这意味着包含/排除仅仅直接应用于当前的工件，而不应用于传入的工件。（从2.2-beta-1）
                            默认值为：false。
                        -->
                        <!--boolean-->
                        <useTransitiveFiltering/>
                    </dependencySet>
                </dependencySets>
                <!--
                    如果设置为true，则此属性将所有模块包解包到指定的输出目录中。当设置为false时，模块包将作为归档（jar）包含在内。
                    默认值是：true。
                -->
                <!--boolean-->
                <unpack/>
                <!--
                    允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
                -->
                <unpackOptions>
                    <!--
                        （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                    -->
                    <!--List<String>-->
                    <includes/>
                    <!--
                        （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                    -->
                    <!--List<String>-->
                    <excludes/>
                    <!--
                        是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                        默认值是：false。
                    -->
                    <!--boolean-->
                    <filtered/>
                    <!--
                        设置文件的行尾。（从2.2开始）有效值：
                        “keep” - 保留所有的行结束
                        “unix” - 使用Unix风格的行结尾
                        “lf” - 使用单个换行符结束符
                        “dos” - 使用DOS风格的行尾
                        “ crlf ” - 使用Carraige返回，换行符结束
                    -->
                    <!--string-->
                    <lineEnding/>
                    <!--
                        在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                        默认值是：true。
                    -->
                    <!--boolean-->
                    <useDefaultExcludes/>
                    <!--
                        允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                    -->
                    <!--string-->
                    <encoding/>
                </unpackOptions>
                <!--
                    设置此程序集中包含的所有非UNPACKED依赖关系的映射模式。（由于2.2-beta-2; 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）注意：如果dependencySet指定unpack == true，则outputFileNameMapping将不要使用; 在这些情况下，使用outputDirectory。有关可用于outputFileNameMapping参数的条目的更多详细信息，请参阅插件FAQ。
                    默认值是：$ {module.artifactId} - $ {module.version} $ {dashClassifier？}。$ {module.extension}。
                -->
                <!--string-->
                <outputFileNameMapping/>
            </binaries>
        </moduleSet>
    </moduleSets>
    <!--
        （许多） 指定在程序集中包含哪些文件组。fileSet通过提供一个或多个<fileSet>子元素来指定。
    -->
    <!--List<FileSet>-->
    <fileSets>
        <!--
            fileSet允许将文件组包含到程序集中。
        -->
        <fileSet>
            <!--
                在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useDefaultExcludes/>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当<include>子元素存在时，它们定义一组要包含的文件和目录。如果不存在，则<includes>表示所有有效值。
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的文件和目录。如果不存在，则<excludes>不表示排除。
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644.
            -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                设置模块目录的绝对或相对位置。例如，“src / main / bin”会选择定义这个依赖关系的项目的这个子目录。
            -->
            <!--string-->
            <directory/>
            <!--
                设置此文件集中文件的行结束符。有效值：
                “keep” - 保留所有的行结束
                “unix” - 使用Unix风格的行尾（即“\ n”）
                “lf” - 使用一个换行符结束符（即“\ n”）
                “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
            -->
            <!--string-->
            <lineEnding/>
            <!--
                是否在复制文件时过滤符号，使用构建配置中的属性。（从2.2-beta-1开始）
                默认值是：false。
            -->
            <!--boolean-->
            <filtered/>
        </fileSet>
    </fileSets>
    <!--
        （许多） 指定在程序集中包含哪些单个文件。通过提供一个或多个<file>子元素来指定文件。
    -->
    <!--List<FileItem>-->
    <files>
        <!--
            一个文件允许单个文件包含选项来更改不受fileSets支持的目标文件名。
        -->
        <file>
            <!--
                设置要包含在程序集中的文件的模块目录的绝对路径或相对路径。
            -->
            <!--string-->
            <source/>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“日志”将把指定的文件放在日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                在outputDirectory中设置目标文件名。默认是与源文件相同的名称。
            -->
            <!--string-->
            <destName/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个八卦价值。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644
            -->
            <!--string-->
            <fileMode/>
            <!--
                设置此文件中文件的行结束符。有效值是：
                “keep” - 保留所有的行结束
                “unix” - 使用Unix风格的行尾（即“\ n”）
                “lf” - 使用一个换行符结束符（即“\ n”）
                “dos” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “windows” - 使用DOS / Windows风格的行尾（即“\ r \ n”）
                “crlf” - 使用回车，换行符结尾（即“\ r \ n”）
            -->
            <!--string-->
            <lineEnding/>
            <!--
                设置是否确定文件是否被过滤。
                默认值是：false。
            -->
            <!--boolean-->
            <filtered/>
        </file>
    </files>
    <!--List<DependencySet>-->
    <dependencySets>
        <!--
            依赖关系集允许在程序集中包含和排除项目依赖关系。
        -->
        <dependencySet>
            <!--
                    设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
                -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组要包含的工件坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组依赖项工件坐标以排除。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0644转换为用户读写，组和其他只读。默认值是0644
            -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                如果指定为true，那么在程序集创建过程中任何用于过滤实际构件的包含/排除模式都将导致构建失败，并显示错误。这是为了强调过时的包含或排除，或者表示程序集描述符配置不正确。（从2.2开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useStrictFiltering/>
            <!--
                为此程序集中包含的所有依赖项设置映射模式。（从2.2-beta-2开始； 2.2-beta-1使用$ {artifactId} - $ {version} $ {dashClassifier？}。$ {extension}作为默认值）。
                默认值是：$ {artifact.artifactId} - $ {artifact.version} $ {dashClassifier？}。$ {artifact.extension}。
            -->
            <!--string-->
            <outputFileNameMapping/>
            <!--
                如果设置为true，则此属性将所有依赖项解包到指定的输出目录中。设置为false时，依赖关系将被包含为档案（jar）。只能解压jar，zip，tar.gz和tar.bz压缩文件。
                默认值是：false。
            -->
            <!--boolean-->
            <unpack/>
            <!--
                允许指定包含和排除以及过滤选项，以指定从相关性工件解压缩的项目。（从2.2-beta-1开始）
            -->
            <unpackOptions>
                <!--
                    （许多） 文件和/或目录模式的集合，用于匹配将在解压缩时从归档文件中包含的项目。每个项目被指定为<include> some / path </ include>（从2.2-beta-1开始）
                -->
                <!--List<String>-->
                <includes/>
                <!--
                    （许多） 用于匹配项目的文件和/或目录模式的集合，在解压缩时将其从归档文件中排除。每个项目被指定为<exclude> some / path </ exclude>（从2.2-beta-1开始）
                -->
                <!--List<String>-->
                <excludes/>
                <!--
                    是否使用构建配置中的属性过滤从档案中解压缩的文件中的符号。（从2.2-beta-1开始）
                    默认值是：false。
                -->
                <!--boolean-->
                <filtered/>
                <!--
                    设置文件的行尾。（从2.2开始）有效值：
                    “keep” - 保留所有的行结束
                    “unix” - 使用Unix风格的行结尾
                    “lf” - 使用单个换行符结束符
                    “dos” - 使用DOS风格的行尾
                    “crlf ” - 使用Carraige返回，换行符结束
                -->
                <!--string-->
                <lineEnding/>
                <!--
                    在计算受该集合影响的文件时，是否应该使用标准排除模式，例如那些匹配CVS和Subversion元数据文件的排除模式。为了向后兼容，默认值是true。（从2.2开始）
                    默认值是：true。
                -->
                <!--boolean-->
                <useDefaultExcludes/>
                <!--
                    允许指定解压档案时使用的编码，支持指定编码的unarchiver。如果未指定，将使用归档程序默认值。Archiver默认值通常代表理智（modern）的values。
                -->
                <!--string-->
                <encoding/>
            </unpackOptions>
            <!--
                为此dependencySet设置依赖项范围。
                默认值是：runtime。
            -->
            <!--string-->
            <scope/>
            <!--
                确定当前项目构建过程中产生的工件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useProjectArtifact/>
            <!--
                确定当前项目构建过程中产生的附件是否应该包含在这个依赖集中。（从2.2-beta-1开始）
                默认值是：false。
            -->
            <!--boolean-->
            <useProjectAttachments/>
            <!--
                确定是否将传递依赖项包含在当前依赖项集的处理中。如果为true，那么include / excludes / useTransitiveFiltering将应用于传递依赖项构件以及主项目依赖项构件。
                如果为false，则useTransitiveFiltering无意义，并且包含/排除仅影响项目的直接依赖关系。
                默认情况下，这个值是真的。（从2.2-beta-1开始）
                默认值是：true。
            -->
            <!--boolean-->
            <useTransitiveDependencies/>
            <!--
                确定此依赖项集中的包含/排除模式是否将应用于给定工件的传递路径。
                如果为真，并且当前工件是由包含或排除模式匹配的另一个工件引入的传递依赖性，则当前工件具有与其相同的包含/排除逻辑。
                默认情况下，此值为false，以保持与2.1版的向后兼容性。这意味着包含/排除仅仅直接应用于当前的工件，而不应用于传入的工件。（从2.2-beta-1）
                默认值为：false。
            -->
            <!--boolean-->
            <useTransitiveFiltering/>
        </dependencySet>
    </dependencySets>
    <!--
        定义要包含在程序集中的Maven仓库。可用于存储库中的工件是项目的依赖工件。创建的存储库包含所需的元数据条目，并且还包含sha1和md5校验和。这对创建将被部署到内部存储库的档案很有用。
        注意：目前，只有来自中央存储库的工件才被允许。
    -->
    <!--List<Repository>-->
    <repositories>
        <repository>
            <!--
                设置输出目录相对于程序集根目录的根目录。例如，“log”会将指定的文件放在归档根目录下的日志目录中。
            -->
            <!--string-->
            <outputDirectory/>
            <!--
                （许多） 当存在<include>子元素时，它们定义一组包含的项目坐标。如果不存在，则<includes>表示所有有效值。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <includes/>
            <!--
                （许多） 当存在<exclude>子元素时，它们定义一组要排除的项目工件坐标。如果不存在，则<excludes>不表示排除。
                工件坐标可以以简单的groupId：artifactId形式给出，或者可以以groupId：artifactId：type [：classifier]：version的形式完全限定。
                另外，可以使用通配符，如*：maven- *
            -->
            <!--List<String>-->
            <excludes/>
            <!--
                    与UNIX权限类似，设置所包含文件的文件模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                    例如，值0644转换为用户读写，组和其他只读。默认值是0644
                -->
            <!--string-->
            <fileMode/>
            <!--
                与UNIX权限类似，设置包含的目录的目录模式。这是一个 OCTAL VALUE。格式：（用户）（组）（其他）[Format: (User)(Group)(Other) ] 其中每个组件是Read = 4，Write = 2和Execute = 1的总和。
                例如，值0755转换为用户读写，Group和其他只读。默认值是0755.
            -->
            <!--string-->
            <directoryMode/>
            <!--
                如果设置为true，则此属性将触发创建存储库元数据，这将允许存储库用作功能性远程存储库。
                默认值是：false。
            -->
            <!--boolean-->
            <includeMetadata/>
            <!--
                （许多） 指定要将一组工件与指定的版本对齐。groupVersionAlignment通过提供一个或多个<groupVersionAlignment>子元素来指定。
                允许一组工件与指定的版本对齐。
            -->
            <!--List<GroupVersionAlignment>-->
            <groupVersionAlignments>
                <groupVersionAlignment>
                    <!--
                        要为其对齐版本的工件的groupId。
                    -->
                    <!--string-->
                    <id/>
                    <!--
                        您想要将该组对齐的版本。
                    -->
                    <!--string-->
                    <version/>
                    <!--
                        （许多） 当存在<exclude>子元素时，它们定义要排除的构件的artifactIds。如果不存在，则<excludes>不表示排除。排除是通过提供一个或多个<exclude>子元素来指定的。
                    -->
                    <!--List<String>-->
                    <excludes/>
                </groupVersionAlignment>
            </groupVersionAlignments>
            <!--
                指定此存储库中包含的工件的范围。（从2.2-beta-1开始）
                默认值是：runtime。
            -->
            <!--string-->
            <scope/>
        </repository>
    </repositories>
    <!--
        （许多） 指定要包含在程序集中的共享组件xml文件位置。指定的位置必须相对于描述符的基本位置。
        如果描述符是通过类路径中的<descriptorRef />元素找到的，那么它指定的任何组件也将在类路径中找到。
        如果通过路径名通过<descriptor />元素找到，则此处的值将被解释为相对于项目basedir的路径。
        当找到多个componentDescriptors时，它们的内容被合并。检查 描述符组件 了解更多信息。
        componentDescriptor通过提供一个或多个<componentDescriptor>子元素来指定。
    -->
    <!--List<String>-->
    <componentDescriptors/>
</assembly>
糯米吃西瓜
关注
专栏目录
【项目实战】Maven插件配置与介绍
本本本添哥
04-21 956
Maven插件是用来扩展Maven构建过程的工具。Maven插件可以用来完成各种任务，例如编译代码、运行测试、打包应用程序等等。
pom文件打包插件
s243471087的博客
12-04 560
<build> <plugins> <!-- 编译插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId...
Maven build插件之Maven-assembly-plugin自定义打包
04-27
Maven-assembly-plugin是maven中针对打包任务而提供的标准插件,可以实现自定义打包。主要提供如下功能： ● 提供一个把工程依赖元素、模块、网站文档等其他文件存放到单个归档文件里。 ● 打包成指定格式分发包，支持各种主流的格式如zip、tar.gz、jar和war等，具体打包哪些文件是高度可控的。 ● 能够自定义包含/排除指定的目录或文件。 并附上了学习过程中应注意的细节，以及遇到的问题及解决方法。
maven打包插件
最新发布
weixin_44144092的博客
09-13 602
即使在pom.xml文件中没有配置任何plugin，maven也会默认设置一些插件，如其中的maven-jar-plugin插件执行 package 打包时，maven 会使用maven-jar-plugin插件打包，这种方式打的包中只含有自己写的程序和资源文件，不包含程序依赖的其他jar包，而且在文件中没有配置Main-class属性值。
自定义Maven打包插件
ZKC_开成的博客
12-21 1512
前言   Maven大家都很熟悉，插件也非常丰富。比如它的打包插件maven-assembly-plugin可以根据模板配置自己想要的打包内容，但当它的模板配置无法满足自己定制化打包需求时，此时就需要我们将maven研究的更深入些，利用自定义maven插件去实现我们自己的打包逻辑。 自定义Maven打包插件实战 打包业务描述：   打包时，根据需要打包的模块.json配置文件，动态打入自己需要的Controller，排除掉不需要的模块Controller类。 打包插件设计思路： 插件使用如下： 一 、先
Maven配置打包插件，过滤java源代码目录文件、过滤resources资源目录文件等
hkl_Forever的博客
03-19 970
【代码】Maven配置打包插件，过滤java源代码目录文件、过滤resources资源目录文件等。
Maven打包插件详解
蓝天⊙白云的博客
05-06 2300
是maven中针对打包任务而提供的标准插件,可以实现自定义打包。提供一个把工程依赖元素、模块、网站文档等其他文件存放到单个归档文件里打包成指定格式分发包，支持各种主流的格式如ziptar.gzjar和war等，具体打包哪些文件是高度可控的能够自定义包含/排除指定的目录或文件是提供的maven打包插件。可打直接可运行的jar包或war包。如果使用版本，则需要maven版本在2.0及以上，JDK在1.8及以上。
Maven 插件列表详解
栗筝i的博客
06-19 3076
Maven 是一个强大的项目管理和构建工具，广泛应用于 Java 项目中。作为一款优秀的构建管理工具，Maven 不仅提供了标准化的项目结构和依赖管理，还通过其丰富的插件系统，极大地扩展了其功能和灵活性。无论是代码编译、测试、打包，还是部署、报告生成，Maven 插件都扮演着不可或缺的角色。 本文将深入探讨 Maven 的插件体系，详细介绍各类插件的用途、主要目标和适用的生命周期阶段。内容涵盖了 Maven 官方插件、被淘汰的插件、社区驱动的 MojoHaus 插件、国内外企业开发的非官方插件以及如何自定
maven 打包时间戳问题
08-25
maven 打包时间戳问题 Maven 打包时间戳问题是 Maven 项目中的一個常见...解决 Maven 打包时间戳问题需要我们了解 Maven 的内置变量和插件机制，并且需要我们了解 IDEA 的 Build 机制，以便正确地使用 Maven 插件。
maven打包的5种方式总有一款适合你【超赞】
热门推荐
健康平安的活着的专栏
08-07 5万+
1.用于生成META-INF/MANIFEST.MF文件的部分内容，com.xxg.Main指定MANIFEST.MF中的Main-Class，true会在MANIFEST.MF加上Class-Path项并配置依赖包，lib/指定依赖包所在目录。2.maven-dependency-plugin插件。
自定义maven插件的实现
06-13
然而，有时候Maven的内置插件无法满足特定的需求，这时就需要自定义Maven插件来扩展其功能。本篇文章将深入探讨如何实现自定义的Maven插件。 首先，了解Maven插件的基本结构至关重要。一个Maven插件通常由一组Mojo...
maven打包时依赖的项目包是时间戳而不是SNAPSHOT？
yangbin1265712的专栏
02-25 9784
如上面： 打包后依赖的包全部是以时间戳存在的，这样在做增量包的时候就必须要删除服务器上的原文件，而不能直接覆盖替换，想要打成SNAPSHOT的包需要执行以下命令： mvn clean deploy -DuseUniqueVersions=false 需要注意的是：所有依赖的模块在打包时也要先运行一次-DuseUniqueVersions=false，例如：上面工程依赖了comm...
Maven学习笔记(十三)-maven-dependency-plugin插件
geejkse_seff的博客
08-20 6604
copy-dependencies和它有点类似，但是它是用来拷当前工程的依赖包的，典型的，例如我们有一个web应用，当打成war包的时候，它所有的依赖也需要被打到应用中。它有很多可用的goal，大部分是和依赖构建、分析和解决相关的goal，这部分goal可以直接用maven的命令操作，例如：mvn dependency:tree、mvn dependency:analyze但是我们最常用到的是。junit和slf4j-log4j12拷完以后，放到lib和libs下的不再是Jar包，还是Jar包里的内容。
Maven（二）：Maven的使用入门
经年藏殊的博客
06-19 1320
Maven的简单使用的一点介绍，供参考
Spring Boot Maven Plugin打包异常及三种解决方法：Unable to find main class
05-19 5469
【背景】spring-boot项目，打包成可执行jar，项目内有两个带有main方法的类并且都使用了@SpringBootApplication注解（或者另一种情形：你有两个main方法并且所在类都没有使用@SpringBootApplication注解），pom.xml如下 <plugin> <groupId>org.springframew...
Maven中POM文件的理解
bjy_fighting的博客
09-22 1473
POM文件通过XML语法来管理Maven项目，其中包含项目间的依赖关系。1、Maven内置属性及使用(Maven自定义，可直接使用） ${basedir} 表示pom文件所在的目录 ${version} 表示项目版本 ${project.basedir} 同basedir ${user.home}表示用户目录 ${env.JAVA_HOME}表示JAVA_HOME变量所在的路径 2、POM文件的结构
Maven 基础教程（三）：build、profile
tian830937的专栏
05-11 1253
《Maven 基础教程》系列，包含以下 5 篇文章：Maven 基础教程（一）：基础介绍、开发环境配置 Maven 基础教程（二）：Maven 的使用 Maven 基础教程（三）：build、profile Maven 基础教程（四）：搭建 Maven 私服 Nexus Maven 基础教程（五）： jar 包冲突问题在实际使用 Maven 的过程中，我们会发现 build 标签有时候有，有时候没，这是怎么回事呢？其实通过有效 POM 我们能够看到，build 标签的相关配置其实一直都在，只是在我们需要定制
maven 内置pom属性
amfxvrd5590的博客
04-07 128
内置属性：如 ${basedir} 表示项目根目录 即包含了pom.xml文件的目录 ${version} 表示项目版本 pom属性 ${project.build.sourcedirectory} : 项目构建输出目录，默认为src/main/java ${project.build.testSourceDirectory} : 项目的测试源码目录，默认为src/test...
Spring Boot 2.x系列【27】应用篇之代码混淆
记录知识、锤炼自我
11-21 1521
代码混淆(Obfuscated code)亦称花指令，是将计算机程序的代码，转换成难于阅读和理解的形式的行为。将代码中的各种元素，如变量，函数，类的名字改写成无意义的名字。比如改写成单个字母，或是简短的无意义字母组合，甚至改写成“__”这样的符号，使得阅读的人无法根据名字猜测其用途。重写代码中的部分逻辑，将其变成功能上等价，但是更难理解的形式。比如将for循环改写成while循环，将循环改写成递归，精简中间变量。打乱代码的格式。比如删除空格，将多行代码挤到一行中，或者将一行代码断成多行等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值