Maven 工具_maven依赖分析工具

Maven简介

Maven 本质是一个项目管理工具，将项目开发和管理过程抽象成一个项目对象模型（POM）。POM（project object model），项目对象模型。

Maven 的功能结构如下：

maven 整体分为两个大的部分，项目的构建和依赖的管理。
项目构建：提供标准的，跨平台的自动化项目构建方式。
依赖管理：方便快捷的管理项目依赖的资源（jar包），避免资源间的版本冲突问题。
统一开放结构：提供标准的，统一的项目结构。
通过pom文件来引入项目所需要的依赖，本地仓库，私服仓库（个人和组织私有的仓库，不放在互联网），中央仓库来存储管理依赖。
maven通过各种插件来构建项目。
通过maven来创建项目，可以统一项目结构。

maven 官网，通过官网下载maven，解压安装。

配置Maven 环境变量。变量值为安装的路径。

在path中添加环境变量。

Maven 基础概念

仓库：用于存储资源，包含各种jar包。

本地仓库：自己电脑上存储资源的仓库，连接远程仓库获取资源。
远程仓库：非本机电脑的仓库，为本地仓库提供资源。中央仓库，maven团队维护，存储所有资源的仓库。私服，部门或公司范围内存储资源的仓库，从中央仓库获取资源。
私服的作用：保存具体版权的资源，包含购买或自主研发的jar。一定范围内共享资源，仅对内部开放，不对外共享。

在项目中，先去本地仓库找资源，资源如果不在本地仓库，去私服或中央仓库获取资源。

坐标：Maven中用于描述仓库中资源的位置。
坐标的构成：

• groupId：定义当前maven项目隶属的组织名称（通常是域名反写，如 org.mybatis）
• artifactId：定义当前maven项目名称（通常是模块名称）
• version：定义当前项目的版本号。

maven坐标的作用，使用唯一标识，唯一性定义资源位置，通过该标识可以将资源的识别与下载工作交由机器完成。

maven 的本地仓库的配置
在maven安装目录的conf目录中，通过设置 setting文件来进行配置。
设置本地仓库的位置

<localRepository>D:\maven\repository</localRepository>
1

设置远程仓库的位置，由于中央仓库在国外，访问比较慢，可以设置阿里云的镜像仓库。

<mirrors>
	<!-- 配置具体的仓库下载镜像 -->
	<mirror>
		<!-- 此镜像的唯一标识符，用来区分不同的mirror元素 -->
		<id>nexus-aliyun</id>
		<!-- 对哪种仓库进行镜像 central 中央仓库 -->
		<mirrorOf>central</mirrorOf>
		<!-- 镜像名称 -->
		<name>Nexus aliyun</name>
		<!-- 镜像URL -->
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>
</mirrors>
1
2
3
4
5
6
7
8
9
10
11
12
13

创建 Maven项目

使用 idea 创建 maven 项目工程。
在idea中配置maven。

原型创建Java项目

创建java项目的目录结构，pom文件为maven的项目管理文件。

原型创建 Web 项目

创建的web项目的目录结构。

在web项目中，需要使用tomcat服务器来运行项目。可以通过在pom文件配置tomcat插件来运行项目。

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.tomcat.maven</groupId>
			<artifactId>tomcat7-maven-plugin</artifactId>
			<version>2.1</version>
			<configuration>
				<port>80</port>
				<path>/</path>
			</configuration>
		</plugin>
</plugins>
</build>
1
2
3
4
5
6
7
8
9
10
11
12
13

在pom文件中配置完成插件，在右侧maven插件中就可以看到。点击tomcat7:run就可以运行web项目。

依赖配置

依赖指当前项目运行所需的jar，一个项目可以设置多个依赖。
格式：

<!-- 在dependencies 中设置当前项目所依赖的所有jar -->
<dependencies>
		<!-- 设置具体的依赖 -->
		<dependency>
		<!-- 设置依赖所属群组id -->
		<groupId>junit</groupId>
		<!-- 依赖所属项目id -->
		<artifactId>junit</artifactId>
		<!-- 依赖版本号 -->
		<version>4.12</version>
	</dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

依赖具有传递性。
直接依赖：在当前项目中通过依赖配置建立的依赖关系。
间接依赖：被依赖的资源的所依赖的资源，当前项目间接依赖其他资源。

如图：

当依赖传递冲突时，也就是有多个相同的依赖，不同的版本。这时候，按照如下的规则进行覆盖：

