Maven入门，读完这篇就够了

Maven 项⽬⽣命周期

Maven从项⽬的三个差别的⻆度，定义了三套⽣命周期，三套⽣命周期是相互独⽴的，它们之间不会相互影响。

• 整理⽣命周期(Clean Lifecycle)：该⽣命周期负责整理项⽬中的多余信息，保持项⽬资源和代码的整齐性。⼀般拿来清空directory(即⼀般的target)⽬录下的⽂件。
  
• 默认构建⽣命周期(Default Lifeclyle)：该⽣命周期表示这项⽬的构建过程，定义了⼀个项⽬的构建要经过的差别的阶段。
  
• 站点管理⽣命周期(Site Lifecycle)：向我们创建⼀个项⽬时，我们偶然候需要提供⼀个站点，来先容这个项⽬的信息，如项⽬先容，项⽬进度状态、项⽬组成成员，版本控制信息，项⽬javadoc索引信息等等。站点管理⽣命周期定义了站点管理过程的各个阶段
  

常用命令

常用打包命令

1. mvn clean package -Dmaven.test.skip=true                -- 跳过单测打包
2. mvn clean install -Dmaven.test.skip=true                -- 跳过单测打包，并把打好的包上传到本地仓库
3. mvn clean deploy -Dmaven.test.skip=true                        -- 跳过单测打包，并把打好的包上传到远程仓库

复制代码

其他命令

1. mvn -v //查看版本
2. mvn archetype:create //创建 Maven 项目
3. mvn compile //编译源代码
4. mvn test-compile //编译测试代码
5. mvn test //运行应用程序中的单元测试
6. mvn site //生成项目相关信息的网站
7. mvn package //依据项目生成 jar 文件
8. mvn package -P profileName //指定profile进行打包,依据项目生成 jar 文件
9. mvn install //在本地 Repository 中安装 jar
10. mvn -Dmaven.test.skip=true //忽略测试文档编译
11. mvn clean //清除目标目录中的生成结果
12. mvn clean compile //将.java类编译为.class文件
13. mvn clean package //进行打包
14. mvn clean test //执行单元测试
15. mvn clean deploy //部署到版本仓库
16. mvn clean install //使其他项目使用这个jar,会安装到maven本地仓库中
17. mvn archetype:generate //创建项目架构
18. mvn dependency:list //查看已解析依赖
19. mvn dependency:tree com.xx.xxx //看到依赖树
20. mvn dependency:analyze //查看依赖的工具
21. mvn help:system //从中央仓库下载文件至本地仓库
22. mvn help:active-profiles //查看当前激活的profiles
23. mvn help:all-profiles //查看所有profiles
24. mvn help:effective -pom //查看完整的pom信息

复制代码

标签解释

常用标签详解

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     
5.      
6.     <parent>
7.          
8.          <artifactId>maventest</artifactId>
9.          
10.          <groupId>com.seven</groupId>
11.          
12.          <version>1.0.0-SNAPSHOT</version>
13.          
14.          <relativePath/>
15.         </parent>
16.     
17.    
18.       
19.     <groupId>com.seven.ch</groupId>  
20.       
21.     <artifactId>Question8_1</artifactId>
22.       
23.     <packaging>jar</packaging>  
24.       
25.     <version>1.0-SNAPSHOT</version>  
26.     
27.     <name></name>
28.       
29.     <url></url>
30.    
31.     <description></description>
32.    
33.    
34.     <modules></modules>
35.     
36.     <modelVersion>4.0.0</modelVersion>
37.    
38.      
39.     <profiles>
40.          
41.         <profile>
42.             <id>betanoah</id>
43.             <properties>
44.                 <deploy.type>betanoah</deploy.type>
45.             </properties>
46.         </profile>
47.     </profiles>
48.    
49.      
50.     <properties>
51.         
52.         <java_target_version>11</java_target_version>
53.         <java_source_version>11</java_source_version>
54.                 <junit.junit>4.12</junit.junit>
55.         <spring-boot.version>2.6.6</spring-boot.version>
56.     </properties>
57.   
58.      
59.    
60.      <dependencyManagement>
61.           <dependencies>
62.                
63.                 <groupId>org.springframework.boot</groupId>
64.                 <artifactId>spring-boot-dependencies</artifactId>
65.                 <version>${spring-boot.version}</version>
66.                 <type>pom</type>
67.                 <scope>import</scope>
68.                //...
69.           </dependencies>
70.      </dependencyManagement>   
71.    
72.     
73.     <dependencies>
74.         <dependency>
75.             
76.             <groupId>com.google.guava</groupId>
77.             <artifactId>guava</artifactId>
78.             
79.             <scope></scope>
80.             
81.             <optional></optional>
82.             
83.             <exclusions>
84.                 <exclusion></exclusion>
85.             </exclusions>
86.         </dependency>
87.     </dependencies>
88.    
89.     
90.     <build>
91.         <plugins></plugins>
92.     </build>
93. </project>

