day47_Maven学习笔记
- Maven的课程计划
- 一、Maven的介绍
- 二、Maven的安装和配置
- 三、建立Maven工程
- 四、M2Eclipse插件
- 五、Maven的核心概念
- a)坐标
- b)依赖管理
- c)生命周期
- d)Maven 插件
- e)继承
- f)聚合
- 六、Maven的仓库管理
1、Maven的介绍
1.一、项目开发中遇到的问题
- 一、都是一样的代码，为何在个人机器上能够编译执行，而在他的机器上就不行？
- 二、为何在个人机器上能够正常打包，而配置管理员却打不出来？
- 三、项目组加入了新的人员，我要给他说明编译环境如何设置，可是让我挠头的是，有些细节我也记不清楚了。
- 四、个人项目依赖一些jar包，我应该把他们放哪里？放源码库里吗？
- 五、这是我开发的第二个项目，仍是须要上面的那些jar包，再把它们复制到我当前项目的svn库里吧。
- 六、如今是第三次，再复制一次吧。。。
- 这样真的好吗？
- 七、我写了一个数据库相关的通用类，而且推荐给了其余项目组，如今已经有五个项目组在使用它了，今天我发现了一个bug，并修正了它，我会把jar包经过邮件发给其余项目组。
- 这不是一个好的分发机制，太多的环节可能致使出现bug。
- 八、项目进入测试阶段，天天都要向测试服务器部署一版。每次都手动部署，太麻烦了。
1.二、什么是Maven
Maven是基于项目对象模型(POM)，能够经过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。
Maven是一个跨平台的项目管理工具，它是使用java开发的，它要依赖于jdk1.6及以上。主要服务于基于Java平台的项目构建、依赖管理和项目信息管理。javascript
- Maven主要有两个功能：
一、项目构建
二、依赖管理
依赖指的就是jar包。
1.三、什么是项目构建
项目构建以下图所示：php
构建过程以下图所示：
1.四、项目构建的方式
- 一、Eclipse
- 手工操做较多，项目的构建过程都是独立的，相对来讲，步骤比较零散，很难一步完成。好比：编译、测试、部署等。
- 开发时每一个人的IDE配置都不一样，很容易出现本地代码换个地方编译就出错。
- 二、Ant
- Ant只是一个项目构建工具，它没有集成依赖管理。
- Ant在进行项目构建时，它能够经过一些配置来完成项目构建，这些配置要明确的告诉Ant，即：它没有对项目目录结构进行约定，须要手动指定源文件、类文件等目录地址。同时它执行task时，须要显示指定依赖的task，这样会形成大量的代码重复。
- 三、`Maven`
- Maven不只是一个项目构建工具，更是一个项目管理工具。它在项目构建工程中，比Ant更全面，更灵活。
- 经过使用Maven，能够对项目进行快速简单的构建，它不须要告诉Maven不少信息，可是须要安装Maven的规范去进行代码的开发。也就是说Maven是有约束的。
- Maven在进行项目构建时，它对项目目录结构拥有约定，知道你的源代码在哪里，类文件应该放到哪里去。
- Maven拥有生命周期的概念，Maven的生命周期是有顺序的，在执行后面的生命周期的任务时，不须要显示的配置前面任务的生命周期。
- 例如：执行 mvn install 就能够自动执行编译、测试、打包等构建过程。
1.五、Maven 的概念模型
以下图所示：css
2、Maven的安装和配置
2.一、下载Maven
- 官方网站：https://maven.apache.org/
- 下载网址：https://maven.apache.org/download.cgi
- 下载界面：
- 本课程使用的maven的版本为3.5.4，软件发展趋势：对于高版本的Maven，之后都会整合到IDE中去。
- Maven是使用java开发，须要安装jdk1.6以上，推荐使用1.8
2.二、Maven的安装
- 第一步：安装jdk，要求1.6或以上版本。
- 第二步：把maven解压缩，解压目录最好不要有中文和空格。
- 第三步：配置maven的系统环境变量MAVEN_HOME
- 第四步：配置环境变量Path，将%MAVEN_HOME%\bin加入Path中，在Windows中必定要注意要用分号与其余值隔开。
- 第五步：验证是否安装成功，打开cmd窗口，输入命令：mvn –v，出现以下界面，表示安装成功。
2.三、Maven的配置
- Maven有两个settings.xml配置文件：一个是全局配置文件（默认），一个是用户配置文件。
2.3.一、全局配置（默认）
在maven安装目录的conf目录里面有一个settings.xml文件，这个文件就是maven的全局配置文件。
该文件中配置了maven本地仓库的地址，以下图所示：html
localRepository：用户仓库，用于检索依赖包路径。
默认在系统的用户目录下的m2/repository中，该目录是本地仓库的目录。以下图所示：
2.3.二、用户配置
用户配置文件的地址：~/.m2/settings.xml是用户的配置文件（默认没有该文件，须要将全局配置文件拷贝过来再进行修改），其中~表示当前用户路径C:\Users[UserName]。以下图所示：java
注意：通常本地仓库的地址不使用默认配置，一般状况下须要在用户配置中，配置新的仓库地址。
配置步骤以下：
第一步：建立一个本地仓库目录，好比：D:\learn\Java\apache-maven-3.5.4\repository。
第二步：复制maven的全局配置文件到~/.m2目录下，即建立用户配置文件
第三步：修改maven的用户配置文件。以下图所示：
注意：用户级别的仓库在全局配置中一旦设置，全局配置将再也不生效，转而使用用户所设置的仓库，不然使用全局配置文件中的默认路径仓库。
3、建立Maven工程
3.一、Maven的工程结构
详解以下：程序员
Project
|-src（源码包）
| |-main（正常的源码包）
| | |-java —— 存放项目的.java文件的目录
| | |-resources —— 存放项目资源文件的目录，例如：spring, hibernate等配置文件
| |-test（测试的源码包）
| |-java —— 存放全部测试.java文件的目录，例如：JUnit测试类
| |-resources —— 存放测试资源文件的目录
|-target —— 目标文件输出位置，例如：.class文件、.jar文件、.war文件、报告等信息
|-pom.xml ——maven项目核心配置文件，即maven工程的描述文件
3.二、Maven的工程建立
- 第一步：根据maven的工程结构来建立helloMaven工程
- 第二步：建立HelloWorld.java
在src/main/java/com/itheima/maven目录下新建文件HelloMaven.java
示例代码以下：
package com.itheima.maven;
public class HelloMaven {
public String sayHello(String name) {
return "hello " + name;
}
}
- 第三步：建立TestHelloWorld.java
在src/test/java/com/itheima/maven目录下新建文件TestHelloMaven.java
示例代码以下：
package com.itheima.maven;
import org.junit.test;
import static junit.framework.Assert.*;
public class TestHelloMaven {
@Test
public String testSayHello() {
HelloMaven hw = HelloMaven();
String result = hw.sayHello("maven");
assertEquals("hello maven", result);
}
}
- 第四步：配置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">
<!-- 版本：4.0.0 -->
<modelVersion>4.0.0</modelVersion>
<!-- 组织名称：暂时使用 组织名称+项目名称 做为组织名称 -->
<!-- 组织名称：实际名称 按照访问路径规范设置，一般以功能做为名称：eg: junit spring -->
<groupId>com.itheima.maven</groupId>
<!-- 项目名称 -->
<artifactId>HelloMaven</artifactId>
<!-- 当前项目版本号：同一个项目开发过程当中能够发布多个版本，此处标示0.0.1版 -->
<!-- 当前项目版本号：每一个工程发布后能够发布多个版本，依赖时调取不一样的版本，使用不一样的版本号 -->
<version>0.0.1</version>
<!-- 名称：可省略 -->
<name>Hello</name>
<!-- 依赖关系 -->
<dependencies>
<!-- 依赖设置 -->
<dependency>
<!-- 依赖组织名称 -->
<groupId>junit</groupId>
<!-- 依赖项目名称 -->
<artifactId>junit</artifactId>
<!-- 依赖版本名称 -->
<version>4.9</version>
<!-- 依赖范围：test包下依赖该设置 -->
<scope>test</scope>
</dependency>
</dependencies>
</project>
注意事项：web
到此maven工程建立成功。
3.三、Maven的命令使用
Maven的命令须要在pom.xml所在目录中执行如下命令。spring
3.3.1、mvn compile
执行 mvn compile 命令，完成编译操做。
执行完毕后，会生成target目录和maven-status目录（新版本出现的），该目录中存放了编译后的字节码文件。
3.3.2、mvn clean
执行 mvn clean 命令
执行完毕后，会将target目录删除。
3.3.3、mvn test
执行 mvn test 命令，该命令会将test目录中的源码进行编译，完成单元测试操做。
执行完毕后，会在target目录中生成三个文件夹：maven-status（旧版本是surefire）、surefire-reports（测试报告）、test-classes（测试的字节码文件）
3.3.4、mvn package
执行 mvn package 命令，完成打包操做。
执行完毕后，会在target目录中生成一个文件，该文件多是jar、war。本例中是：helloMaven-0.0.1.jar
3.3.5、mvn install
执行 mvn install 命令，完成将打好的jar包安装到本地仓库的操做。
执行完毕后，会在本地仓库中出现安装后的jar包，方便其余工程引用。
3.3.6、mvn clean compile
cmd 中录入 mvn clean compile 命令
组合指令，先执行clean，再执行compile，一般应用于上线前执行，清除测试类。
3.3.7、mvn clean test
cmd 中录入 mvn clean test 命令
组合指令，先执行clean，再执行test，一般应用于测试环节。
3.3.8、mvn clean package
cmd 中录入 mvn clean package 命令
组合指令，先执行clean，再执行package，将项目打包，一般应用于发布前。
执行过程：
清理 --> 清空环境
编译 --> 编译源码
测试 --> 测试源码
打包 --> 将编译的非测试类打包
3.3.9、mvn clean install
cmd 中录入 mvn clean install 查看仓库，当前项目被发布到仓库中。
组合指令，先执行clean，再执行install，将项目打包，一般应用于发布前。
执行过程：
清理 --> 清空环境
编译 --> 编译源码
测试 --> 测试源码
打包 --> 将编译的非测试类打包
部署 --> 将打好的包发布到资源仓库中
4、M2Eclipse插件
- M2Eclipse是eclipse中的Maven插件。（低版本的ecplise须要手动安装，高版本的eclipse自带，本博主用的是高版本的eclipse）
- M2Eclipse是MyEclipse中自带的Maven插件。
4.一、演示：安装配置M2Eclipse插件
- 第一步：将如下包中的插件进行复制
- 第二步：粘贴到eclipse中的dropins目录中
- 第三步：查看eclipse中是否有maven插件
MyEclipse中自带的Maven插件截图：
手动安装M2Eclipse插件后，截图同上。 - 第四步：设置maven的安装目录
- 第五步：设置maven的用户配置，由于咱们经过eclipse方式使用maven，因此用户配置文件咱们想放哪就放哪！！！注意：这种方式须要指定用户配置文件的目录便可。
4.二、经过骨架建立MavenFirst工程-Java工程
经过骨架建立maven工程，建立的是Java工程。sql
- 第一步：选择 new --> maven --> Maven Project
- 第二步：点击 next
- 第三步：点击 next，选择maven的工程骨架，这里咱们选择先以quickstart为例
- 第四步：点击 next
输入GroupId、ArtifactId、Version、Package信息点击finish完成 - 第五步：点击 finish，建立maven工程，建立成功以下图所示：
- 第六步：根据工程骨架建立的maven工程没有源resources目录，须要手动建立，以下图所示：
/MavenFirst/src/main/resources
/MavenFirst/src/test/resources - 第七步：建立 MavenFirst.java
在src/main/java中建立com.itheima.maven包，而后建立MavenFirst.java
示例代码以下：
package com.itheima.maven;
public class MavenFirst {
public String sayHello(String name) {
return "hello " + name;
}
}
- 第八步：建立 TestMavenFirst.java
在src/test/java中建立com.itheima.maven包，而后建立TestMavenFirst.java
示例代码以下：
package com.itheima.maven;
import org.junit.Assert;
import org.junit.Test;
// import static junit.framework.Assert.*;
public class TestMavenFirst {
@Test
public void testSayHello() {
MavenFirst first = new MavenFirst();
String result = first.sayHello("maven");
Assert.assertEquals("hello maven", result);
}
}
- 第九步：执行 maven命令进行测试
在MyEclipse的maven插件中执行maven命令，须要在maven工程或者pom.xml文件上点击右键，选择Run as --> Maven build..，以下图所示：
能够在菜单中看到maven经常使用的命令已经以菜单的形式出现。
例如：
Maven build
Maven build…
Maven clean
Maven install
Maven package
Maven test
其中：
Maven build和Maven build… 并非Maven的命令。
Maven build…只是提供一个命令输入功能，能够在此功能中输入自定义的Maven命令。以下图所示：
Maven build的功能就是执行上次自定义命令。
4.三、不经过骨架建立MavenSecond工程（推荐方式）
经过选择骨架建立maven工程，每次选择骨架时都须要联网下载，若是网络不通或者较慢的状况下会有很长时间的等待。使用非常不方便，因此建立工程时能够不选择骨架直接建立工程。数据库
- 第一步：选择 new --> maven --> Maven Project
截图同上。 - 第二步：点击 next
- 第三步：点击 next
- 第四步：点击 finish，完成maven工程建立。以下图所示：
- 第五步：修改pom文件
在MavenSecond工程中依赖使用MavenFirst工程的代码
示例代码以下：
<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.itheima.maven</groupId>
<artifactId>MavenSecond</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- 在MavenSecond工程中依赖使用Junit的代码 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- 同理：在MavenSecond工程中依赖使用MavenFirst工程的代码 -->
<dependency>
<groupId>com.itheima.maven</groupId>
<artifactId>MavenFirst</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
- 第六步：建立 MavenSecond.java
在src/main/java中建立com.itheima.maven包，而后建立MavenSecond.java
示例代码以下：
package com.itheima.maven;
public class MavenSecond {
public String sayHello(String name) {
MavenFirst first = new MavenFirst();
return first.sayHello(name);
}
}
注意：会出现一个问题，以下图所示：
解决办法：
办法一：
一、这是由于未Update Project…，而且项目的clean与maven的clean不一样步的结果
二、选择要更新的项目
三、maven项目，clean build以后；MyEclipse也须要 Project --> Clean… 下，以下图所示：
错误消失了，感受整个世界都清爽了许多，以下图所示：
- 第七步：建立 TestMavenSecond.java
在src/test/java中建立com.itheima.maven包，而后建立TestMavenSecond.java
示例代码以下：
package com.itheima.maven;
import org.junit.Assert;
import org.junit.Test;
public class TestMavenSecond {
@Test
public void testSayHello() {
MavenSecond second = new MavenSecond();
String result = second.sayHello("maven");
Assert.assertEquals("hello maven", result);
}
}
- 第八步：执行 maven命令进行测试工程
在MyEclipse的maven插件中执行maven命令，须要在maven工程或者pom.xml文件上点击右键，选择Run as --> Maven test，以下图所示：
若是MavenFirst工程没有安装，则会出现如下错误：
[INFO] Scanning for projects...
[INFO]
[INFO] -------------------< com.itheima.maven:MavenSecond >--------------------
[INFO] Building MavenSecond 0.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[WARNING] The POM for com.itheima.maven:MavenFirst:jar:0.0.1-SNAPSHOT is missing, no dependency information available
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.884 s
[INFO] Finished at: 2018-09-24T12:30:47+08:00
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal on project MavenSecond: Could not resolve dependencies for project com.itheima.maven:MavenSecond:jar:0.0.1-SNAPSHOT: `Could not find artifact com.itheima.maven:MavenFirst:jar:0.0.1-SNAPSHOT` -> [Help 1]
[ERROR]
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.
[ERROR] Re-run Maven using the -X switch to enable full debug logging.
[ERROR]
[ERROR] For more information about the errors and possible solutions, please read the following articles:
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/DependencyResolutionException
提示找不到MavenFirst的jar包。当系统运行时是从本地仓库中找依赖的jar包的，因此必须先MavenFirst安装才能正常运行，须要在MavenFirst工程上运行 mvn install命令安装到本地仓库。而后在MavenSecond工程上再次运 mvn test 命令测试工程。
正确的测试结果以下：
[INFO] Scanning for projects...
[INFO]
[INFO] -------------------< com.itheima.maven:MavenSecond >--------------------
[INFO] Building MavenSecond 0.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ MavenSecond ---
[WARNING] Using platform encoding (GBK actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ MavenSecond ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding GBK, i.e. build is platform dependent!
[INFO] Compiling 1 source file to D:\learn\Java\MyEclipse\Workspaces\MyEclipse 2017 CI\MavenSecond\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ MavenSecond ---
[WARNING] Using platform encoding (GBK actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ MavenSecond ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding GBK, i.e. build is platform dependent!
[INFO] Compiling 1 source file to D:\learn\Java\MyEclipse\Workspaces\MyEclipse 2017 CI\MavenSecond\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ MavenSecond ---
[INFO] Surefire report directory: D:\learn\Java\MyEclipse\Workspaces\MyEclipse 2017 CI\MavenSecond\target\surefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.itheima.maven.TestMavenSecond
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.06 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.482 s
[INFO] Finished at: 2018-09-24T12:33:39+08:00
[INFO] ------------------------------------------------------------------------
5、Maven的核心概念
5.一、坐标
- 什么是坐标？
在平面几何中坐标（x,y）能够标识平面中惟一的一点。在maven中坐标就是为了定位一个惟一肯定的jar包。
Maven世界拥有大量构建，咱们须要找一个用来惟一标识一个构建的统一规范，拥有了统一规范，就能够把查找工做交给机器。 - Maven坐标的主要组成
groupId：定义当前Maven组织名称
artifactId：定义实际项目名称
version：定义当前项目的当前版本
5.二、依赖管理
- 就是对项目中 jar包的管理。能够在pom文件中定义jar包的GAV坐标，管理依赖。
- 依赖声明主要包含以下元素：
<dependencies>
<!-- 在MavenSecond工程中依赖使用Junit的代码 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- 同理：在MavenSecond工程中依赖使用MavenFirst工程的代码 -->
<dependency>
<groupId>com.itheima.maven</groupId>
<artifactId>MavenFirst</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
5.2.一、依赖范围
详解以下：
其中依赖范围scope 用来控制`依赖`和`编译、测试、运行的classpath的关系`，主要的是三种依赖关系以下：
1.compile：默认编译依赖范围。对于编译、测试、运行三种classpath都有效。
2.test：测试依赖范围。只对于测试classpath有效。
3.provided：已提供依赖范围。对于编译、测试的classpath都有效，但对于运行的classpath无效。由于容器已经提供，例如：servlet-api。
4.runtime：运行时依赖范围。例如：jdbc驱动。
5.2.二、依赖传递
若是C中使用B，B中使用A，则称B是C的直接依赖，而称A是C的间接依赖。
C->B，B->A
C直接依赖B
C间接依赖A
- 示例：建立MavenThird工程演示依赖传递（不经过骨架建立）
- 第一步：建立MavenThird工程
- 第二步：建立MavenThird.java
- 在src/main/java中建立com.itheima.maven包，而后建立MavenThird.java
- 第三步：建立TestMavenThird.java
- 在src/test/java中建立com.itheima.maven包，而后建立TestMavenThird.java
- 分析第一间接依赖和第二直接依赖，以下图所示：
- 依赖范围对依赖传递的影响：即依赖范围传递，以下图所示：
详解以下：
左边第一列表示第一直接依赖范围
上面第一行表示第二直接依赖范围
中间的交叉单元格表示传递性依赖范围。
总结：
当第二直接依赖的范围是compile的时候，传递性依赖的范围与第一直接依赖的范围一致。
当第二直接依赖的范围是test的时候，依赖不会得以传递。
当第二直接依赖的范围是provided的时候，只传递第一直接依赖范围也为provided的依赖，且传递性依赖的范围一样为provide。
当第二直接依赖的范围是runtime的时候，传递性依赖的范围与第一直接依赖的范围一致，但compile例外，此时传递的依赖范围为runtime。
5.2.三、依赖冲突
- 在maven中存在两种依赖冲突方式：一种是
跨pom文件的依赖冲突；一种是同一个pom文件中的依赖冲突。- 跨pom文件的依赖冲突
若是MavenFirst工程的pom文件中依赖来junit的4.9版本，因此MavenSecond和MavenThird中都是使用了4.9版本。
依赖的jar包以下：
若是MavenSecond工程中从新依赖junit的4.8版本，那么MavenSecond和MavenThird中都是使用了4.8本，这体现来依赖的`就近使用原则`。
依赖的jar包以下： - 同一个pom文件中的依赖冲突
依赖的jar包以下：
- 跨pom文件的依赖冲突
5.2.四、可选依赖
`<optional>` 标签表示该依赖是否可选，默认是false。
能够理解为，若是为true，则表示该依赖不会传递下去，若是为false，则会传递下去。
可选依赖很差使，由于有的工程想要该依赖，有的工程不想要该依赖，而你在源头就已经设置成可选的了，这样就致使很差使了。
以下图所示：
5.2.五、排除依赖
`<exclusions>`标签能够排除依赖。排除依赖包中所包含的依赖关系，`不须要添加版本号`。
若是在本次依赖中有一些多余的jar包也被传递依赖过来，若是想把这些jar包排除的话能够配置exclusions进行排除。
这种方式更灵活，在实际的项目中也是这种方式。
以下图所示：
5.三、生命周期
- 什么是生命周期？
Maven生命周期就是为了对全部的构建过程进行抽象和统一。包括项目清理、初始化、编译、打包、测试、部署等几乎全部构建步骤。生命周期能够理解为构建工程的步骤。 - 在Maven中有三套相互独立的生命周期，请注意这里说的是“三套”，并且“相互独立”，这三套生命周期分别是：
- Clean Lifecycle：在进行真正的构建以前进行一些清理工做。
- Default Lifecycle：构建的核心部分，编译、测试、打包、部署等等。
- Site Lifecycle：生成项目报告、站点、发布站点。
- 生命周期是由多个阶段（Phase）组成。每一个阶段都是一个完整的功能，好比mvn clean中的clean就是一个阶段。
- 再次强调一下它们是相互独立的，你能够仅仅调用clean来清理工做目录，仅仅调用site来生成站点。
固然你也能够直接运行 mvn clean install site 运行全部这三套生命周期。
5.3.一、Clean生命周期：清理项目
每套生命周期都由一组阶段(Phase)组成，咱们平时在命令行输入的命令总会对应于一个特定的阶段。好比，运行mvn clean ，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：
pre-clean 执行一些须要在clean以前完成的工做
clean 移除全部上一次构建生成的文件
post-clean 执行一些须要在clean以后马上完成的工做
mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它以前的全部阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean，若是咱们运行 mvn post-clean，那么 pre-clean、clean 都会被运行。这是Maven很重要的一个规则，能够大大简化命令行的输入。
5.3.二、Default生命周期：构建项目（重点）
Default生命周期是Maven生命周期中最重要的一个，绝大部分工做都发生在这个生命周期中。这里，只解释一些比较重要和经常使用的阶段：
validate
generate-sources
process-sources
generate-resources
process-resources 复制并处理资源文件，至目标目录，准备打包。
`compile` 编译项目的源代码。
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 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
运行任何一个阶段的时候，它前面的全部阶段都会被运行，这样大大减轻了程序员的工做。。
这也就是为何咱们运行mvn install的时候，代码会被编译、测试、打包。
此外，Maven的插件机制是彻底依赖Maven的生命周期的，所以理解生命周期相当重要。
5.3.三、Site生命周期：生成项目站点
pre-site 执行一些须要在生成站点文档以前完成的工做
`site` 生成项目的站点文档
post-site 执行一些须要在生成站点文档以后完成的工做，而且为部署作准备
`site-deploy` 将生成的站点文档部署到特定的服务器上
这里常常用到的site阶段和site-deploy阶段，用以生成和发布Maven站点，这但是Maven至关强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。
可是通常在工程中不多使用个，领导要看的是更简单、更直接东西，好比：作的PPT、报表等。
5.四、Maven 插件
Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。每一个插件都能实现一个功能，每一个功能就是一个插件目标。Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
插件（plugin），每一个插件都能实现一个阶段的功能。Maven的核心是生命周期，可是生命周期至关于主要指定了maven命令执行的流程顺序，而没有真正实现流程的功能，功能是有插件来实现的。
好比：compile就是插件maven-compiler-plugin的一个插件目标。
5.4.一、Maven 编译插件
编译使用的jdk是由Maven编译插件指定，若是咱们没有指定编译用的jdk版本，当咱们修改了编译用的jdk版本，一更新Maven项目，就会还原回去，还原成默认配置的编译用的jdk版本。以下图所示：
咱们如今要配置编译插件：指定编译用的jdk版本
示例代码以下：
/MavenFirst/pom.xm
<build>
<plugins>
<!-- 配置编译插件：指定编译用的jdk版本 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
示例代码截图：
而后咱们保存修改配置文件后，在工程上点击右键选择Maven --> Update Project…，
即再次更新Maven项目，发现编译用的jdk版本变了，以下图所示：
5.4.二、Tomcat 插件--Web工程
- 若是使用maven的tomcat插件的话，那么本地则不须要安装tomcat了。
使用maven建立一个Web工程，不使用骨架。步骤以下：
- 第一步：建立方式：不选用骨架
- 第二步：将打包方式选择为war，以下图所示：
- 第三步：点击finish，Web工程建立成功。
- 第四步：在/MavenWeb/src/main/webapp建立WEB-INF目录以及在WEB-INF目录建立web.xml文件
web.xml内容以下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
id="WebApp_ID" version="3.1">
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
- 第五步：在webapp下建立index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
第一个Maven Web工程！
</body>
</html>
- 第六步：使用tomcat插件运行web工程
右键项目 --> Run As --> Maven build…默认输入tomcat:run去使用tomcat插件来启动web工程，可是默认的tomcat插件使用的tomcat版本是tomcat6。而目前主流的tomcat是使用的tomcat7或tomcat8或tomcat9，因此须要手动配置tomcat插件。
即：
tomcat:run 运行tomcat6（默认）
tomcat7:run 运行tomcat7（推荐，可是须要添加插件）
添加插件代码以下：
/MavenWeb/pom.xml
<build>
<plugins>
<plugin>
<!-- 配置tomcat7插件 -->
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>
<port>8085</port>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>
使用tomcat7来运行web工程，它的命令是：tomcat7:run
效果截图以下：
5.五、继承
在maven中的继承，指的是pom文件的继承。继承是为了消除重复，能够把不少相同的配置提取出来。例如：grouptId，version等。
5.5.一、建立父工程-不使用骨架
建立maven工程，不使用骨架，以下图所示：
/MavenParent/pom.xml文件截图以下：
5.5.二、建立子工程-不使用骨架
- 建立子工程方式有两种：
- 方式一：建立新工程为子工程，在建立时设置父工程的GAV。
- 方式二：修改原有的工程为子工程，在子工程的pom.xml文件中手动添加父工程的GAV。
咱们使用方式一：
/MavenSub/pom.xml文件截图以下：
同理：
方式二：原有工程继承父工程只须要在pom文件中添加parent节点便可。
5.5.三、父工程统一依赖jar包
在父工程中对jar包进行依赖，在子工程中都会继承此依赖。
子工程依赖效果以下图所示：
5.5.四、父工程统一管理版本号
Maven使用dependencyManagement 标签来管理依赖的版本号。注意：此处只是定义依赖jar包的版本号，并不实际依赖。若是子工程中须要依赖jar包还须要添加dependency节点。
父工程的pom文件：
没有真实依赖，以下图所示：
子工程的pom文件：
当子工程配置好后，就会有真实依赖，以下图所示：
5.5.五、父工程中版本号提取
当父工程中定义的jar包愈来愈多，找起来愈来愈麻烦，因此能够把版本号提取成一个属性集中管理。
子工程的jar包版本不受影响。
5.六、聚合
聚合通常是一个工程拆分红多个模块开发，每一个模块是一个独立的工程，可是要是运行时必须把全部模块聚合到一块儿才是一个完整的工程，此时可使用maven的聚合工程。
例如：电商项目中，包括商品模块、订单模块、用户模块等。就能够对不一样的模块单首创建工程，最终在打包时，将不一样的模块聚合到一块儿。
例如：在真实项目中，同一个项目中的表现层、业务层、持久层，也能够分层建立不一样的工程，最后打包运行时，再聚合到一块儿。对于业务层和持久层，它们能够在多个工程中被使用，因此通常会将业务层和持久单首创建为java工程，为其余工程依赖。
5.6.一、建立一个聚合工程-不使用骨架
聚合工程的打包方式必须是pom，通常把聚合工程和父工程合并为一个工程。
5.6.二、建立持久层工程
第一步：在MavenWeb2工程上，点击new –-> Project…
第二步：点击 next
/MavenWeb2/pom.xml文件以下图所示：
5.6.三、建立业务层工程
与持久层工程建立同样。不在赘述！
5.6.四、建立表现层工程
点击Next，进行下面的页面
在MavenController中/MavenWeb2/MavenController/src/main/webapp手动新建WEB-INF目录和index.jsp文件，并在目录WEB-INF里添加web.xml文件，以下图所示：
聚合以后的MavenWeb工程的pom文件内容以下：
5.6.五、运行MavenWeb聚合工程
命令：tomcat7:run
效果截图以下：
6、Maven的仓库管理
6.一、什么是Maven仓库？
详解以下：
用来统一存储全部Maven共享构建的位置就是仓库。
根据Maven坐标定义每一个构建在仓库中惟一存储路径大体为：groupId/artifactId/version/artifactId-version.packaging
例如：D:\learn\Java\maven\repository\junit\junit\4.9\junit-4.9.jar
以下图所示：
6.二、仓库的分类
详解以下：
1、本地仓库
默认在：~/.m2/repository，若是在用户配置中有配置，则以用户配置的地址为准。
每一个用户只有一个本地仓库。
2、远程仓库
中央仓库：Maven默认的远程仓库，不包含版权资源（即：不包含有版本的jar包）
http://repo1.maven.org/maven2
私服：是一种特殊的远程仓库，它是架设在局域网内的仓库。
私服图解以下图所示：
6.三、Maven 的私服
6.3.一、安装Nexus
nexus是用于maven项目中的仓库的服务器，常常称其为：私服。
它是用来存储和下载一些java依赖文件，经过这些java文件就能够直接从本地进行一系列用来配置maven中获取引用jar文件的服务器，而不须要从中央仓库下载文件。
Nexus是私服的载体，为全部来自中央仓库的构建安装提供本地缓存。
下载网站：http://nexus.sonatype.org/
网站如今变为：https://www.sonatype.com/
下载地址变为：https://www.sonatype.com/download-oss-sonatype
因为官网没有下载war包的连接了，提供个下载的地方：
连接: https://pan.baidu.com/s/1i6C2sHf 密码: 2b5t
安装版本：nexus-2.14.5-02.war
第一步：安装tomcat，咱们建议：对于不一样的工程，最好给每个工程配一个专门的tomcat。
第二步：将下载的nexus的war包复制到tomcat下的webapps目录，以下图所示：
第三步：启动tomcat。在 D:\learn\JavaWeb\apache-tomcat\apache-tomcat-9.0.7\bin 目录中找到 startup.bat，运行它。
nexus将在c盘建立sonatype-work目录【C:\Users\当前用户\sonatype-work\nexus】。例如个人：C:\Users\Bruce\sonatype-work\nexus
第四步：nexus的本地目录，以下图所示：
第五步：nexus的目录结构，以下图所示：
indexer 索引目录结构，以下图所示：
storage 存储目录结构，以下图所示:
6.3.二、访问Nexus
访问URL: http://localhost:8080/nexus-2.14.5-02/
默认帐号:
用户名：admin
密码：admin123
6.3.三、Nexus的仓库和仓库组
详解以下：
仓库有4种类型：
`group(仓库组)`：一组仓库的集合
`hosted(宿主)`：配置第三方仓库（包括公司内部私服）
proxy(代理)：私服会对中央仓库进行代理，用户链接私服，私服自动去中央仓库下载jar包或者插件
virtual(虚拟)：兼容Maven1 版本的jar或者插件
Nexus的仓库和仓库组介绍:
3rd party：一个策略为Release的宿主类型仓库，用来部署没法从公共仓库得到的第三方发布版本构建
Apache Snapshots：一个策略为Snapshot的代理仓库，用来代理Apache Maven仓库的快照版本构建
Central：代理Maven中央仓库
Central M1 shadow：代理Maven1版本的中央仓库
Codehaus Snapshots：一个策略为Snapshot的代理仓库，用来代理Codehaus Maven仓库的快照版本构建
Releases：一个策略为Release的宿主类型仓库，用来部署组织内部的发布版本构件
Snapshots：一个策略为Snapshot的宿主类型仓库，用来部署组织内部的快照版本构件
`Public Repositories：该仓库组将上述全部策略为Release的仓库聚合并经过一致的地址提供服务`
注意：下面这个界面的设置：
6.3.四、配置全部构建均从私服下载
在本地仓库的setting.xml文件中配置以下：
setting.xml文件所在位置为：D:\learn\Java\maven\settings.xml
<mirrors>
<!-- mirror
| Specifies a repository mirror site to use instead of a given repository. The repository that
| this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
| for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
|
<mirror>
<id>mirrorId</id>
<mirrorOf>repositoryId</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://my.repository.com/repo/path</url>
</mirror>
-->
<mirror>
<!-- 此处配置全部的构建均从私有仓库中下载 *表明全部，也能够写central -->
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<name>nexus</name>
<url>http://localhost:8080/nexus-2.14.5-02/content/groups/public/</url>
</mirror>
</mirrors>
截图以下：
6.3.五、部署构建到Nexus--发布到SNAPSHOT中
第一步：Nexus的访问权限控制
在本地仓库的setting.xml文件中配置以下：
setting.xml文件所在位置为：D:\learn\Java\maven\settings.xml
<servers>
<!-- server
| Specifies the authentication information to use when connecting to a particular server, identified by
| a unique name within the system (referred to by the 'id' attribute below).
|
| NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
| used together.
|
<server>
<id>deploymentRepo</id>
<username>repouser</username>
<password>repopwd</password>
</server>
-->
<!-- Another sample, using keys to authenticate.
<server>
<id>siteServer</id>
<privateKey>/path/to/private/key</privateKey>
<passphrase>optional; leave empty if not used.</passphrase>
</server>
-->
<server>
<id>releases</id>
<username>admin</username>
<password>admin123</password>
</server>
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>
</servers>
第二步：配置pom文件
在须要构建的项目中修改pom文件，添加以下配置代码：
......
<version>0.0.1-SNAPSHOT</version>
......
<!-- 部署构建到Nexus -->
<distributionManagement>
<repository>
<id>releases</id>
<name>Internal Releases</name>
<url>http://localhost:8080/nexus-2.14.5-02/content/repositories/releases/</url>
</repository>
<snapshotRepository>
<id>snapshots</id>
<name>Internal Snapshots</name>
<url>http://localhost:8080/nexus-2.14.5-02/content/repositories/snapshots/</url>
</snapshotRepository>
</distributionManagement>
第三步：对须要放到Nexus中的项目执行maven的deploy命令
控制台输出构建成功截图：
Nexus Repository Manager OSS 页面显示截图为：
6.3.六、部署构建到Nexus--发布到RELEASE中
只在须要构建的项目中修改pom文件的一处地方便可，以下：
......
<version>0.0.1-RELEASE</version>
......
其余操做同上。
Nexus Repository Manager OSS 页面显示截图为：
7、附录（几个问题的解决）
7.一、在Nexus Repository Manager OSS 页面上搜索时，搜索的结果是空白，该如何解决呢？
问题缘由：咱们在中央仓库索引库中没有咱们要找的文件，也即咱们没有下载下。
中央仓库索引库的位置：C:\Users\Bruce\sonatype-work\nexus\indexer\central-ctx
解决办法：咱们把从网络上下载好的中央仓库索引库文件去覆盖原来的中央仓库索引库文件。
7.二、环境变量：JAVA_HOME最好指定为jre的路径，这样Maven在读取jar包时才不会出错。
即如今：JAVA_HOME = D:\learn\Java\JRE\jre1.8.0_161
原来的：JAVA_HOME = D:\learn\Java\JDK\jdk1.8.0_161
至此，Maven的学习到此结束！！！累屎了o(╥﹏╥)o ♥晓艺♥
相关文章
- 1. 「学习笔记」学习笔记合集
- 2. 【学习笔记】FastCGI学习笔记
- 3. [学习笔记]CentOS 学习笔记01
- 4. 【Java 学习笔记】 Hadoop学习笔记
- 5. 【学习笔记】Unity3d学习笔记（一）
- 6. 【笔记】Golang学习笔记
- 7. 【笔记】vim 学习笔记
- 8. Phalcon笔记学习笔记
- 9. 学习笔记
- 更多相关文章...
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • 我们已经学习了 SQL，下一步学习什么呢？ - SQL 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 「学习笔记」学习笔记合集
- 2. 【学习笔记】FastCGI学习笔记
- 3. [学习笔记]CentOS 学习笔记01
- 4. 【Java 学习笔记】 Hadoop学习笔记
- 5. 【学习笔记】Unity3d学习笔记（一）
- 6. 【笔记】Golang学习笔记
- 7. 【笔记】vim 学习笔记
- 8. Phalcon笔记学习笔记
- 9. 学习笔记