Maven笔记（初级-快速上手）

maven，java开发离不开的构建工具，虽然天天在使用maven，但是自己对它的一些配置细节理解的并不透彻，有时候为了解决一些不起眼的小问题，竟然能够浪费掉我大半天的时间，有点不能忍受，在网上发现尚硅谷的maven课程讲的不错，所以决定参照他们的课程重新梳理一下maven的知识点，以备复查。

1、Why，为什么要用maven

1. 管理规模庞大的 jar 包，需要专门工具

• 项目中用的jar包越来越多，jar包之间的依赖也越来越复杂，完全靠人力手动解决几无可能
• jar包所属技术的官网，页面千差万别，很难找到jar包下载的位置，而使用maven，直接写坐标就能下载

2. 脱离 IDE 环境执行构建操作，需要专门工具
   构建就是以我们编写的 Java 代码、框架配置文件、国际化等其他资源文件、JSP 页面和图片等静态资源作为“原材料”，去“生产”出一个可以在服务器上运行的项目的过程

2、What，什么是maven

Maven 是 Apache 软件基金会组织维护的一款专门为 Java 项目提供构建和依赖管理支持的工具。

2.1 构建

Java 项目开发过程中，构建指的是使用『原材料生产产品』的过程。
构建过程包含的主要的环节：

• 清理：删除上一次构建的结果，为下一次构建做好准备
• 编译：Java 源程序编译成 *.class 字节码文件
• 测试：运行提前准备好的测试程序
• 报告：针对刚才测试的结果生成一个全面的信息
• 打包
  • Java工程：jar包
  • Web工程：war包
• 安装：把一个 Maven 工程经过打包操作生成的 jar 包或 war 包存入 Maven 仓库
• 部署
  • 部署 jar 包：把一个 jar 包部署到 Nexus 私服服务器上
  • 部署 war 包：借助相关 Maven 插件（例如 cargo），将 war 包部署到 Tomcat 服务器上

2.2 依赖

• jar 包的下载：使用 Maven 之后，jar 包会从规范的远程仓库下载到本地
• jar 包之间的依赖：通过依赖的传递性自动完成
• jar 包之间的冲突：通过对依赖的配置进行调整，让某些jar包不会被导入

2.3 maven工作机制

2.4 生命周期

为了让构建过程自动化完成，Maven 设定了三个生命周期，生命周期中的每一个环节对应构建过程中的一个操作

生命周期名称	作用	包含的环节
Clean	清理操作相关	pre-clean、clean、post-clean
Site	生成站点相关	pre-site、site、post-site、deploy-site
Default	主要构建过程	validate generate-sources process-sources generate-resources process-resources 复制并处理资源文件，至目标目录，准备打包。 compile 编译项目 main 目录下的源代码。 process-classes generate-test-sources process-test-sources generate-test-resources process-test-resources 复制并处理资源文件，至目标测试目录。 test-compile 编译测试源代码。 process-test-classes test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。 prepare-package package 接受编译好的代码，打包成可发布的格式，如JAR。 pre-integration-test integration-test post-integration-test verify install将包安装至本地仓库，以让其它项目依赖。 deploy将最终的包复制到远程的仓库，以让其它开发人员共享；或者部署到服务器上运行（需借助插件，例如：cargo）

• 前面三个生命周期彼此是独立的
• 在任何一个生命周期内部，执行任何一个具体环节的操作，都是从本周期最开始的地方执行，直到指定的地方

Maven 之所以这么设计其实就是为了提高构建过程的自动化程度：让使用者只关心最终要干的即可，过程中的各个环节是自动执行的

2.5 仓库

• 本地仓库：在当前电脑上，为电脑上所有 Maven 工程服务
• 远程仓库：需要联网
  • 局域网：我们自己搭建的 Maven 私服，例如使用 Nexus 技术。
  • Internet
    • 中央仓库
    • 镜像仓库：内容和中央仓库保持一致，但是能够分担中央仓库的负载，同时让用户能够就近访问提高下载速度，例如：Nexus aliyun

