Maven pom.xml常用配置解析

合集下载

Mavenpom.xml详解

Mavenpom.xml详解⼀、pom 简介POM 是项⽬对象模型 (Project Object Model) 的简称, XML 格式,名称为 pom.xml ,它是 Maven 项⽬的核⼼配置⽂件,该⽂件⽤于管理源代码、配置⽂件、开发者的信息和⾓⾊、问题追踪系统、组织信息、项⽬授权、项⽬的url、项⽬的依赖关系等等.事实上,在 Maven 的世界中,⼀个项⽬可以什么都没有,甚⾄没有代码,但是必须包含 pom.xml ⽂件.并且⼀个 Maven 项⽬有且只有⼀个 pom.xml ⽂件,该⽂件必须在项⽬的根⽬录下.⼆、pom.xml 完整结构<project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>...</groupId><artifactId>...</artifactId><version>...</version><packaging>...</packaging><dependencies>...</dependencies><parent>...</parent><dependencyManagement>...</dependencyManagement><modules>...</modules><properties>...</properties><build>...</build><reporting>...</reporting><name>...</name><description>...</description><url>...</url><inceptionYear>...</inceptionYear><licenses>...</licenses><organization>...</organization><developers>...</developers><contributors>...</contributors><issueManagement>...</issueManagement><ciManagement>...</ciManagement><mailingLists>...</mailingLists><scm>...</scm><prerequisites>...</prerequisites><repositories>...</repositories><pluginRepositories>...</pluginRepositories><distributionManagement>...</distributionManagement><profiles>...</profiles></project>我们这⾥就选择⼀些⽐较常⽤的配置来说三、pom 常⽤配置1、坐标坐标是⼀个项⽬的唯⼀标识符,可以通过坐标准确的定位到某⼀个具体的项⽬.有了坐标进⾏定位之后,如果其它的 Maven 项⽬想使⽤该项⽬⽣成的 jar 包,只需要通过坐标引⼊依赖即可Maven 坐标是通过 groupId、artifactId、version 来共同定位的.groupId: 组织 Id ,表⽰当前模块所⾪属的项⽬.起名规范：⼀级域名(com、org).⼆级域名(公司名称).项⽬名称artifactId: 模块 Id, 表⽰⼀个项⽬中的某个模块,例如商城项⽬⾥⾯的订单模块、⽤户模块、商品模块...等等version：当前的版本为什么坐标需要三个元素才能定位呢?⽐如你⾃⼰的项⽬中需要使⽤某⼀个 jar 包,那么怎么找到这个 jar 包呢?这个时候你就需要使⽤ groupId 来定位这个 jar 包是属于哪个公司的哪个项⽬,定位到了项⽬之后呢,你还需要使⽤ artifactId 定位到该项⽬的具体模块,因为⼀个项⽬可以有很多的模块,定位到了具体模块之后呢,还需要使⽤ version 来定位具体的版本号,因为⼀个模块可以进⾏迭代,如果不指定具体的版本号也就⽆法准确的定位,这个类似于地理⾥⾯只有通过东经和北纬才能准确定位⼀个地理位置⼀样.<groupId>com.xiaomaomao.springAnalyse</groupId><artifactId>spring-ioc</artifactId><version>1.0-SNAPSHOT</version>2、全局变量 propertiesproperties: 全局属性,⼀般情况下⽤于定义全局的 jar 包版本.仅仅是定义全局变量,不起其他作⽤.应⽤场景:在实际项⽬中如果我们使⽤同⼀个公司的 jar 包, jar 包的版本号最好是保持⼀致,因为有时候 jar 包版本不⼀致的情况下,有可能会出现不同版本之间发⽣不兼容的错误, 我们这⾥就以 spring 为例,下⾯的这些依赖当中 spring-context、spring-webmvc 都是属于 spring 的 jar 包,并且它们的版本号都是 4.3.11.RELEASE,突然有⼀天,项⽬经理兴奋的告诉我,spring 推出了 5.0 版本,功能很强⼤,我们要升级版本,那么这个时候你就只能挨个的找到 spring 相关的依赖,⼀个⼀个的把它们升级到 5.0 版本,我们这⾥仅仅只有两个 spring 相关的依赖,改起来⽐较快,可是如果你的项⽬⾥⾯使⽤了⼏⼗个,甚⾄上百个 spring 的依赖呢?这个时候你挨个挨个的去替换,⼯作量⽐较⼤,并且还有可能⼀不留神改错了,好不容易改完了,也没有改错,终于可以休息⼀下了,这个时候项⽬经理那个糟⽼头⼦⼜来了,他告诉你 spring 5.0 有版本缺陷,我们还是改回原来的 4.3.11.RELEASE 版本吧,我想此时你是奔溃的,你就只能挨个挨个的将 spring 的依赖 jar 包⼀个⼀个的还原,好了,还原了,也改好了,终于没事了,你冷不丁的冒出⼀个念头,万⼀项⽬经理⼜要我切换成其它的版本,⼯作量太⼤了,有没有什么⽐较好的办法呢?答案是有的,我们就可以通过 properties 标签来统⼀管理 jar 包的版本<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>4.3.11.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>4.3.11.RELEASE</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.0</version><scope>provided</scope></dependency></dependencies>在 <properties> 标签中定义⼀类 jar 包的版本,引⼊依赖的时候通过 ${标签名} 的⽅式来控制版本<properties><spring-version>4.3.11.RELEASE</spring-version><junit-version>4.11</junit-version><javax.servlet-version>4.0.0</javax.servlet-version></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring-version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${spring-version}</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit-version}</version><scope>test</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>${javax.servlet-version}</version><scope>provided</scope></dependency></dependencies>如果以后想统⼀切换 spring、junit 等 jar 包的版本,我们只需要在 properties 标签中切换就可以了,再也不⽤去依赖中挨个挨个的替换 jar 包的版本了3、dependencydependency 标签统⼀的定义在 dependencies 标签中,它代表的意思是我们可以通过该标签引⼊我们需要的相关 jar 包3.1、如何查找⼀个 jar 包的地址?Maven 依赖官⽹:3.1.1、进⼊官⽹,查找需要的 jar 包3.1.2、选择 jar 包版本3.1.3、复制依赖到项⽬ pom.xml 中3.2、如何查看引⼊的依赖4、依赖的 scope 作⽤域依赖的 scope 标签表⽰的意思是依赖的使⽤范围(也就是这个 jar 包在什么范围内是可以使⽤的),scope 的取值有 compile、test、provided、runtime、system 4.1、compile该依赖可以在整个项⽬中使⽤(是指代码范围, main ⽬录和 test ⽬录下都能使⽤这个依赖),参与打包部署.是 scope 的默认值.典型的例如: commons f ileupload 例如:我们修改 spring 核⼼依赖 spring-context 的 scope 为 test<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring-version}</version><scope>test</scope></dependency>在 main ⽬录下使⽤就出现了报错在 test ⽬录下使⽤就是正常的4.2、test该依赖只能在测试代码中使⽤(是指代码范围,只能在 test ⽬录下使⽤这个依赖),不参与打包部署.典型的例如: junit4.3、provided该依赖编写源代码时需要使⽤,因为当我们使⽤ Servlet 的时候,如果不添加 javax.servlet-api 依赖,就⽆法使⽤⾥⾯相关的 API,如果使⽤了编译就会报错,provided 不参与打包部署.只是在编写源码的时候使⽤,为什么不参与打包部署呢?因为我们的项⽬打包部署到服务器的时候,服务器会为我们提供 javax.servlet-api ,这⾥以 tomcat 为例,找到 tomcat 的安装⽬录,打开⾥⾯的 lib ⽬录,在 tomcat 容器启动的时候会为我们提供 servlet-api.jar ,那么我们项⽬中的 pom.xml 中就不需要再提供 servlet-api 这个依赖了4.4、runtime该依赖编写代码时不需要,运⾏时需要,参与打包部署.典型的例如数据库驱动 mysql-connector-java<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.20</version></dependency>为什么编写代码时不需要呢？jvm 运⾏期的时候通过反射加载数据库驱动,完成例如注册驱动、获取连接、获取 PrepareStatement 对象等,我们编写代码的时候只是在编译期间,根本不会使⽤到数据库驱动,项⽬最终打包部署的时候也是需要数据驱动的,否则你⽆法连接数据库和操作 Sql 语句.4.5、system表⽰使⽤本地系统路径下的 jar 包,需要和 systemPath 配合使⽤,典型的例如 Oracle 数据库驱动: ojdbc.jar ,它是未授权 Maven 中央仓库的(刚刚去 Maven 中央仓库发现有,但是我们就假设它没有被Maven 中央仓库录⼊)有些 jar 包可能因为授权的问题或者是⼀些个⼈的 jar 包,这些 jar 包不会被 Maven 中央仓库录⼊,这个时候如果我们想在项⽬中使⽤这些 jar 包的话,我们可以先将 jar 包下载先来,然后可以在 pom.xml 中配置指向本地某个 jar 包的路径,引⼊相关的 jar 包对主程序是否有效对测试程序是否有效是否参与打包是否参与部署典型例⼦compile 是是是是spring-context test 否是否否junit provided 是是否否servlet-api 、jsp-api runtime 否否是是mysql-connector-java system -----引⼊ Oracle 驱动之后就可以使⽤了,没有出现报错其实吧,我觉得如果某些 jar 包 Maven 中央仓库没有录⼊,我们可以将需要的 jar 包下载下来,然后上传到私服中,通过左边从私服中下载就可以了.这⾥总结⼀下 scope 依赖范围4.6、远程仓库 repositoriesrepositories:⽤来配置当前⼯程使⽤的远程仓库依赖查找顺序:本地仓库--->当前⼯程 pom.xml 中配置的远程仓库--->⽤户级别的 settings.xml 中配置的远程仓库----> 全局 settings.xml 中配置的远程仓库---->Maven 中央仓库应⽤场景：如果有些 jar 包在 Maven 中央仓库没有,但是在其他仓库(例如:阿⾥仓库、spring 仓库、mybatis 仓库)⾥是有这个 jar 包的,例如 spring 新发布了⼀个版本,由于是刚发⾏的版本,性能不太稳定,这个时候Maven 中央仓库⼀般不会将这些 jar 包录⼊,但是你就是想⽤ spring 最新的版本,那么可以在 pom.xml 中通过配置 repositories 从指定的某公司官⽅仓库来获取相应的 jar 包<repositories><repository><id>spring_repo</id><name>Private Repository</name><url>http://repo.spring.io/milestone</url><layout>default</layout><releases><enabled>true</enabled><updatePolicy>always</updatePolicy><checksumPolicy>warn</checksumPolicy></releases><snapshots><enabled>true</enabled><updatePolicy>always</updatePolicy></snapshots></repository><repository><id>alimaven</id><name>aliyun maven</name><url>/nexus/content/groups/public/</url></repository></repositories>4.7、插件 plugins插件,就是⼀种⼯具.常见的如:清理插件 maven c lean p lugin ,编译插件 maven c ompile p lugin插件和依赖的区别:插件是⼯具,偏向于开发环境.和项⽬功能、源码、打包好的 jar 包没有任何关系.插件和依赖的关系,类似于 IDEA ⼯具和上线的 jar 包.Maven 的核⼼⽂件很⼩,主要的任务都是由插件来完成.定位到：%本地仓库%\org\apache\maven\plugins ,可以看到⼀些下载好的插件4.7.1、插件的⽬标 (Plugin Goals)⼀个插件通常可以完成多个任务,每⼀个任务就叫做插件的⼀个⽬标.如执⾏ mvn install 命令时,调⽤的插件和执⾏的插件⽬标如下4.7.2、将插件绑定到⽣命周期Maven 的⽣命周期是抽象的,实际需要插件来完成任务,这⼀过程是通过将插件的⽬标 (goal) 绑定到⽣命周期的具体阶段 (phase) 来完成的.例如将 maven-compiler-plugin 插件的 compile ⽬标绑定到 default ⽣命周期的 compile 阶段,完成项⽬的源代码编译.Maven 对⼀些⽣命周期的阶段（phase）默认绑定了插件⽬标,因为不同的项⽬有 jar、war、pom 等不同的打包⽅式,因此对应的有不同的绑定关系,其中针对 default ⽣命周期的 jar 包打包⽅式的绑定关系如下第⼆列中,冒号后⾯即是绑定的插件⽬标,冒号前⾯是插件的前缀(prefix),是配置和使⽤插件的⼀种简化⽅式.4.7.3、⾃定义绑定⽤户可以根据需要将任何插件⽬标绑定到任何⽣命周期的阶段, 例如将 maven-source-plugin 的 jar-no-fork ⽬标绑定到 default ⽣命周期的 package 阶段, 这样,以后在执⾏ mvn package 命令打包项⽬时,在 package 阶段之后会执⾏源代码打包,⽣成如 ehcache-core-2.5.0-sources.jar 形式的源码包.<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-source-plugin</artifactId><version>2.2.1</version><executions><execution><id>attach-source</id><phase>package</phase><goals><goal>jar-no-fork</goal></goals></execution></executions></plugin></plugins>……</build>4.7.4、pom.xml 中配置插件<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-clean-plugin</artifactId><version>3.0.0</version></plugin><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.2</version><configuration><path>/xiaomaomao</path><port>8888</port></configuration></plugin></plugins></build>这⾥有个很奇怪的现象,我使⽤ IDEA 帮我创建 Web 项⽬, IDEA ⾃动帮我下载了插件,其中 maven-clean-plugin 插件的版本是 3.1.0 ,我这⾥把插件的版本替换成了 3.0.0然后看⼀下我们加⼊的 maven-tomcat 插件五、超级 pom当我们利⽤ IDEA 为我们创建⼯程的时候,我们没有进⾏任何配置,为什么能下载各种插件呢?这是由于存在超级 pom 的原因,所有的 Maven 项⽬都要继承超级 pom,⾥⾯有 Maven 默认的⼀些配置超级 pom 存放位置: Maven 的安装⽬录\bin\maven-model-builder-3.6.0.jar\org\apache\maven\model\pom-4.0.0.xml解压开 maven-model-builder-3.6.0.jar 这个压缩包,⾥⾯有两个⽬录在 org/apache/maven/model/ ⽬录下有⼀个 pom-4.0.0.xml ,这个 pom 就是超级 pom ,例如⾥⾯就配置了相关的仓库信息。

