项目管理构建工具——Maven（高阶篇)

秋落雨微凉

发布于 2022-10-25 18:18:11

1.6K00

代码可运行

文章被收录于专栏：秋落雨微凉Java开发栏秋落雨微凉Java开发栏

运行总次数：0

代码可运行

项目管理构建工具——Maven（高阶篇）

我们在之前的文章中已经基本了解了Maven，但也仅仅只止步于了解

Maven作为我们项目管理构建的常用工具，具备许多功能，在这篇文章中我们来仔细介绍

分模块开发与设计

在我们之前的项目开发中，我们常常只创建一个Maven项目来承载所有的项目内容：

我们可以注意到我们的Config配置类，Dao数据层，Service业务层，Controller服务层均处于同一Maven项目下

模块开发思想

在实际开发中，我们的开发并非由一个人开发，因此我们的项目也不可能由一个人在一个项目中研究开发

所以我们需要实现分模块开发：

按原始模块按照功能拆分成若干个子模块，方便模块间的相互调用，接口共享

模块开发实现

在有了分模块开发的理念后，实际实现步骤其实很简单：

创建Maven模块

书写模块代码

实际开发中，我们不同模块的代码由不同的人员书写，并在最后进行统筹

通过maven指令安装模块到本地仓库（install指令）

我们将原项目的部分代码分离出来后，原项目并不具备该分离代码，我们需要重新引用分离部分但分离部分的包是不会出现在本地仓库，我们需要先将分离项目的包导入本地仓库，才能被其他项目导入该包并使用

在主项目的pom.xml中书写相关依赖坐标（分离项目的坐标）

<!--以下代码出现在ssm项目的pom.xml的dependencies中-->

<!--依赖domain运行-->
        
    <dependency>
      <groupId>com.itheima</groupId>
      <artifactId>maven_03_pojo</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

依赖管理

我们的项目由多人开发，就会产生有多个项目，而我们项目之间的交互就是通过依赖来进行的管理的

下面我们来介绍依赖的几种特性

依赖传递

依赖具有传递性，传递分为两种：

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

如上图所示，在当前项目中的依赖被称为直接依赖，但直接依赖中还包括有其他依赖资源，这些资源就被称为间接依赖

当然，即使是同一个依赖，针对不同的项目可能也会成为直接或间接依赖

如果我们采用IDEA来观察，如下图所示：

依赖传递冲突问题

我们会注意到：

我们所采用的依赖通过层层叠加，可能一些我们采用的依赖在其他依赖的间接依赖中已经被使用过
但我们所希望使用的版本与间接依赖所提供的版本不同，这样就会导致很多问题

所以Maven给出了一套依赖传递冲突问题解决方案：

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

我们常用“度”来表示依赖的层级

可选依赖

我们在上一小节讲到的是IDEA的默认依赖选择机制

我们可以采用一些特殊的方法来忽略选择一些依赖来达到我们的目的

这里我们介绍一下可选依赖：

可选依赖指对外隐藏当前所依赖的资源——不透明
通俗来说就是我们在当前项目可以定义当当前项目的pom.xml依赖被采用时，该直接依赖是否可以被忽略

<!--
该项目为04-dao，
我们将dao单独分离处理，但dao的运行需要采用03-pojo才可以
所以我们将03-pojo项目的依赖导入进来
在后续我们创建其他项目时，可能需要导入04-dao的依赖
我们不希望03-pojo随着04-dao的导入而导入，所以我们采用可选依赖，用来隐藏03的依赖传递性

<optional></optional>
用来控制依赖是否开启

true：开启依赖
false：关闭依赖
-->

	<dependency>
            <groupId>com.itheima</groupId>
            <artifactId>maven_03_pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
            <!--可选依赖是隐藏当前工程所依赖的资源，隐藏后对应资源将不具有依赖传递性-->
            <optional>false</optional>
        </dependency>

在使用可选依赖之后，我们导入04-dao的依赖时，将不再导入03-pojo的依赖

排除依赖

可选依赖需要在当前项目进行设置，才可以排除依赖条件

但是我们在开发时，可能会引用第三方资源的依赖，这时我们就无法从导入依赖资源中采用可选依赖

所以我们提供了排除依赖直接在当前项目设置依赖的选取

这里我们介绍一下排除依赖：

排除依赖指主动断开依赖的资源，被排除的资源无需指定版本（默认排除所有）
排除依赖资源仅指定GA即可，无需指定V

