Maven的介绍以及使用_maven 阿里源

一、为什么使用Maven

1. 一个项目就是一个工程
   • 如果项目非常庞大，就不适合使用package来划分模块，最好是每一个模块对应一个工程，利于分工协作。
   • 借助于maven就可以将一个项目拆分成多个工程
2. 项目中使用jar包，需要 复制、粘贴 项目的lib中
   • 同样的jar包重复的出现在不同的项目工程中，你需要做不停的复制粘贴的重复工作。
   • 借助于maven，可以将jar包保存在 仓库 中，不管在哪个项目只要使用引用即可就行。
3. jar包需要的时候每次都要自己准备好或到官网下载
   • 借助于maven我们可以使用统一的规范方式下载jar包.
4. jar包版本不一致的风险
   • 不同的项目在使用jar包的时候，有可能会导致各个项目的jar包版本不一致，导致未执行错误。
   • 借助于maven，所有的jar包都放在 仓库 中，所有的项目都使用仓库的一份jar包。
5. 一个jar包依赖其他的jar包需要自己手动的加入到项目中
   • commons-fileupload-1.3.jar 依赖于 commons-io-2.0.1.jar
   • 使用commons-fileupload-1.3.jar的时候需要对应的引入commons-io-2.0.1.jar
     • 需要花费时间在jar的依赖关系处理上。
   • 借助于maven，它会自动的将依赖的jar包导入进来。

二、maven是什么

1. maven是一款服务于java平台的自动化构建工具(Maven本身是java实现的)
2. 构建指的是什么
   • 构建定义：把软件项目经过编译得到的结果，部署到服务器上的整个过程。
     • 编译：java源文件[.java]->编译->Class字节码文件[.class]
     • 部署：把项目编译后的结果部署到服务器中
3. 构建的各个环节
   • [1] 清理clean：将以前编译得到的旧文件class字节码文件删除
   • [2] 编译compile：将java源程序编译成class字节码文件
   • [3] 测试test：自动测试，自动调用junit程序
   • [4] 报告report：测试程序执行的结果
   • [5] 打包package：动态Web工程打War包，java工程打jar包
   • [6] 安装install：Maven特定的概念-----将打包得到的文件复制到“仓库”中的指定位置（项目打包后将来可以当做第三方jar包使用）
   • [7] 部署deploy：将工程生成的结果放到服务器中或者容器中，使其可以运行

三、安装maven

1. 当前系统是否配置JAVA_HOME的环境变量
2. 下载maven，解压maven放在一个非中文无空格的路径下
3. 配置maven的相关环境变量
   • [1] 在环境变量增加M2_HOME，路径是maven解压后的根目录
   • [2] 在环境变量里的path中增加maven/bin的目录
4. 验证：mvn -v 查看maven版本

四、maven项目

1. 创建约定的目录结构（maven工程必须按照约定的目录结构创建），maven可以帮我们管理这个项目，自动构建整个项目结构

   • [1] 根目录：工程名

   • [2] |—src：源码

   • [3] |—|---main:存放主程序

   • [4] |—|---|—java：java源码文件

   • [5] |—|---|—resources：存放框架的配置文件

   • [6] |—|---test：存放测试程序

   • [7] |—|---|—java：java测试文件源码

   • [8] |—|---|—resources：存放框架的测试配置文件

   • [9] |—pom.xml：maven的核心配置文件（Project Object Model项目对象模型）

     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">
     
     ​    <modelVersion>4.0.0</modelVersion>
     
     ​    <!-- 一组坐标，唯一标识项目和jar包 -->
     ​    <!-- 1.公司或者组织域名倒序+项目名 -->
     ​    <groupId>com.briup.demo</groupId>
     ​    <!-- 2.模块名 -->
     ​    <artifactId>mvn-test</artifactId>
     ​    <!-- 3.版本 -->
     ​    <version>0.0.1-SNAPSHOT</version>
     ​	
     ​    <!-- 项目名 -->
     ​    <name>mvn-test</name>
     
     ​    <!-- 配置编码，编译使用的jdk版本，jar包的名字 -->
     ​    <properties>
     ​        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     ​        
     ​        <maven.compiler.source>1.8</maven.compiler.source>
     ​        <maven.compiler.target>1.8</maven.compiler.target>
     ​        
     ​        <!-- jar包名字 -->
     ​        <fianlName>mvn_test</fianlName>
     ​    </properties>
     
     ​    <!-- 配置需要用的依赖jar包 -->
     ​    <dependencies>
     ​        <!-- 依赖jar包会从中央仓库下载，通过唯一标识去寻找jar包，下载到本地jar包，再引用到项目中 -->
     ​        <dependency>
     ​            <!-- maven通过junit自动调用测试方法，不需要main函数 -->
     ​            <groupId>junit</groupId>
     ​            <artifactId>junit</artifactId>
     ​            <version>4.0</version>
     ​            <!--作用范围，test，compile，runtime,provide-->
     ​            <!--test:测试依赖范围-->
     ​            <!--compile：编译依赖范围-->
     ​            <!--runtime：运行时候依赖范围-->
     ​            <!--provide:编译和测试依赖范围-->
     ​            <scope>test</scope>
     ​        </dependency>
     ​    </dependencies>
     
     ​    <build>
     ​        <plugins>
     ​            <!-- 配置需要用的插件 -->
     ​            <!-- 每个生命周期都由固定的阶段（phase），每个阶段都由固定的步骤绑定到具体的插件（plugin），每个插件有一个或者多个目标（goal），即要完成的工作 -->
     ​        </plugins>
     ​    </build>
     
     </project>
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55

