Java之Maven

---

1、Maven简介

Maven是专门用于管理和构建Java项目的工具。

主要功能：

• 提供了一套标准化的项目结构

• 提供了一套标准化的构建流程（编译，测试，打包，发布……）

• 提供了一套依赖管理机制。

标准化的项目结构：

• 每一个开发工具（IDE）都有自己不同的项目结构，它们互相之间不通用。在eclipse中创建的目录，无法在idea中进行使用，造成了很大的不方便。
  
• Maven提供了一套标准化的项目结构，所有的IDE使用Maven构建的项目完全一样，所以IDE创建的Maven项目可以通用。如下图右边就是Maven构建的项目结构。
  

标准化的构建流程：

• 代码需要进行编译、测试、打包、发布，这些操作如果需要反复进行就显得特别麻烦，而Maven提供了一套简单的命令来完成项目构建。
  

依赖管理：

• 依赖管理其实就是管理你项目所依赖的第三方资源（jar包、插件）。如项目中需要使用JDBC和Druid的话，就需要去网上下载对应的依赖包，复制到项目中，还要将jar包加入工作环境这一系列的操作。
  

• 而Maven使用标准的 坐标 配置来管理各种依赖，只需要简单的配置就可以完成依赖管理。
  

• 上图右边所示就是mysql驱动包的坐标，在项目中只需要写这段配置，其他都不需要我们担心，Maven都帮我们进行操作了。

• 市面上有很多构建工具，而Maven依旧还是主流构建工具，如下图是常用构建工具的使用占比。
  

简介

• Apache Maven 是一个项目管理和构建工具，它基于项目对象模型(POM)的概念，通过一小段描述信息来管理项目的构建、报告和文档。

• 官网 ：https://maven.apache.org/

2、 Maven模型

• 项目对象模型 (Project Object Model)
• 依赖管理模型(Dependency)
• 插件(Plugin)

• 如上图所示就是Maven的模型，而我们先看紫色框框起来的部分，他就是用来完成 标准化构建流程 。如我们需要编译，Maven提供了一个编译插件供我们使用，我们需要打包，Maven就提供了一个打包插件提供我们使用等。
  
  上图中紫色框起来的部分，项目对象模型就是将我们自己抽象成一个对象模型，有自己专属的坐标，如下图所示是一个Maven项目：
  

依赖管理模型则是使用坐标来描述当前项目依赖哪儿些第三方jar包，如下图所示

3、Maven基础概念

3.1、仓库

创建Maven项目，在项目中使用坐标来指定项目的依赖，那么依赖的jar包到底存储在什么地方呢？其实依赖jar包是存储在我们的本地仓库中。而项目运行时从本地仓库中拿需要的依赖jar包。

仓库分类：

• 本地仓库：自己计算机上的一个目录

• 中央仓库：由Maven团队维护的全球唯一的仓库

  地址： https://repo1.maven.org/maven2/

• 远程仓库(私服)：一般由公司团队搭建的私有仓库

当项目中使用坐标引入对应依赖jar包后，首先会查找本地仓库中是否有对应的jar包：

• 如果有，则在项目直接引用;

• 如果没有，则去中央仓库中下载对应的jar包到本地仓库。
  

• 如果还可以搭建远程仓库，将来jar包的查找顺序则变为：
  本地仓库–远程仓库–中央仓库
  

3.2、坐标

什么是坐标

• Maven中的坐标用描述仓库中资源的位置。
• 地址： https://repo1.maven.org/maven2/

Maven坐标主要组成

• groudId：定义当前Maven项目隶属组织名称通常是域名反写，如：org.mybatis)。
• artifactId：定义当前Maven项目名称（通常是模块名称，如CRM、SMS）。
• version：定义当前项目版本号。
• packaging：定义该项目的打包方式。

Maven坐标的作用

• 使用唯一标识，唯一性定位资源位置，通过该标识可以将资源的识别与下载工作交由程序完成。

4、Maven安装配置

4.1、安装

• 解压缩即可
  

4.2、 配置环境变量

4.3、配置本地仓库

修改 conf/settings.xml 中的 为一个指定目录作为本地仓库，用来存储jar包。

4.4、配置镜像仓库

