一篇文章彻底搞懂Maven

最新推荐文章于 2024-07-17 18:35:36 发布

我很菜所以我要多练

最新推荐文章于 2024-07-17 18:35:36 发布

阅读量778

点赞数 14

文章标签： maven java

本文链接：https://blog.csdn.net/qq_48357941/article/details/139627868

版权

一、Maven简介

1-Maven介绍

https://maven.apache.org/what-is-maven.html

Maven 是自动化构建工具。

Maven 是 Apache 软件基金会组织维护的一款自动化构建工具，专注服务于 Java 平台的项目构建和依赖管理。Maven 这个单词的本意是：专家，内行。

Maven 是目前最流行的自动化构建工具，对于生产环境下多框架、多模块整合开发有重要作用，Maven 是一款在大型项目开发过程中不可或缺的重要工具。

Maven就是一个软件，掌握软件安装、配置、以及基本功能 （项目构建、依赖管理） 使用就是

本篇文章的主要目标！

场景 1 ：例如我们项目需要第三方库（依赖），如 Druid 连接池、 MySQL 数据库驱动和 Jackson 等。那么我们可以将需要的依赖项的信息编写到Maven 工程的配置文件， Maven 软件就会自动下载并复制这些依

赖项到项目中，也会自动下载依赖需要的依赖！确保依赖版本正确无冲突，依赖链路完整！

场景 2 ：完成项目开发后，想要将项目打成 .war 文件，并部署到服务器中运行，使用 Maven 软件，我们可以通过一行构建命令（mvn package ）快速项目构建和大包！节省大量时间！

2-为什么要使用Maven

我们知道，项目开发不仅仅是写写代码而已，期间会伴随着各种必不可少的事情要做，例如：

我们需要引用各种 jar 包，尤其是比较大的工程，引用的 jar 包往往有几十个乃至上百个，每个都要到不同的官网去下载，而且每次用到的 jar 包，都需要手动引入工程目录，而且经常遇到各种让人抓狂的 jar 包冲突，版本冲突，Maven可以自动下载jar包及依赖包添加到项目中，大大减轻了工作负担。
我们开发的 Java 文件，都是需要将它编译成二进制字节码文件。好在这项工作可以由各种集成开发工具帮我们完成，Eclipse、IDEA 等都可以将代码即时编译。但有时候我们需要多个模块同时编译，就必须要借助于Maven工具了。
每个项目或模块开发过程中都会有 bug，因此写完了代码，我们还要写一些单元测试，然后一个个的运行来检验代码质量，Maven提供了专门的测试插件来实施测试。
再优雅的代码也是要出来卖的。我们后面还需要把代码与各种配置文件、资源整合到一起，定型打包，如果是 web项目，还需要将之发布到服务器进行调用，这些都可以通过Maven轻松搞定。

总之，Maven是项目开发必须不可少的工具。

3-项目构建过程

4-Maven的核心功能和作用（重点）

4.1-项目构建

对项目进行编译，测试，打包，部署等构建。

4.2-依赖管理

5-Maven软件工作原理模型图

二、Maven的核心概念

1-什么是pom

POM(Project Object Model)项目对象模型，它是Maven的核心组件。它是Maven中的基本工作单元。它是一个xml文件，以pom.xml驻留在项目的根目录中。POM不仅包含有关项目的信息及Maven用于构建项目的各种配置的详细信息，还包含目标和插件。

pom.xml文件示例：

<!--添加父工程的引用-->
<parent>
  <groupId>com.bjpowernode.xiaomi</groupId>
  <artifactId>xiaomi-parent</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</parent>

<!--本项目的身份证号gav-->
<groupId>com.bjpowernode</groupId>
<artifactId>springmvc_006_ssm</artifactId>	  
<version>1.0.0</version>
<!--打包方式-->
<packaging>war</packaging>

<!--集中定义依赖版本号,使用属性-->
<properties>
  <!--mysql驱动的依赖-->
  <mysql.version>5.1.32</mysql.version>