2. 常用maven命令

   • [1] mvn clean：清理
   • [2] mvn compile：编译主程序
   • [3] mvn test-compile：编译测试程序
   • [4] mvn test：执行测试
   • [5] mvn package：打包
   • [6] mvn install：安装
   • 注意：执行maven命令必须进入到pom.xml的目录中进行执行

五、仓库和坐标

1. pom.xml：Project Object Model 项目对象模型。它是maven的核心配置文件，所有的构建的配置都在这里设置。

2. 坐标：使用下面的三个向量在仓库中唯一的定位一个maven工程

3. maven工程的坐标与仓库中路径的关系：

   • maven坐标和仓库对应的映射关系：[groupId][artifactId] [version] [artifactId]-[version].jar

4. 仓库

   仓库的分类：

   1. 本地仓库：当前电脑上的仓库，有默认位置，有可以在maven安装包中的setting文件中进行配置
   2. 远程仓库：
      1. 私服：搭建在局域网中，一般公司都会有私服，私服一般使用nexus来搭建。
      2. 中央仓库：例如maven官方自己的中央仓库

六、依赖

1. maven解析依赖信息时会到本地仓库中取查找被依赖的jar包

   • 对于本地仓库中没有的会去中央仓库去查找maven坐标来获取jar包，获取到jar之后会下载到本地仓库
   • 对于中央仓库也找不到依赖的jar包的时候，就会编译失败了

2. 如果依赖的是自己或者团队开发的maven工程，需要先使用install命令把被依赖的maven工程的jar包导入到本地仓库中

3. 依赖范围

   • scope就是依赖的范围
     • 1、compile，默认值，适用于所有阶段（开发、测试、部署、运行），jar包会一直存在所有阶段。
     • 2、provided，只在开发、测试阶段使用，目的是不让将来部署的容器和你本地仓库的jar包冲突 。因为有些jar包在将来部署的服务器或者容器中是存在的。所以打包的是就不需要把这些jar添加进来了。
     • 3、runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
     • 4、test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
     • 5、system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。

4. 把已有的jar安装到仓库中

   • 因为有些jar中央仓库中没有，例如oracle连接的驱动包，由于版权等相关问题，中央仓库不提供下载，所以需要我们拿到jar后，自己手动安装到自己本地仓库中。

   • 4.1.提前需要配置俩个环境变量

     • M2_HOME=…
     • 将%M2_HOME%\bin加入到PATH中

   • 4.2.在jar所在目录中执行maven命令

     mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=6 -Dpackaging=jar -Dfile=ojdbc6.jar -DgeneratePom=true
     
     mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc14 -Dversion=14 -Dpackaging=jar -Dfile=ojdbc14.jar -DgeneratePom=true
     
     mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc5 -Dversion=5 -Dpackaging=jar -Dfile=ojdbc5.jar -DgeneratePom=true
     1
     2
     3
     4
     5

   • 4.3.pom文件中添加依赖

     <dependency>
         <groupId>com.oracle</groupId>
         <artifactId>ojdbc14</artifactId>
         <version>14</version>
     </dependency>
     <dependency>
         <groupId>com.oracle</groupId>
         <artifactId>ojdbc6</artifactId>
         <version>6</version>
     </dependency>
     <dependency>
         <groupId>com.oracle</groupId>
         <artifactId>ojdbc5</artifactId>
         <version>5</version>
     </dependency>
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15

七、生命周期

​ Maven有三套相互独立的生命周期，这三套生命周期分别是：
​

1 Clean Lifecycle 在进行真正的构建之前进行一些清理工作。Clean生命周期一共包含了三个阶段：

	1、pre-clean 执行一些需要在clean之前完成的工作

	2、clean 移除所有上一次构建生成的文件

	3、post-clean 执行一些需要在clean之后立刻完成的工作