• 路径优先:当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高。
• 声明优先:当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的。
• 特殊优先:当同级配置了相同资源的不同版本，后配置的覆盖先配置的。
  
  1度的优先级大于2度的，以此类推。

可选依赖，即当前项目所依赖的资源对外是不透明的。如果A依赖于B，B依赖于C，在B中设置对C进行可选依赖，那么在A中，就看不到B依赖了C，A就不能使用C中的资源。
可以通过如下方式进行设置：

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
	<!-- optional 标签设置为 true，当前依赖项对外隐藏 -->
	<optional>true</optional>
</dependency>
1
2
3
4
5
6
7

排除依赖指主动断开依赖的资源，被排除的资源无需指定版本。如 A依赖于B，B依赖于C，则根据依赖的传递性，A也可以使用C的资源。可以在依赖的时候进行设置 排除掉对C资源的依赖。

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
	<!-- exclusions 标签中设置排除依赖 -->
	<exclusions>
		<!-- exclusion标签中设置具体的排除依赖 -->
		<exclusion>
			<!-- 不需要指定版本 -->
			<groupId>org.hamcrest</groupId>
			<artifactId>hamcrest-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

依赖范围，依赖的jar默认的情况可以在任何地方使用，可以通过scope标签设定其作用范围。
作用范围：

• 主程序范围有效（main文件夹范围内）
• 测试程序范围有效（test文件夹范围内）
• 是否参与打包（package 指令范围内）

scope标签可设置属性如下：

示例：

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
	<!-- scope 标签中设置依赖范围，不设置默认为 compile  -->
	<scope>test</scope>
</dependency>
1
2
3
4
5
6
7

依赖传递对依赖范围的影响，带有依赖范围的资源在进行传递时，作用范围将受到影响。
依赖范围如图所示：

生命周期与插件

Maven 对项目构建的生命周期划分为3套

• clean：清理工作
• default：核心工作，如编译，测试，打包，部署等。
• site：产生报告，发布站点等。

clean 生命周期

• pre-clean 执行一些需要在clean之前完成的工作
• clean 移除所有上一次构建生成的文件
• post-clean 执行一些需要在clean之后立刻完的工作

default 构建生命周期

• validate（校验） 校验项目是否正确并且所有必要的信息可以完成项目的构建过程。
• initialize（初始化） 初始化构建状态，比如设置属性值。
• generate-sources（生成源代码） 生成包含在编译阶段中的任何源代码。
• process-sources（处理源代码） 处理源代码，比如说，过滤任意值。
• generate-resources（生成资源文件） 生成将会包含在项目包中的资源文件。
• process-resources （处理资源文件） 复制和处理资源到目标目录，为打包阶段最好准备。
• compile（编译） 编译项目的源代码。
• process-classes（处理类文件） 处理编译生成的文件，比如说对Java class文件做字节码改善优化。
• generate-test-sources（生成测试源代码） 生成包含在编译阶段中的任何测试源代码。
• process-test-sources（处理测试源代码） 处理测试源代码，比如说，过滤任意值。
• generate-test-resources（生成测试资源文件） 为测试创建资源文件。
• process-test-resources（处理测试资源文件） 复制和处理测试资源到目标目录。
• test-compile（编译测试源码） 编译测试源代码到测试目标目录.
• process-test-classes（处理测试类文件） 处理测试源码编译生成的文件。
• test（测试） 使用合适的单元测试框架运行测试（Juint是其中之一）。
• prepare-package（准备打包） 在实际打包之前，执行任何的必要的操作为打包做准备。
• package（打包） 将编译后的代码打包成可分发格式的文件，比如JAR、 WAR或者EAR文件。
• pre-integration-test（集成测试前） 在执行集成测试前进行必要的动作。比如说，搭建需要的环境。
• integration-test（集成测试） 处理和部署项目到可以运行集成测试环境中。
• post-integration-test（集成测试后） 在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境。
• verify （验证） 运行任意的检查来验证项目包有效且达到质量标准。
• install（安装） 安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖。
• deploy（部署） 将最终的项目包复制到远程仓库中与其他开发者和项目共享。

site构建生命周期

• pre-site 执行一些需要在生成站点文档之前完成的工作
• site 生成项目的站点文档
• post-site 执行一些需要生成站点文档之后完成的工作，并且为部署做准备
• site-deploy 将生成的站点文档部署到特定的服务器上。

插件
插件与生命周期内的阶段绑定，在执行到对应生命周期时执行对应的插件功能。
默认maven在各个生命周期上绑定有预设的功能。
通过插件可以自定义其他功能。