</properties>

<!--添加依赖-->
<dependencies>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
  </dependency>	    
</dependencies>

<build>
  
  <!--聚合工程-->
  <modules>
    <module>xiaomi-manager-pojo</module>
    <module>xiaomi-manager-mapper</module>
    <module>xiaomi-manager-service</module>
    <module>xiaomi-manager-web</module>
  </modules>
  
  <!--插件配置-->
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <source>17</source>
        <target>17</target>
        <encoding>UTF-8</encoding>
      </configuration>
    </plugin>
  </plugins>
  
  <!--指定配置文件识别路径-->
  <resources>
    <resource>
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.properties</include>
        <include>**/*.xml</include>
      </includes>
    </resource>
    <resource>
      <directory>src/main/resources</directory>
      <includes>
        <include>**/*.properties</include>
        <include>**/*.xml</include>
      </includes>
    </resource>
  </resources>
</build>

2- 什么是约定的目录结构

会有预先约定好的目录结构，必须要遵循的规范，所有的Maven项目都依照这个规范。主要的目的是将项目的源码文件，测试代码，资源文件完全分开，便于项目管理和扩展。

<dependency>
  <groupId>com.bjpowernode</groupId>
  <artifactId>springmvc_006_ssm</artifactId>	  
  <version>1.0.0</version>
</dependency>

3-什么是坐标GAV

也称为gav定位。使用三个标签来唯一定位jar资源。项目的唯一的名称，创建项目时定义gav名称，引用项目时使用gav名称。相当于项目的身份证号。

groupId: 组织名称,一般是公司域名的倒写 com.bjpowernode
artifactId: 项目名称 springmvc_006_ssm
version: 版本编号 1.0-SNAPSHOT(开发时的临时版本号） 5.2.5.RELEASE（发布版本）

【定义项目】

<groupId>com.bjpowernode</groupId>
<artifactId>springmvc_006_ssm</artifactId>	  
<version>1.0.0</version>

【定义项目】

<dependency>
  <groupId>com.bjpowernode</groupId>
  <artifactId>springmvc_006_ssm</artifactId>	  
  <version>1.0.0</version>
</dependency>

4-什么是仓库

存放jar包的位置。Maven中所有的jar包都在仓库中。仓库分为本地仓库和远程仓库。

我们依赖的jar包它从哪儿获取呢？有同学说已经安装了，在它的安装包里啊，大家可以看一下maven下载下来才8M，我们需要的jar包有时候都几百兆甚至几个G，它从哪儿弄去呢？其实，maven有仓库的概念。在Maven中，任何一个依赖、插件或者项目构建的输出，都可以称之为构件。Maven 核心程序仅仅定义了自动化构建项目的生命周期，但具体的构建工作是由特定的构件完成的。而且为了提高构建的效率和构件复用，maven把所有的构件统一存储在某一个位置，这个位置就叫做仓库。

4-1本地仓库

本地仓库，存在于当前电脑上，默认存放在~\.m2\repository中,为本机上所有的Maven工程服务。你也可以通过Maven的配置文件Maven_home/conf/settings.xml中修改本地仓库所在的目录。~ 是用户的主目录，windows系统中是 c:/user/登录系统的用户名

我课程里是存放在本机上的某个磁盘的位置(一定是没有中文的路径). D:\repository

秘密: gav就是仓库中一级一级的目录名称

4-2远程仓库

        远程仓库，分为为全世界范围内的开发人员提供服务的中央仓库、为全世界范围内某些特定的用户提供服务的中央仓库镜像、为本公司提供服务自己架设的私服。

        中央仓库是maven默认的远程仓库，其地址是:http://repo.maven.apache.org/maven2/，中央仓库包含了绝大多数流行的开源Java构件，以及源码、作者信息、许可证信息等。一般来说，简单的Java项目依赖的构件都可以在这里下载得到。

        私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的Maven用户使用。当Maven需要下载构件的时候，它从私服请求，如果私服上不存在该构件，则从外部的远程仓库下载，缓存在私服上之后，再为Maven的下载请求提供服务。我们还可以把一些无法从外部仓库下载到的构件上传到私服上。

4-3常用仓库

http://mvnrepository.com/

4-4仓库之间的关系和优先级

5-什么是依赖

一个Maven 项目正常运行需要其它项目的支持，Maven 会根据坐标自动到本地仓库中进行查找。对于程序员自己的 Maven 项目需要进行安装，才能保存到仓库中。不用maven 的时候所有的 jar 都不是你的，需要去各个地方下载拷贝，用了 maven 所有的 jar 包都是你的，想用谁，叫谁的名字就行。maven 帮你下载。

除了管理当前要使用的jar包，并且同时管理与其有依赖关系的jar包，自动去下载，并添加到当前的仓库，并给项目添加引用。是通过<dependencies>大标签中的子标签<dependency>，使用gav添加依赖。

<dependencies>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.11</version>
  </dependency>
</dependencies>

6-什么是生命周期

        对项目的构建是建立在生命周期模型上的，它明确定义项目生命周期各个阶段，并且对于每一个阶段提供相对应的命令，对开发者而言仅仅需要掌握一小堆的命令就可以完成项目各个阶段的构建工作。

        构建项目时按照生命周期顺序构建，每一个阶段都有特定的插件来完成。不论现在要执行生命周期中的哪个阶段，都是从这个生命周期的最初阶段开始的。

        对于我们程序员而言，无论我们要进行哪个阶段的构建，直接执行相应的命令即可，无需担心它前边阶段是否构建，Maven 都会自动构建。这也就是 Maven 这种自动化构建工具给我们带来的好处。

        使用idea后，生命周期要调用的命令被集成化一些按钮，只需要双击即可调用相应的插件来运行。

7-什么是插件

Maven本质上是一个插件框架，它的核心并不执行任何具体的构建任务，所有这些任务都交给插件来完成，例如编译源代码是由maven- compiler-plugin完成的。进一步说，每个任务对应了一个插件目标（goal），每个插件会有一个或者多个目标，例如maven- compiler-plugin的compile目标用来编译位于src/main/java/目录下的主源码，testCompile目标用来编译位于src/test/java/目录下的测试源码。

Maven支持极简化的插件添加.使用<plugins>大标签中添加<plugin>子标签引用插件.

<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
      <source>17</source>
      <target>17</target>
      <encoding>UTF-8</encoding>
    </configuration>
  </plugin>
</plugins>

三、Maven安装及简单应用

1-资源分享

链接：https://pan.baidu.com/s/1KHfipkr1eP-pIvaZzvAt8A?pwd=1234
提取码：1234
--来自百度网盘超级会员V4的分享

【软件结构说明】

2-环境设置

3-Maven功能配置

我们需要需改 maven/conf/settings.xml 配置文件，来修改 maven 的一些默认配置。我们主要要修改的有三个配置：

1. 依赖本地缓存位置（本地仓库位置）

2.maven 下载镜像

3.maven 选用编译项目的jdk 版本！

【配置阿里云镜像】

<!--在mirrors节点(标签)下添加中央仓库镜像 160行附近-->
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>

4-IDEA配置本地Maven软件

我们需要将配置好的maven 软件，配置到 idea 开发工具中即可！注意： idea 工具默认自带 maven 配置软件，但是因为没有修改配置，建议替换成本地配置好的maven ！

5-基于Maven开发javaSE的项目

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

切记:点M刷新依赖

开发Hello.java类

public class Hello {
    //加法运算
    public int sum(int num1,int num2){
       return num1 + num2;
    }
    //乘法运算
    public int mul(int num1,int num2){
        return num1 * num2;
    }
}

开发测试类

public class MyTest {
    /**
     * 测试功能由测试方法来实现
     * 测试方法的规范
     * 1)访问权限是public
     * 2)方法没有返回值void
     * 3)方法名称自 定义,推荐以test开头
     * 4)方法没有参数
     * 5)使用@Test注解声明是测试方法
     */
    @Test
    public void testSum(){
        Hello  hello = new Hello();
        System.out.println(hello.sum(3,6));
    }
    @Test
    public void testMul(){
        Hello  hello = new Hello();
        System.out.println(hello.mul(3,6));
    }
}