专门搜索 Maven 依赖信息的网站：https://mvnrepository.com/

2.6 插件和目标

Maven 的核心程序仅仅负责宏观调度，不做具体工作。具体工作都是由 Maven 插件完成的。例如：编译就是由 maven-compiler-plugin-3.1.jar 插件来执行的

一个插件可以对应多个目标，而每一个目标都和生命周期中的某一个环节对应。
Default 生命周期中有 compile 和 test-compile 两个和编译相关的环节，这两个环节对应 compile 和 test-compile 两个目标，而这两个目标都是由 maven-compiler-plugin-3.1.jar 插件来执行的

3、安装maven

3.1 下载安装

到maven官网下载：Maven – Download Apache Maven
解压核心程序压缩包，解压到非中文、没有空格的目录，在解压目录中，我们需要着重关注 Maven 的核心配置文件：conf/settings.xml

3.2 核心配置

1. 仓库位置
   本地仓库默认在C盘，jar包变多后，可能会拖慢电脑的运行速度，所以我们最好指定本地仓库的位置
   <localRepository>D:\maven-repository</localRepository>

2. 仓库镜像（阿里云）
   Maven 下载 jar 包默认访问境外的中央仓库，而国外网站速度很慢。改成阿里云提供的镜像仓库，访问国内网站，可以让 Maven 下载 jar 包的时候速度更快。配置的方式是，将下面 mirror 标签整体复制到 settings.xml 文件的 mirrors 标签的内部：

	<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>

3. maven工程的基础JDK版本
   maven默认的JDK版本比1.8老，我们需要改成1.8，修改配置的方式是：将 profile 标签整个复制到 settings.xml 文件的 profiles 标签内

	<profile>
	  <id>jdk-1.8</id>
	  <activation>
		  <activeByDefault>true</activeByDefault>
		  <jdk>1.8</jdk>
	  </activation>
	  <properties>
		  <maven.compiler.source>1.8</maven.compiler.source>
		  <maven.compiler.target>1.8</maven.compiler.target>
		  <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	  </properties>
	</profile>

3.3 配置环变量

1. 条件
   Maven 是 Java 语言开发的，它必须基于 JDK 来运行，所以必须配置好了JAVA_HOME才能运行，可以在cmd窗口输入echo %JAVA_HOME%验证

2. 配置环境变量
   先配置MAVEN_HOME，再配置path，最后在任意位置输入mvn -v验证

4、使用maven（命令行）

4.1 坐标

  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>

groupId、artifactId、version相当于坐标，使用这三个参数，在maven仓库中唯一的定位到一个jar包

• groupId：公司或组织域名的倒序，通常也会加上项目名称

例如：com.iecas.maven

• artifactId：模块的名称，将来作为 Maven 工程的工程名
• version：模块的版本号，根据自己的需要设定

例如：SNAPSHOT 表示快照版本，正在迭代过程中，不稳定的版本
例如：RELEASE 表示正式版本

jar 包在 Maven 本地仓库中的位置：
Maven本地仓库根目录\javax\servlet\servlet-api\2.5\servlet-api-2.5.jar

4.2 生成maven工程

新建文件夹work，在文件夹中打开命令行窗口，使用mvn archetype:generate命令生成maven工程

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 7:【直接回车，使用默认值】
Define value for property ‘groupId’: com.iecas.maven
Define value for property ‘artifactId’: pro01-maven-java
Define value for property ‘version’ 1.0-SNAPSHOT: :【直接回车，使用默认值】
Define value for property ‘package’ com.iecas.maven: :【直接回车，使用默认值】
Confirm properties configuration: groupId: com.iecas.maven artifactId: pro01-maven-java version: 1.0-SNAPSHOT package: com.iecas.maven Y: :【直接回车，表示确认。如果前面有输入错误，想要重新输入，则输入 N 再回车。】