史上最全的maven的pom.xml文件详解（转载）

史上最全的maven的pom.xml⽂件详解（转载）此⽂出处：——1<project xmlns="/POM/4.0.0"2xmlns:xsi="/2001/XMLSchema-instance"3xsi:schemaLocation="/POM/4.0.0 /maven-v4_0_0.xsd ">45<!-- ⽗项⽬的坐标。

如果项⽬中没有规定某个元素的值，那么⽗项⽬中的对应值即为项⽬的默认值。

6坐标包括group ID，artifact ID和 version。

-->7<parent>89<artifactId>xxx</artifactId>101112<groupId>xxx</groupId>131415<version>xxx</version>1617<!-- ⽗项⽬的pom.xml⽂件的相对路径。

相对路径允许你选择⼀个不同的路径。

默认值是../pom.xml。

18 Maven⾸先在构建当前项⽬的地⽅寻找⽗项⽬的pom，其次在⽂件系统的这个位置（relativePath位置），19然后在本地仓库，最后在远程仓库寻找⽗项⽬的pom。

-->20<relativePath>xxx</relativePath>21</parent>2223<!-- 声明项⽬描述符遵循哪⼀个POM模型版本。

模型本⾝的版本很少改变，虽然如此，但它仍然是必不可少的，24这是为了当Maven引⼊了新的特性或者其他模型变更的时候，确保稳定性。