• 配置阿里云私服
  中央仓库在国外，所以下载jar包速度可能比较慢，而阿里公司提供了一个远程仓库，里面基本也都有开源项目的jar包。
  修改 conf/settings.xml 中的 标签，为其添加如下子标签：

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

5、Maven基本使用

5.1、Maven常用命令

 mvn compile  		编译

 mvn clean 			清理

 mvn test  			测试

 mvn  package 		打包

 mvn install 		安装到本地仓库

5.2、Maven常用命令演示

• pom.xml所在目录下执行

一、编译命令

mvn compile

执行上述命令可以看到：

• 从阿里云下载编译需要的插件的jar包，在本地仓库也能看到下载好的插件
• 在项目下会生成一个 target 目录

二、清理命令

mvn clean

• 从阿里云下载清理需要的插件jar包
• 删除项目下的 target 目录

三、打包命令

mvn package

• 从阿里云下载打包需要的插件jar包
• 在项目的 terget 目录下有一个jar包（将当前项目打成的jar包）

四、测试命令
该命令会执行所有的测试代码。

mvn test  

五、安装命令
该命令会将当前项目打成jar包，并安装到本地仓库

mvn install

5.3、Maven生命周期

Maven 构建项目生命周期描述的是一次构建过程经历经历了多少个事件

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

• clean ：清理工作。
• default ：核心工作，例如编译，测试，打包，安装等。
• site ： 产生报告，发布站点等。这套声明周期一般不会使用。

同一套生命周期内，执行后边的命令，前面的所有命令会自动执行。

5.4、插件

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

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-source-plugin</artifactId>
			<version>2.2.1</version>
			<executions>
				<execution>
					<goals>
						<goal>jar</goal>
					</goals>
					<phase> generate-test-resources</phase>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

6、IDEA配置Maven

6.1、插件创建工程

• 创建工程

  mvn archetype:generate
  -DgroupId={project-packaging} 
  -DartifactId={project-name} 
  -DarchetypeArtifactId=maven-archetype-quickstart
  -DinteractiveMode=false
  

• 创建Java工程

  mvn archetype:generate -DgroupId=com.chuhe -DartifactId=java-project -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=0.0.1-snapshot -DinteractiveMode=false
  

• 创建web工程

  mvn archetype:generate -DgroupId=com.chuhe -DartifactId=web-project -DarchetypeArtifactId=maven-archetype-webapp -Dversion=0.0.1-snapshot -DinteractiveMode=false
  

6.2、IDEA配置Maven环境

一、创建一个空项目

二、 File --> Settings

三、搜索maven，进入Maven界面并修改配置文件路径

6.3、Maven坐标详解

一、什么是坐标？

• Maven 中的坐标是资源的唯一标识
• 使用坐标来定义项目或引入项目中需要的依赖

二、Maven 坐标主要组成

• groupId：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）
• artifactId：定义当前Maven项目名称（通常是模块名称，例如 order-service、goods-service）
• version：定义当前项目版本号

如下图就是使用坐标表示一个项目：

   <groupId>com.chuhe</groupId>
   <artifactId>maven_demo</artifactId>
   <version>1.0</version>

注意：
上面所说的资源可以是插件、依赖、当前项目。
我们的项目如果被其他的项目依赖时，也是需要坐标来引入的。

6.4、IDEA创建Maven项目

一、创建模块，选择Maven

6.5、IDEA导入Maven项目

• 选择右侧Maven面板，点击 + 号，选中对应项目的pom.xml文件，双击即可
  
• 如果没有Maven面板，选择
  View --> Appearance --> Tool Window Bars
  

可以通过下图所示进行命令的操作：

6.6、配置 Maven-Helper 插件

一、IDEA中 File --> Settings

二、重启 IDEA后，右键菜单新增相关菜单选项

7、依赖管理

7.1、使用坐标引入jar包

具体坐标可查看：https://mvnrepository.com/
步骤：

• 在项目的 pom.xml 中编写 标签。

• 在 标签中 使用 引入坐标。

• 定义坐标的 groupId，artifactId，version。

• 点击刷新按钮，使坐标生效
  -

注意：
具体的坐标我们可以到如下网站进行搜索
https://mvnrepository.com/

7.2、快捷导入jar包坐标

• 在 pom.xml 中 按 alt + insert，选择 Dependency
  

• 在弹出的面板中搜索对应坐标，然后双击选中对应坐标
  