复制代码

依赖管理

Maven项目，依赖，构建配置，以及构件：所有这些都是要建模和表述的对象。这些对象通过一个名为项目对象模子(Project Object Model, POM)的XML文件形貌。
POM是Maven项目管理和构建的核心文件，它通常是一个名为pom.xml的XML文件。POM文件包罗了项目的所有配置信息，Maven通过这些信息来构建项目、管理依赖以及执行其他构建任务。
这个POM告诉Maven它正处理什么类型的项目，如何修改默认的行为来从源码生成输出。同样的方式，一个Java Web应用有一个web.xml文件来形貌，配置，及自定义该应用，一个Maven项目则通过一个 pom.xml 文件定义。该文件是Maven中一个项目的形貌性陈述；也是当Maven构建项目的时候需要理解的一份“地图”。
坐标详解

坐标，实在就是从浩繁jar包中找到需要的那个jar包
传递性依赖

先考虑一个基于Spring Framework 的项目，如果不使用Maven, 那么在项目中就需要手动 下载干系依赖。由于Spring Framework 又会依赖于其他开源类库，因此现实中往往会下载一个很大的如 spring-framework-2.5.6-with-dependencies.zip 的包，这里包罗了所有Spring Framework 的 jar包，以及所有它依赖的其他 jar包。这么做往往就引入了很多不必要的依赖。另一种做法是只下载 spring-framework-2.5.6.zip 如许一个包，这里不包罗其他干系依赖，到现实使用的时候，再根据出错信息，大概查询干系文档，加入需要的其他依赖。
Maven 的传递性依赖机制可以很好地解决这一题目。
传递性依赖就是，当项目A依赖于B，而B又依赖于C的时候，自然的A会依赖于C，如许Maven在建立项目A的时候，会自动加载对C的依赖。
groupId

1. <groupId>org.sonatype.nexus</groupId>
2. <artifactId>nexus-indexer</artifactId>
3. <version>2.0.0<Nersion>
4. <packaging>jar<packaging>

复制代码

这是 nexus-indexer 的坐标定义， nexus-indexer 是一个对Maven 仓库编纂索引并提供搜刮功能的类库，它是 Nexus 项目的一个子模块。背面会详细先容 Nexus。上述代码片段中，其坐标分别为 groupldrg.sonatype.nexus、artifactld:nexus-indexer、version:2.0.0、packaging: jar, 没有 classifier。下面详细解释一下各个坐标元素：

• groupId：定义当前 Maven 项目从属的现实项目。起首， Maven 项目和现实项目不肯定是一对一的关系。好比 Spring Framework 这一现实项目，其对应的 Maven 项目会有很多，如 spring-core、spring-context 等。这是由于Maven 中模块的概念，因此，一个现实项目往往会被划分成很多模块。其次， groupId不应该对应项目从属的组织或公司。缘故原由很简单，一个组织下会有很多现实项目，如果 groupId 只定义到组织级别， 而背面我们会看到，artifactId 只能定义Maven 项目(模块), 那么现实项目这个层将难以定义。最后， groupId 的表示方式与Java包名的表示方式类似，通常与域名反向一一对应。上例中， groupId 为 org.sonatype.nexus, org.sonatype 表示 Sonatype 公司建立的一 个非红利性组织，nexus 表示 Nexus 这一现实项目，该 groupId 与域名 nexus.sonatype.org 对应。
  