6- 基于Maven开发JavaWeb的项目

<name>maven_002_javaweb Maven Webapp</name>
<url>http://maven.apache.org</url>



<!--添加Servlet的依赖-->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>4.0.1</version>
</dependency>



<build>
  <finalName>maven_002_javaweb</finalName>
</build>

@WebServlet("/demo")
public class DemoServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("我来过.........");
        //跳 回 main.jsp
        request.getRequestDispatcher("/main.jsp").forward(request,response);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

7-导入Maven工程项目

四、Maven工程的依赖管理

在JAVA开发中,项目的依赖管理是一项重要任务。通过合理管理项目的依赖关系，我们可以有效的管理第三方库，模块的引用及版本控制。而Maven作为一个强大的构建工具和依赖管理工具，为我们提供了便捷的方式来管理项目的依赖。

1-什么是依赖范围

Maven的依赖构件包含一个依赖范围的属性。这个属性描述的是三套classpath的控制，即编译、测试、运行。这说白了就是添加的jar包起作用的范围。 maven提供了以下几种依赖范围:compile,test,provided.runtime,system。

分别介绍如下：

compile

编译依赖范围，如果没有指定，默认使用该依赖范围，对于编译、测试、运行3种classpath都有效。

<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.24</version>
    <scope>compile</scope>
  </dependency>
