Maven

已于 2022-11-04 21:17:05 修改
阅读量623 收藏 1
点赞数
分类专栏： JavaEE 文章标签： maven java jar
于 2022-11-04 21:13:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Libra_97/article/details/127696442
版权

Maven

1.为什么要使用maven

之所以会提出这个问题，是因为即使不使用Maven我们仍然可以进行B/S结构项目的开发。从表述层、业务逻辑层到持久化层再到数据库都有成熟的解决方案——不使用Maven我们一样可以开发项目啊？所以我们有必要通过企业开发中的实际需求来看一看哪些方面是我们现有技术的不足。

1.1 获取第三方jar包

开发中需要使用到的jar包种类繁多，获取jar包的方式都不尽相同。为了查找一个jar包找遍互联网，身心俱疲。不仅如此，费劲心血找到的jar包里有的时候并没有你需要的那个类，又或者有同名的类没有你要的方法——以不规范的方式获取的jar包也往往是不规范的。

*使用Maven**我们可以享受到**一个**完全**统一**规范的**jar**包管理**体系*****。****你只需要在你的项目中以坐标的方式依赖一个jar包，Maven就会自动从中央仓库进行下载，并同时下载这个jar包所依赖的其他jar包——规范、完整、准确！一次性解决所有问题！

1.2 添加第三方jar包

在今天开发领域，有大量的第三方框架和工具可以供我们使用。要使用这些jar包最简单的方法就是复制粘贴到WEB-INF目录下的lib目录下。但是这会导致每次创建一个新的工程就需要将jar包重复复制到lib目录下，从而造成工作区中存在大量重复的文件。

*而**使用Maven后**每个**jar包**只**在本地仓库中**保存**一份，**需要**jar**包**的**工程**只需要**维护**一个**文本**形式的jar包的引用——**我们**称之为**“坐标”*****。****不仅极大的节约了存储空间，让项目更轻巧，更避免了重复文件太多而造成的混乱。

1.3 jar包之间的依赖关系

jar包往往不是孤立存在的，很多jar包都需要在其他jar包的支持下才能够正常工作，我们称之为jar包之间的依赖关系。最典型的例子是：commons-fileupload-1.3.jar依赖于commons-io-2.0.1.jar，如果没有IO包，FileUpload包就不能正常工作。

那么问题来了，你知道你所使用的所有jar包的依赖关系吗？当你拿到一个新的从未使用过的jar包，你如何得知他需要哪些jar包的支持呢？如果不了解这个情况，导入的jar包不够，那么现有的程序将不能正常工作。再进一步，当你的项目中需要用到上百个jar包时，你还会人为的，手工的逐一确认它们依赖的其他jar包吗？这简直是不可想象的。

*而**引入Maven后，**Maven**就可以替我们自动的将当前jar包所依赖的其他所有jar包全部导入进来，**无需**人工参与，**节约**了我们大量的**时间*****和精力。****用实际例子来说明就是：通过Maven导入commons-fileupload-1.3.jar后，commons-io-2.0.1.jar会被自动导入，程序员不必了解这个依赖关系。

1.4 处理jar包之间的冲突

上一点说的是jar包不足项目无法正常工作，但其实有的时候jar包多了项目仍然无法正常工作，这就是jar包之间的冲突。

举个例子：我们现在有三个工程MakeFriend、HelloFriend、和Hello。MakeFriend依赖HelloFriend，HelloFriend依赖Hello。而Hello依赖log4j.1.2.17.jar，HelloFriend依赖log4j.1.2.14.jar。如下图所示：
在这里插入图片描述

那么MakeFriend工程的运行时环境中该导入log4j.1.2.14.jar呢还是log4j.1.2.17.jar呢？

这样的问题一个两个还可以手工解决，但如果系统中存在几十上百的jar包，他们之间的依赖关系会非常复杂，几乎不可能手工实现依赖关系的梳理。

*使用**Maven就可以自动的**处理**jar包**之间*****的冲突问题。****因为Maven中内置了两条依赖原则：最短路径者优先和先声明者优先，上述问题MakeFriend工程会自动使用log4j.1.2.14.jar。