在pom文件中，设置插件，并指定对应的生命周期。

<build>
	<plugins>
		<!-- 配置插件 -->
		<plugin>
			<!-- 配置插件坐标 -->
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-source-plugin</artifactId>
			<version>2.2.1</version>
			<!-- 配置执行的生命周期 -->
			<executions>
				<execution>
					<!-- goals 标签设置执行的位置 -->
					<goals>
						<goal>jar</goal>
					</goals>
					<!-- phase 标签指明插件所对应的生命周期，这里为 generate-test-resources -->
					<phase>generate-test-resources</phase>
				</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

分模块开发

一个大的项目，可以按照功能或模块拆分为几个子模块，将一个单独的功能模块抽取为一个独立的模块，其他模块想要使用可以像添加第三方jar包依赖一样。

下面用一个示例演示分模块开发。

将项目中的每一层，拆分成一个模块。
抽取 domain 层
创建一个新的项目，将domain层所需的文件，拷贝出来。

将domain 项目 使用maven的install命令，把其安装到Maven的本地仓库中。

然后再原来的项目中引入domain 的依赖即可。

<dependency>
	<groupId>com.itheima</groupId>
	<artifactId>maven_03_pojo</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
1
2
3
4
5

抽取 dao 层
创建新的一个模块，将需要的文件拷贝到当前项目。

因为dao需要依赖domain，所以在pom文件中添加依赖。

<dependencies>
	<dependency>
		<groupId>com.itheima</groupId>
		<artifactId>maven_03_pojo</artifactId>
		<version>1.0-SNAPSHOT</version>
	</dependency>
</dependencies>
1
2
3
4
5
6
7

dao层还需要对mybatis依赖，还需要数据库驱动的依赖。

<dependencies>
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.6</version>
	</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.47</version>
	</dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

将dao安装到本地仓库，使用 mvn install 命令。

在原来的项目中删除 dao的内容，然后再pom文件中添加dao的依赖。

<dependency>
	<groupId>com.itheima</groupId>
	<artifactId>maven_04_dao</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
1
2
3
4
5

其它模块拆分类似…

总结：
对于项目的拆分，会有如下几个步骤：

• 创建maven模块
• 书写模块代码
• 通过maven指令安装模块到本地仓库（install指令）
• 在需要的项目中，引入依赖即可

聚合和继承

聚合

分模块开发后，需要将每个模块都安装到本地仓库，如果模块太多，一个个安装起来比较麻烦。如果其中一个模块进行了修改，为了确保修改不会影响到其他项目模块。需要对所有模块重新编译，比较麻烦。
可以抽取一个项目，将所有的模块进行管理。通过这个项目管理所有模块的构建。称为聚合。
聚合：将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
聚合工程：通常是一个不具有业务功能的空工程（有且仅有一个pom文件）。
作用：使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建，当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题。

聚合具体的实现步骤：
1.创建一个空的maven项目

2.将项目的打包方式改为pom

<?xml version="1.0" encoding="UTF-8"?>
<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</groupId>
	<artifactId>maven_01_parent</artifactId>
	<version>1.0-RELEASE</version>
	<packaging>pom</packaging>
</project>
1
2
3
4
5
6
7
8
9
10
11

项目的打包方式说明：

• jar：默认情况，说明该项目为 java项目
• war：说明该项目为 web项目
• pom：说明该项目为聚合或继承项目

3.pom文件中添加要管理的项目

<?xml version="1.0" encoding="UTF-8"?>
<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</groupId>
	<artifactId>maven_01_parent</artifactId>
	<version>1.0-RELEASE</version>
	<packaging>pom</packaging>
	<!--设置管理的模块名称-->
	<modules>
		<module>../maven_02_ssm</module>
		<module>../maven_03_pojo</module>
		<module>../maven_04_dao</module>
	</modules>