• 点击刷新按钮，使坐标生效。

7.3、自动导入设置

• 上面每次操作都需要点击刷新按钮，让引入的坐标生效。当然我们也可以通过设置让其自动完成

• 选择 IDEA中 File --> Settings
  

• 在弹出的面板中找到 Build Tools，选择 Any changes
  

7.4、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>

7.5、快速启动Tomcat插件

• 点击Add Configuration…
  
• 新增Maven
  
• 设置参数
  

7.6、依赖传递

• 项目被其他项目依赖
  

• 依赖具有传递性

  • 直接依赖：在当前项目中通过依赖配置建立的依赖关系。
  • 间接依赖：被依赖的资源如果依赖其它资源，当前项目间接依赖其他资源。

7.7、依赖传递冲突

• 路径优先：当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高。
• 声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的。
• 特殊优先：当同缘配置了相同资源的不同版本，后配置的覆盖先配置的。
  

7.8、可选依赖

• 可选依赖 ：指对外隐藏当前所依赖的资源–不透明。
  用<optional>true</optional>设置了可选依赖后，被其他项目依赖时，将无法看到本项目的这个依赖。

  <dependency>
  	<groupId>junit</groupId>
  	<artifactId>junit</artifactId>
  	<version>4.12</version>
  	<optional>true</optional>
  </dependency>
  

7.9、排除依赖

• 排除依赖：指主动断开依赖的资源，被排除的资源无需指定版本–不需要
  主动断开指定的依赖

  <dependency>
  	<groupId>junit</groupId>
  	<artifactId>junit</artifactId>
  	<version>4.12</version>
  	<exclusions>
  		<!--主动断开junit4中的下面这个依赖，不需要指定版本号-->
  		<exclusion>
  			<groupId>org.hamcrest</groupId>
  			<artifactId>hamcrest-core</artifactId>
  		</exclusion>
  	</exclusions>
  </dependency>
  

7.10、依赖范围

• 通过设置坐标的依赖范围(scope)，可以设置 对应jar包的作用范围：编译环境、测试环境、运行环境。

• 作用范围：

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

• 如下图所示给 junit 依赖通过 scope 标签指定依赖的作用范围。 那么这个依赖就只能作用在测试环境，其他环境下不能使用。
  

scope 都可以有哪些取值呢？

依赖范围	编译classpath	测试classpath	打包classpath	例子
compile(默认)	Y	Y	Y	logback 、log4j
test	-	Y	-	Junit
provided	Y	Y	-	servlet-api
runtime	-	-	Y	jdbc驱动
system	Y	Y	-	存储在本地的jar包

• compile ：作用于编译环境、测试环境、运行环境。
• test ： 作用于测试环境。典型的就是Junit坐标，以后使用Junit时，都会将scope指定为该值
• provided ：作用于编译环境、测试环境。我们后面会学习 servlet-api ，在使用它时，必须将 scope 设置为该值，不然运行时就会报错
• runtime ： 作用于测试环境、运行环境。jdbc驱动一般将 scope 设置为该值，当然不设置也没有任何问题

注意：

• 如果引入坐标不指定 scope 标签时，默认就是 compile 值。以后大部分jar包都是使用默认值。

7.11、依赖范围传递性

• 带有依赖范围的资源在进行传弟时，作用范围将受到影响。
  

8、分模块开发与设计

9、聚合

9.1、简介

✈ 聚合产生前出现的问题：

• 分模块开发后，需要将这些项目都安装到本地仓库，目前我们只能通过项目Maven面板的install来安装，并且需要安装每一个，如果我们的项目足够多，那么一个个安装起来还是比较麻烦的。
• 如果所有项目都已经安装成功，当ssm_pojo发生变化后，我们就得将ssm_pojo重新安装到maven仓库，但是为了确保我们对ssm_pojo的修改不会影响到其他项目模块，我们需要对所有的模块进行重新编译，那又需要将所有的模块再来一遍。

• 聚合可以解决这个问题。

✈ 聚合定义：

• 所谓 聚合 ：将多个模块组织成一个整体，同时进行项目构建的过程称为聚合。
• 聚合工程：通常是一个不具有业务功能的"空"工程（有且仅有一个pom文件）。

✈ 作用：

• 使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建。
• 当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题。

