Skip to main content

MAVEN

一个jar包的依赖和管理工具。

http://maven.apache.org/

jar包在 http://mvnrepository.com/

主要功能

依赖管理

引用中央(远程)仓库的jar包,只需要维护一个 配置文件 pom.xml ,这个文件就是描述整个项目中的jar包依赖。
如果是离线环境,需要维护一个(本地)仓库,如果本地仓库中没有会从镜像仓库中下载,下载之后使用本地仓库使用。

构建自动化

自动编译,自动单元测试,自动安装

安装

一个软件,解压缩就能够使用,不要有中文和空格

需要从maven的官网下载maven的安装包 apache-maven-3.3.9-bin.zip

解压安装包,解压到一个目录,非中文目录。

子目录 bin :执行程序,主要是mvn.cmd

conf :maven工具本身的配置文件 settings.xml

配置,打开conf/中的一个 setting.xml 文件。

// 配置文件-本地仓库地址
搜索关键字 localRepository D:\maven-repository 为本地仓库路径
<localRepository>D:\maven-repository</localRepository>
指定你自己电脑上 Maven 下载 jar 包的存储目录
默认是在:
C:\Users\你的用户名\.m2\repository
// 配置镜像仓库地址
搜索关键字 mirrors
<mirrors>
<!-- 阿里云仓库 -->
<mirror>
<id>alimaven</id>
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
</mirror>


<!-- 中央仓库1 -->
<mirror>
<id>repo1</id>
<mirrorOf>central</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://repo1.maven.org/maven2/</url>
</mirror>


<!-- 中央仓库2 -->
<mirror>
<id>repo2</id>
<mirrorOf>central</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://repo2.maven.org/maven2/</url>
</mirror>
</mirrors>

// 配置maven工程的基础JDK版本
搜索关键字 配置profiles

<profiles>
<profile>
<id>jdk-1.8</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.8</jdk>
</activation>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
</properties>
</profile>
</profiles>

配置环境变量,配置Java_Home;


配置Maven_Home;

在系统的环境变量中,指定一个M2_HOME的名称, 指定它的值是maven工具安装目录,bin之前的目录

D:\Software\apache-maven-3.9.11

配置Maven的PATH;

把 maven 的 bin目录放在Path中即可

再把M2_HOME加入到path之中,在所有路径之前加入 %M2_HOME%\bin;

验证Maven

// cmd 页面中输入
验证,新的命令行中,执行mvn -v

生命周期

1.清理, 把之前项目编译的东西删除掉,我新的编译代码做准备。
2.编译, 把程序源代码编译为执行代码, java-class文件
批量的,maven可以同时把成千上百的文件编译为class
javac 不一样,javac一次编译一个文件。
3.测试, maven可以执行测试程序代码,验证你的功能是否正确。
批量的,maven同时执行多个测试代码,同时测试很多功能。
4.报告, 生成测试结果的文件, 测试通过没有。
5.打包, 把你的项目中所有的class文件,配置文件等所有资源放到一个压缩文件中。
这个压缩文件就是项目的结果文件, 通常java程序,压缩文件是jar扩展名的。
对于web应用,压缩文件扩展名是.war
6.安装, 把5中生成的文件jar,war安装到本机仓库
7.部署, 把程序安装好可以执行。

核心概念

POM : 一个文件 名称是pom.xml ,  pom翻译过来叫做项目对象模型。 
maven把一个项目当做一个模型使用。控制maven构建项目的过程,管理jar依赖。

②约定的目录结构 : maven项目的目录和文件的位置都是规定的。
③坐标 : 是一个唯一的字符串,用来表示资源的。
④依赖管理 : 管理你的项目可以使用jar文件
⑤仓库管理(了解) :你的资源存放的位置
⑥生命周期 (了解) : maven工具构建项目的过程,就是生命周期。
⑦插件和目标(了解):执行maven构建的时候用的工具是插件
⑧继承
⑨聚合

讲maven的使用,先难后易的。 难是说使用maven的命令,完成maven使用 , 在idea中直接使用maven,代替命令。

基本使用

pom文件

