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（默认）	✔	✔	✔	✔	普通依赖，如工具包、数据库驱动（若需打包）
provided	✔	✔	✖	✖	Servlet / 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

<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

常用设置

全局变量

在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中的刷新按钮，然后点击子模块，右击选择出这个页面。

选择这个页面

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

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

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