1.5 将项目拆分成多个工程模块

随着JavaEE项目的规模越来越庞大，开发团队的规模也与日俱增。一个项目上千人的团队持续开发很多年对于JavaEE项目来说再正常不过。那么我们想象一下：几百上千的人开发的项目是同一个Web工程。那么架构师、项目经理该如何划分项目的模块、如何分工呢？这么大的项目已经不可能通过package结构来划分模块，必须将项目拆分成多个工程协同开发。多个模块工程中有的是Java工程，有的是Web工程。

那么工程拆分后又如何进行互相调用和访问呢？这就需要用到Maven的依赖管理机制。大家请看调查项目拆分的情况：
在这里插入图片描述

下层模块依赖上层，所以上层模块中定义的API都可以为下层所调用和访问。

1.6 实现项目的分布式部署

在实际生产环境中，项目规模增加到一定程度后，可能每个模块都需要运行在独立的服务器上，我们称之为分布式部署，这里同样需要用到Maven。

在这里插入图片描述

2.Maven是什么？

在这里插入图片描述

如果上面的描述能够使你认识到使用Maven是多么的重要，我们下面就来介绍一下Maven是什么。

2.1 自动化构建工具

  • Maven这个单词的本意是：专家，内行。读音是['meɪv(ə)n]或['mevn]，不要读作“妈文”。

  • Maven是一款自动化构建工具，专注服务于Java平台的项目构建和依赖管理。在JavaEE开发的历史上构建工具的发展也经历了一系列的演化和变迁：

​ Make→Ant→Maven→Gradle→其他……

2.2 构建的概念

构建并不是创建，创建一个工程并不等于构建一个项目。*构建是一个过程*，就是以我们编写的Java代码、框架配置文件、国际化等其他资源文件、JSP页面和图片等静态资源作为“原材料”，去**“生产”出一个可以运行的项目**的过程。

那么项目构建的全过程中都包含哪些环节呢？

2.3 构建环节

  • 清理：删除以前的编译结果，为重新编译做好准备。
  • 编译：将Java源程序编译为字节码文件。
  • 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
  • 报告：在每一次测试后以标准的格式记录和展示测试结果。
  • 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java工程对应jar包，Web工程对应war包。
  • 安装：在Maven环境下特指将打包的结果——jar包或war包安装到本地仓库中。
  • 部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。

在这里插入图片描述

3.maven如何使用

3.1 安装Maven核心程序

\1) 下载地址：http://maven.apache.org/

\2) 检查JAVA_HOME环境变量。Maven是使用Java开发的，所以必须知道当前系统环境中JDK的安装目录。

C:\Users\86152>echo %JAVA_HOME%D:\Java\jdk1.8.0_111

\3) 解压Maven的核心程序。

将apache-maven-3.6.3-bin.zip解压到一个非中文无空格的目录下。例如：

D:\installation\apache-maven-3.5.4

\4) 配置环境变量。

MAVEN_HOME
D:\installation\apache-maven-3.5.4
path
%MAVEN_HOME%\bin

\5) 查看Maven版本信息验证安装是否正确

C:\Users\86152>mvn -v
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-18T02:33:14+08:00)
Maven home: D:\maven\apache-maven-3.5.4\bin\..
Java version: 1.8.0_131, vendor: Oracle Corporation, runtime: C:\Program Files\Java\jdk1.8.0_131\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

在这里插入图片描述

3.2 第一个Maven程序

3.2.1 Maven约定的目录结构及说明

在这里插入图片描述

main目录用于存放主程序。

test目录用于存放测试程序。

java目录用于存放源代码文件。

resources目录用于存放配置文件和资源文件。

3.2.2 通过命令行的方式运行maven程序

\1) 在电脑的任意位置创建Hello目录（文件夹）

\2) 在Hello目录中创建src目录和pom.xml文件

\3) 在src目录中创建main和test目录

\4) 在main和test目录中分别创建java和resources目录