1)坐标:唯一值, 在互联网中唯一标识一个项目的
<groupId>公司域名的倒写</groupId>
<artifactId>自定义项目名称</artifactId>
<version>自定版本号</version>
https://mvnrepository.com/ 搜索使用的中央仓库, 使用groupId 或者 artifactId作为搜索条件


2) packaging: 打包后压缩文件的扩展名,默认是jar ,web应用是war
packaging 可以不写, 默认是jar


3) 依赖
dependencies 和dependency,相当于是java代码中import
你的项目中要使用的各种资源说明, 比我的项目要使用mysql驱动
这样指定依赖项之后,如果在本机仓库中找到这个jar包,加到你的项目中就可以使用了

<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
</dependencies>

4)properties:设置属性
5)build : maven在进行项目的构建时, 配置信息,例如指定编译java代码使用的jdk的版本等

添加依赖

<!-- log4j日志依赖 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>

<!-- junit单元测试依赖 -->

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

<!-- java Servlet API -->
<!-- 从maven仓库搜索 -->
<dependency>
<scope>provided</scope>
</dependency>

依赖程度

scope的取值

Maven 依赖 scope 的全部取值

scope编译测试运行打入 war/jar常见用途
compile(默认)普通依赖,如工具包、数据库驱动(若需打包)
providedServlet / Tomcat / JDK 自带依赖,不打包
runtime运行时需要,如 JDBC 驱动
test单元测试,如 JUnit、Mockito
system本地 jar 包,已经不推荐

常用命令

Maven提供一个项目构建的模型,把编译、测试、打包、部署等都对应成一个个的生命周期阶段, 并对每一个阶段提供相应的命令,程序员只需要掌握一小堆命令,就可以完成项目的构建过程。

// 清理 (会删除原来编译和测试的目录,即 target目录,但是已经 install到仓库里的包不会删除 )
mvn clean

//编译主程序 (会在当前目录下生成一个 target,里边存放编译主程序之后生成的字节码文件 )
mvn compile

// 编译测试程序 (会在当前目录下生成一个 target,里边存放编译测试程序之后生成的字节码文件 )
mvn test-compile

// 测试 (会生成一个目录 surefire reports,保存测试结果 )
mvn test

// 打包主程序 (会编译、编译测试、测试、并且按照 pom.xml配置把主程序打包生成 jar包或者 war包 )
mvn package

// 安装主程序 (会把本工程打包好的jar包例如 ssm.jar,并且按照本工程的坐标保存到本地仓库中,然后在另一个项目中使用 )
mvn install

// 部署主程序 (会把本工程打包,按照本工程的坐标保存到本地库中,并且还会保存到私服仓库中。还会自动把项目部署到 web容器中 )。

mvn deploy

注意:执行以上命令必须在命令行进入pom.xml所在目录!
执行后边的命令前边的命令会自动执行

依赖的传递性

pro01的pom文件依赖mysql5.7.1,同时scope的取值是compile,pro02的pom文件依赖pro01,这样pro02就可以依赖mysql5.7.1这叫做依赖的传递性。

依赖传递:A 依赖 B,B 依赖 C,则 A 自动依赖 C。

传递的前提:依赖的 scope 必须是 compile 或 runtime。

依赖的排除

pro01的pom文件依赖mysql5.7.1,pro02的pom依赖mysql8.0,同时依赖pro01,这样pro02就可能同时依赖mysql5.7.1和mysql8.0,这时可以在 pro02 中添加依赖 pro01的时候添加排除mysql5.7.1

<dependency>
<groupId>com.example</groupId>
<artifactId>pro01</artifactId>
<version>1.0-SNAPSHOT</version>

<!-- 排除 pro01 传递过来的 mysql 5.7.1 -->
<exclusions>
<exclusion>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</exclusion>
</exclusions>
</dependency>

<!-- pro02 自己使用 mysql 8.0 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.34</version>
</dependency>

插件使用

maven构建周期,由maven的插件plugin来执行完成;

官方插件说明:http://maven.apache.org/plugins/

在项目根目录下执行:mvn clean install