<!--
该项目为02-ssm
我们希望采用04-dao的依赖，但不采用04-dao依赖中的log4j和mybatis依赖
所以我们在导入依赖时采用<exclusions></exclusions>来添加排除依赖选项来直接排除依赖关系

<exclusion>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
</exclusion>
我们只需指定groupId和artifactId，系统自动排除所有相关依赖

-->

	<dependency>
      <groupId>com.itheima</groupId>
      <artifactId>maven_04_dao</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!--排除依赖是隐藏当前资源对应的依赖关系-->
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

继承与聚合

前面我们已经介绍了模块开发和依赖管理

接下来我们继续来学习简化开发的一些相关信息

聚合

我们在前面讲解了分模块开发的思想

假设我们各个项目分开开发使用，每个项目具有一定的任务

但是当一个项目进行更新或修改时，我们当前项目进行重新编译打包，

但其他使用该依赖的项目却没有接收到该信息就会导致整个大项目其实并没有进行更新，没有进行统一的开发

所以我们提出了聚合这一思想：

聚合：将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
聚合工程：通常是一个不具有业务功能的“空”工程（有且仅有一个pom.xml文件）
聚合工程作用：使用聚合工程可以将多个工程组编，通过对聚合工程进行构建，实现对所包含的模块进行同步构建

当工程中的某个模块发生更新时，必须保障工程中与已更新模块关联的模块同步更新，此时可以采用聚合工程来解决

接下来我们介绍聚合工程开发的具体步骤：

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

   <!--注意：修改打包类型为pom-->
    <groupId>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>

</project>

<!--
每个maven工程都有对应的打包方式
默认为jar，web工程打包采用war
-->

设置当前聚合工程所包含的子模块名称

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

<!--
聚合工程中所包含的模块在进行构建时会根据模块间的依赖关系设置构建顺序，与聚合工程中模块的配置书写位置无关
参与聚合的工程无法向上感知是否参与聚合，只能向下配置哪些模块参与本工程的聚合
-->

继承

我们在Java的学习中也学习过继承，Maven的继承也大同小异：

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

下面我们给出继承的相关流程：

创建一个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>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>

</project>

在父工程的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>

    <!--定义相关依赖-->
    <dependencies>
        <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>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</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>${mybatis-spring.version}</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>

配置子工程中可选的依赖关系(子工程可以选择是否使用的依赖关系)

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

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</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>${mybatis-spring.version}</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>

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

</project>

<!--
我们采用<dependencyManagement></dependencyManagement>来定义依赖管理
在里面同样采用<dependencies></dependencies>定义依赖
-->

在子工程中配置当前工程所继承的父工程

<?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_02_ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

    <!--
	我们采用parent双标签来配置父类
	当前情况下默认继承父类的所有显性依赖
	对于可选依赖，我们需要重新在dependencies中书写，但不必标记版本号，版本号继承父类
	-->
    
    
  <!--配置当前工程继承自parent工程-->
  <parent>
    <groupId>com.ithedima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <relativePath>../maven_01_parent/pom.xml</relativePath>
  </parent>

  <dependencies>

      <!--继承父类的可选依赖，不必携带版本号-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>com.itheima</groupId>
      <artifactId>maven_04_dao</artifactId>
      <version>1.0-SNAPSHOT</version>
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
        <exclusion>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

  </dependencies>
    
</project>

聚合和继承

我们对聚合和继承进行一些功能性的比较

作用：

聚合用于快速构建项目
继承用于快速配置

相同点：

聚合与继承的pom.xml文件打包方式均为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>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>

    <!--定义属性-->
    <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>

</project>

<!--
属性定义在<properties>双标签中
我们直接采用双标签定义，双标签的标签名就是属性名，标签内的值就是属性值
-->

属性的引用：

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

    <!--我们采用${属性名}来引用属性值-->
    <dependencies>
        <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>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring.version}</version>
        </dependency>

    </dependencies>

    <!--定义属性-->
    <properties>
        <spring.version>5.2.10.RELEASE</spring.version>
        <mybatis-spring.version>1.3.0</mybatis-spring.version>
    </properties>
    
</project>

配置加载属性

我们的配置资源中的值同样也可以在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>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-RELEASE</version>
    <packaging>pom</packaging>

    <!--定义属性-->
    <properties>
        <jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
    </properties>

</project>

配置文件中引用属性

#jdbc.driver=com.mysql.jdbc.Driver
#jdbc.url=jdbc:mysql://localhost:3306/ssm_db
#jdbc.username=root
#jdbc.password=root

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