• artifactId：该元素定义现实项目中的一个Maven项目(模块), 推荐的做法是使用现实项目名称作为 artifactId 的前缀。好比上例中的 artifactId 是 nexus-indexer, 使用了现实项目名 nexus 作为前缀，如许做的好处是方便寻找现实构件。在默认情况下， Maven生成的构件，其文件名会以 artifactId 作为开头，如 nexus-indexer-2.0.0.jar, 使用现实项目名称作为前缀之后，就能方便从一个 lib文件夹中找到某个项目的一组构件。考虑有5个项目，每个项目都有一个 core模块，如果没有前缀，我们会看到很多 core-1.2.jar如许的文件，加上现实项目名前缀之后，便能很轻易区分 foo-core-1.2.jar、bar-core-1.2.jar … … 。
  
• version：该元素定义Maven 项目当前所处的版本，如上例中 nexus-indexer 的版本是 2.0.0。需要注意的是， Maven 定义了一套完备的版本规范，以及快照 (SNAPSHOT)的概念。
  
• packaging：该元素定义 Maven 项目的打包方式。起首，打包方式通常与所生成构件的文件扩展名对应， 如上例中 packaging 为 jar, 最终文件名为 nexus-indexer-2.0.0.jar, 而使用 war 打包方式的Maven 项目，最终生成的构件会有一个 .war 文件， 不过这不是绝对的。其次，打包方式会影响到构建的生命周期，好比 jar打包和 war打包会使用差别的命令。最后，当不定义 packaging 的时候，Maven 会使用默认值 jar。
  
• classifier：该元素用来资助定义构建输出的一些附属构件。附属构件与主构件对应， 如上例中的主构件是 nexus-indexer-2.0.0.jar, 该项目可能还会通过使用一些插件生成如nexus-indexer-2.0.0-javadoc.jar、nexus-indexer-2.0.0-sources. jar 如许一些附属构件，其包罗了Java 文档和源代码。这时候， javadoc和 sources 就是这两个附属构件的classifier。如许，附属构件也就拥有了本身唯一的坐标。还有一个关于classifier 的典型例子是 TestNG, TestNG 的主构件是基于Java 1.4平台的，而它又提供了一个classifier为 jdk5 的附属构件。注意，不能直接定义项目的 classifier, 因为附属构件不是项目直接默认生成的，而是由附加的插件资助生成。
  

上述5个元素中， groupId、artifactId、version 是必须定义的， packaging是可选的(默认为jar), 而 classifier是不能直接定义的。
同时，项目构件的文件名是与坐标相对应的， 一般的规则为 artifactId-version [-classifier].packaging, [-classifier] 表示可选。好比上例 nexus-indexer 的主构件为 nexus-indexer-2.0.0.jar, 附属构件有 nexus-indexer-2.0.0-javadoe.jar。这里还要强调的一点是，packaging 并非肯定与构件扩展名对应，好比 packaging 为 maven-plugin 的构件扩展名为 jar。
此外， Maven 仓库的布局也是基于Maven 坐标，这一点会在先容 Maven 仓库的时候详细解释。同样地，理解清楚 Maven 坐标之后，我们就能开始讨论Maven 的依赖管理了。
dependencies

在dependencies标签中添加需要添加的jar对应的Maven坐标

1. <project>
2.     ...
3.     <dependencies>
4.         <dependency>
5.             <groupId>...</groupId>
6.             <artifactId>...</artifactId>
7.             <version>...</version>
8.             <type>...</type>
9.             <scope>...</scope>
10.             <optional>...</optional>
11.             <exclusions>
12.                 <exclusion>
13.                 ...
14.                 </exclusion>
15.             </exclusions>
16.         </dependency>
17.     </dependencies>
18.     ...
19. </project>

复制代码

根元素 project 下的 dependencies 可以包罗一个大概多个 dependency 元素，以声明一个大概多个项目依赖。每个依赖可以包罗的元素有：

• groupId 、artifactId 和 version：依赖的基本坐标，对于任何一个依赖来说，基本坐标是最重要的， Maven 根据坐标才能找到需要的依赖。
  