聊聊maven的pom.xml中的exclusions标签的作用

聊聊maven的pom.xml中的exclusions标签的作⽤maven pom.xml的exclusions标签作⽤项⽬中的例⼦<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId><exclusions><exclusion><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId></exclusion></exclusions></dependency>解释exclusion标签这个标签的作⽤是排除关联依赖的引⼊，因为maven的pom依赖其中有⼀点是将关联的依赖全都引⼊进来，这个标签在这的作⽤就是如果关联的依赖和引⼊的其他依赖可能存在冲突，就必须将关联的依赖排除掉，所以就⽤这个标签。

另外这个＋s的，⼤家应该也明⽩，就是可以包含多个吗⽤exclusions来进⾏排除依赖exclusions但依赖调节并不解决所有问题，我们还需要exclusions来进⾏排除依赖。

例如这样⼀个情况，⼯程中引⼊了A，A依赖B，但是B的版本过旧。

此时可以使⽤exclusions排除该传递性依赖，并显⽰声明⼀个最新版本的B依赖。

⽐如这样<dependency><groupId>com.lowagie</groupId><artifactId>itext</artifactId><version>4.2.1</version><exclusions><exclusion><artifactId>bcmail-jdk14</artifactId><groupId>bouncycastle</groupId></exclusion><exclusion><artifactId>bcprov-jdk14</artifactId><groupId>bouncycastle</groupId></exclusion><exclusion><artifactId>bctsp-jdk14</artifactId><groupId>bouncycastle</groupId></exclusion></exclusions></dependency>在⽐如若是使⽤zookeeper发现有log4j的冲突。