image-20251120162952216

image-20251120163001930

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven compiler plugin</artifactId> <version>3.8.13.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

IDEA集成Mavne

在idea中设置maven,让idea和maven结合使用

idea中内置了maven,一般不使用内置的,因为用内置修改maven的设置不方便

使用自己安装的maven,需要覆盖idea中的默认的设置,让idea指定maven安装位置信息

file--settings---Build, Excution,Deployment--Build Tools--Maven
或者直接搜索 maven

Maven Home directory: maven的安装目录
User Settings File : 就是maven安装目录conf/setting.xml配置文件
Local Repository : 本机仓库的目录位置

配置runner(可选)

--Build Tools--Maven--Runner  
VM Options : -DarchetypeCatalog=internal
JRE: 你项目的jdk
-DarchetypeCatalog=internal , maven项目创建时,会联网下载模版文件,
比较大, 使用-DarchetypeCatalog=internal,不用下载, 创建maven项目速度快。
配置以后新建工程的设置, file--other settings--Settings for New Project

约定大于配置

src/main/test目录就是测试目录,这是约定,没有配置文件配置,写错就报错
src/main/java目录就是源代码目录,这是约定,没有配置文件配置,写错就报错

创建Maven项目

命令创建

每一个maven项目在磁盘中都是一个文件夹

cmd 创建maven项目
mvn archetype:generate


Define value for property 'package' : com.example.demo 真实项目
[WARNING] Archetype is not fully configured
[INFO] Using property: javaCompilerVersion = 17
[INFO] Using property: junitVersion = 5.11.0
Define value for property 'groupId': com.example 通常与你的 package 前两段一致
Define value for property 'artifactId': my-app 项目名称

命令创建MAVEN创建web项目

mvn archetype:generate -DgroupId=com.example \
-DartifactId=myweb \
-DarchetypeArtifactId=maven-archetype-webapp \
-DinteractiveMode=false

手动创建test目录,在src目录下创建java目录。按照约定。

项目目录结构

myweb
├─ pom.xml // Maven 配置文件
├─ src
│ ├─ main
│ │ ├─ java // 你的 Java 源码(需要自己创建)
│ │ ├─ resources // 配置文件(需要自己创建)
│ │ └─ webapp
│ │ ├─ index.jsp // 默认主页
│ │ └─ WEB-INF
│ │ └─ web.xml // web.xml 配置文件
│ └─ test
│ └─ java // 测试代码
└─ target // 编译输出目录(自动生成)

如果你想要项目一生成就包含 java 和 resources 文件夹,可以手动添加

src/main/java
src/main/resources

web项目的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>pro02-maven-web</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 表示当前项目是web工程,将来打包成war包 -->
<packaging>war</packaging>

<name>pro02-maven-web</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>

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

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

<dependency>
<!-- 这个就是之前安装到本地仓库的Java项目 -->
<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 这里没有设置scope选项,那么默认值就是compile -->
<scope>provided</scope>
<!-- 依赖的排除 -->
<exclusions>
<exclusion>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</exclusion>
</exclusions>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.32</version>
</dependency>


</dependencies>

<build>
<finalName>pro02-maven-web</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>

打包然后把war包,放在tomcat的webapp中运行。

工程(Model)之间依赖设置

pro01-maven-java -- 这个是Java项目
pro02-maven-web -- 这个是Web项目
<!--pro02-maven-web.pom-->

<dependency>
<!-- 这个就是之前安装到本地仓库的Java项目 -->
<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 这里没有设置scope选项,那么默认值就是compile -->
<scope>provided</scope>
<!-- 依赖的排除 -->
<exclusions>
<exclusion>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</exclusion>
</exclusions>
</dependency>

IDEA创建

File-New-Modual选择Maven

// 配置坐标
组织名-自定义-对应到文件夹
项目名-model名称-对应到应用(文件夹)名称
版本-自定义

创建maven父子项目,首先创建一个maven父项目,删除src文件夹,然后点击项目名,添加module,添加maven项目作为子项目,最后配置父pom(依赖配置版本号),配置子pom(子pom不用配置版本号)。