此工程目录下，会自动生成一个pom.xml文件

  <!-- 当前Maven工程的坐标 -->
  <groupId>com.iecas.maven</groupId>
  <artifactId>pro01-maven-java</artifactId>
  <version>1.0-SNAPSHOT</version>
  
  <!-- 当前Maven工程的打包方式，可选值有下面三种： -->
  <!-- jar：表示这个工程是一个Java工程  -->
  <!-- war：表示这个工程是一个Web工程 -->
  <!-- pom：表示这个工程是“管理其他工程”的工程 -->
  <packaging>jar</packaging>

  <name>pro01-maven-java</name>
  <url>http://maven.apache.org</url>

  <properties>
	  <!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!-- 当前工程所依赖的jar包 -->
  <dependencies>
    
	  <!-- 使用dependency配置一个具体的依赖 -->
    <dependency>
	    <!-- 在dependency标签内使用具体的坐标依赖我们需要的一个jar包 -->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
	    <!-- scope标签配置依赖的范围 -->
      <scope>test</scope>
    </dependency>
    
  </dependencies>

4.3 POM

POM：Project Object Model，项目对象模型。和 POM 类似的是：DOM（Document Object Model），文档对象模型。它们都是模型化思想的具体体现。
POM 理念集中体现在 Maven 工程根目录下 **pom.xml **这个配置文件中。所以这个 pom.xml 配置文件就是 Maven 工程的核心配置文件。其实学习 Maven 就是学这个文件怎么配置，各个配置有什么用。

4.4 约定的目录结构

另外还有一个 target 目录专门存放构建操作输出的结果
Maven 为了让构建过程能够尽可能自动化完成，所以必须约定目录结构的作用。例如：Maven 执行编译操作，必须先去 Java 源程序目录读取 Java 源代码，然后执行编译，最后把编译结果存放在 target 目录。

4.5 执行构建命令

1. 清理，mvn clean：删除target目录
2. 编译，mvn compile/test-compile：编译主程序/测试程序，在target目录生成class文件
3. 测试，mvn test：生成测试报告target/surefire-reports
4. 打包，mvn package：在target目录生成jar包
5. 安装，mvn install：将本地构建过程中生成的 jar 包存入 Maven 本地仓库

4.6 查看maven工程依赖树信息

• mvn dependency:list：查看当前maven工程所依赖的 jar 包的列表

[INFO] The following files have been resolved:
[INFO] org.hamcrest:hamcrest-core:jar:1.3:test
[INFO] javax.servlet:javax.servlet-api:jar:3.1.0:provided
[INFO] com.iecas.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile
[INFO] junit:junit:jar:4.12:test

• mvn dependency:tree：以树形结构查看当前maven工程的依赖信息

[INFO] com.iecas.maven:pro02-maven-web:war:1.0-SNAPSHOT
[INFO] ± junit:junit:jar:4.12:test
[INFO] | - org.hamcrest:hamcrest-core:jar:1.3:test
[INFO] ± javax.servlet:javax.servlet-api:jar:3.1.0:provided
[INFO] - com.iecas.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile

在 pom.xml 中并没有依赖 hamcrest-core，但是它却被加入了我们依赖的列表。原因是：junit 以compile范围依赖了hamcrest-core，然后基于依赖的传递性，hamcrest-core 被传递到我们的工程了

4.7 依赖的范围

标签的位置：dependencies/dependency/scope
标签的可选值：compile(缺省值)/test/provided/system/runtime/import

范围	main目录	test目录	开发过程	部署到服务器
compile	有效	有效	有效	有效
test	无效	有效	有效	无效(不参与打包)
provided	有效	有效	有效	无效(不参与打包)

注：【有效】指的是能不能用，如main目录下的代码能用以compile范围引入的依赖

compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。
test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。
provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar 包产生冲突，同时减轻服务器的负担。