pom.xml详解

parent的使用方法如下：
<parent>
<groupId>org.codehaus.mojo</groupId>
<artifactId>my-parent</artifactId>
<version>2.0</version>
<relativePath>../my-parent</relativePath>
<groupId>com.alibaba.external</groupId>
</exclusion>
....
</exclusions>
......
</dependencies>
其中groupId, artifactId, version这三个组合标示依赖的具体工程，而且这个依赖工程必需是maven中心包管理范围内的，如果碰上非开源包，maven支持不了这个包，那么则有有三种方法处理：
<java.target.version>1.5</java_target_version>
</.encoding}
还可以使用project.xx引用pom里定义的其它属性：如$(project.version}


<groupId>...</groupId>
<artifactId>...</artifactId>

maven运行时的配置及命令详解

maven运⾏时的配置及命令详解上⾯是指定端⼝运⾏程序的，也可以先指定好，直接在上⾯的地⽅写jettty:run 当然，如果你是在控制台运⾏且安装了maven，直接可以进⼊项⽬的⽂件中：mvn jetty:run就是说，在控制台运⾏只要加上⼀个mvn就ok了源代码格式的包Maven install将项⽬输出构件部署到本地仓库maven最主要的作⽤有两个⽅⾯，⼀个是对jar包的依赖解决功能，⾃⼰管理jar包，另⼀个功能就是项⽬的构建，打包部署。

现在我觉得最重要的还是maven的⽣命周期和插件机制，下⾯就来总结⼀下吧。

mvn install 是将你打好的jar包安装到你的本地库中，⼀般没有设置过是在⽤户⽬录下的 .\下⾯。

mvn package 只是将你的代码打包到输出⽬录，⼀般的是 target下⾯。

eclipse插件，m2eclipse1.maven install相当于maven原⽣的命令： mvn install2.aven build是 m2eclipse这个插件⾃⼰创造的概念，需要你来配置到底需要执⾏什么命令，如下图中的goals输⼊的就是你想执⾏的命令： Goals就是mvn的意思，所以中间不需要加mvn了 Eclipse中maven常⽤的命令点击Run As就可以发现⼏个Maven的命令： Maven Build: 这个命令⽤于编译Maven⼯程，执⾏命令后会在target⽂件夹中的classes中⽣成对应的class⽂件。

Maven Clean: 删除target⽂件夹，即删除⽣成的package包以及class等⽂件。

Maven Test: 先⾃动进⾏编译，在运⾏所有的测试⽤例。

Maven install: 发布⽣成对应的package包。

注意：留意上⾯的命令的作⽤，build和test都会⽣成相应的class⽂件。

也就是说，当你新建⼀个maven⼯程，或者clean⼀个maven⼯程后，如果没有使⽤这两个命令，直接针对类进⾏测试，会跑出java.class.notfound的错误。

maven pom文件pluginrepositories标签详解

maven pom文件pluginrepositories
标签详解
在 Maven的`pom`文件中，`repositories`标签的作用是配置maven项目的远程仓库。

示例如下：
```xml
<repositories>
<repository>
<id>nexus</id>
<name>Nexus Repository</name>
<url>远程仓库地址</url>
<releases><enabled>true</enabled></releases>
<snapshots><enabled>true</enabled> </snapshots>
</repository>
</repositories>
```
按照上述配置，可以实现配置maven项目的远程仓库。

这样的配置在创建一个项目时，需要配置一次，比较麻烦。

在`pluginRepositories`标签中，可以配置 Maven从什么地方下载插件构件。

该元素的内部配置和`repository`完全一样，不再解释。

maven的pom.xml中profiles的作用详解

maven的pom.xml中profiles的作⽤详解⽬录1、profiles是什么？有什么作⽤2、如何配置3、区别构建发布包maven多环境profiles参数切换项⽬结构图1、profiles是什么？有什么作⽤在maven构建的项⽬都存在⼀个pom.xml的项⽬对象模型配置⽂件，⽤于约束项⽬（如：jar包管理、构建管理等）。

profiles 是pom.xml中的⼀个配置项。

我们在开发项⽬时⼀般都会区分线上环境和测试环境，这两个环境需要切换以适应不同的环境需求正式环境的配置，⼀般放置于src/main/resources下，⽽测试环境放置于/src/test/resources下⾯。

profile的主要作⽤就是区分正式环境和测试环境的配置2、如何配置<profiles><profile><id>release</id><build><resources><resource><directory>src/main/resources</directory><includes><include>**/*</include></includes></resource></resources></build></profile><profile><id>test</id><build><resources><resource><directory>src/test/resources</directory><includes><include>config/*.properties</include><include>log4j.xml</include></includes></resource><resource><directory>src/main/resources</directory><includes><include>**/*.xml</include></includes><excludes><exclude>log4j.xml</exclude></excludes></resource></resources></build><activation><activeByDefault>true</activeByDefault></activation></profile></profiles>如上，我配置了两个profile⼀个release⽤于正式环境发布，test⽤于测试环境使⽤；默认开启测试环境，activation->true测试环境与正式环境只是部分的配置不同，我们需要公⽤这部分配置。