<?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>
    
    <!--定义属性-->
    <properties>
        <jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
    </properties>

    <build>
        <resources>
            <!--设置资源目录，并设置能够解析${}-->
            <resource>
                <!--${project.basedir}属于内置属性，project.basedir表示根节点的下级节点-->
                
                <!--设置资源目录-->
                <directory>${project.basedir}/src/main/resources</directory>
                
                <!--设置是否能够解析${}-->
                <filtering>true</filtering>
                
            </resource>
        </resources>
    </build>

</project>

其他属性（了解）

属性大致分为五种：

属性分类	引用格式	示例
自定义属性	${自定义属性名}	${Spring.version}
内置属性	${内置属性名}	${basedir} ${version}
Setting属性	${setting.属性名}	${setting.localRepository}
Java系统属性	${系统属性分类.系统属性名}	${user.home}
环境变量属性	${env.环境变量属性名}	${env.JAVA_HOME}

版本管理

最后我们简单介绍一下版本问题：

我们在创建项目时，通常在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>

    <!--如下列的version-->
    <groupId>com.itheima</groupId>
    <artifactId>maven_01_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

</project>

我们会发现我们的版本默认情况下为1.0-SNAPSHOT

其实这些在网络上是有协议规定的：

工程版本：
- SNAPSHOT（快照版本）
  - 项目开发过程中临时输出的版本，称为快照版本
  - 快照版本会随着开发的进展不断更新
- RELEASE（发布版本）
  - 项目开发到进入阶段里程碑后，向团队外部发布相对稳定的版本
  - 这种版本所对应的构建文件是稳定的，即使进行功能的后续开发，也不会改变当前发布版本内容
发布版本：
- alpha版
- beta版
- 纯数字版

多环境配置与应用

我们的项目通常会在多个环境中进行运行

单我们常见的环境来说就分为生产环境，开发环境，测试环境等

因而Maven提供了配置多种环境的设定，帮助开发者使用过程中快速切换环境

多环境的配置

在更改环境前，我们首先要学会配置环境：

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

    <!--
	我们采用<profiles></profiles>双标签来配置环境
	<profile></profile>需包含

	环境id名称
	<id></id>

	环境配置属性
	<properties>
    	<jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
    </properties>

	我们可以采用
	<activation>
    	<activeByDefault>true</activeByDefault>
    </activation>
	来设置是否为默认启动环境
	-->
    
    
    <!--配置多环境-->
    <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>

</project>

默认情况下启动时，会以默认启动环境为标准进行项目启动

多环境的使用

在Maven使用界面中，专门为我们提供了一种启动方式：

我们点击Maven启动界面的M标志：

// 我们采用指定的形式进行项目开启

// 标准格式
mvn 指令 -P 环境定义id
    
// 示例格式
mvn install -P pro_env

跳过测试（了解）

我们在实际开发中可能需要简单启动项目

但我们的项目可能并未完善导致无法启动，这时就需要我们跳过相关测试直接启动：

// 我们采用指定的形式进行项目跳过测试开启

// 标准格式
mvn 指令 -D skipTests
    
// 示例格式
mvn install -D skipTests

执行的项目构建指令必须包含测试生命周期，否则无效果例如执行compile生命周期，但不执行test生命周期

细粒度控制跳过测试：

<?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-SNAPSHOT</version>
    <packaging>pom</packaging>

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

</project>

私服

首先我们来简单介绍一下私服：

私服是一台独立的服务器，用于解决团队内部资源共享与资源同步问题

私服出现的原因：

我们每个人项目的中心仓库是独立的，在我们的中心仓库的上传与下载都是单独的
因而我们就需要一个独立于外界，在该项目中共享的中心仓库来存储与下载相关资源

Nexus：

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

下载使用

我们来介绍Nexus的私服启动过程：

在官网下载该压缩包并压缩在纯英目录下
使用cmd进入到解压目录下的nexus-3.30.1-01\bin,执行如下命令:

nexus.exe /run nexus

访问网页，默认情况下端口号为8081

http://localhost:8081

进入网页后登录重置密码即可

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

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

私服仓库分类

私服资源操作流程分析:

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

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

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

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

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

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

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

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

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

宿主仓库hosted

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

代理仓库proxy

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

仓库组group

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

本地仓库访问私服配置

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

上面所说的这些内容，我们需要在本地Maven的配置文件settings.xml中进行配置。

步骤1:私服上配置仓库

说明: 第5，6步骤是创建itheima-snapshot仓库第7，8步骤是创建itheima-release仓库

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

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

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

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

私服资源上传与下载

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

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

步骤2:发布资源到私服或者执行Maven命令