\5) 将以下内容复制到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.atguigu.maven</groupId>
    <artifactId>HelloMaven</artifactId>
    <version>1.0-SNAPSHOT</version>

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

</project>

\6) 编写主程序

在src/*main*/java目录下新建文件Hello.java

public class Hello {
    public String sayHello(String name){
        return "Hello "+name+"!";
    }
}

\7) 编写测试程序

在/src/*test*/java目录下新建测试文件HelloTest.java

import org.junit.Test;

public class HelloTest {

    @Test
    public void testHello(){
        Hello hello = new Hello();
        String maven = hello.sayHello("Maven");
        System.out.println(maven);
    }
}

\8) 运行以下常用的Maven命令

打开cmd命令行，进入Hello项目根目录(pom.xml文件所在目录)执行mvn compile命令，查看根目录变化
cmd 中继续录入mvn clean命令，然后再次查看根目录变化
cmd 中录入 mvn  compile命令, 查看根目录变化
cmd 中录入 mvn  test-compile命令， 查看target目录的变化
cmd 中录入 mvn  test命令，查看target目录变化
cmd 中录入 mvn  package命令,查看target目录变化
cmd 中录入 mvn  install命令， 查看本地仓库的目录变化

*注意：运行Maven命令时一定要进入pom.xml文件所在的目录！*

3.3 配置本地仓库

maven的解压目录下
  conf
    settings.xml
       定义一个本地仓库的位置 路径全英文
      <localRepository>D:\software\maven\Repository</localRepository>

3.4 配置阿里镜像

maven的解压目录下
  conf
    settings.xml
          找到mirros 在标签内部
     <mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
     </mirror>

3.5 在idea中使用Maven

3.5.1 在idea中配置maven

在这里插入图片描述

3.5.2 在idea中创建maven项目

  • 点击File→New→Module…（如果之前没有Project选Project）→Maven
    在这里插入图片描述

  • 点击Next，配置要继承的模块（如果直接创建的是Project不存在这一项）、坐标（GAV）、路径。不同的Idea版本可能有所差别

在这里插入图片描述

  • 点击Finish即可创建成功
  • 配置Maven的核心配置文件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.atguigu.maven</groupId>
    <artifactId>day42Maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
<!--            compile: main  test  打包到web-inf 下  而且可以依赖传递  默认-->
<!--            test: test用 不会打包 不会传递-->
<!--            privoted: main test  不会打包  不会传递-->
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>
  • 编写主代码

​ src/main/java目录下新建文件Hello.java

package com.atguigu;

public class Hello {

    public String sayHello(String message){
        return "hello" + message + "!";
    }
}
  • 编写测试代码

​ 在/src/test/java目录下新建测试文件HelloTest.java

package com.atguigu;

import org.junit.Test;

public class HelloTest {

    @Test
    public void test(){
        Hello hello = new Hello();
        String s = hello.sayHello("zs");
        System.out.println("s = " + s);
    }
}
  • 使用Maven的方式运行Maven工程

在这里插入图片描述

4.Maven的核心概念

4.1 核心概念

\1) POM

\2) 约定的目录结构

\3) 插件和目标

\4) 生命周期

\5) 仓库

\6) 坐标

\7) 依赖

\8) 继承

\9) 聚合

4.2 POM

Project Object Model：项目对象模型。将Java工程的相关信息封装为对象作为便于操作和管理的模型。Maven工程的核心配置。可以说学习Maven就是学习pom.xml文件中的配置。

4.3 约定的目录结构

现在JavaEE开发领域普遍认同一个观点：约定>配置>编码。意思就是能用配置解决的问题就不编码，能基于约定的就不进行配置。而Maven正是因为指定了特定文件保存的目录才能够对我们的Java工程进行自动化构建。

目录结构含义参见前面的描述。

4.4 插件和目标

\1) Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。

\2) 每个插件都能实现多个功能，每个功能就是一个插件目标。

\3) Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务。

例如：compile就是插件maven-compiler-plugin的一个功能；pre-clean是插件maven-clean-plugin的一个目标。

4.5 生命周期