Maven常用参数及其说明

Maven常⽤参数及其说明⽬录Maven常⽤参数及其说明***\*Maven常⽤参数及其说明\*******-h,--help\*** Display help information***-am,--also-make\*** 构建指定模块,同时构建指定模块依赖的其他模块;***-amd,--also-make-dependents*** 构建指定模块,同时构建依赖于指定模块的其他模块;***-B,--batch-mode*** 以批处理(batch)模式运⾏;***-C,--strict-checksums*** 检查不通过,则构建失败;(严格检查)***-c,--lax-checksums*** 检查不通过,则警告;(宽松检查)***-D,--define <arg>\*** Define a system property***-e,--errors\*** 显⽰详细错误信息***-emp,--encrypt-master-password <arg>\*** Encrypt master security password***-ep,--encrypt-password <arg>\*** Encrypt server password***-f,--file <arg>*** 使⽤指定的POM⽂件替换当前POM⽂件***-fae,--fail-at-end\*** 最后失败模式：Maven会在构建最后失败（停⽌）。

如果Maven refactor中⼀个失败了，Maven会继续构建其它项⽬，并在构建最后报告失败。

***-ff,--fail-fast*** 最快失败模式：多模块构建时,遇到第⼀个失败的构建时停⽌。

***-fn,--fail-never*** 从不失败模式：Maven从来不会为⼀个失败停⽌，也不会报告失败。

***-gs,--global-settings <arg>*** 替换全局级别settings.xml⽂件(Alternate path for the global settings file)***-l,--log-file <arg>\*** 指定输出⽇志⽂件***-N,--non-recursive\*** 仅构建当前模块，⽽不构建⼦模块(即关闭Reactor功能)。

Maven pom文件常用配置小结

Maven pom文件常用配置小结什么是POMProject Object Model，项目对象模型。

通过xml格式保存的pom.xml文件。

作用类似ant 的build.xml文件，功能更强大。

该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。

一个完整的pom.xml文件，放置在项目的根目录下。

<project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0/maven-v4_0_0.xsd"><modelVersion>4.0.0</modelVersion><!– The Basics –><groupId>…</groupId><artifactId>…</artifactId><version>…</version><packaging>…</packagi ng><dependencies>…</dependencies><parent>…</parent><dependencyManagement>…</dependencyManagement><modules>…</modules><properties>…</properties><!– Build Settings –><build>…</build><reporting>…</reporting><!– More Project Information –><name>…</name><description>…</description><url>…</url><inceptionYear>…</inceptionYear><licenses>…</licenses><organization>…</organization><developers>…</developers><contributors>…</contributors><!– Environment Settings –><issueManagement>…</issueManagement><ciManagement>…</ciManagement><mailingLists>…</mailingLists><scm>…</scm><prerequisites>…</prerequisites><repositories>…</repositories><pluginRepositories>…</pluginRepositories><distributionManagemen t>…</distributionManagement><profiles>…</profiles></project>基本设置maven的协作相关属性<project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0/maven-v4_0_0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.codehaus.mojo</groupId><artifactId>my-project</artifactId><version>1.0</version><packaging>war</packaging></project>1.groupId : 组织标识，例如：org.codehaus.mojo，在M2_REPO目录下，将是:org/codehaus/mojo目录。

java 中maven和pom文件的用法

java 中maven和pom文件的用法Java中Maven和POM文件的用法在Java开发过程中，Maven是一个常用的构建工具，而POM文件是Maven项目的核心配置文件。

本文将详细介绍Maven和POM文件的用法，并讲解如何使用它们来管理Java项目的构建和依赖。

1. Maven介绍Maven是一个基于项目对象模型（POM）的项目管理工具。

它提供了一种标准的方式来构建、测试和部署Java项目。

Maven还能够自动下载和管理项目所需的依赖库，使开发者能够更方便地管理项目的构建过程。

2. POM文件介绍POM文件是Maven项目的核心配置文件，它使用XML格式来描述项目的结构和构建配置。

POM文件定义了项目的坐标、依赖关系、插件配置等信息，Maven根据这些信息来进行构建和管理项目。

3. 创建Maven项目要使用Maven来构建Java项目，首先需要创建一个Maven项目。

可以使用使用IDE（如Eclipse、IntelliJ IDEA）自动生成Maven项目结构，或者手动创建包含POM文件的文件夹结构。

4. 配置POM文件POM文件包含在项目根目录下，并命名为pom.xml。

打开POM文件后，可以通过修改各种元素和属性来对项目进行配置。

a) 项目坐标POM文件的<groupId>、<artifactId>和<version>元素一起定义了项目的坐标。

groupId代表组织或者公司的唯一标识，artifactId代表项目的唯一标识，version代表项目的版本。

例如：<groupId>com.example</groupId><artifactId>my-project</artifactId><version>1.0</version>b) 依赖管理POM文件的<dependencies>元素用于管理项目的依赖关系。

maven configuration解析

Maven是一个流行的项目管理工具，它主要用于Java评台的项目构建、依赖管理和项目报告的生成。

在Maven中，配置是一个非常重要的部分，它决定了项目的构建、打包、部署等行为。

本文将对Maven 的配置进行解析，包括Maven的配置文件、项目的POM文件以及常见的配置项。

一、Maven的配置文件Maven的配置文件包括全局配置文件和用户配置文件。