添加Web项目作为Module

image-20251126170824638

常用设置

全局变量

在Maven的 pom.xml文件中
<properties>用于定义全局变量
POM中通过 ${property_name}的形式引用变量的值。

自定义的属性,
1.<properties> 通过自定义标签声明变量(标签名就是变量名)
2.在pom.xml文件中的其它位置,使用 ${标签名} 使用变量的值
自定义全局变量一般是定义 依赖的版本号, 当你的项目中要使用多个相同的版本号,先使用全局变量定义, 在使用${变量名}

// 自定义系统变量
<properties>
<spring.version>4.3.10.RELEASE</spring.version>
</properties>

// 引用全局变量
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring context</artifactId>
<version>${spring.version}</version>
</dependency>

// maven系统采用的变量
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF 8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF 8</project.reporting.outputEncoding>
</properties>

指定资源位置

编译结果分别放到了 target/classes 和 targe/test classes目录中,但是这两个目录中的其他文件都会被忽略掉,如果需要把 src目录下的文件包放到 target/classes目录,作为输出的 jar一部分。需要指定资源文件位置。

<build>
<resources>
<resource>
<!--所在的目录-->
<directory>src/main/java</directory>
<!--包括目录下的.properties,.xml 文件都会扫描到-->
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<!-- filtering 选项 false 不启用过滤器, *.property 已经起到过滤的作用了 -->
<filtering>false</filtering>
</resource>
</resources>
</build>

添加tomcat8的插件

<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8080</port>
<path>/</path>
</configuration>
<!--此时点击idea最右侧Maven Projects,就可以看到我们新添加的tomcat7插件,双击tomcat7插件下tomcat7:run命令直接运行项目-->
</plugin>
</plugins>
</build>

继承

在父工程中创建子工程,需要将项目的打包方式设置为pom,而不是jar或者war方法,后期idea中,会自动将打包方式设置为pom格式。

父子Maven工程时,父工程的pom打包方式必须是 pom 形式,idea已自动配置。

父工程:parent.pom

子工程:parent.pom

父子工程的继承关系证明:

父工程(parent/pom.xml)中:必须有 modules 标签

<modules>
<module>module-a</module>
<module>module-b</module>
</modules>

子工程(module-a/pom.xml)中:必须有 parent 标签

<parent>
<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>

如果同时满足 modules + parent ,说明就是一个标准的 Maven 父子工程

在父工程中统一管理子工程中的jar包版本

// 使用 <dependencyManagement> 标签统一管理

注意:此处有dependencyManagement这个标签,如果没有这个标签,那么表示父工程依赖mysql5.1.47,然后所有的子模块强制性的依赖mysql5.1.47(不论子模块是否需要这个jar)


<!-- 父 pom 统一管理版本(不引入依赖) -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.2.3</version>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.34</version>
</dependency>
</dependencies>
</dependencyManagement>

<!-- 子工程使用时,不用写 version -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

在父工程中声明自定义属性

可以用于 变量抽取插件统一配置

父 pom 写属性

<properties>
<java.version>1.8</java.version>
<spring.version>6.1.0</spring.version>
</properties>

子工程中引用:

<properties>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
</properties>

聚合

聚合就是使用 父工程一次性构建多个模块

父工程依然用 pom 打包方式

父 pom 中包含 modules

<modules>
<module>module-a</module>
<module>module-b</module>
<module>module-c</module>
</modules>

聚合作用

在父工程目录执行

mvn install

可以一次性构建整个项目,非常适合:

  • 多模块微服务
  • 分层架构(api、service、dao 等)

子模块如果需要时web项目,则需要更改子模块中的pom文件中的packaging标签为war,然后点击Maven中的刷新按钮,然后点击子模块,右击选择出这个页面。

image-20260109110744301

选择这个页面

image-20260109110807045

然后选择这个模块,这个web文件夹,是在更改了packaging标签后才显示的,然后选中,

image-20260109111034083

更改项目的路径为当前项目路径。增加 /src/main/webapp/路径

然后更改下边的,点击后创建目录。

image-20260109111147178