9.2、聚合实现步骤

✈步骤一： 创建一个空的Maven项目

✈步骤二：将项目的打包方式改为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>org.example</groupId>
    <artifactId>maven_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

</project>

说明: 项目的打包方式，我们接触到的有三种，分别是

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

✈步骤三：pom.xml添加所要管理的项目

<?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>org.example</groupId>
    <artifactId>maven_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <!--设置管理的模块名称-->
    <!--路径：是要配置的项目相对于当前pom.xml的路径-->
    <modules>    	
        <module>../maven_ssm</module>
        <module>../maven_pojo</module>
        <module>../maven_dao</module>
    </modules>

</project>

✈步骤四：使用聚合统一管理项目

当maven_parent的compile被点击后，所有被其管理的项目都会被执行编译操作。这就是聚合工程的作用。

说明：

• 聚合工程管理的项目在进行运行的时候，会按照项目与项目之间的依赖关系来自动决定执行的顺序和配置的顺序无关。

• 聚合工程主要是用来管理项目。

10、继承

10.1、简介

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

10.2、继承实现步骤

✈步骤一：创建一个空的Maven项目并将其打包方式设置为pom。

可以单独创建一个新的工程，也可以直接和聚合公用一个工程。实际开发中，聚合和继承一般也都放在同一个项目中，但是这两个的功能是不一样的。

✈步骤二：在子项目中设置其父工程

分别在maven_ssm,maven_pojo,maven_dao的pom.xml中添加其父项目为maven_parent，这里以maven_dao的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>

    <groupId>org.example</groupId>
    <artifactId>maven_dao</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>


    <!--配置当前工程继承自parent工程-->
    <parent>
        <groupId>org.example</groupId>
        <artifactId>maven_parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!--设置父项目pom.xml位置路径-->
        <relativePath>../maven_parent/pom.xml</relativePath>
    </parent>
</project>

✈步骤三：所有子项目共有依赖导入问题

1. 将子项目共同使用的jar包都抽取出来，维护在父项目的pom.xml中。

   
   其它内容略...
   
       <groupId>org.example</groupId>
       <artifactId>maven_parent</artifactId>
       <version>1.0-SNAPSHOT</version>
       <packaging>pom</packaging>
   
       <!--设置管理的模块名称-->
       <modules>
           <module>../maven_ssm</module>
           <module>../maven_pojo</module>
           <module>../maven_dao</module>
       </modules>
       <dependencies>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-webmvc</artifactId>
               <version>5.2.10.RELEASE</version>
           </dependency>
           <!--其它的坐标略...-->
       </dependencies>
       
   其它内容略...
   
   

2. 删除子项目中已经被抽取到父项目的pom.xml中的jar包

   • 删除完后，发现父项目中有依赖对应的jar包，子项目虽然已经将重复的依赖删除掉了，但是刷新的时候，子项目中所需要的jar包依然存在。

   • 当项目的<parent>标签被移除掉，会发现多出来的jar包依赖也会随之消失。

✈步骤四：部分子项目依赖版本问题

• 步骤三可以在maven_parent中配置依赖坐标，让子项目不配置坐标依赖的情况下，依然可以使用这些赖，这就是继承。
• 有一种场景，可能某些坐标依赖，并不是所有的子项目都需要配置。比如juit的坐标依赖，mavn_dao项目中需要，其它子项目不需要。就不能使用步骤三的配置方法。
• 可以使用定义依赖管理。

定义依赖管理

1. 在父工程mavne_parent的pom.xml来定义依赖管理

       <!--定义依赖管理-->
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>junit</groupId>
                   <artifactId>junit</artifactId>
                   <version>4.12</version>
                   <scope>test</scope>
               </dependency>
           </dependencies>
       </dependencyManagement>
   

   此时子项目中并不会出现junit依赖，还需要在需要依赖junit的子项目中配置该依赖。

2. maven_dao中的pom.xml配置junit的依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
   

   注意：

   • 这里就不需要添加版本了。
   • 这样做的好处就是当父工程dependencyManagement标签中的版本发生变化后，子项目中的依赖版本也会跟着发生变化。

10.3、聚合与继承的区别

✈两种之间的作用:

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

✈聚合和继承的相同点:

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

✈聚合和继承的不同点:

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

11、属性

11.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>