4.8 依赖的传递性

A 依赖 B，B 依赖 C，那么在 A 没有配置对 C 的依赖的情况下，A 里面能不能直接使用 C？
分情况，取决于 B 依赖 C 时使用的依赖范围：

• B 依赖 C 时使用 compile 范围：C就可以传递到A
• B 依赖 C 时使用 test 或 provided 范围：C就不能传递A，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以。

4.9 依赖的排除

配置依赖的排除其实就是阻止某些 jar 包的传递。因为这样的 jar 包传递过来可能会和其他 jar 包冲突
配置方式，使用exclusions和exclusion标签：

<dependency>
	<groupId>com.iecas.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
	<scope>compile</scope>
	<!-- 使用excludes标签配置依赖的排除	-->
	<exclusions>
		<!-- 在exclude标签中配置一个具体的排除 -->
		<exclusion>
			<!-- 指定要排除的依赖的坐标（不需要写version） -->
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
		</exclusion>
	</exclusions>
</dependency>

运行 mvn dependency:tree 命令查看效果：

[INFO] com.iecas.maven:pro02-maven-web:war:1.0-SNAPSHOT
[INFO] ± junit:junit:jar:4.12:test
[INFO] | - org.hamcrest:hamcrest-core:jar:1.3:test
[INFO] ± javax.servlet:javax.servlet-api:jar:3.1.0:provided
[INFO] - com.iecas.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile
[INFO] - org.springframework:spring-core:jar:4.0.0.RELEASE:compile

commons-logging没有传递过来

4.10 继承

作用

在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。
它的背景是：

• 对一个比较大型的项目进行了模块拆分。
• 一个 project 下面，创建了很多个 module。
• 每一个 module 都需要配置自己的依赖信息。

它背后的需求是：

• 在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
• 使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
• 使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。

通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

举例

在一个工程中依赖多个 Spring 的 jar 包

[INFO] ± org.springframework:spring-core:jar:4.0.0.RELEASE:compile
[INFO] | - commons-logging:commons-logging:jar:1.1.1:compile
[INFO] ± org.springframework:spring-beans:jar:4.0.0.RELEASE:compile
[INFO] ± org.springframework:spring-context:jar:4.0.0.RELEASE:compile
[INFO] ± org.springframework:spring-expression:jar:4.0.0.RELEASE:compile
[INFO] ± org.springframework:spring-aop:jar:4.0.0.RELEASE:compile
[INFO] | - aopalliance:aopalliance:jar:1.0:compile

使用 Spring 时要求所有 Spring 自己的 jar 包版本必须一致。为了能够对这些 jar 包的版本进行统一管理，我们使用继承这个机制，将所有版本信息统一在父工程中进行管理。

实操

1. 创建父工程
   和之前操作一样，只不过创建好pro03-maven-parent 工程后，需要改它的打包方式为
   <packaging>pom</packaging>
   只有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。

2. 创建模块工程（子工程）
   进入 pro03-maven-parent 工程的根目录，然后运行 mvn archetype:generate 命令来创建模块工程。
   假设创建三个子工程。

3. 查看父工程的pom.xml
   下面 modules 和 module 标签是聚合功能的配置

<!-- 创建完子工程后，父工程的pom文件自动多了下面几行 -->
<modules>  
	<module>pro04-maven-module</module>
	<module>pro05-maven-module</module>
	<module>pro06-maven-module</module>
</modules>

4. 查看子工程的pom.xml

<!-- 使用parent标签指定当前工程的父工程 -->
<!-- 在父工程内生成的子工程，parent标签内容会自动生成 -->
<parent>
	<!-- 父工程的坐标 -->
	<groupId>com.iecas.maven</groupId>
	<artifactId>pro03-maven-parent</artifactId>
	<version>1.0-SNAPSHOT</version>
</parent>

<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.iecas.maven</groupId> -->
<artifactId>pro04-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->