1)什么是Maven的生命周期？
Maven生命周期定义了各个构建环节的执行顺序，有了这个清单，Maven就可以自动化的执行构建命令了。
Maven有三套相互独立的生命周期，分别是： 
Clean Lifecycle在进行真正的构建之前进行一些清理工作。
Default Lifecycle构建的核心部分，编译，测试，打包，安装，部署等等。
Site Lifecycle生成项目报告，站点，发布站点。
再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。

每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean，这个clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。

2)clean生命周期
Clean生命周期一共包含了三个阶段：
pre-clean 执行一些需要在clean之前完成的工作 
clean 移除所有上一次构建生成的文件 
post-clean 执行一些需要在clean之后立刻完成的工作 

3)Site生命周期
	pre-site 执行一些需要在生成站点文档之前完成的工作
	site 生成项目的站点文档
	post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
	site-deploy 将生成的站点文档部署到特定的服务器上
这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

4)Default生命周期
Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
validate
generate-sources
process-sources
generate-resources
process-resources 复制并处理资源文件，至目标目录，准备打包。
compile 编译项目的源代码。
process-classes
generate-test-sources
process-test-sources
generate-test-resources
process-test-resources 复制并处理资源文件，至目标测试目录。
test-compile 编译测试源代码。
process-test-classes
test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package
package 接受编译好的代码，打包成可发布的格式，如JAR。
pre-integration-test
integration-test
post-integration-test
verify
install将包安装至本地仓库，以让其它项目依赖。
deploy将最终的包复制到远程的仓库，以让其它开发人员与项目共享或部署到服务器上运行。

5)生命周期与自动化构建
运行任何一个阶段的时候，它前面的所有阶段都会被运行，例如我们运行mvn install 的时候，代码会被编译，测试，打包。这就是Maven为什么能够自动执行构建过程的各个环节的原因。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

4.6 仓库

\1) 分类

① 本地仓库：为当前本机电脑上的所有Maven工程服务。

② 远程仓库

[1] 私服：架设在当前局域网环境下，为当前局域网范围内的所有Maven工程服务。

在这里插入图片描述

[2]中央仓库：架设在Internet上，为全世界所有Maven工程服务。

[3]中央仓库的镜像：架设在各个大洲，为中央仓库分担流量。减轻中央仓库的压力，同时更快的响应用户请求。

\2) 仓库中的文件

① Maven的插件

② 我们自己开发的项目的模块

③ 第三方框架或工具的jar包

​ ※不管是什么样的jar包，在仓库中都是按照坐标生成目录结构，所以可以通过统一的方式查询或依赖。

4.7 坐标

\1) 几何中的坐标

[1]在一个平面中使用x、y两个向量可以唯一的确定平面中的一个点。

[2]在空间中使用x、y、z三个向量可以唯一的确定空间中的一个点。

\2) Maven的坐标

使用如下三个向量在Maven的仓库中唯一的确定一个Maven工程。

[1]groupId：公司或组织的域名倒序+当前项目名称

[2]artifactId：当前项目的模块名称

[3]version：当前模块的版本

	<groupId>com.atguigu.maven</groupId>
	<artifactId>Hello</artifactId>
	<version>1.0-SNAPSHOT</version>

\3) 如何通过坐标到仓库中查找jar包？

[1]将gav三个向量连起来

com.atguigu.maven+Hello+1.0-SNAPSHOT

[2]以连起来的字符串作为目录结构到仓库中查找

com/atguigu/maven/Hello/1.0-SNAPSHOT/Hello**-**1.0-SNAPSHOT.jar

*※注意：我们自己的Maven工程必须执行安装操作才会进入仓库。**安装**的**命令是：**mvn install*

4.8 第二个Maven工程 Hello

  • 在pom.xml配置文件中配置当前工程依赖Hello

    <?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.atguigu.maven</groupId>
    <artifactId>Hello</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>com.atguigu.maven</groupId>
            <artifactId>day42Maven</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

</project>

  • 主程序

    ​ 在src/test/java目录下新建测试文件HelloTest

    import com.atguigu.Hello;
import org.junit.Test;