2 Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。

	1、validate

	2、generate-sources

	3、process-sources

	4、generate-resources

	5、process-resources 复制并处理资源文件，至目标目录，准备打包

	6、compile 编译项目的源代码

	7、process-classes

	8、generate-test-sources

	9、process-test-sources

	10、generate-test-resources

	11、process-test-resources 复制并处理资源文件，至目标测试目录

	12、test-compile 编译测试源代码

	13、process-test-classes

	14、test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署

	15、prepare-package

	16、package 接受编译好的代码，打包成可发布的格式，如 JAR
		注意，打包时可以跳过测试阶段：
		mvn package -Dmaven.test.skip=true

	17、pre-integration-test

	18、integration-test

	19、post-integration-test

	20、verify

	21、install 将包安装至本地仓库，以让其它项目依赖。

	22、deploy

	注意：在一个生命周期中，每一个阶段（phase）可以理解为一个步骤，这些步骤按照既定的顺序执行来完成一个项目的构建。

	生命周期中，各个步骤的工作是由相应的插件（plugin）来完成的，一个插件通常完成一个或多个步骤的工作，每个步骤的工作对应插件的一个目标（goal）。不同的插件结合起来，就可以完成整个项目的构建，例如：编译插件，compiler；测试插件，surefire；打包插件，jar；安装插件，install，部署插件，deploy。
	
	maven中默认情况下，已经有设置了相应的插件来处理相应的步骤了。
	
3 Site Lifecycle 生成项目报告，站点，发布站点。

	1、pre-site 执行一些需要在生成站点文档之前完成的工作

	2、site 生成项目的站点文档

	3、post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备

	4、site-deploy 将生成的站点文档部署到特定的服务器上
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

compile编译时候默认为jdk1.5:

可以设置-source和-target两个阶段用jdk1.8编译

项目的配置文件
    <project>
      [...]
      <properties>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
      [...]
    </project>

直接设置插件配置  
    <project>
      [...]
      <build>
        [...]
        <plugins>
          <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>
            </configuration>
          </plugin>
        </plugins>
        [...]
      </build>
      [...]
    </project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

七、build配置

在pom文件中的标签中，可以配置打包后jar（war：web项目）的名字、项目中资源文件的位置、配置构建时候的插件等
例如：

<build>
	<!-- 打包后项目的名字，可以使用变量表示 -->
	<finalName>${project.artifactId}</finalName>

	<!-- 描述项目中资源的位置 -->
	<resources>
		<!-- 自定义资源1 -->
	    <resource>
			<!-- 资源目录 -->
	        <directory>src/main/resources</directory>
			<!-- 包括哪些文件参与打包 -->
	        <includes>
	            <include>**/*</include>
	        </includes>
			<!-- 排除哪些文件不参与打包 -->
	        <excludes>
	        	<exclude>config/*</exclude>
	        </excludes>
	    </resource>
	</resources>
	
	<!-- 设置构建时候的插件 -->
	<plugins>
		<!-- 资源编码插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-resources-plugin</artifactId>
			<version>3.1.0</version>
			<configuration>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>

		<!-- 代码编译插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.8.1</version>
			<configuration>
				<！-- 编译按照jdk1.8进行编译 -->
				<source>1.8</source>
				<target>1.8</target>
				<encoding>UTF-8</encoding>
			</configuration>
		</plugin>

		<!-- 源码打包插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-source-plugin</artifactId>
			<version>3.1.0</version>
			<executions>
				<execution>
					<!-- 绑定source插件到Maven的生命周期 (compile) -->
					<phase>compile</phase>
					<!--在生命周期后执行绑定的source插件的goals(jar-no-fork) -->
					<goals>
						<goal>jar-no-fork</goal>
					</goals>
				</execution>
			</executions>
		</plugin>

		<!-- 可执行jar插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-shade-plugin</artifactId>
			<version>3.2.1</version>
			<configuration>
				<!-- 设置打包时候生成dependency-reduced-pom.xml文件为false -->
				<createDependencyReducedPom>false</createDependencyReducedPom>
			</configuration>
			<executions>
				<execution>
					<!-- 绑定shade插件到Maven的生命周期 (package) -->
					<phase>package</phase>
					<!--在生命周期后执行绑定的shade插件的goals -->
					<goals>
						<goal>shade</goal>
					</goals>
					<configuration>
						<transformers>
							<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
								<!--指定程序入口类 -->
								<mainClass>com.briup.test.HelloTest</mainClass>
							</transformer>
						</transformers>
					</configuration>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93