5. 在父工程中配置依赖的统一管理

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
	</dependencies>
</dependencyManagement>

6. 在子工程中引用被父工程管理的依赖

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。	-->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
    <!-- version省略（绝大部分情况），子工程使用的版本就是父工程管理的版本 -->
    <!-- version不省略，子工程使用的版本就是自己指定的的版本 -->
    <!-- <version>4.1.4.RELEASE</version> -->
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-expression</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
	</dependency>
</dependencies>

7. 父工程中改变版本信息

			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>4.1.4.RELEASE</version>
			</dependency>

然后在子工程中运行mvn dependency:list，效果如下：

[INFO] org.springframework:spring-aop:jar:4.1.4.RELEASE:compile
[INFO] org.springframework:spring-core:jar:4.1.4.RELEASE:compile
[INFO] org.springframework:spring-context:jar:4.1.4.RELEASE:compile
[INFO] org.springframework:spring-beans:jar:4.1.4.RELEASE:compile
[INFO] org.springframework:spring-expression:jar:4.1.4.RELEASE:compile

8. 在父工程中声明自定义属性

<!-- 通过自定义属性，统一指定Spring的版本 -->
<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	
	<!-- 自定义标签，维护Spring版本数据，真正实现“一处修改，处处生效” -->
	<iecas.spring.version>4.3.6.RELEASE</atguigu.spring.version>
</properties>

...
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-core</artifactId>
        <!-- 在需要的地方使用${}的形式来引用自定义的属性名 -->
				<version>${iecas.spring.version}</version>
			</dependency>
...

实际意义

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。
如上图所示，公司级的父工程中管理的就是成熟的依赖组合方案，各个新项目、子系统各取所需即可。

4.11 聚合

作用

• 一键执行 Maven 命令：很多构建命令都可以在“总工程”中一键执行。
  以 mvn install 命令为例：Maven 要求有父工程时先安装父工程；有依赖的工程时，先安装被依赖的工程。我们自己考虑这些规则会很麻烦。但是工程聚合之后，在总工程执行 mvn install 可以一键完成安装，而且会自动按照正确的顺序执行。

• 配置聚合之后，各个模块工程会在总工程中展示一个列表，让项目中的各个模块一目了然

配置

在总工程中配置 modules 即可：

	<modules>  
		<module>pro04-maven-module</module>
		<module>pro05-maven-module</module>
		<module>pro06-maven-module</module>
	</modules>

注意

如果 A 工程依赖 B 工程，B 工程依赖 C 工程，C 工程又反过来依赖 A 工程，那么在执行构建操作时会报“循环引用”的错误：

[ERROR] [ERROR] The projects in the reactor contain a cyclic reference:

5、使用maven（IDEA）

5.1 创建父工程

开启自动导入。。
另外也可以通过 IDEA 的 Settings 设置来开启：

每次创建 Project 后都需要设置 Maven 家目录位置，否则 IDEA 将使用内置的 Maven 核心程序（不稳定）并使用默认的本地仓库位置。默认的本地仓库通常在 C 盘，还影响系统运行

5.2 创建Java模块工程

可以不手动添加<packaging>war</packaging>，因为当pom文件中没有设置packaging参数时，默认使用jar方式打包

5.3 创建web模块工程

初始创建同5.2一样，然后手动更改pom，添加<packaging>war</packaging>

选中module之后，借助IDEA生成web.xml

6、导入别人的工程/模块

6.1 导入工程

通过File–>Open打开对应工程，设置settins–>maven的家目录即可

6.2 模块导入

在实际开发中，通常会忽略模块（也就是module）所在的项目（也就是project）仅仅导入某一个模块本身。这么做很可能是类似这样的情况：

复制老师的module，粘贴到自己的工程路径下

在Idea中配置





修改pom，刚刚导入的 module 的父工程坐标还是以前的，需要改成我们自己的 project