Maven的使用经验分享
首先明确一下Maven的概念，Maven 是一个项目管理工具，可以对 Java 项目进行构建、依赖管理。。
pom文件
使用Maven时，接触最多的就是pom文件了，POM( Project Object Model，项目对象模型 ) 是 Maven 工程的基本工作单元，是一个XML文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。
所有 POM 文件都需要 project 元素和三个必需字段：groupId，artifactId，version。举一个简单的例子，我们创建一个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">
<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.***.***，maven会将该项目打成的jar包放本地路径：/com/***/*** -->
<groupId>com.***.***</groupId>
<!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>myproject</artifactId>
<!-- 版本号 -->
<version>1.0</version>
</project>
上面只是一个很简单的例子，实际上pom文件支持的功能很完善，就是标签太多，需要使用者熟悉，标签大全如下：
<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 />
<!-- 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项
目的pom，其次在文件系统的这个位置（relativePath位置），然后在本地仓库，最后在远程仓库寻找父项目的pom。 -->
<relativePath />
</parent>
<!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。 -->
<modelVersion>4.0.0</modelVersion>
<!--项目的全球唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app -->
<groupId>asia.banseon</groupId>
<!-- 构件的标识符，它和group ID一起唯一标识一个构件。换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个
特定的group ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源 码，二进制发布和WARs等。 -->
<artifactId>banseon-maven2</artifactId>
<!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型 -->
<packaging>jar</packaging>
<!--项目当前版本，格式为:主版本.次版本.增量版本-限定版本号 -->
<version>1.0-SNAPSHOT</version>
<!--项目的名称, Maven产生的文档用 -->
<name>banseon-maven</name>
<!--项目主页的URL, Maven产生的文档用 -->
<url>http://www.baidu.com/banseon</url>
<!-- 项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标
签）， 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->
<description>A maven project to study maven.</description>
<!--描述了这个项目构建环境中的前提条件。 -->
<prerequisites>
<!--构建该项目或使用该插件所需要的Maven的最低版本 -->
<maven />
</prerequisites>
<!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira -->
<issueManagement>
<!--问题管理系统（例如jira）的名字， -->
<system>jira</system>
<!--该项目使用的问题管理系统的URL -->
<url>http://jira.baidu.com/banseon</url>
</issueManagement>
<!--项目持续集成信息 -->
<ciManagement>
<!--持续集成系统的名字，例如continuum -->
<system />
<!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->
<url />
<!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->
<notifiers>
<!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->
<notifier>
<!--传送通知的途径 -->
<type />
<!--发生错误时是否通知 -->
<sendOnError />
<!--构建失败时是否通知 -->
<sendOnFailure />
<!--构建成功时是否通知 -->
<sendOnSuccess />
<!--发生警告时是否通知 -->
<sendOnWarning />
<!--不赞成使用。通知发送到哪里 -->
<address />
<!--扩展配置项 -->
<configuration />
</notifier>
</notifiers>
</ciManagement>
<!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
<inceptionYear />
<!--项目相关邮件列表信息 -->
<mailingLists>
<!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->
<mailingList>
<!--邮件的名称 -->
<name>Demo</name>
<!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<post>banseon@126.com</post>
<!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<subscribe>banseon@126.com</subscribe>
<!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<unsubscribe>banseon@126.com</unsubscribe>
<!--你可以浏览邮件信息的URL -->
<archive>http:/hi.baidu.com/banseon/demo/dev/</archive>
</mailingList>
</mailingLists>
<!--项目开发者列表 -->
<developers>
<!--某个项目开发者的信息 -->
<developer>
<!--SCM里项目开发者的唯一标识符 -->
<id>HELLO WORLD</id>
<!--项目开发者的全名 -->
<name>banseon</name>
<!--项目开发者的email -->
<email>banseon@126.com</email>
<!--项目开发者的主页的URL -->
<url />
<!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
<roles>
<role>Project Manager</role>
<role>Architect</role>
</roles>
<!--项目开发者所属组织 -->
<organization>demo</organization>
<!--项目开发者所属组织的URL -->
<organizationUrl>http://hi.baidu.com/banseon</organizationUrl>
<!--项目开发者属性，如即时消息如何处理等 -->
<properties>
<dept>No</dept>
</properties>
<!--项目开发者所在时区， -11到12范围内的整数。 -->
<timezone>-5</timezone>
</developer>
</developers>
<!--项目的其他贡献者列表 -->
<contributors>
<!--项目的其他贡献者。参见developers/developer元素 -->
<contributor>
<name />
<email />
<url />
<organization />
<organizationUrl />
<roles />
<timezone />
<properties />
</contributor>
</contributors>
<!--该元素描述了项目所有License列表。 应该只列出该项目的license列表，不要列出依赖项目的 license列表。如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->
<licenses>
<!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->
<license>
<!--license用于法律上的名称 -->
<name>Apache 2</name>
<!--官方的license正文页面的URL -->
<url>http://www.baidu.com/banseon/LICENSE-2.0.txt</url>
<!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->
<distribution>repo</distribution>
<!--关于license的补充信息 -->
<comments>A business-friendly OSS license</comments>
</license>
</licenses>
<!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。 -->
<scm>
<!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。 -->
<connection>
scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)
</connection>
<!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->
<developerConnection>
scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk
</developerConnection>
<!--当前代码的标签，在开发阶段默认为HEAD -->
<tag />
<!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->
<url>http://svn.baidu.com/banseon</url>
</scm>
<!--描述项目所属组织的各种属性。Maven产生的文档用 -->
<organization>
<!--组织的全名 -->
<name>demo</name>
<!--组织主页的URL -->
<url>http://www.baidu.com/banseon</url>
</organization>
<!--构建项目需要的信息 -->
<build>
<!--该元素设置了项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<sourceDirectory />
<!--该元素设置了项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。 -->
<scriptSourceDirectory />
<!--该元素设置了项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<testSourceDirectory />
<!--被编译过的应用程序class文件存放的目录。 -->
<outputDirectory />
<!--被编译过的测试class文件存放的目录。 -->
<testOutputDirectory />
<!--使用来自该项目的一系列构建扩展 -->
<extensions>
<!--描述使用到的构建扩展。 -->
<extension>
<!--构建扩展的groupId -->
<groupId />
<!--构建扩展的artifactId -->
<artifactId />
<!--构建扩展的版本 -->
<version />
</extension>
</extensions>
<!--当项目没有规定目标（Maven2 叫做阶段）时的默认值 -->
<defaultGoal />
<!--这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。 -->
<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>
<!--在列的项目构建profile，如果被激活，会修改构建处理 -->
<profiles>
<!--根据环境参数或命令行参数激活某个构建处理 -->
<profile>
<!--构建配置的唯一标识符。即用于命令行激活，也用于在继承时合并具有相同标识符的profile。 -->
<id />
<!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它 能够在某些特定的环境中自动使用某些特定的值；这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。 -->
<activation>
<!--profile默认是否激活的标志 -->
<activeByDefault />
<!--当匹配的jdk被检测到，profile被激活。例如，1.4激活JDK1.4，1.4.0_2，而!1.4激活所有版本不是以1.4开头的JDK。 -->
<jdk />
<!--当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。 -->
<os>
<!--激活profile的操作系统的名字 -->
<name>Windows XP</name>
<!--激活profile的操作系统所属家族(如 'windows') -->
<family>Windows</family>
<!--激活profile的操作系统体系结构 -->
<arch>x86</arch>
<!--激活profile的操作系统版本 -->
<version>5.1.2600</version>
</os>
<!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。如果值 字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 -->
<property>
<!--激活profile的属性的名称 -->
<name>mavenVersion</name>
<!--激活profile的属性的值 -->
<value>2.0.3</value>
</property>
<!--提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活 profile。另一方面，exists则会检查文件是否存在，如果存在则激活profile。 -->
<file>
<!--如果指定的文件存在，则激活profile。 -->
<exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/
</exists>
<!--如果指定的文件不存在，则激活profile。 -->
<missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/
</missing>
</file>
</activation>
<!--构建项目所需要的信息。参见build元素 -->
<build>
<defaultGoal />
<resources>
<resource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</resource>
</resources>
<testResources>
<testResource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</testResource>
</testResources>
<directory />
<finalName />
<filters />
<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>
</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>
<!--参见repositories/repository元素 -->
<repository>
<releases>
<enabled />
<updatePolicy />
<checksumPolicy />
</releases>
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
<id />
<name />
<url />
<layout />
</repository>
</repositories>
<!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
<pluginRepositories>
<!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->
<pluginRepository>
<releases>
<enabled />
<updatePolicy />
<checksumPolicy />
</releases>
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
<id />
<name />
<url />
<layout />
</pluginRepository>
</pluginRepositories>
<!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。 -->
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<!--不赞成使用. 现在Maven忽略该元素. -->
<reports />
<!--该元素包括使用报表插件产生报表的规范。当用户执行"mvn site"，这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素 -->
<reporting>
......
</reporting>
<!--参见dependencyManagement元素 -->
<dependencyManagement>
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
</dependencyManagement>
<!--参见distributionManagement元素 -->
<distributionManagement>
......
</distributionManagement>
<!--参见properties元素 -->
<properties />
</profile>
</profiles>
<!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->
<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></classifier>
<!--依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。 - compile ：默认范围，用于编译 - provided：类似于编译，但支持你期待jdk或者容器提供，类似于classpath
- runtime: 在执行时需要使用 - test: 用于test任务时使用 - system: 需要外在提供相应的元素。通过systemPath来取得
- systemPath: 仅用于范围为system。提供相应的路径 - optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用 -->
<scope>test</scope>
<!--仅供system范围使用。注意，不鼓励使用这个元素，并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径，例如${java.home}。 -->
<systemPath></systemPath>
<!--当计算传递依赖时， 从依赖构件列表里，列出被排除的依赖构件集。即告诉maven你只依赖指定的项目，不依赖项目的依赖。此元素主要用于解决版本冲突问题 -->
<exclusions>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
<!--可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。 -->
<optional>true</optional>
</dependency>
</dependencies>
<!--不赞成使用. 现在Maven忽略该元素. -->
<reports></reports>
<!--该元素描述使用报表插件产生报表的规范。当用户执行"mvn site"，这些报表就会运行。 在页面导航栏能看到所有报表的链接。 -->
<reporting>
<!--true，则，网站不包括默认的报表。这包括"项目信息"菜单中的报表。 -->
<excludeDefaults />
<!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->
<outputDirectory />
<!--使用的报表插件和他们的配置。 -->
<plugins>
<!--plugin元素包含描述报表插件需要的信息 -->
<plugin>
<!--报表插件在仓库里的group ID -->
<groupId />
<!--报表插件在仓库里的artifact ID -->
<artifactId />
<!--被使用的报表插件的版本（或版本范围） -->
<version />
<!--任何配置是否被传播到子项目 -->
<inherited />
<!--报表插件的配置 -->
<configuration />
<!--一组报表的多重规范，每个规范可能有不同的配置。一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标 -->
<reportSets>
<!--表示报表的一个集合，以及产生该集合的配置 -->
<reportSet>
<!--报表集合的唯一标识符，POM继承时用到 -->
<id />
<!--产生报表集合时，被使用的报表的配置 -->
<configuration />
<!--配置是否被继承到子POMs -->
<inherited />
<!--这个集合里使用到哪些报表 -->
<reports />
</reportSet>
</reportSets>
</plugin>
</plugins>
</reporting>
<!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述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 />
<!--如果构件有了新的group ID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。 -->
<relocation>
<!--构件新的group ID -->
<groupId />
<!--构件新的artifact ID -->
<artifactId />
<!--构件新的版本号 -->
<version />
<!--显示给用户的，关于移动的额外信息，例如原因。 -->
<message />
</relocation>
<!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。有效的值有：none（默认），converted（仓库管理员从
Maven 1 POM转换过来），partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部 署），verified（被核实时正确的和最终的）。 -->
<status />
</distributionManagement>
<!--以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml配置文件里activation元素的说明）。格式是<name>value</name>。 -->
<properties />
</project>
项目管理
在我们工作中，如果只是一个单体的maven项目，其实并不难，但是更多的时候，有可能会遇到多模块的springboot项目，就比如微服务项目，这个时候就需要建立多个应用之间的依赖关系管理。
父pom和子pom
Maven对依赖包的关系管理的主要手段是继承，这很像Java语言的继承关系一样。在pom文件中，我们可以通过继承，使得子模块从父模块继承一些东西，包括依赖，插件配置等等。例如最简单的继承方式，在parent pom文件申明了依赖关系，在children pom中可以不用再申明依赖就能直接使用，而如果需要，children也可以申明依赖来覆盖parent的依赖，这种思想完全和Java的继承与重载机制一致。但是同样的maven也面临单继承的问题，一个父pom可有多个子pom，但是一个子pom无法直接继承多个父pom。不过也不是完全没有办法，利用scope:import的方式可以解决单继承的问题，这样也相当于继承了这份pom。
那么我们在实际使用中，是不是就可以将一些公共的依赖和插件放在父pom中。下面是一个简单的例子，包含具体的使用方法。
父pom
<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.***.***</groupId>
<!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>parent</artifactId>
<!-- 版本号 -->
<version>1.0.0.RELEASE</version>
<!--项目产生的构件类型，例如jar、war、ear、pom。 -->
<packaging>pom</packaging>
<!-- 管理子模块 -->
<modules>
<module>child</module>
</modules>
<!-- 继承 Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.2.RELEASE</version>
</parent>
<properties>
<!-- 第三方依赖版本号 -->
<java.version>8</java.version>
<fastjson.version>1.2.54</fastjson.version>
<swagger.version>2.9.2</swagger.version>
<swagger.ui.version>1.8.7</swagger.ui.version>
</properties>
<!-- 项目相关的依赖 -->
<dependencies>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${swagger.version}</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>${swagger.version}</version>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<!-- 第三方依赖 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!-- 远程仓库列表 -->
<repositories>
<repository>
<id>central</id>
<name>central</name>
<url>*****</url>
<!--配置如何处理远程仓库里发布版本的下载-->
<releases>
<!--是否支持更新-->
<enabled>true</enabled>
<!--构件更新的策略，可选值有daily, always, never, interval:X(其中的X是一个数字，表示间隔的时间，单位min)，默认为daily-->
<updatePolicy>always</updatePolicy>
<!--校验码异常的策略，可选值有ignore, fail, warn-->
<checksumPolicy>warn</checksumPolicy>
</releases>
<!--配置如何处理远程仓库里快照版本的下载-->
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
<checksumPolicy>warn</checksumPolicy>
</snapshots>
</repository>
</repositories>
<!-- 公司内部私有 Maven 仓库 -->
<distributionManagement>
<!--正式版本-->
<repository>
<id>releases</id>
<name>releases</name>
<url>*****</url>
</repository>
<!--快照-->
<snapshotRepository>
<id>snapshots</id>
<name>snapshots</name>
<url>*****</url>
</snapshotRepository>
</distributionManagement>
<!--插件的远程仓库列表-->
<pluginRepositories>
<pluginRepository>
<id>central</id>
<name>central</name>
<url>****</url>
<releases>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
<checksumPolicy>warn</checksumPolicy>
</releases>
<snapshots>
<enabled>true</enabled>
<updatePolicy>always</updatePolicy>
<checksumPolicy>warn</checksumPolicy>
</snapshots>
</pluginRepository>
</pluginRepositories>
<!-- 构建可执行的 jar 包 -->
<build>
<!--使用的插件列表-->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.0.2.RELEASE</version>
</plugin>
</plugins>
<!--项目相关的资源路径列表-->
<resources>
<resource>
<directory>***/***/***</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
子pom
<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.***.***</groupId>
<artifactId>child</artifactId>
<version>1.0.0.RELEASE</version>
<packaging>jar</packaging>
<!-- 引用父pom，这样就实现了pom文件的继承 -->
<parent>
<!-- 注意标签的内容需与父pom相同 -->
<groupId>com.***.***</groupId>
<artifactId>parent</artifactId>
<version>1.0.0.RELEASE</version>
</parent>
<!-- 其他属性配置 -->
<properties>
<!-- 可选填 -->
</properties>
<!-- 子模块依赖 -->
<dependencies>
<!-- 框架 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 工具类 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
<!-- 其他依赖 -->
<dependency>
<!-- 可选填 -->
</dependency>
</dependencies>
</project>
上面的例子已经说明了如何继承，但是里面具体的一些标签有什么用，具体怎么用，下面详细说一下。
modules
module就是模块，而pom.xml中的modules也正是这个意思，用来管理同个项目中的各个模块。
如果我们的项目中包含了好几个模块，那么我们构建的时候是不是有几个模块就需要构建几次了（到每个模块的目录下执行mvn的命令）？一个一个构建确实没问题，但是这样太麻烦，那么简单的做法就是使用聚合，一次构建全部模块。
所以我们可以通过<modules>来管理我们项目里的子模块，当我们编码完成后，只需要构建父工程，下面的子模块也会构建。
父pom中的dependencies标签和dependencyManagement标签
在父pom中的，我有同时用到<dependencies>标签和<dependencyManagement>标签，按道理它们的用处都是一样，但是为什么我会这么使用，其实他们之间还是有一点区别的。
-
在父pom使用这种方式，子模块会直接继承父模块中的jar包，此种方式一般用于：在父pom中配置每个模块都需要的jar包及其他配置信息。
<depedencies> <!--省略--> </depedencies> -
在父pom使用这种方式，子模块pom不会自动继承父模块pom中的依赖，如果需要使用，就要给出 groupId 和 artifactId，此种方式由父模块统一管理依赖的版本配置（当然在子pom中也可以重写版本，最终结果以子pom的为准，如果不重写，版本以父pom的为准）。
<dependencyManagement> <dependencies> <!--其他依赖--> </dependencies> </dependencyManagement>如需使用，使用方式如下：
<dependencyManagement> <dependencies> <!-- 父pom中已包含的依赖，但是可省略version --> <dependency> <groupId>***</groupId> <artifactId>***</artifactId> </dependency> </dependencies> </dependencyManagement>
私服的使用
私服是一种特殊的远程Maven仓库，它是架设在局域网内的仓库服务，私服一般被配置为互联网远程仓库的镜像，供局域网内的Maven用户使用。当Maven需要下载构件的时候，先向私服请求，如果私服上不存在该构件，则从外部的远程仓库下载，同时缓存在私服之上，然后为Maven下载请求提供下载服务，另外，对于自定义或第三方的jar可以从本地上传到私服，供局域网内其他maven用户使用。
首先，要使用Nexus搭建maven私有仓库，具体方式不做过多描述，可自行百度。当搭建好了私有仓库后，接下里就需要修改我们maven里的setting.xml文件配置，这一步就是为了引入我们的私有仓库，让私有仓库能在项目中用起来，setting.xml配置如下：
<servers>
<server>
<id>central</id>
<username>admin</username>
<password>admin23</password>
</server>
<server>
<id>releases</id>
<username>admin</username>
<password>admin123</password>
</server>
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>
</servers>
<!--配置镜像-->
<mirrors>
<mirror>
<id>central</id>
<mirrorOf>central</mirrorOf>
<name>Central Repository</name>
<url>http://xxx.xxx.xxx.xxx:8081/nexus/content/groups/public/</url>
</mirror>
</mirrors>
<!--配置私服多环境-->
<profiles>
<profile>
<id>nexus</id>
<repositories>
<repository>
<id>central</id>
<name>Central Repository</name>
<url>http://xxx.xxx.xxx.xxx:8081/nexus/content/groups/public/</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>central</id>
<name>Central Repository</name>
<url>http://xxx.xxx.xxx.xxx:8081/nexus/content/groups/public</url>
</pluginRepository>
</pluginRepositories>
</profile>
</profiles>
然后就是像例子中那样通过<distributionManagement>在pom.xml中配置我们的私有仓库，另外需要注意，pom.xml中repository里的id需要和maven中setting.xml里的server id名称保持一致。
repositories标签和distributionManagement标签的区别
在例子中有用到<distributionManagement>和<repositories>两种标签，它们都是远程仓库相关的配置，但是还是有很大的区别的。
- <
repositories>中的<repository>标签配置表示从什么地址可以下载项目依赖的库文件。 - <
distributionManagement>中的<repository>标签配置表示项目打包成库文件后要上传到什么库地址。
在使用的时候，要注意配置认证，在maven的setting.xml文件中的<servers>下，我配置了3个<server>，当然这是例子，实际开发中需根据具体情况配置。另外还要注意一点，maven中的仓库分为两种，snapshot快照仓库和release发布仓库。snapshot快照仓库用于保存开发过程中的不稳定版本，release正式仓库则是用来保存稳定的发行版本。
另外提一下，<pluginRepositories>和<repositories>类似，表示插件从什么库地址下载。它里面repository的用法与repositories中的repository基本一致。
依赖冲突或依赖循环的解决办法
发生这两种情况，可以用一个通用的办法去解决，那就是直接将出现问题的依赖排除掉。
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.7.RELEASE</version>
<!--排除依赖-->
<exclusions>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
</dependencies>
spring-context和spring-aop都有引入spring-core的依赖，那么我们在同时申明了spring-context和spring-aop的情况下，我们只想使用5.2.0版本的spring-core，那么就可以直接用<exclusions>排除，这样就解决了依赖冲突。
如果出现了依赖循环，比如，我们引入了两个依赖A和B，但是A依赖B，B依赖A，这样就出现了套娃。我们同样可以用<exclusions>在A里排除B，或者在B里排除A即可。
常用插件
Maven 有以下三个标准的生命周期：
- clean：项目清理的处理
- default(或 build)：项目部署的处理
- site：项目站点文档创建的处理
三个生命周期是相互独立的，而在某一个生命周期中是存在前后依赖关系的。生命周期为构建规定了整体架构，而具体的工作则由插件提供，Maven提供了一套默认的插件来完成通用的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等工作。但Maven并不是以一种封闭式的机制来设计的，它在提供极大便利性的同时，仍然是灵活的、可扩展的，这可以通过用户配置现有插件或者自行编写插件来自定义构建行为。除自行编写的插件外，下面介绍一下现有的常用插件。
maven-compiler-plugin
一个典型的 Maven 构建（build）生命周期是由以下几个阶段的序列组成的：验证项目(validate)-> 执行编译(compile)->测试(test)->打包(package)->检查(verify)->安装(install)->部署(deploy)。
maven-compiler-plugin插件就是用于编译 Java 源文件的。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<!-- 一般而言，target与source是保持一致的，但是，有时候为了让程序能在其他版本的jdk中运行(对于低版本目标jdk，源代码中不能使用低版本jdk中不支持的语法)，会存在target不同于source的情况 -->
<source>1.8</source> <!-- 源代码使用的JDK版本 -->
<target>1.8</target> <!-- 需要生成的目标class文件的编译版本 -->
<encoding>UTF-8</encoding><!-- 字符集编码，防止中文乱码 -->
<skipTests>true</skipTests><!-- 跳过测试 -->
<verbose>true</verbose>
<showWarnings>true</showWarnings>
<fork>true</fork><!-- 要使compilerVersion标签生效，还需要将fork设为true，用于明确表示编译版本配置的可用 -->
<executable><!-- path-to-javac --></executable><!-- 使用指定的javac命令，例如：<executable>${JAVA_1_4_HOME}/bin/javac</executable> -->
<compilerVersion>1.3</compilerVersion><!-- 指定插件将使用的编译器的版本 -->
<meminitial>128m</meminitial><!-- 编译器使用的初始内存 -->
<maxmem>512m</maxmem><!-- 编译器使用的最大内存 -->
<compilerArgument>-verbose -bootclasspath ${java.home}\lib\rt.jar</compilerArgument><!-- 这个选项用来传递编译器自身不包含但是却支持的参数选项 -->
</configuration>
</plugin>
maven-surefire-plugin
maven-surefire-plugin是maven里执行测试用例的插件。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19</version>
<!-- 手动指定提供者 -->
<dependencies>
<dependency>
<groupId>org.apache.maven.surefire</groupId>
<artifactId>surefire-junit47</artifactId>
<version>2.19</version>
</dependency>
</dependencies>
<configuration>
<!--跳过测试-->
<skipTests>true</skipTests>
<!--设定方法并行执行，最大线程数10个-->
<parallel>methods</parallel>
<threadCount>10</threadCount>
<!--指定执行***的测试用例-->
<includes>
<include>**/test.java</include>
</includes>
<!--指定不执行***的测试用例-->
<excludes>
<exclude>**/test.java</exclude>
</excludes>
<!--配置分组-->
<groups>***</groups>
<!--当有一个测试用例执行失败或发生异常时,跳过后续的其他测试用例-->
<skipAfterFailureCount>1</skipAfterFailureCount>
<!--执行失败后，重试次数-->
<rerunFailingTestsCount>2</rerunFailingTestsCount>
</configuration>
</plugin>
Spring Boot Maven plugin
spring-boot-maven-plugin能够将Spring Boot应用打包为可执行的jar或war文件。
spring-boot-maven-plugin的最主要goal就是repackage，其在Maven的package生命周期阶段，能够将mvn package生成的软件包，再次打包为可执行的软件包，并将mvn package生成的软件包重命名为*.original。
最后生成了两个jar文件，一个是*.jar，另一个是*.jar.original。
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!--程序main方法所在的类文件-->
<mainClass>com.***.***</mainClass>
</configuration>
<executions>
<execution>
<goals>
<!--在 mvn package 执行之后，这个命令再次打包生成可执行的 jar，同时将 mvn package 生成的 jar 重命名为 *.origin-->
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
maven-assembly-plugin
再介绍一下另一种打包插件maven-assembly-plugin，它的特点就是支持自定义的打包结构，也可以定制依赖项等。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>${maven-assembly-plugin.version}<version>
<executions>
<execution>
<id>make-assembly</id>
<!-- 绑定到package生命周期 -->
<phase>package</phase>
<goals>
<!-- 只运行一次 -->
<goal>single</goal>
</goals>
</execution>
</executions>
<configuration>
<!-- 配置描述符文件 -->
<descriptor>src/main/assembly/assembly.xml</descriptor>
<!-- 也可以使用Maven预配置的描述符
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs> -->
</configuration>
</plugin>
描述符文件assembly.xml，示例如下：
<assembly>
<!--id 标识符，添加到生成文件名称的后缀符。如果指定 id 的话，目标文件则是 ${artifactId}-${id}.tar.gz-->
<id>assembly</id>
<!--maven-assembly-plugin 支持的打包格式有zip、tar、tar.gz (or tgz)、tar.bz2 (or tbz2)、jar、dir、war，可以同时指定多个打包格式-->
<formats>
<format>tar.gz</format>
</formats>
<!--是否包含基目录，就是在打包之后是否将artifactId作为一个目录，打包完的tar文件总是内含artifactId目录-->
<includeBaseDirectory>true</includeBaseDirectory>
<!--管理一组文件的存放位置-->
<fileSets>
<fileSet>
<directory>src/main/bin</directory>
<!--包含文件-->
<includes>
<include>*.sh</include>
</includes>
<!--排除文件-->
<!--<excludes>
<exclude>*.sh</exclude>
</excludes>-->
<!--指定文件集合的输出目录，该目录是相对于根目录-->
<outputDirectory>bin</outputDirectory>
<!--指定文件属性，使用八进制表达，分别为(User)(Group)(Other)所属属性，默认为 0644-->
<fileMode>0755</fileMode>
</fileSet>
<fileSet>
<directory>src/main/conf</directory>
<outputDirectory>conf</outputDirectory>
</fileSet>
<fileSet>
<directory>src/main/sql</directory>
<includes>
<include>*.sql</include>
</includes>
<outputDirectory>sql</outputDirectory>
</fileSet>
<fileSet>
<directory>target/classes/</directory>
<includes>
<include>*.properties</include>
<include>*.xml</include>
<include>*.txt</include>
</includes>
<outputDirectory>conf</outputDirectory>
</fileSet>
</fileSets>
<!--可以指定目的文件名到指定目录，其他和 fileSets 相同-->
<files>
<file>
<!--源文件，相对路径或绝对路径-->
<source>target/${project.artifactId}-${project.version}.jar</source>
<!--输出目录-->
<outputDirectory>.</outputDirectory>
<!--目标文件名-->
<!--<destName>***</destName>-->
<!--设置文件 UNIX 属性-->
<!--<fileMode>***</fileMode>-->
</file>
</files>
<!--用来定制工程依赖 jar 包的打包方式，-->
<dependencySets>
<dependencySet>
<unpack>false</unpack>
<!--设置作用域-->
<scope>runtime</scope>
<!--指定包依赖目录，该目录是相对于根目录-->
<outputDirectory>lib</outputDirectory>
<!--包含依赖-->
<!--<includes>
<include>***</include>
</includes>-->
<!--排除依赖-->
<!--<excludes>
<exclude>***</exclude>
</excludes>-->
</dependencySet>
</dependencySets>
</assembly>
proguard-maven-plugin
代码混淆(Obfuscated code)亦称花指令，是将计算机程序的代码，转换成一种功能上等价，但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码，也可以用于程序编译而成的中间代码。使用proguard-maven-plugin其目的就是为了保护我们的代码，防止别人反编译获取代码。详情可查看官网
<!--代码混淆-->
<plugin>
<groupId>com.github.wvengen</groupId>
<artifactId>proguard-maven-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals><goal>proguard</goal></goals>
</execution>
</executions>
<configuration>
<proguardVersion>6.0.3</proguardVersion>
<injar>${project.build.finalName}.jar</injar>
<!-- <injar>classes</injar> -->
<outjar>${project.build.finalName}.jar</outjar>
<obfuscate>true</obfuscate>
<!--配置一些混淆时的选项，但是这种写法可能看上去不是很舒服，我们可以在工程根目录下加入工程配置文件proguard.conf-->
<options>
<!-- ##默认是开启的，这里关闭shrink，即不删除没有使用的类/成员-->
<option>-dontshrink</option>
<!-- ##默认是开启的，这里关闭字节码级别的优化-->
<option>-dontoptimize</option>
<!--##对于类成员的命名的混淆采取唯一策略-->
<option>-useuniqueclassmembernames</option>
<!--- 混淆类名之后，对使用Class.forName('className')之类的地方进行相应替代-->
<option>-adaptclassstrings </option>
<!--忽略所有告警-->
<option>-ignorewarnings</option>
<!-- 混淆时不生成大小写混合的类名，默认是可以大小写混合-->
<option>-dontusemixedcaseclassnames</option>
<!--平行包结构（重构包层次），所有混淆的类放在 pg 包下-->
<option>-repackageclasses org.noahx.proguard.example.project2.pg</option>
<!-- 以下为 Keep，哪些内容保持不变，因为有一些内容混淆后（a,b,c）导致反射或按类名字符串相关的操作失效，怎么配置视具体情况而定，以下只是一个例子 -->
<!-- 此选项将用新的类名替换反射方法调用中的所有字符串。例如，调用Class.forName（'className'））-->
<!-- <option>-adaptclassstrings</option> -->
<!-- 不混淆所有特殊的类-->
<option>-keepattributes Exceptions,InnerClasses,Signature,Deprecated,
SourceFile,LineNumberTable,*Annotation*,EnclosingMethod</option>
<!-- 此选项将在接口中保存所有原始名称.-->
<option>-keepnames interface **</option>
<!-- 此选项将把所有原始方法参数保存在-keep节中定义的文件中，否则所有参数名称都将模糊.-->
<option>-keepparameternames</option>
<!-- <option>-libraryjars **</option> -->
<!-- 此选项将保存所有原始类文件，但模糊域包中的所有文件.-->
<!--<option>-keep class !com.slm.proguard.example.spring.boot.domain.** { *; }</option>-->
<option>-keep class !com.dsys.project.** { *; }</option>
<option>-keep class com.dsys.project.App { *; }</option>
<option>-keep class com.dsys.project.config.** { *; }</option>
<!--保留不然Mybatis报错-->
<option>-keep class com.test.project.entity.** { *; }</option>
<option>-keep class com.test.project.utils.PageRes { *; }</option>
<option>-keep class com.test.project.controller.** { *; }</option>
<option>-keep class com.test.project.mp.controller.** { *; }</option>
<option>-keep class com.test.project.mp.config.** { *; }</option>
<option>-keep class com.test.project.dto.** { *; }</option>
<option>-keep class * implements java.io.Serializable </option>
<!-- 此选项将在服务包中保存所有原始类文件-->
<!--<option>-keep class com.slm.proguard.example.spring.boot.service { *; }</option>-->
<!-- 此选项将保存所有包中的所有原始接口文件.-->
<option>-keep interface * extends * { *; }</option>
<!-- <option>-keep @org.springframework.stereotype.Service class *</option> -->
<!-- 此选项将保存所有包中所有类中所有原始定义的注释.-->
<option>-keepclassmembers class * {
<!-- @org.springframework.beans.factory.annotation.Autowired *; -->
@org.springframework.beans.factory.annotation.Value *;
}
</option>
<!--保持包注解类-->
<option>-keep class **.package-info</option>
<!--保持源码名与行号（异常时有明确的栈信息），注解（默认会过滤掉所有注解，会影响框架的注解）-->
<option>-keepattributes SourceFile,LineNumberTable,*Annotation*</option>
<!--保持枚举中的名子，确保枚举 valueOf 可以使用-->
<option>-keepclassmembers enum org.noahx.proguard.example.project2.** { *;}</option>
<!--保持 Bean 类，（由于很多框架会对 Bean 中的内容做反射处理，请根据自己的业务调整） -->
<option>-keep class org.noahx.proguard.example.project2.bean.** { *;}</option>
<!-- 保持对外的接口性质类对外的类名与方法名不变 -->
<option>-keep class org.noahx.proguard.example.project2.Project2 { public void init(); public void destroy(); }
</option>
</options>
<libs>
<!-- Include main JAVA library required.-->
<lib>${java.home}/lib/rt.jar</lib>
</libs>
</configuration>
<dependencies>
<dependency>
<groupId>net.sf.proguard</groupId>
<artifactId>proguard-base</artifactId>
<version>6.2.2</version>
</dependency>
</dependencies>
</plugin>
如果不想在pom文件中写太多配置，可单独创建proguard.conf文件，将其放在pom文件同目录下即可，如下：
-target 1.8 ##指定java版本号
-dontshrink ##默认是开启的，这里关闭shrink，即不删除没有使用的类/成员
-dontoptimize ##默认是开启的，这里关闭字节码级别的优化
-useuniqueclassmembernames ##对于类成员的命名的混淆采取唯一策略
-adaptclassstrings ## 混淆类名之后，对使用Class.forName('className')之类的地方进行相应替代
-dontusemixedcaseclassnames ## 混淆时不生成大小写混合的类名，默认是可以大小写混合
-keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,*Annotation*,EnclosingMethod ##对异常、注解信息在runtime予以保留，不然影响springboot启动
-keepclasseswithmembers public class * { public static void main(java.lang.String[]);} ##保留main方法的类及其方法名
-keepclassmembers enum * { *; } ##保留枚举成员及方法
maven-install-plugin
maven-install-plugin负责将获取的jar包安装到本地仓库，例如：将 ojdbj14 的驱动jar包安装到本地仓库。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
<!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->
<executions>
<!--execution元素包含了插件执行需要的信息 -->
<execution>
<!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 -->
<id>install-external</id>
<!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 -->
<phase>compile</phase>
<!-- 安装配置 -->
<configuration>
<!-- 目标文件路径 -->
<file>${project.basedir}/src/lib/ojdbc14.jar</file>
<repositoryLayout>default</repositoryLayout>
<groupId>ojdbc14</groupId>
<artifactId>ojdbc14</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<generatePom>true</generatePom>
</configuration>
<!--配置的执行目标 -->
<goals>
<!--install：安装到本地仓库，默认是从java源码编译成jar，再进行安装，install-file：直接将jar文件安装到本地仓库，而不需要源码-->
<goal>install-file</goal>
</goals>
</execution>
</executions>
</plugin>
MAVEN依赖的优先原则
-
依赖最短路径优先原则：一个项目Demo依赖了两个jar包，其中A-B-C-X(1.0) ， A-D-X(2.0)。由于X(2.0)路径最短，所以项目使用的是X(2.0)。
-
pom文件中申明顺序优先：如果A-B-X(1.0) ，A-C-X(2.0) 这样的路径长度一样怎么办呢？这样的情况下，maven会根据pom文件声明的顺序加载，如果先声明了B，后声明了C，那就最后的依赖就会是X(1.0)。
-
覆盖优先原则：子pom内声明的优先于父pom中的依赖。
如果两个依赖一个达成1的优先原则，另一个达成2的优先原则，路径最短优先，申明顺序其次。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