• type：依赖的类型，对应于项目坐标定义的 packaging 。大部分情况下，该元素不必声明，其默认值为jar。
  
• scope：依赖的范围。
  
• optional：标志依赖是否可选。
  
• exclusions：用来排除传递性依赖。
  

大部分依赖声明只包罗基本坐标，然而在一些特殊情况下，其他元素至关重要。
scope

依赖范围编译有用测试有用运行时有用打包有用例子Complie√√√√spring-coretest×√××Junitprovided√√××servlet-api,lombokruntime×√√√JDBC驱动system√√××当地maven仓库之外的类库importN/AN/AN/AN/ABOM文件optional

假设有如许一个依赖关系，项目A 依赖于项目B, 项目B 依赖于项目X 和Y, B 对于X 和Y 的依赖都是可选依赖：A->B、B->X(可选)、B->Y(可选)。根据传递性依赖的定义，如果所有这三个依赖的范围都是 compile, 那么 X、Y 就是A 的 compile 范围传递性依赖。然而，由于这里X、Y 是可选依赖，依赖将不会得以传递。换句话说， X、Y 将不会对 A有任何影响，如下图所示。

为什么要使用可选依赖这一特性呢? 可能项目B 实现了两个特性，此中的特性一依赖于X, 特性二依赖于Y, 而且这两个特性是互斥的，用户不可能同时使用两个特性。好比 B 是一个持久层隔离工具包，它支持多种数据库，包括 MySQL、PostgreSQL 等，在构建这个工具包的时候，需要这两种数据库的驱动程序，但在使用这个工具包的时候，只会依赖一种数据库。

1. <project>
2.     <modelVersion>4.0.0</modelVersion>
3.     <groupId>com.xiaoshan.mvnbook</groupId>
4.     <artifactId>project-b</artifactId>
5.     <version>1.0.0</version>
6.     <dependencies>
7.         <dependency>
8.             <groupId>mysql</groupId>
9.             <artifactId>mysql-connector-java</artifactId>
10.             <version>5.1.10</version>
11.             <optional>true</optional>
12.         </dependency>
13.         <dependency>
14.             <groupId>postgresql</groupId>
15.             <artifactId>postgresql</artifactId>
16.             <version>8.4-701.jdbc3</version>
17.             <optional>true</optional>
18.         </dependency>
19.     </dependencies>
20. </project>

复制代码

上述 XML代码片段中，使用元素表示 mysql-connector-java 和 postgresql 这两个依赖为可选依赖，它们只会对当前项目产生影响，当其他项目依赖于这个项目的时候，这两个依赖不会被传递。
因此，当项目A依赖于项目B的时候，如果其现实使用基于MySQL数据库，那么在项目A中就需要显式地声明 mysgl-connectorjava这一依赖，见以下代码清单。

1. <project>
2.     <modelVersion>4.0.0</modelVersion>
3.     <groupId>com.xiaoshan.mvnbook</groupId>
4.     <artifactId>project-a</artifactId>
5.     <version>1.0.0</version>
6.     <dependencies>
7.         <dependency>
8.             <groupId>com.xiaoshan.mvnbook</groupId>
9.             <artifactId>project-b</artifactId>
10.             <version>1.0.0</version>
11.         </dependency>
12.         <dependency>
13.             <groupId>mysql</groupId>
14.             <artifactId>mysql-connector-java</artifactId>
15.             <version>5.1.10</version>
16.         </dependency>
17.     </dependencies>
18. </project>

复制代码

但是现实上，在抱负的情况下，是不应该使用可选依赖的。 使用可选依赖的缘故原由是某一个项目实现了多个特性，在面向对象计划中，有个单一职责性原则，意指一个类应该只有一项职责，而不是糅合太多的功能。
这个原则在规划 Maven 项目的时候也同样实用。在上面的例子中，更好的做法是为MySQL 和 PostgreSQL分别创建一个 Maven 项目 ， 基于同样的 groupId 分配差别的artifactId, 如 com.xiaoshan. mvnbook:project-b-mysql 和 com.xiaoshan. mvnbook:project-b-postgresgl, 在各自的 POM 中声明对应的JDBC 驱动依赖，而且不使用可选依赖，用户则根据需要选择使用 pro-ject-b-mysql 大概 project-b-postgresql。 由于传递性依赖的作用，就不用再声明JDBC 驱动依赖。
排除依赖exclusions