✈步骤二：父工程中修改依赖的veision

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <!--其它的坐标略...-->
    </dependencies>

    <!--定义依赖管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

11.2、配置文件加载属性

想让Maven对于属性的管理范围能更大些，比如我们之前项目中的jdbc.properties，这个配置文件中的属性，也可以让Maven进行管理。

✈ Maven管理配置文件的属性实现步骤为:

• ✈步骤一：父工程定义属性

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

• ✈步骤二：jdbc.properties文件中引用属性

  jdbc.driver=com.mysql.jdbc.Driver
  jdbc.url=${jdbc.url}
  jdbc.username=root
  jdbc.password=root
  

• ✈步骤三：设置maven过滤文件范围
  Maven在默认情况下是从当前项目的src\main\resources下读取文件进行打包。现在我们需要打包的资源文件是在maven_dao下,需要我们通过配置来指定下具体的资源目录。

  ✱方式一：

  <build>
      <resources>
          <!--设置资源目录，有多个的话，可以配置多个resource标签-->
          <resource>
          	<!--路径：是以父工程，pom.xml的相对路径-->
              <directory>../maven_02_ssm/src/main/resources</directory>
              <!--设置能够解析${}，默认是false -->
              <filtering>true</filtering>
          </resource>
      </resources>
  </build>
  

  ✱方式二：

  <build>
      <resources>
          <!--
  			${project.basedir}: 当前项目所在目录,子项目继承了父项目，
  			相当于所有的子项目都添加了资源目录的过滤
  		-->
          <resource>
              <directory>${project.basedir}/src/main/resources</directory>
              <filtering>true</filtering>
          </resource>
      </resources>
  </build>
  

说明:
打包的过程中如果报如下错误:

• 原因就是Maven发现项目为web项目，就会去找web项目的入口web.xml，发现没有找到，就会报错。
• 解决方法一：maven_dao项目下src\main\webapp\WEB-INF\添加一个web.xml文件，内容为空。
• 解决方法二：配置maven打包war时，忽略web.xml检查

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.2.3</version>
            <configuration>
            		<!--设为false，忽略web.xml检查 -->
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>
    </plugins>
 </build>
    ```

11.3、Maven的自定义属性

✈ Maven中的属性分为:

• 自定义属性（常用）
• 内置属性：${project.basedir},它属于Maven的内置系统属性。
• Setting属性
• Java系统属性
• 环境变量属性
  

✈ 如何查看这些属性？
maven的安装路径中执行：mvn help:system

12、版本管理

✈在jar包的版本定义中，有两个工程版本用的比较多:

• ✈SNAPSHOT（快照版本）
  • 项目开发过程中临时输出的版本，称为快照版本
  • 快照版本会随着开发的进展不断更新
• ✈RELEASE（发布版本）
  • 项目开发到一定阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的
  • 即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本

✈除了上面的工程版本，我们还经常能看到一些发布版本:

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

13、多环境开发配置

✈父工程配置多个环境,并指定默认激活环境

<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>

✈命令行实现环境切换

14、跳过测试

• ✈方式一：
  图中的按钮为Toggle 'Skip Tests' Mode,Toggle翻译为切换的意思，也就是说在测试与不测试之间进行切换。
  

• ✈方式二： 配置插件实现跳过测试
  在父工程中的pom.xml中添加测试插件配置
  skipTests:如果为true，则跳过所有测试，如果为false，则不跳过测试。
  excludes：哪些测试类不参与测试，即排除，针对skipTests为false来设置的。
  includes: 哪些测试类要参与测试，即包含,针对skipTests为true来设置的。

  <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>
  

• ✈方式三：
  
  使用Maven的命令行，mvn 指令 -D skipTests

  注意事项:

  • 执行的项目构建指令必须包含测试生命周期，否则无效果。例如执行compile生命周期，不经过test生命周期。
  • 该命令可以不借助IDEA，直接使用cmd命令行进行跳过测试，需要注意的是cmd要在pom.xml所在目录下进行执行。

15、私服

15.1、简介

搭建Maven私服的方式有很多，介绍其中一种使用量比较大的实现方式:

• Nexus
  • Sonatype公司的一款maven私服产品
  • 下载地址：https://help.sonatype.com/repomanager3/download

15.2、私服安装

✈步骤一：下截解压

✈步骤二：
cmd执行下面的命令，启动Nexus

nexus.exe /run nexus

看到以下内容，说明启动成功。

✈步骤三：浏览器访问

访问地址：http://localhost:8081

✈步骤四：首次登录重置密码



设置是否运行匿名访问


至此私服就已经安装成功。如果要想修改一些基础配置信息，可以使用:

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

15.3、私服仓库分类

私服资源操作流程分析:

(1)在没有私服的情况下，我们自己创建的服务都是安装在Maven的本地仓库中。

(2)私服中也有仓库，我们要把自己的资源上传到私服，最终也是放在私服的仓库中。

(3)其他人要想使用你所上传的资源，就需要从私服的仓库中获取。

(4)当我们要使用的资源不是自己写的，是远程中央仓库有的第三方jar包，这个时候就需要从远程中央仓库下载，每个开发者都去远程中央仓库下速度比较慢(中央仓库服务器在国外)。

(5)私服就再准备一个仓库，用来专门存储从远程中央仓库下载的第三方jar包，第一次访问没有就会去远程中央仓库下载，下次再访问就直接走私服下载。

(6)前面在介绍版本管理的时候提到过有SNAPSHOT和RELEASE，如果把这两类的都放到同一个仓库，比较混乱，所以私服就把这两个种jar包放入不同的仓库。

(7)上面我们已经介绍了有三种仓库，一种是存放SNAPSHOT的，一种是存放RELEASE还有一种是存放从远程仓库下载的第三方jar包，那么我们在获取资源的时候要从哪个仓库种获取呢?

(8)为了方便获取，我们将所有的仓库编成一个组，我们只需要访问仓库组去获取资源。

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

✈宿主仓库hosted

• 保存无法从中央仓库获取的资源
  • ✱自主研发
  • ✱第三方非开源项目,比如Oracle,因为是付费产品，所以中央仓库没有。

✈代理仓库proxy

• 代理远程仓库，通过nexus访问其他公共仓库，例如中央仓库

✈仓库组group

• 将若干个仓库组成一个群组，简化配置
• 仓库组不能保存资源，属于设计型仓库

15.4、本地仓库访问私服配置

• 我们通过IDEA将开发的模块上传到私服，中间是要经过本地Maven的
• 本地Maven需要知道私服的访问地址以及私服访问的用户名和密码
• 私服中的仓库很多，Maven最终要把资源上传到哪个仓库?
• Maven下载的时候，又需要携带用户名和密码到私服上找对应的仓库组进行下载，然后再给IDEA
• 上面所说的这些内容，需要在本地Maven的配置文件settings.xml中进行配置。
  

15.4.1、私服上配置仓库

✈步骤一：


创建Snapshot仓库



创建Release仓库

✈步骤二：配置本地Maven对私服的访问权限
E:\ProgramFiles\apache-maven-3.6.1\conf\settings.xml 中配置

<servers>
    <server>
        <id>chuhe-snapshot</id>
        <username>admin</username>
        <password>admin</password>
    </server>
    <server>
        <id>chuhe-release</id>
        <username>admin</username>
        <password>admin</password>
    </server>
</servers>

✈步骤三：配置私服的访问路径

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

✈步骤四：将新加的两个仓库添加成仓库组的成员


至此本地仓库就能与私服进行交互了。

15.5、私服资源上传与下载

✈步骤一：配置工程上传私服的具体位置
pom.xml中配置

 <!--配置当前工程保存在私服中的具体位置-->
<distributionManagement>
    <repository>
        <!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>chuhe-release</id>
         <!--release版本上传仓库的具体地址-->
        <url>http://localhost:8081/repository/chuhe-release/</url>
    </repository>
    <snapshotRepository>
        <!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>chuhe-snapshot</id>
        <!--snapshot版本上传仓库的具体地址-->
        <url>http://localhost:8081/repository/chuhe-snapshot/</url>
    </snapshotRepository>
</distributionManagement>

✈步骤二：发布资源到私服

或者执行Maven命令：java mvn deploy

注意:

• 要发布的项目都需要配置distributionManagement标签，要么在自己的pom.xml中配置，要么在其父项目中配置，然后子项目中继承父项目即可。

• 发布成功，在私服中就能看到。
  

15.6、将中央仓库配置成阿里中央仓库