全局配置文件是指Maven安装目录下的conf目录中的settings.xml文件，它包含了Maven的全局配置信息，例如Maven的本地仓库路径、代理服务器设置、镜像设置等。

用户配置文件是指用户目录下的.m2目录中的settings.xml文件，它包含了用户自定义的配置信息，例如用户的身份认证信息、仓库的设置等。

二、项目的POM文件Maven项目的POM文件是项目的核心配置文件，它包含了项目的基本信息、依赖关系、构建配置等。

POM文件的主要配置包括：1. 项目的基本信息：包括项目的groupId、artifactId、版本号等，这些信息在Maven中用来唯一标识一个项目。

2. 项目的依赖关系：通过dependencies元素可以指定项目的依赖项，包括依赖的groupId、artifactId、版本号等信息。

3. 项目的构建配置：包括项目的源代码目录、资源目录、输出目录等，通过build元素可以指定项目的构建配置信息。

4. 项目的插件配置：Maven通过插件来完成各种构建任务，通过plugins元素可以指定项目所使用的插件及其配置信息。

三、常见的配置项除了全局配置文件和POM文件外，Maven还有一些常见的配置项，这些配置项可以通过命令行参数、环境变量、系统属性等方式进行配置，主要包括：1. 仓库的配置：Maven使用仓库来存储项目的依赖项，通过指定仓库的路径、远程仓库的位置区域等可以进行仓库的配置。

2. 编译插件的配置：Maven使用插件来完成项目的编译任务，通过配置插件的参数可以对编译过程进行定制。

maven项目一般的构建结构

maven项目一般的构建结构首先，让我们在开始讨论maven项目一般的构建结构之前，先了解一下Maven是什么。

Maven是一个项目管理工具，通过提供一种标准的构建方法和一套默认的构建生命周期，使得项目的构建、编译、测试和发布等过程变得更加简单和可靠。

Maven项目的构建结构是一种约定俗成的结构，它有助于提高项目的可维护性和可扩展性。

下面将逐步介绍Maven项目的构建结构的各个组成部分。

1. 项目根目录：Maven项目的根目录是一个包含pom.xml文件的目录。

pom.xml文件是项目的核心配置文件，它定义了项目的依赖关系、构建方式等重要信息。

项目根目录通常被用作版本控制系统的根目录。

2. src目录：src目录是项目的源代码目录，通常包含以下两个子目录：- src/main：该目录包含项目的主要源代码。

主要的Java源代码通常位于src/main/java目录下，而资源文件（如配置文件、图片等）则位于src/main/resources目录下。

- src/test：该目录包含项目的单元测试代码。

测试的Java源代码通常位于src/test/java目录下，而测试资源文件则位于src/test/resources目录下。

3. target目录：target目录是项目构建的目标目录，它是Maven构建过程的输出目录。

在执行Maven构建命令后，生成的编译目标（如编译后的class文件、打包的jar文件等）将被输出到target目录。

4. pom.xml文件：pom.xml文件是Maven项目的核心配置文件。

它使用XML格式来描述项目的元数据、依赖关系、构建配置以及其他相关信息。

通过编辑pom.xml 文件，开发者可以指定项目的依赖关系、构建插件、构建生命周期等。

5. Maven标准目录结构：除了src目录外，Maven项目还遵循一种标准目录结构，用于存放其他项目相关的文件。

常见的标准目录结构包括：- src/main/java：项目的主要Java源代码目录。

详细解读maven的exclusions

Maven是一个强大的项目管理工具，它能够帮助开发人员管理项目依赖以及构建项目。

在日常开发中，我们经常会遇到依赖冲突的情况，这时就需要使用Maven的exclusions来排除特定的依赖。

一、什么是exclusions？1.1 依赖冲突当一个项目依赖的第三方库A版本为1.0，而另一个依赖的库B却依赖A版本为2.0时，就会发生依赖冲突。

这种情况会导致项目构建失败或者在运行时出现异常。

1.2 exclusions的作用exclusions是Maven中用来排除特定依赖的机制。

通过exclusions，开发人员可以在声明依赖的指定要排除的传递依赖，从而解决依赖冲突的问题。

二、如何使用exclusions？2.1 在pom.xml中进行配置在项目的pom.xml文件中，可以对特定的依赖进行exclusions配置。

以下是一个示例：```xml<dependency><groupId.example</groupId><artifactId>example-library</artifactId><version>1.0</version><exclusions><exclusion><groupId>org.example</groupId><artifactId>conflicting-library</artifactId></exclusion></exclusions></dependency>```在这个示例中，我们排除了example-library依赖中的conflicting-library模块。

这样就能确保项目中不会出现依赖冲突的情况。

需要注意的是，exclusions中的groupId和artifactId需要和要排除的依赖一致。

SpringBoot项目pom.xml常用基本配置

SpringBoot项⽬pom.xml常⽤基本配置<project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.example</groupId><artifactId>SpringBoot</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><name>SpringBoot</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.6.RELEASE</version><relativePath/> </parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId></dependency><dependency><groupId>com.fasterxml.jackson.datatype</groupId><artifactId>jackson-datatype-joda</artifactId></dependency><dependency><groupId>com.fasterxml.jackson.module</groupId><artifactId>jackson-module-parameter-names</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin> </plugins></build></project>mybatis、数据库相关依赖注释了，没有注释且没进⾏相关配置则会报错。

Springboot项目pom.xml配置文件以及启动类的一些配置