假设有如许一种依赖关系，A->B->C，这个时候由于某些缘故原由，不需要对C的依赖，但是又必须要对B的依赖，针对这种情况，可以在添加A对B的依赖时申明不需要引进B对C的依赖。具体做法如下：

1. <dependency>
2.   <groupId>org.apache.struts</groupId>
3.   <artifactId>struts2-spring-plugin</artifactId>
4.   <version>2.5.20</version>
5.   <exclusions>
6.     <exclusion>
7.       <groupId>org.springframework</groupId>
8.       <artifactId>spring-beans</artifactId>
9.     </exclusion>
10.   </exclusions>
11. </dependency>

复制代码

依赖冲突

冲突产生的根本缘故原由

由于传递依赖的缘故原由，a会通过b引入c的依赖，也会通过d引入c的依赖，因此出现了冲突
依赖关系实例直接依赖a和b的依赖关系间接依赖a和c的依赖关系依赖冲突的解决方案

路径最近者优先

Maven 依赖调解 (Dependency Mediation) 的第一原则是：路径最近者优先
项目A 有如许的依赖关系： A->B->C->X(1.0)、A->D->X(2.0)，根据路径最近者优先原则，X(1.0) 的路径长度为 3 , 而 X(2.0) 的路径长度为2, 因此X(2.0) 会被解析使用。
第一优先声明

但是如果路径长度一样呢，如A->B->Y(1.0)、A-> C->Y(2.0)
从 Maven 2.0.9开始，第二原则是：第一优先声明，也就是谁先定义就使用谁的
覆写优先原则

⼦ POM 内声明的依赖优先于⽗ POM 中声明的依赖。

• 找到 Maven 加载的 Jar 包版本，使⽤ mvn dependency:tree 检察依赖树，根据依赖原则来调解依赖在POM ⽂件的声明顺序。
  
• 发现了冲突的包之后，剩下的就是选择⼀个合适版本的包留下，如果是传递依赖的包精确，那么把显示依赖的包exclude掉。如果是某⼀个传递依赖的包有题目，那需要⼿动把这个传递依赖execlude掉
  

如何处理无法拉取的jar包

注：本文中所有解决方案均使用IDEA操作
设置了离线工作

有些用户的IDEA中可能设置了离线工作，这项设置会让IDEA无法连接网络，自然也无法下载所需资源了。要修改这一设置，具体操作如下：
点击File>>Settings，在弹出的菜单中选择Build,Execution,Deployment >> Build Tools >> Maven，然后检察页面中的Work Offline项是否处于勾选状态，如果是，则IDEA无法联网，应该取消勾选。如下图所示：

配置文件题目

设置maven的 settings.xml文件的镜像 为阿里云镜像

1.         <mirror>
2.           <id>alimaven-new</id>
3.           <name>aliyun maven</name>
4.           <url>https://maven.aliyun.com/repository/central</url>
5.           <mirrorOf>central</mirrorOf>
6.     </mirror>
7.    
8.     <mirror>
9.         <id>aliyun-public</id>
10.         <mirrorOf>central</mirrorOf>
11.         <name>aliyun public</name>
12.         <url>https://maven.aliyun.com/repository/public</url>
13.     </mirror>

复制代码

手动下载

到以下网站寻找所需要的jar包：
https://repo.maven.apache.org/maven2/
根据控制台输出信息可知，需要的 com.github.spotbugs:spotbugs-maven-plugin:4.2.2

找到所需的jar包，进行下载

并放到当地的maven仓库中
面试题专栏

Java面试题专栏已上线，欢迎访问。

• 如果你不知道简历怎么写，简历项目不知道怎么包装；
  
• 如果简历中有些内容你不知道该不该写上去；
  
• 如果有些综合性题目你不知道怎么答；
  

那么可以私信我，我会尽我所能资助你。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。