</dependencies>

test

测试依赖范围，使用此依赖范围的maven依赖，只对编译测试、运行测试的classpath有效，在编译主代码、运行项目时无法使用此类依赖。比如junit，它只有在编译测试代码及运行测试的时候才需要。

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

provided

已提供依赖范围。表示项目的运行环境中已经提供了所需要的构件，对于此依赖范围的maven依赖，对于编译源码、编译测试、运行测试中classpath有效，但在运行时无效。比如上面说到的servlet-api，这个在编译和测试的时候需要用到，但是在运行的时候，web容器已经提供了，就不需要maven帮忙引入了。

<dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

runtime

运行时依赖范围，使用此依赖范围的maven依赖，对于测试和运行项目的classpath有效，但在编译时无效，比如jdbc驱动实现，项目代码编译的时候只需要提供JDK提供的JDBC接口，运行的时候才需要具体的jdbc驱动实现。

<dependencies>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
    <scope>runtime</scope>
  </dependency>
</dependencies>

system

系统依赖范围，该依赖与3中classpath的关系，和provided依赖范围完全一致。但是，使用system范围的依赖时必须通过systemPath元素显示第指定依赖文件的路径。这种依赖直接依赖于本地路径中的构件，可能每个开发者机器中构件的路径不一致，所以如果使用这种写法，你的机器中可能没有问题，别人的机器中就会有问题，所以建议谨慎使用。

<dependencies>
  <dependency>
    <groupId>com.bjpowernode</groupId>
    <artifactId>maven_001_javase</artifactId>
    <version>1.0-SNAPSHOT</version>
    <scope>system</scope>
    <systemPath>D:/repository/com/bjpowernode/maven_001_javase/1.0-SNAPSHOT/maven_001_javase-1.0-SNAPSHOT.jar</systemPath>
  </dependency>
</dependencies>

2-什么是依赖传递

依赖范围对依赖传递的影响

规范化依赖传递的结果:

交叉部分的单元格的取值为传递性依赖的依赖范围，若交叉单元格取值为 “-”，则表示该传递性依赖不能被传递。

通过上表，可以总结出以下规律：