Springboot项⽬pom.xml配置⽂件以及启动类的⼀些配置1.pom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion> //当前项⽬的名称<groupId>dhcc.basicbusiness</groupId><artifactId>dhcc-basicbusiness</artifactId><version>0.0.1-SNAPSHOT</version> //打包⽅式：jar、war<packaging>jar</packaging><name>dhcc-basicbusiness</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.8.RELEASE</version><relativePath/></parent><properties> //通过mybatis⾃动⽣成mapper.实体类。

maven配置编码格式

maven配置编码格式Maven 是一个强大的项目管理工具，它可以帮助开发人员构建、发布和管理项目。

在 Maven 中配置编码格式是非常重要的，因为它可以确保项目中的所有文件都遵循相同的编码规范，从而避免出现编码不一致导致的问题。

要配置 Maven 项目的编码格式，需要在项目的 pom.xml 文件中进行相应的设置。

首先，我们需要在 pom.xml 文件中添加以下配置：xml.<properties>。

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>。

</properties>。

这段配置指定了项目的源文件编码格式为 UTF-8，你也可以根据需要将 UTF-8 替换为其他编码格式，比如 ISO-8859-1 或者 GBK 等。

这样做可以确保项目中的源文件都按照指定的编码格式进行编译和构建。

除了在 pom.xml 文件中配置编码格式，还可以在 Maven 的插件中进行相应的设置。

比如，在 maven-compiler-plugin 插件中，我们可以添加以下配置：xml.<plugin>。

<groupId>org.apache.maven.plugins</groupId>。

<artifactId>maven-compiler-plugin</artifactId>。

<version>3.8.1</version>。

<configuration>。

<source>1.8</source>。

<target>1.8</target>。

<encoding>UTF-8</encoding>。

</configuration>。

pom.xml systempath引用相对路径

Pom.xml文件是Maven项目的核心配置文件，通过这个文件可以指定项目的依赖、插件、构建过程等信息。

在项目开发中，经常会遇到需要在pom.xml中引用系统路径的情况，而在引用系统路径时，很多开发者会遇到使用相对路径的问题。

本文将介绍在pom.xml文件中如何使用systemPath引用相对路径的方法，帮助开发者更好地理解和解决这一问题。

1. 了解systemPath的作用在pom.xml文件中，可以通过<systemPath>标签来指定系统路径，该标签用于解决Maven无法直接从Maven仓库中获取所需jar包的问题。

通常情况下，Maven会从中央仓库或私有仓库中下载jar包，但是有些jar包可能并没有被部署到任何仓库中，这时就需要使用systemPath来引用本地安装的jar包。

但是在实际应用中，有时会遇到需要引用相对路径的情况，下面将介绍如何在pom.xml中使用相对路径来引用系统路径。

2. 使用相对路径引用systemPath在pom.xml文件中，可以使用${project.basedir}变量来表示项目的根目录，通过结合这个变量，可以轻松地使用相对路径来引用systemPath。

如果希望引用项目根目录下的lib目录中的jar包，可以这样配置：```xml<dependency><groupId.example</groupId><artifactId>example</artifactId><version>1.0.0</version><scope>system</scope><systemPath>${project.basedir}/lib/example.jar</systemPath> </dependency>```在这个示例中，${project.basedir}表示项目的根目录，/lib/example.jar表示项目根目录下的lib目录中的example.jar文件。

Maven的pom.xml文件结构之基本配置parent和继承结构

Maven的pom.xml文件结构之基本配置parent和继承结构1.Maven项目的继承Maven项目之间不仅存在多模块的聚合关系，而且Maven项目之间还可以存在相互继承的关系。

Maven项目之间的继承关系通过<parent>表示，在子Maven项目的POM中配置示例如下：[html] view plain copy1.<parent>2.<groupId>com.ericsson.jcat</groupId>3.<artifactId>jcat-bundle</artifactId>4.<version>2.0</version>5.<relativePath>../jcat-bundle</relativePath>6.</parent>说明：给出被继承的父项目的具体信息。

其中的relativePath给出父项目相对于子项目的路径，这样在构件子项目时首先从该相对路径查找父项目，如果没有才会从本地库或进而远程库中查找父项目。

2.在子项目中，能够继承父项目的如下配置：•dependencies•developers•contributors•plugin lists•reports lists•plugin executions with matching ids•plugin configuration3.Maven的Super POM类似于Java中的ng.Object类，所有Java类都继承自该类。

在Maven中也存在一个特殊的POM，被称为Super POM。

任何Maven项目的POM都继承自Super POM。

在Super POM中，设置如下：•Maven的central库•Maven的central插件库•build的基本参数和4个插件（maven-antrun-plugin、maven-assembly-plugin、maven-dependency-plugin和maven-release-plugin）•reporting的基本目录•一个profile（id=release-profile）。

（转）如何在maven的pom.xml中添加本地jar包

（转）如何在maven的pom.xml中添加本地jar包1 maven本地仓库认识maven本地仓库中的jar⽬录⼀般分为三层：图中的1 2 3分别如下所⽰：1 groupId2 artifactId3 version 4 jar包的依赖如果要将maven本地仓库中的jar包添加到项⽬中，直接打开4 xx.pom⽂件，将改jar包的相关依赖复制pom.xml⽂件中即可。

2 将本地jar包添加到本地仓库2.1 添加jar到本地仓库原则上Maven的设计是不需要这么做的，因为pom.xml中依赖的jar包会⾃动实现从中央仓库下载到本地仓库。

但也有特殊情况。

⽐如我下载了lucene-queryparser-4.6.1.jar怎么添加jar到本地仓库呢？步骤：1.cmd命令进⼊该jar包所在路径（快捷键：shift+右键选择在此处打开命令⾏窗⼝）ps:jar包可以在任意⼀个⽂件夹⽬录下⾯，不要放在分区的根⽬录，也不要⾃⼰去创建maven中的相关⽬录。