public class HelloTest {

    @Test
    public void test(){
        Hello hello = new Hello();
        String zs = hello.sayHello("zs");
        System.out.println("zs = " + zs);
    }
}

  • 关键：对Hello的依赖

    这里HelloMaven就是我们的第一个Maven工程，现在HelloTest对它有依赖。那么这个依赖能否成功呢？更进一步的问题是：HelloTest会到哪里去找Hello呢？
答案是：本地仓库。任何一个Maven工程会根据坐标到本地仓库中去查找它所依赖的jar包。如果能够找到则可以正常工作，否则就不行。

4.9 依赖管理

  • 基本概念
当A jar包需要用到B jar包中的类时，我们就说A对B有依赖。例如：commons-fileupload-1.3.jar依赖于commons-io-2.0.1.jar。

通过第二个Maven工程我们已经看到，当前工程会到本地仓库中根据坐标查找它所依赖的jar包。

配置的基本形式是使用dependency标签指定目标jar包的坐标。例如：

<dependency>
    <!--坐标-->
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.0</version>
    <!--依赖的范围-->
    <scope>test</scope>
</dependency>
  • 直接依赖和间接依赖

如果A依赖B，B依赖C，那么A→B和B→C都是直接依赖，而A→C是间接依赖。

4.9.1 依赖的范围
1)compile（默认就是这个范围）
[1]main目录下的Java代码可以访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时要放在WEB-INF的lib目录下
例如：对Hello的依赖。主程序、测试程序和服务器运行时都需要用到。

2)test
[1]main目录下的Java代码不能访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
例如：对junit的依赖。仅仅是测试程序部分需要。

3)provided
[1]main目录下的Java代码可以访问这个范围的依赖
[2]test目录下的Java代码可以访问这个范围的依赖
[3]部署到Tomcat服务器上运行时不会放在WEB-INF的lib目录下
例如：servlet-api在服务器上运行时，Servlet容器会提供相关API，所以部署的时候不需要。

4)其他：runtime、import、system等。

各个依赖范围的作用可以概括为下图：

在这里插入图片描述

4.9.2 依赖的传递性

当存在间接依赖的情况时，主工程对间接依赖的jar可以访问吗？这要看间接依赖的jar包引入时的依赖范围——只有依赖范围为compile时可以访问，即依赖范围是compile时才具有传递性。例如：

Maven工程依赖范围对A的可见性
ABCcompile√
Dtest×
Eprovided×
4.9.3 依赖的原则：解决jar包冲突

\1) 路径最短者优先

在这里插入图片描述

\2) 路径相同时先声明者优先

​ 在这里插入图片描述

这里“声明”的先后顺序指的是dependency标签配置的先后顺序。

4.9.4 依赖的排除

\1) 有的时候为了确保程序正确可以将有可能重复的间接依赖排除。请看如下的例子：

假设当前工程为MakeFriend，直接依赖OurFriends。

OurFriends依赖commons-logging的1.1.1对于MakeFriend来说是间接依赖。

当前工程MakeFriend直接依赖commons-logging的1.1.2

加入exclusions配置后可以在依赖OurFriends的时候排除版本为1.1.1的commons-logging的间 接依赖

<dependency>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>OurFriends</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--依赖排除-->
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.2</version>
</dependency>
4.9.5 统一管理目标jar包的版本

以对Spring的jar包依赖为例：Spring的每一个版本中都包含spring-context，springmvc等jar包。我们应该导入版本一致的Spring jar包，而不是使用5.3.1的spring-context的同时使用5.3.2的springmvc。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.1</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.1</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.1</version>
</dependency>

问题是如果我们想要将这些jar包的版本统一升级为5.3.2，是不是要手动一个个修改呢？显然，我们有统一配置的方式：

<!--统一管理当前模块的jar包的版本-->
<properties>
    <spring.version>5.3.1</spring.version>
</properties>

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

这样一来，进行版本调整的时候只改一改地方就行了。

5.继承

5.1 为什么需要继承机制？