当间接依赖的范围是 compile 时，与直接依赖的范围一致；
当间接依赖的范围是 test 或 provided时，传递性依赖不会被传递；
当间接依赖的范围是 runtime 时，传递性依赖的范围与直接依赖的范围一致，但 compile 例外，此时传递性依赖的范围为 runtime。

3-依赖冲突

3-1 什么是依赖冲突？

在 Maven 项目中，依赖通常被定义在项目的 pom.xml 文件中。当多个依赖项引入了不同版本的相同库时，就会发生依赖冲突。这可能是因为项目的直接依赖和间接依赖导致了同一库的多个版本存在于类路径中。每个显式声明的类包都会依赖于一些其它的隐式类包，这些隐式的类包会被maven间接引入进来，从而造成类包冲突。

3-2 依赖冲突解决方案

Maven可以通过以下途径解决依赖冲突。

1）版本锁定

在父工程中使用dependencyManagement 进行版本锁定，dependencyManagement可以统一管理整个项目的版本号，确保应用的各个项目的依赖和版本一致。 dependencyManagement只是声明依赖，并不自动实现引入，因此子项目需要显示的声明需要用的依赖，便可以忽略版本号。如果排斥父工程中定义的版本号，可以显示的进行版本号声明。

2）短路径优先

3）声明优先

如果存在短路径，则优先选择短路径，如果路径相同的情况下，先声明者优先，POM 文件中依赖声明的顺序决定了间接依赖会不会被解析使用，顺序靠前的优先使用。如图。

注意去掉<scope>标签，否则会因为依赖范围的影响导致效果无法显示。

4）特殊优先（后来者居上）

同一个pom.xml文件中进行了多次依赖jar包不同版本的配置，后面的覆盖前面的配置。这种情况比较少见

5）可选依赖

maven_03项目可选择是否传递间接依赖junit_4.13，主动权在当前项目maven_03中。

如果当前项目被依赖到其它项目中，当前项目可以拒绝交出间接依赖项。

例如maven_02添加了maven_03的依赖，maven_03可以自主设置其依赖项junit_4.13是否被间接传递。<optional>true</optional> 为不传递间接依赖，那么在maven_02项目中就没有junit_4.13的依赖。

默认是false，是传递间接依赖。

6）排除依赖

是当前项目是否主动断开其依赖项目的间接依赖。也就是控制当前项目是否使用其直接依赖传递下来的接间依赖。在maven_02项目中添加maven_03项目的依赖，但不要maven_03项目中的junit_4.13的依赖，可以选择排除依赖。这样可以保证当前项目依赖的纯净性。

排除依赖使用 exclusions 元素排除依赖，说明如下：

exclusions 元素下可以包含若干个 exclusion 子元素，用于排除若干个间接依赖，该元素包含两个子元素：groupId 和 artifactId，用来确定需要排除的间接依赖的坐标信息
exclusion 元素中只需要设置 groupId 和 artifactId 就可以确定需要排除的依赖，无需指定版本version

如图

7）可选依赖和排除依赖的区别

排除依赖和可选依赖都能在项目中将间接依赖排除在外，但两者实现机制却完全不一样。

可选依赖是自己决定是否向外提供间接依赖（maven_03设置拒绝提供间接依赖junit）
排除依赖是主动拒绝添加直接依赖关联的间接依赖（maven_02项目设置排除maven_03的junit依赖）
可选依赖的优先级高于排除依赖
若对于同一个间接依赖同时使用排除依赖和可选依赖进行设置，那么可选依赖的取值必须为 false，否则排除依赖无法生效。

如果用一个生活中的例子可能更易懂一些。

国民党（maven_02)抓住了共产党人（依赖了maven_03）,要求供出联系人名单（maven_03中依赖的junit_4.13)，最终结果是没有得到联系人名单（不依赖jjunit_4.13)。

可选依赖：是maven_03共产党人死活不说联系人的名单junit_4.13（可选，我选择不说）。