</project>![请添加图片描述](https://img-blog.csdnimg.cn/3412bcaa0a714bd6a8cdeca3764ea8e4.png)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.使用聚合统一管理项目

当 maven_01_parent 的 compile 被点击后，所有被其管理的项目都会被执行编译操作。这就是聚合工程的作用。
说明：聚合工程管理的项目在进行运行的时候，会按照项目与项目之间的依赖关系来自动决定执行的顺序和配置的顺序无关。
总结：聚合工程主要是用来管理项目。

继承

多模块开发存中存在重复配置的问题，不同的模块，可能会存在重复配置相同的依赖项。如下：

spring-webmvc、spring-jdbc在三个项目模块中都有出现，这样就出现了重复的内容。
spring-test只在ssm_crm和ssm_goods中出现，而在ssm_order中没有，这里是部分重复的内容。
现在使用的spring版本目前是5.2.10.RELEASE,假如后期要想升级spring版本，所有跟Spring相关jar包都得被修改，涉及到的项目越多，维护成本越高。使用继承就可以解决这些问题。

继承：描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
继承的作用：简化配置，减少版本冲突。

继承的实现步骤：
1.创建一个空的maven项目并将其打包方式设置为pom
2.在子项目中设置其父工程
分别在maven_02_ssm,maven_03_pojo,maven_04_dao的pom.xml中添加其父项目为maven_01_parent。

<!--配置当前工程继承自parent工程-->
<parent>
	<groupId>com.itheima</groupId>
	<artifactId>maven_01_parent</artifactId>
	<version>1.0-RELEASE</version>
	<!--设置父项目pom.xml位置路径-->
	<relativePath>../maven_01_parent/pom.xml</relativePath>
</parent>
1
2
3
4
5
6
7
8

3.优化子项目共有依赖导入问题
将子项目共同使用的jar包抽取出来，维护在父项目的pom中。

<?xml version="1.0" encoding="UTF-8"?>
<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</groupId>
	<artifactId>maven_01_parent</artifactId>
	<version>1.0-RELEASE</version>
	<packaging>pom</packaging>
	<!--设置管理的模块名称-->
	<modules>
		<module>../maven_02_ssm</module>
		<module>../maven_03_pojo</module>
		<module>../maven_04_dao</module>
	</modules>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>5.2.10.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.10.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.2.10.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>5.2.10.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.6</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.0</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.47</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.16</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.0</version>
		</dependency>
	</dependencies>
</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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

在子项目中，将依赖删除，引入父项目工程

<?xml version="1.0" encoding="UTF-8"?>
<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</groupId>
	<artifactId>maven_04_dao</artifactId>
	<version>1.0-SNAPSHOT</version>
	<!--配置当前工程继承自parent工程-->
	<parent>
		<groupId>com.itheima</groupId>
		<artifactId>maven_01_parent</artifactId>
		<version>1.0-RELEASE</version>
		<relativePath>../maven_01_parent/pom.xml</relativePath>
	</parent>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.优化子项目依赖版本问题
如果把所有用到的jar包都管理在父项目的pom.xml，看上去更简单些，但是这样就会导致有很多项目引入了过多自己不需要的jar包。
针对于这种部分项目有的jar包，在父工程的pom中，使用dependencyManagement标签进行设置。

<!--定义依赖管理-->
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
1
2
3
4
5
6
7
8
9
10
11

dependencyManagement 标签不真正引入jar包，而是配置可供子项目选择的 jar 包依赖，子项目要想使用它所提供的这些 jar 包，需要自己添加依赖，并且不需要指定 version。

在子项目中添加，不需要指定版本。

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<scope>test</scope>
</dependency>
1
2
3
4
5

继承总结：

• 将所有项目公共的jar包依赖提取到父工程的pom.xml中，子项目就可以不用重复编写，简化开发
• 将所有项目的 jar 包配置到父工程的dependencyManagement标签下，实现版本管理，方便维护。
• dependencyManagement标签不真正引入jar包，只是管理jar包的版本子项目在引入的时候，只需要指定groupId和artifactId，不需要加version。当dependencyManagement标签中jar包版本发生变化，所有子项目中有用到该 jar 包的地方对应的版本会自动随之更新。
• 父工程主要是用来快速配置依赖jar包和管理项目中所使用的资源。

继承的实现步骤:

• 创建 Maven 模块，设置打包类型为 pom
• 在父工程的 pom 文件中配置依赖关系
• 在父工程中配置子工程中可选的依赖关系
• 在子工程中配置当前工程所继承的父工程
• 在子工程中配置使用父工程中可选依赖的坐标

聚合与继承的区别

两者之间的作用：

• 聚合用于快速构建项目，对项目进行管理
• 继承用于快速配置和管理子项目中所使用jar包的版本

相同点：

• 聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中
• 聚合与继承均属于设计型模块，并无实际的模块内容

不同点：

• 聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些。
• 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己。

属性

在父工程中的dependencyManagement标签中对项目中所使用的jar包版本进行了统一的管理，但是如果在标签中有如下的内容：

如果现在想更新Spring的版本，就需要更新多个jar包的版本，可以使用变量属性定义版本号。在管理依赖的地方使用该属性来管理版本信息。

步骤如下：
1.父工程中定义属性

<properties>
	<spring.version>5.2.10.RELEASE</spring.version>
	<junit.version>4.12</junit.version>
	<mybatis-spring.version>1.3.0</mybatis-spring.version>
</properties>
1
2
3
4
5

2.修改依赖的version

<!-- 在依赖管理的时候，使用 ${} 来引入对于的版本-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>${spring.version}</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>${spring.version}</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

只需要更新父工程中 properties 标签中所维护的 jar 包版本，所有子项目中的版本也就跟着更新。

配置文件加载属性
1.父工程定义属性

<properties>
	<jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
</properties>
1
2
3

2.jdbc.properties 文件中引用属性
在 jdbc.properties，将 jdbc.url 的值直接获取Maven配置的属性

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=${jdbc.url}
jdbc.username=root
jdbc.password=root
1
2
3
4

3.设置maven过滤文件范围
Maven在默认情况下是从当前项目的src\main\resources下读取文件进行打包。如果需要打包的资源文件是在别的项目下,需要通过配置来指定下具体的资源目录。

<build>
	<resources>
		<!--设置资源目录-->
		<resource>
		<directory>../maven_02_ssm/src/main/resources</directory>
		<!--设置能够解析${}，默认是false -->
		<filtering>true</filtering>
		</resource>
	</resources>
</build>
1
2
3
4
5
6
7
8
9
10

这样就可以了，通过父工程来管理子项目的属性。如果有多个项目需要管理，则都需要加入配置。

<build>
	<resources>
		<!--
			${project.basedir}: 当前项目所在目录,子项目继承了父项目，
			相当于所有的子项目都添加了资源目录的过滤
		-->
		<resource>
			<directory>${project.basedir}/src/main/resources</directory>
			<filtering>true</filtering>
		</resource>
	</resources>
</build>
1
2
3
4
5
6
7
8
9
10
11
12

小结：配置文件中读取pom属性值

• 在pom文件中设定配置文件路径
• 开启加载pom属性过滤功能
• 使用${}格式引用pom属性

版本管理

常见的版本名称

SNAPSHOT（快照版本）

• 项目开发过程中临时输出的版本，称为快照版本。
• 快照版本会随着开发的进展不断更新。

RELEASE（发布版本）

• 项目开发到一定阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的。
• 即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本。

alpha 版：内测版，bug多不稳定内部版本不断添加新功能
beta 版：公测版，不稳定(比alpha稳定些)，bug相对较多不断添加新功能
纯数字版

多环境配置与应用

我们平常都是在自己的开发环境进行开发，当开发完成后，需要把开发的功能部署到测试环境供测试人员进行测试使用，等测试人员测试通过后，我们会将项目部署到生成环境上线使用。

maven 提供配置多种环境的设定，帮助开发者在使用过程中快速切换环境。
父工程配置多个环境,并指定默认激活环境

<profiles>
	<!--开发环境-->
	<profile>
		<id>env_dep</id>
		<properties>
			<jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
		</properties>
		<!--设定是否为默认启动环境-->
		<activation>
			<activeByDefault>true</activeByDefault>
		</activation>
	</profile>
	<!--生产环境-->
	<profile>
		<id>env_pro</id>
		<properties>
			<jdbc.url>jdbc:mysql://127.2.2.2:3306/ssm_db</jdbc.url>
		</properties>
	</profile>
	<!--测试环境-->
	<profile>
		<id>env_test</id>
		<properties>
			<jdbc.url>jdbc:mysql://127.3.3.3:3306/ssm_db</jdbc.url>
		</properties>
	</profile>
</profiles>
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

进行安装即可。

也可以使用命令行实现环境切换。

mvn 指令 -P 环境定义ID[环境定义中获取]
1

跳过测试
前面在执行install指令的时候，Maven都会按照顺序从上往下依次执行，每次都会执行test。

对于test来说有它存在的意义，

• 可以确保每次打包或者安装的时候，程序的正确性，假如测试已经通过在我们没有修改程序的前提下再次执行打包或安装命令，由于顺序执行，测试会被再次执行，就有点耗费时间了。
• 功能开发过程中有部分模块还没有开发完毕，测试无法通过，但是想要把其中某一部分进行快速打包，此时由于测试环境失败就会导致打包失败。

方式一:IDEA工具实现跳过测试

方式二:配置插件实现跳过测试
在父工程中的pom.xml中添加测试插件配置

<build>
	<plugins>
		<plugin>
			<artifactId>maven-surefire-plugin</artifactId>
			<version>2.12.4</version>
			<configuration>
				<skipTests>false</skipTests>
				<!--排除掉不参与测试的内容-->
				<excludes>
					<exclude>**/BookServiceTest.java</exclude>
				</excludes>
			</configuration>
		</plugin>
	</plugins>
</build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

skipTests：如果为true，则跳过所有测试，如果为false，则不跳过测试
excludes：哪些测试类不参与测试，即排除，针对skipTests为false来设置的
includes：哪些测试类要参与测试，即包含,针对skipTests为true来设置的

方式三：命令行跳过测试

使用Maven的命令行，mvn 指令 -D skipTests

私服

私服：公司内部搭建的用于存储Maven资源的服务器
远程仓库：Maven开发团队维护的用于存储Maven资源的服务器

私服是一台独立的服务器，用于解决团队内部的资源共享与资源同步问题
搭建Maven私服的方式有很多，介绍其中一种使用量比较大的实现方式:
Nexus 是 Sonatype公司的一款maven私服产品。下载地址

下载解压。

使用cmd进入到解压目录下的nexus-3.30.1-01\bin,执行如下命令：

nexus.exe /run nexus
1

访问 http://localhost:8081 即可看到效果。首次登录需要重置密码。

修改基础配置信息
安装路径下etc目录中nexus-default.properties文件保存有nexus基础配置信息，例如默认访问端口。

修改服务器运行配置信息
安装路径下bin目录中nexus.vmoptions文件保存有nexus服务器启动对应的配置信息，例如默认占用内存空间。

私服资源操作流程分析:

私服仓库总共分为三大类:

• 宿主仓库hosted，保存无法从中央仓库获取的资源。自主研发，第三方非开源项目,比如Oracle,因为是付费产品，所以中央仓库没有。
• 代理仓库proxy，代理远程仓库，通过nexus访问其他公共仓库，例如中央仓库。
• 仓库组group，将若干个仓库组成一个群组，简化配置，仓库组不能保存资源，属于设计型仓库。

本地仓库访问私服配置

通过IDEA将开发的模块上传到私服，中间是要经过本地Maven的，本地Maven需要知道私服的访问地址以及私服访问的用户名和密码，还需要知道访问的是私服中的哪个仓库。Maven下载的时候，又需要携带用户名和密码到私服上找对应的仓库组进行下载，然后再给IDEA。

需要在本地Maven的配置文件settings.xml中进行配置。
步骤1.私服上配置仓库

步骤2.配置本地Maven对私服的访问权限

<servers>
	<server>
		<id>itheima-snapshot</id>
		<username>admin</username>
		<password>admin</password>
	</server>
	<server>
		<id>itheima-release</id>
		<username>admin</username>
		<password>admin</password>
	</server>
</servers>
1
2
3
4
5
6
7
8
9
10
11
12

步骤3.配置私服的访问路径

<mirrors>
	<mirror>
		<!--配置仓库组的ID-->
		<id>maven-public</id>
		<!--*代表所有内容都从私服获取-->
		<mirrorOf>*</mirrorOf>
		<!--私服仓库组maven-public的访问路径-->
		<url>http://localhost:8081/repository/maven-public/</url>
	</mirror>
</mirrors>
1
2
3
4
5
6
7
8
9
10

在私服中设置仓库组

私服资源上传与下载
本地仓库与私服已经建立了连接，接下来就需要往私服上上传资源和下载资源
具体的实现步骤为:
步骤1.配置工程上传私服的具体位置

<!--配置当前工程保存在私服中的具体位置-->
<distributionManagement>
	<repository>
		<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
		<id>itheima-release</id>
		<!--release版本上传仓库的具体地址-->
		<url>http://localhost:8081/repository/itheima-release/</url>
	</repository>
	<snapshotRepository>
		<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
		<id>itheima-snapshot</id>
		<!--snapshot版本上传仓库的具体地址-->
		<url>http://localhost:8081/repository/itheima-snapshot/</url>
	</snapshotRepository>
</distributionManagement>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

步骤2.发布资源到私服

要发布的项目都需要配置 distributionManagement 标签，要么在自己的pom.xml中配置，要么在其父项目中配置，然后子项目中继承父项目即可。
发布成功，在私服中就能看到：

如果想删除已经上传的资源，可以在界面上进行删除操作:

如果私服中没有对应的jar，会去中央仓库下载，速度很慢。可以配置让私服去阿里云中下载依赖。