不需要去创建相关⽬录，mvn install之后会⾃动将相关的jar包放⼊本地仓库。

2.执⾏命令：mvn install:install-file -Dfile=lucene-queryparser-4.6.1.jar -DgroupId=org.apache.lucene -DartifactId=lucene-queryparser -Dversion=4.6.1 -Dpackaging=jar其中：-DgroupId和-DartifactId的作⽤是指定了这个jar包在repository的安装路径，只是⽤来告诉项⽬去这个路径下寻找这个名称的jar包。

⼀般⽤的jar包都是在mven仓库中下载的，所以groupId和artifactId直接将复制maven仓库中的设置即可。

<dependency><groupId>org.apache.lucene</groupId><artifactId>lucene-queryparser</artifactId><version>4.6.1</version></dependency>⽐如：mvn install:install-file -Dfile=hadoop-hdfs-2.2.0.jar -DgroupId=org.apache.hadoop -DartifactId=hadoop-hdfs -Dversion=2.2.0 -D -Dpackaging=jar就是指把hadoop-hdfs-2.2.0.jar安装到repository\org.apache.hadoop\hadoop-hdfs\2.2.0⽬录下，执⾏完命令后，如果需要在项⽬中使⽤这个jar，则在pom.xml中添加如下配置即可：<dependency><groupId>org.apache.hadoop</groupId><artifactId>hadoop-hdfs</artifactId><version>2.2.0</version></dependency>ps：执⾏上述命令后，在该jar包所在⽬录中会⽣成⼀个 jar包名字.pom的⽂件，⾥⾯有描述改jar包的坐标信息。

四种常用的通知类型和环绕通知（注解）

四种常⽤的通知类型和环绕通知（注解）1、maven依赖<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.ly.spring</groupId><artifactId>spring05</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.6</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.2.RELEASE</version><scope>test</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>13</source><target>13</target></configuration></plugin></plugins></build></project>2、实体类package com.ly.spring.domain;import java.io.Serializable;public class Account implements Serializable {private String accountName;public String getAccountName() {return accountName;}public void setAccountName(String accountName) {this.accountName = accountName;}@Overridepublic String toString() {'}';}}3、service接⼝package com.ly.spring.service;import com.ly.spring.domain.Account;import java.util.List;public interface IAccountService {public List<Account> findAll();}4、service实现类package com.ly.spring.service.impl;import com.ly.spring.domain.Account;import com.ly.spring.service.IAccountService;import org.springframework.stereotype.Service;import java.util.ArrayList;import java.util.List;@Service("accountService")public class AccountServiceImpl implements IAccountService { @Overridepublic List<Account> findAll() {System.out.println("AccountServiceImpl---findAll");List<Account> list = new ArrayList<>();Account account = new Account();account.setAccountName("hehe");list.add(account);return list;}}5、通知类package com.ly.spring.utils;import ng.annotation.*;import ponent;@Component("logUtil")//@Aspect：指定此类为切⾯通知类@Aspectpublic class LogUtil {//@Pointcut:配置切⼊点@Pointcut("execution(* com.ly.spring.service.impl.*.*(..))") private void pointCut1() {}//@Before：配置前置通知⽅法并指定切⼊点@Before("pointCut1()")public void beforeFunc() {System.out.println("---前置通知---");}//@AfterReturning:配置后置通知⽅法并指定切⼊点@AfterReturning("pointCut1()")public void afterReturnFunc() {System.out.println("---后置通知---");}//@AfterThrowing:配置异常通知⽅法并指定切⼊点@AfterThrowing("pointCut1()")public void afterThrowFunc() {System.out.println("---异常通知---");}//@After:配置最终通知⽅法并指定切⼊点@After("pointCut1()")public void afterFunc() {System.out.println("--最终通知--");}6、spring配置⽂件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd"><context:component-scan base-package="com.ly.spring"></context:component-scan><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>7、测试类package com.ly.spring.test;import com.ly.spring.domain.Account;import com.ly.spring.service.IAccountService;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import java.util.List;//替换junit的main⽅法@RunWith(SpringJUnit4ClassRunner.class)//指定spring配置⽂件的位置@ContextConfiguration(locations = "classpath:bean.xml")public class MainTest {@Autowiredprivate IAccountService accountService;@Testpublic void test1() {List<Account> result = accountService.findAll();System.out.println(result);}}8、基于注解的环绕通知，只需在上⾯的基础上修改通知类package com.ly.spring.utils;import ng.ProceedingJoinPoint;import ng.annotation.*;import ponent;@Component("logUtil")//@Aspect：指定此类为切⾯通知类@Aspectpublic class LogUtil {//@Pointcut:配置切⼊点@Pointcut("execution(* com.ly.spring.service.impl.*.*(..))")private void pointCut1() {}public void beforeFunc() {System.out.println("---前置通知---");}public void afterReturnFunc() {System.out.println("---后置通知---");}public void afterThrowFunc() {System.out.println("---异常通知---");public void afterFunc() {System.out.println("--最终通知--");}//@Around:配置环绕通知⽅法并指定切⼊点@Around("pointCut1()")public Object arroundFunc(ProceedingJoinPoint pjp) { try {Object result = null;Object[] args = pjp.getArgs();beforeFunc();//前置通知result = pjp.proceed(args);afterReturnFunc();//后置通知return result;}catch (Throwable t) {afterThrowFunc();//异常通知throw new RuntimeException(t);}finally {afterFunc();//最终通知}}}。