排除依赖：是maven_02国民党不要共产党人提供的联系人名单（排除，我就是不要你的名单, 估计你是乱说的）。

4-刷新依赖的八种方式

5-资源文件的指定

src/main/java 和 src/test/java 这两个目录中的所有*.java 文件会分别在 comile 和 test-comiple 阶段被编译，编译结果分别放到了 target/classes 和 targe/test-classes 目录中，但是这两个目录中的其他文件(后缀是.properties或.xml等文件)都会被忽略掉(编译后丢失)，如果需要把 src 目录下的除.java之外的文件包放到 target/classes 目录，作为输出的 jar 一部分。需要指定资源文件位置。以下内容放到<build>标签中。简单来说就是在resources目录下的*.properties文件和*.xml文件编译时不丢失,但resources目录外的*.properties文件和*.xml文件会丢失,所以要指定位置,保证编译后文件都在.

【指定代码】

<build>
        <resources>
            <resource>
                <!--指定java目录下的所有路径下的所有文件-->
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <!--指定resources目录下的所有路径下的所有文件-->
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>

一般情况下,会两个目录都指定.

五、Maven工程的继承和聚合

1-什么是继承

Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。继承可

以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作。

【子工程可以继承父工程的元素】

父工程示例

<modelVersion>4.0.0</modelVersion>
<groupId>com.bjpowernode</groupId>
<artifactId>maven_parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包方式必须是pom,声明是父工程-->
<packaging>pom</packaging>

<!--聚合子模块-->
<modules>
  <module>maven_son</module>
  <module>maven_web</module>
</modules>

<properties>
  <!--定义属性，便于版本的管理-->
  <spring-version>5.3.24</spring-version>
  <servlet-version>4.0.1</servlet-version>
</properties>

<!--只是定义，并没有真正的添加依赖，子工程根据需要有选择的添加依赖-->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <!--引用定义好的属性-->
      <version>${spring-version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-version}</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <pluginManagement>
    <plugins>
      <!--只定义Tomcat插件 -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8089</port>
          <url>/</url>
        </configuration>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

子工程示例

<modelVersion>4.0.0</modelVersion>
<parent>
  <groupId>com.bjpowernode</groupId>
  <artifactId>maven_parent</artifactId>
  <version>1.0-SNAPSHOT</version>
</parent>
<!--可以省略groupId和version，因为与父工程保持一致-->
<artifactId>maven_web</artifactId>
<packaging>war</packaging>

<!--需要什么依赖，添加什么依赖，可以省略版本号，版本由父工程统一管理 -->
<dependencies>
  <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  </dependency>
  <dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  </dependency>
</dependencies>

<build>
  <plugins>
    <!--配置Tomcat插件 -->
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.2</version>
      <!--子工程可以自定义端口号，不自定义使用父工程的-->
      <configuration>
        <port>8060</port>
        <url>/</url>
      </configuration>
    </plugin>
  </plugins>
</build>

2-什么是聚合

使用 Maven 聚合功能对项目进行构建时，需要在该项目中额外创建一个的聚合模块，然后通过这个模块构建整个项目的所有模块。聚合模块仅仅是帮助聚合其他模块的工具，其本身并无任何实质内容，因此聚合模块中只有一个 POM 文件，不包含 src 等目录。

与父模块相似，聚合模块的打包方式（packaging）也是 pom，用户可以在其 POM 中通过 modules 下的 module 子元素来添加需要聚合的模块的目录路径。父模块的 pom.xml 文件的 <modules> 把子模块聚集起来.

<modelVersion>4.0.0</modelVersion>

<groupId>com.bjpowernode</groupId>
<artifactId>maven_ju</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>

<modules>
  <module>../maven_02</module>
  <module>../maven_03</module>
  <module>../maven_01</module>
  <module>../maven_parent</module>