由于非compile范围的依赖信息是不能在“依赖链”中传递的，所以有需要的工程只能单独配置。例如：

Hello<*dependency*> <*groupId*>junit</*groupId*> <*artifactId*>junit</*artifactId*> <*version*>4.0</*version*> <*scope*>test</*scope*> </*dependency*>
HelloFriend<*dependency*> <*groupId*>junit</*groupId*> <*artifactId*>junit</*artifactId*> <*version*>4.0</*version*> <*scope*>test</*scope*> </*dependency*>
MakeFriend<*dependency*> <*groupId*>junit</*groupId*> <*artifactId*>junit</*artifactId*> <*version*>4.0</*version*> <*scope*>test</*scope*> </*dependency*>

此时如果项目需要将各个模块的junit版本统一为4.9，那么到各个工程中手动修改无疑是非常不可取的。使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。

5.2 创建父工程 parent

父工程的打包方式为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.atguigu.maven</groupId>
    <artifactId>day42parent</artifactId>
    <version>1.0-SNAPSHOT</version>
<!--    父工程打包 pom-->
    <packaging>pom</packaging>

</project>

父工程只需要保留pom.xml文件即可

5.3 在子工程中引用父工程 创建子工程son1和son2

son1的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.atguigu.maven</groupId>
    <artifactId>day42Son1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
<!--        父亲坐标-->
        <groupId>com.atguigu.maven</groupId>
        <artifactId>day42parent</artifactId>
        <version>1.0-SNAPSHOT</version>

<!--        找到父亲的pom-->
        <relativePath>../day42parent/pom.xml</relativePath>
    </parent>


</project>

son2的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.atguigu.maven</groupId>
    <artifactId>day42Son2</artifactId>
    <version>1.0-SNAPSHOT</version>


    <parent>
        <groupId>com.atguigu.maven</groupId>
        <artifactId>day42parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../day42parent/pom.xml</relativePath>
    </parent>

</project>

5.4 在父工程中管理依赖

将Parent项目中的dependencies标签，用dependencyManagement标签括起来

<?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.atguigu.maven</groupId>
    <artifactId>day42parent</artifactId>
    <version>1.0-SNAPSHOT</version>
<!--    父工程打包 pom-->
    <packaging>pom</packaging>


    <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>
    </dependencyManagement>
</project>

在子项目中重新指定需要的依赖，删除范围和版本号

son1 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.atguigu.maven</groupId>
    <artifactId>day42Son1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
<!--        父亲坐标-->
        <groupId>com.atguigu.maven</groupId>
        <artifactId>day42parent</artifactId>
        <version>1.0-SNAPSHOT</version>

<!--        找到父亲的pom-->
        <relativePath>../day42parent/pom.xml</relativePath>

    </parent>

    <!--    子项目中指定需要的依赖 不需要版本号-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

</project>

son2 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.atguigu.maven</groupId>
    <artifactId>day42Son2</artifactId>
    <version>1.0-SNAPSHOT</version>


    <parent>
        <groupId>com.atguigu.maven</groupId>
        <artifactId>day42parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../day42parent/pom.xml</relativePath>
    </parent>

<!--    子项目中指定需要的依赖 不需要版本号-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

</project>

6.聚合

6.1 为什么要使用聚合？

将多个工程拆分为模块后，需要手动逐个安装到仓库后依赖才能够生效。修改源码后也需要逐个手动进行clean操作。而使用了聚合之后就可以批量进行Maven工程的安装、清理工作。

6.2 如何配置聚合？

在总的聚合工程中使用modules/module标签组合，指定模块工程的相对路径即可

parent pom.xml

<!--    聚合项目
    如果聚合项目中有自己的子模块
    需要在子模块内 添加一个配置-->
    <modules>
        <module>../day42Son1</module>
        <module>../day42Son2</module>
        <module>../day42juhe</module>
    </modules>

Maven可以根据各个模块的继承和依赖关系自动选择安装的顺序

如果聚合项目中有自己的子模块

需要在子模块内 添加一个配置

如果是聚合项目的子模块 需要添加配置

<relativePath>../day42parent/pom.xml</relativePath>

7.通过Maven创建Web工程

  • 创建简单的Maven工程 打包方式为war包
    <groupId>com.atguigu.maven</groupId>
    <artifactId>day42web</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
  • 点击Project Structure

在这里插入图片描述

  • 选择对应的Module，添加web目录

在这里插入图片描述

  • 设置目录名称

  • 在webapp目录下创建index.html页面
    在这里插入图片描述

  • 部署到Tomcat上运行

创建servlet
在这里插入图片描述

  • 没写scope默认是compile 会将junit依赖一起跟项目打包
    在这里插入图片描述

  • 打包为war包 复制到tomcat的webapps中
    在这里插入图片描述

  • bin目录中点击startup.bat启动服务 Tomcat会自动解析war包
    在这里插入图片描述

  • 会在web-inf下生成lib目录 里面存放的是跟随项目一起打包的依赖文件
    在这里插入图片描述
    在这里插入图片描述

  • 复制模块名到浏览器打开 能够成功显示页面
    在这里插入图片描述

  • 如果scope为test或privoted，那么打包后不会在web-inf下生成lib文件
    在这里插入图片描述
    在这里插入图片描述

Libra_97
关注
专栏目录
maven实现的commons-fileupload的demo
11-18
利用servlet实现的commons-fileupload的实例。也就是文件上传实例。
maven的简介
weixin_30922589的博客
07-24 241
Java课程系列之Maven 尚硅谷Java研究院 版本：V1.0 第一章 Why Maven是干什么用的？这是很多同学在学完这个课程后最大的问题。之所以会提出这个问题，是因为即使不使用Maven我们仍然可以进行B/S结构项目的开发。从表述层、业务逻辑层到持久化层再到数据库都有成熟的解决方案——不使用Maven我们一样可以开发项目啊？所以我们有必要通过企业开发中...
Maven知识必知必会，看完你就明白
Remix_xy的博客
05-13 686
Maven一、 为什么使用Maven二、什么是Maven三、Maven的使用（重点掌握）四、Maven核心概念五、Maven的继承– 注意事项： Maven中的继承是针对 Maven工程之间的继承，父工程可以统一管理一些事物，子工程就可以继承的方式获取父工程的资源。六、Maven中的聚合概念：在Maven管理项目的前提下，并且建立好父子工程结构下，我们通常在父工程中将子工程聚集到一起，进行统一的管理操作。最终实现一键式管理多个Maven的项目的目的。Maven是干什么用的？
Maven的入门
Princess_Y
11-27 656
文章目录Maven的入门第1章 为什么要使用Maven1.1 获取第三方jar包1.2 添加第三方jar包1.3 jar包之间的依赖关系1.4 处理jar包之间的冲突1.5 将项目拆分成多个工程模块1.6 实现项目的分布式部署第2章 Maven 是什么？2.1 自动化构建工具2.2 构建的概念2.3 构建环节第3章 Maven 如何使用3.1 安装Maven核心程序3.2 第一个Maven程序3.2.1 Maven约定的目录结构3.2.2 通过命令行的方式运行Maven程序3.4 在Idea中使用Maven
Apache Commons FileUpload maven依赖
沧笙踏歌的博客
05-19 2421
Apache Commons是一个专注于可重用Java组件的所有方面的 Apache 项目。Apache Commons项目由三个部分组成：Commons Proper - 可重用Java组件的存储库。The Commons Sandbox - 用于Java组件开发的工作区。The Commons Dormant - 当前不活动的组件存储库。
maven项目使用commonsfileupload实现文件的上传和下载
weixin_44434951的博客
08-04 9325
pom.xml依赖 <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.1</version> </dependency> <dependency> <groupId&g
javaweb(八)文件上传
m0_53698336的博客
09-09 717
文件上传概述 文件上传实际上就是Browser (浏览器)跟 Server(服务器)的数据互动 上传：我们把需要上传的资源，发送给服务器，在服务器上保存下来。在智联招聘上填写一个完整的简历还需要上传照片呢。 下载：下载某一个资源时，将服务器上的该资源发送给浏览器。例如网络硬盘！就是用来上传下载文件的。 服务器端获取资源 浏览器在上传的过程中是将文件以流的形式提交到服务器端的，如果直接使用Servlet获取上传文件的输入流然后再解析里面的请求参数是比较麻烦，所以一般选择采用apache的开源工具common
使用commons-fileupload包实现文件上传
Rosen's
02-21 1400
首先，需要在pom文件中添加相关依赖 <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version&...
Maven仓库 版本为3.8.8
10-29
在Maven中，任何一个依赖、插件或者项目构建的输出，都可以称之为构件。 Maven在某个统一的位置存储所有项目的共享的构件，这个统一的位置，我们就称之为仓库。（仓库就是存放依赖和插件的地方） 任何的构件都有唯一...
maven-3.6.3
06-06
maven-3.6.3 官方直下，无任何修改与添加，下载后解压即可用。maven-3.6.3 官方直下，无任何修改与添加，下载后解压即可用。maven-3.6.3 官方直下，无任何修改与添加，下载后解压即可用。maven-3.6.3 官方直下，无...
maven3.8.5压缩包
03-21
maven3.8.5压缩包
maven 3.8.4 版本
03-07
maven 3.8.4 版本
maven-3.3.9
04-17
maven-3.3.9
maven项目中运行报错java.lang.ClassNotFoundException: org.apache.commons.fileupload.FileItemFactory
Abraham_Kevin的博客
08-05 1531
这个是因为fileupload的依赖包没有依赖成功。 如果不是maven项目的话，那就是fileupload的jar包没有引入成功。 maven项目，在http://mvnrepository.com/artifact/commons-fileupload/commons-fileupload/1.3.1直接将fileupload的依赖粘贴到项目的pom.xml中便可以了。 如果是wab项目，...
pom.xml中解决Provides transitive vulnerable dependency maven:org.yaml:snakeyaml:1.33警告
热门推荐
m0_54250110的博客
03-31 3万+
pom.xml中解决Provides transitive vulnerable dependency maven:org.yaml:snakeyaml:1.33警告
provides transitive vulnerable dependency maven
Abel的博客
09-09 3237
pom文件添加以下mp依赖的时候出现警告。要解决这个警告，升级版本。
springmvc-文件上传
winnifred的博客
07-19 140
文件上传客户端三要素： 1.文件上传项 2.所在表单post提交 3.表单的enctype必须是多部分表单形式"multipart/form-data" 单文件上传步骤： 1.导入pom坐标 <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version&g.
Java 文件上传与下载
S_Chen
11-04 719
注：本文章是抄袭大牛的。 依赖插件：common-fileupload与common-io JSP：       文件上传                    上传用户：         上传文件1：         上传文件2：               web.xml：     UploadHandleServlet
Maven、JavaWeb基础开发
最新发布
IT从业者，生活精致一点，工作认真一点！
05-13 265
1、标准化的项目结构2、标准化的构建流程3、依赖管理4、依赖范围。
Tabula maven
04-03
Tabula Maven是一个基于Apache Maven的开源项目，用于提取PDF文件中的表格数据。它是Tabula项目的一个扩展，Tabula是一个用于提取表格数据的工具。Tabula Maven提供了一个Maven插件，可以方便地将Tabula集成到Maven项目中。 使用Tabula Maven，你可以在Maven项目中添加Tabula依赖，并使用Tabula提供的API来提取PDF文件中的表格数据。它提供了一些配置选项，可以根据需要进行调整，例如指定要提取的页面范围、表格区域等。 Tabula Maven的使用步骤如下： 1. 在Maven项目的pom.xml文件中添加Tabula Maven插件的依赖。 2. 配置Tabula Maven插件，指定要提取的PDF文件路径、输出文件路径等。 3. 运行Maven命令，执行Tabula Maven插件。 Tabula Maven的优点是它能够方便地与Maven项目集成，使得在项目中使用Tabula更加便捷。同时，Tabula本身也是一个功能强大的表格提取工具，支持多种表格布局和格式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值