</modules>

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO] 
[INFO] maven_03                                                           [jar]
[INFO] maven_02                                                           [jar]
[INFO] maven_01                                                           [jar]
[INFO] maven_parent                                                       [pom]
[INFO] maven_son                                                          [jar]
[INFO] maven_web                                                          [war]
[INFO] maven_ju                                                           [pom]
[INFO] 
......
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ maven_03 ---
[INFO] Surefire report directory: E:\BJ2310\10-Maven\04_project\mavenall\maven_03\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running test.MyTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.068 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] 
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ maven_03 ---
[INFO] Building jar: E:\BJ2310\10-Maven\04_project\mavenall\maven_03\target\maven_03-1.0-SNAPSHOT.jar
[INFO] 
[INFO] ----------------------< com.bjpowernode:maven_02 >----------------------
[INFO] Building maven_02 1.0-SNAPSHOT                                     [2/7]
[INFO]   from ..\maven_02\pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ maven_02 ---
......
Running test.MyTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.055 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] 
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ maven_02 ---
[INFO] Building jar: E:\BJ2310\10-Maven\04_project\mavenall\maven_02\target\maven_02-1.0-SNAPSHOT.jar
[INFO] 
[INFO] ----------------------< com.bjpowernode:maven_01 >----------------------
[INFO] Building maven_01 1.0-SNAPSHOT                                     [3/7]
[INFO]   from ..\maven_01\pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ maven_01 ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 0 resource
[INFO] 
.......
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ maven_01 ---
[INFO] No tests to run.
[INFO] 
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ maven_01 ---
[INFO] Building jar: E:\BJ2310\10-Maven\04_project\mavenall\maven_01\target\maven_01-1.0-SNAPSHOT.jar
[INFO] 
[INFO] --------------------< com.bjpowernode:maven_parent >--------------------
[INFO] Building maven_parent 1.0-SNAPSHOT                                 [4/7]
[INFO]   from ..\maven_parent\pom.xml
[INFO] --------------------------------[ pom ]---------------------------------
[INFO] 
[INFO] ---------------------< com.bjpowernode:maven_son >----------------------
[INFO] Building maven_son 1.0-SNAPSHOT                                    [5/7]
[INFO]   from ..\maven_parent\maven_son\pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
......
[INFO] 
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ maven_son ---
[INFO] Building jar: E:\BJ2310\10-Maven\04_project\mavenall\maven_parent\maven_son\target\maven_son-1.0-SNAPSHOT.jar
[INFO] 
[INFO] ---------------------< com.bjpowernode:maven_web >----------------------
[INFO] Building maven_web 1.0-SNAPSHOT                                    [6/7]
[INFO]   from ..\maven_parent\maven_web\pom.xml
[INFO] --------------------------------[ war ]---------------------------------
[INFO] 
.......
[INFO] ----------------------< com.bjpowernode:maven_ju >----------------------
[INFO] Building maven_ju 1.0-SNAPSHOT                                     [7/7]
[INFO]   from pom.xml
[INFO] --------------------------------[ pom ]---------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary for maven_ju 1.0-SNAPSHOT:
[INFO] 
[INFO] maven_03 ........................................... SUCCESS [  2.506 s]
[INFO] maven_02 ........................................... SUCCESS [  0.609 s]
[INFO] maven_01 ........................................... SUCCESS [  0.083 s]
[INFO] maven_parent ....................................... SUCCESS [  0.000 s]
[INFO] maven_son .......................................... SUCCESS [  0.127 s]
[INFO] maven_web .......................................... SUCCESS [  1.043 s]
[INFO] maven_ju ........................................... SUCCESS [  0.002 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  4.543 s
[INFO] Finished at: 2024-03-16T00:07:25+08:00
[INFO] ------------------------------------------------------------------------

总结：一句话，聚合就是集中构建项目的。

六、Maven的私服

1-什么是私服

Maven 私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的远程仓库（中央仓库、其他远程公共仓库）。一些无法从外部仓库下载到的构件，也能从本地上传到私服供其他人使用。

Maven 私服其实并不是 Maven 的核心概念，它仅仅是一种衍生出来的特殊的仓库，但这并不代表它不重要，相反由于私服具有降低中央仓库负荷、节省外网带宽、以及提高项目稳定性等优点，使得私服在实际开发过程中得到了相当普遍地使用。建立了 Maven 私服后，当局域网内的用户需要某个构件时，会先请求本地仓库，若本地仓库不存在所需构件，则请求 Maven 私服，将所需构件下载到本地仓库，若私服中不存在所需构件，再去请求外部的远程仓库，将所需构件下载并缓存到 Maven 私服，若外部远程仓库不存在所需构件，则 Maven 直接报错。

2-Maven仓库管理器Nexus

1）什么是Nexus

Nexus 是 Sonatype 公司发布的一款仓库（Repository）管理软件，常用来搭建 Maven 私服，所以也有人将 Nexus 称为“Maven仓库管理器”。 Sonatype Nexus 是当前最流行，使用最广泛的 Maven 仓库管理器。Nexus 分为开源版和专业版，其中开源版足以满足大部分 Maven 用户的需求。

2）Nexus仓库的类型

Nexus默认内置了很多仓库，这些仓库可以划分为3种类型，每种类型的仓库用于存放特定的jar包，具体说明如下：

hosted：宿主仓库，部署自己的jar包到这个类型的仓库中，包括Releases和Snapshots两部分，Releases为公司内部发行版本仓库，Snapshots为公司内部测试版本仓库。
proxy：代理仓库，用于代理远程的公共仓库，如Maven中央仓库，用户连接私服，私服自动去中央仓库下载Jar包或者插件。
group：仓库组，用来合并多个hosted/proxy仓库，通常用于配置自己的Maven连接仓库组。当我们下载jar包时，从仓库组中的每个仓库找一遍，找到后下载。

3）如何搭建私服

下载Nexus

官网地址：Download

3-Nexus私服的应用

1）登录

2）设置仓库

1.创建仓库

3）使用Nexus下载jar包

创建一个新的本地仓库，用来接收Nexus下载下来的jar包。

因为要使用Maven工具访问私服，所以settings.xml文件要修改。

本地仓库地址修改为新地址

4）使用Idea部署jar包到Nexus私服

私服Nexus是部署在局域网的，是全公司共享的仓库地址，每个团队都可以将已完成的功能或测试版本发布到私服供别人来使用。

打开要部署的项目的pom.xml文件，设置上传路径

<distributionManagement>
  <repository>
    <id>dljd-nexus</id>
    <url>http://localhost:8081/repository/dljd-release/</url>
  </repository>
  <snapshotRepository>
    <id>dljd-nexus</id>
    <url>http://localhost:8081/repository/dljd-snapshot/</url>
  </snapshotRepository>
</distributionManagement>

七、清理错误缓存

@echo off
set REPOSITORY_PATH=D:\software\profession\repository  //替换成自己的路径
rem 正在搜索...
for /f "delims=" %%i in ('dir /b /s "%REPOSITORY_PATH%\*lastUpdated*"') do (
    del /s /q %%i
)
rem 搜索完毕
pause

Maven总结

总结：整个Maven工具的应用就讲完了。其中一二三章是基础应用，四五六章是高级应用，工作时遇到的问题四五六章有解决方案，到时候再看也来得及。

如果写的不好的地方，欢迎大家提提意见

我很菜所以我要多练

关注

14
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
一篇文章彻底搞懂Maven

POM(Project Object Model)项目对象模型，它是Maven的核心组件。它是Maven中的基本工作单元。它是一个xml文件，以pom.xml驻留在项目的根目录中。POM不仅包含有关项目的信息及Maven用于构建项目的各种配置的详细信息，还包含目标和插件。--添加父工程的引用--><parent></parent>--本项目的身份证号gav-->--打包方式-->--集中定义依赖版本号,使用属性-->--mysql驱动的依赖-->--添加依赖--><build>
复制链接

扫一扫