Maven 知识点总结

核心点：

1、仓库，私服，repository，servers，mirror 标签
2、dependencyManagement，父子 pom
3、依赖传递规则：1、最短路径，2、路径长度相同时，使用写在上面的

Maven 能做什么？

Maven 是项目构建和依赖管理工具，提供仓库(公共和私服)，提供插件(扩展功能)
项目构建简单点理解就是把源码，编译，生成 jar 包或者 war 包的过程。
依赖管理就是项目中依赖的各种 jar 包，Maven 能用简单的方式对这个依赖 jar 包进行管理

Maven的安装

1、安装

maven 的安装非常简单，参考官网文档：https://maven.apache.org/install.html

1、安装好 jdk，设置好 JAVA_HOME 环境变量，指向 jdk的安装目录。或者让 java 命令在任何目录都能执行

2、解压Maven安装包

unzip apache-maven-3.9.1-bin.zip

或者

tar xzvf apache-maven-3.9.1-bin.tar.gz

3、在环境变量中设置 Maven

mac 或者 Linux 环境：执行命令 vim ~/.bash_profile 编辑文件

export MAVEN_HOME=/Users/awesome/tools/apache-maven-3.8.2
export PATH=$MAVEN_HOME/bin:$GRADLE_HOME/bin:$PATH

保存后，执行 source ~/.bash_profile,然后执行 mvn -v ，看能否成功打印 Maven 信息

2、配置文件

Maven 的安装目录下的 /conf/settings.xml

Maven 的概念

1、坐标：通过坐标唯一定位

groupId（必须定义）：不关键，比如com.dianping.zebra，或者 com.sankuai.meituan
artifactId必须定义：项目中的一个模块，推荐用模块名，比如xy-trade-microloan-thrift-api，或者 zebra-client
version（必须定义）：版本，比如 2.9.2-SNAPSHOT
packaging（可选定义）：定义了maven的打包方式，不定义packaging时默认jar包，当然也可以定义war包
scope（可选定义）：作用范围，默认为compile。如果test，表示只能在测试代码中import该依赖，主代码依赖会报错
classifier（不能直接定义）：定义一些附属组件，比如【javadoc文档】和【sources源代码】

依赖：用于描述一个依赖的 jar 包，在 pom.xml 文件中定义

<dependency>
	<groupId>commons-io</groupId>
	<artifactId>commons-io</artifactId>
	<version>2.4</version>
</dependency>
<dependency>
   <groupId>org.powermock</groupId>
   <artifactId>powermock-api-mockito2</artifactId>
   <version>2.0.2</version>
   <scope>test</scope>
</dependency>
<dependency>
  <groupId>it.lianyangguorong</groupId>
  <artifactId>codec</artifactId>
  <version>1.0</version>
  <scope>system</scope>
  <!-- 本地依赖 -->
  <systemPath>${basedir}/lib/lianyangguorong/commons-codec-sdk-1.0-SNAPSHOT.jar</systemPath>
</dependency>

：依赖范围，compile,test,provided,runtime,system,import

2、scope依赖范围

概述：用来控制依赖与这三种classpath（编译，测试，运行）的关系，有以下几种选择
compile（默认）：在【编译，测试，运行】时都使用该依赖。比如spring-core（都需要用到）
test：只对【test文件夹下】有效，比如JUnit，mockito（只有在单元测试才用到这些依赖）
provided：已提供该依赖。对于【编译和测试】有效。在运行时无效，比如 servlet-api，编译和测试的时候需要，运行的时候由于容器已经提供，就不需要了。
runtime：对【测试和运行】有效，编译主代码时无效。典型的例子是JDBC驱动实现
system：类似provided，但是要通过systemPath 指定文件路径
import：导入依赖范围，后面解释dependencyManagement时再介绍

3、maven的传递性依赖性质

何为依赖传递：【我的项目A】依赖【spring-core】，【spring-core】pom.xml中依赖【commons-logging】。则 【我的项目A】依赖【commons-logging】
依赖传递的范围：【我的项目A】依赖scope=test【spring-core】，【spring-core】依赖scope=compile【commons-logging】。则【我的项目A】依赖scope=test【commons-logging】

依赖的规则：第一原则优先，相同则采用第二原则
第一原则：依赖路径越短越优先。比如：A->B->C->X(1.0)；A->D->X(2.0)。由于X(2.0)的路径短，X(2.0)会被解析使用
第二原则：看pom.xml中的依赖顺序，谁写在上面谁先依赖。比如A->B->Y(1.0)；A->C->Y(2.0)。如果pom.xml文件中B写在C的上面，则Y(1.0)会被解析使用

4、optional可选依赖

配置 true ，则该依赖为【可选依赖】
【可选依赖】有什么用：不具有传递性
比如：A->B，B->mysql.jar（可选），B->oracle.jar（可选）
则依赖不会传递，即 A不会依赖mysql.jar和oracle.jar。换句话说：项目里没有mysql.jar和oracle.jar不会对A产生任何影响
为什么要【可选依赖】
假如项目B实现了两个特性，其中的特性一依赖于X，特性二依赖于Y，而且这两个特性是互斥的，用户不可能同时使用这两个特性
比如B是一个持久层隔离工具包，特性一用于mysql，特性二用于oracle，这两者是互斥的，究竟用哪个，让用户自己来手动选（手动引入）
例子：B的pom.xml，用户如果要用mysql的jar包，需要在A中自己手动引

<dependencies>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.10</version>
    <optional>true</optional>
  </dependency>
  <dependency>
    <groupId>postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>8.4-701.jdbc3</version>
    <optional>true</optional>
  </dependency>
</dependencies>

A 的 pom.xml

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.10</version>
  <optional>true</optional>
</dependency>

5、exclusion排除依赖

假如项目里有个第三方依赖，该依赖还依赖了另一个1.0.0-SNAPSHOT版本的库，那么该1.0.0-SNAPSHOT就会成为当前项目的传递性依赖。此时我想排除该依赖，则要使用标签

需要注意的是：声明exclusion时候只需要groupId和artifactId，不需要version（显然，根据前两者就可以在pom.xml中唯一确定一个Maven坐标了）

6、properties归类依赖

假如项目里有很多Spring Framework的依赖（如下），你希望保持它们版本号一致，并且统一管理它们的版本
org.springframework:spring-core:2.5.6
org.springframework:spring-beans:2.5.6
org.springframework:spring-context:2.5.6
org.springframework:spring-context-support:2.5.6
使用标签

7、优化依赖

可以通过命令查看项目中的所有依赖和依赖关系
显示所有已解析依赖：mvn dependency:list
查看解析后的依赖树：mvn dependency:tree
分析当前的项目依赖：mvn dependency:analyze

一般在 idea 中安装 Maven Helper ，方便可视化查看依赖关系

Maven基本使用

1、常用命令

mvn clean：清理 target/目录
mvn compile：编译项目主代码，生成 class 文件到 target/classes 目录
mvn test：执行单元测试
mvn package：打包，如果POM中没有指定，默认打jar包，位于target/目录中
mvn install：将jar包安装到本地仓库
mvn deploy: 将 jar包部署到远程仓库

仓库

1、Maven仓库

何为仓库：Maven将所有构建完成的jar包安装部署到Maven本地仓库（本地电脑上的一个文件夹），所有项目可以共用

2、仓库的分类

只分为两类：【本地仓库】和【远程仓库】，一个用户只有一个【本地仓库】，但是可以配置多个【远程仓库】，远程仓库中，一般公司会提供私服仓库

jar查找规则
（1）先从【本地仓库】找
（2）找不到再去【远程仓库】下载到【本地仓库】
（3）如果都没有则报错

3、本地仓库

默认配置下，【本地仓库】的路径为：用户目录/.m2/repository/…
比如Windows：C:\Users\jyy.m2\repository\

如何更改【本地仓库】地址?
修改 $MAVEN_HOME/conf/settings.xml ，增加一行 标签配置。

<localRepository>/Users/xxxx/tools/maven_repository</localRepository>

如何安装【本地Maven项目】到【本地仓库】?
命令：mvn install

4、远程仓库

中央仓库：
Maven自带的远程仓库，包含了绝大部分开源的构件：https://mvnrepository.com/
Maven的安装文件自带【中央仓库】的配置，可以通过 $MAVEN_HOME/lib/maven-model-builder-3.0.jar中的 org/apache/maven/model/pom-4.0.0.xml看到，该pom文件是一个超级POM，所有Maven项目都会继承

私服：架设在局域网内，代理外部广域网上的远程仓库
jar包查询规则：先找【本地仓库】，再找【私服】，找不到再找【远程仓库】

为什么需要私服：
有些jar包是公司内部用的，不开源，可以放在私服
如果Internet不稳定，私服提高了稳定性

比较著名的有：Nexus

5、如何配置指定远程仓库

在pom.xml中添加 标签
：必须是唯一的，Maven自带的中央仓库使用的id为central，如果其他仓库id声明也使用central，则会覆盖中央仓库的配置
：名称，随便去取
：仓库地址，一般是http协议格式，可以在浏览器中打开
和标签
snapshots的为false，表示不允许从 JBoss仓库下载【快照版本】的jar包
releases 的 为true，表示可以从 JBoss仓库下载【发布版本】的jar包
：从Maven远程仓库检查更新的频率，3种选择
never（从不检查更新）
always（每次都检查）
X（每隔X分钟检查一次）
：检查策略，3种选择
warn（出错则输出warn警告）
fail（出错则构建失败）
ignore（完全忽略检验失败）
：default表示仓库的布局是Maven2和Maven3的默认布局

  <profiles>
    <profile>
      <id>company_profile</id>
      <repositories>
        <repository>
          <id>my_maven_repository</id>
          <name>Nexus</name>
          <url>http://nexus.xxxxx.com/repository/maven/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>true</enabled>
          </snapshots>
        </repository>
      </repositories>
      <pluginRepositories>
        <pluginRepository>
          <id>my_maven_repository</id>
          <name>Nexus</name>
          <url>http://nexus.xxxxx.com/repository/maven/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>true</enabled>
          </snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
  </profiles>

  <activeProfiles>
    <activeProfile>company_profile</activeProfile>
  </activeProfiles>

6、如何通过用户名和密码访问远程仓库

settings.xml中配置 标签。需要注意的是，必须与前面pom.xml中的id相同

  <servers>
    <server>
      <username>xxxxxx</username>
      <password>password</password>
      <id>my_maven_repository</id>
    </server>
  </servers>

7、如何把本地项目部署到远程仓库？

在项目的 pom.xml 文件中，增加以下配置

<distributionManagement>
    <repository>
        <id>myCompany-nexus-releases</id>
        <name>myCompany Nexus Repository</name>
        <url>http://xxx.xxxxxxx.com/repository/releases</url>
    </repository>
    <snapshotRepository>
        <id>myCompany-nexus-snapshots</id>
        <name>myCompany Nexus Repository</name>
        <url>http://xxx.xxxxxxx.com/repository/snapshots</url>
    </snapshotRepository>
</distributionManagement>

表示：releases版本的仓库地址
表示：snapshots版本的仓库地址
标签必须要与 settings.xml中的id一致
需要注意的是，如果repository需要用户名密码的话，需要在 settings.xml 中配合标签使用

settings.xml文件内容：

  <servers>
    <server>
      <username>xxxxx</username>
      <password>password</password>
      <id>myCompany-nexus-releases</id>
    </server>
    <server>
      <username>xxxxx</username>
      <password>password</password>
      <id>myCompany-nexus-snapshots</id>
    </server>
  </servers>

配置好之后：mvn clean deploy 命令会自动部署到远程仓库

8、如何配置镜像

比如中央仓库在外网，国内访问比较慢，可以配置中央仓库的国内镜像，相当于是覆盖了中央仓库的地址
何为镜像：就比如，阿里云提供了Maven仓库的国内镜像，国内用户下载起来会更快（https://maven.aliyun.com/repository/public）
在settings.xml中配置标签，代替某些的url
例1：下图的为central，表示用该url替代了【Maven中央仓库】，所有去中央仓库的请求都会转到该url

<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>central</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>

例2：下图的为*，表示用该url替代了所有的配置，所有配置的都会转到该url镜像

<mirrors>
  <mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
  </mirror>
  <mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云谷歌仓库</name>
    <url>https://maven.aliyun.com/repository/google</url>
  </mirror>
  <mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云spring仓库</name>
    <url>https://maven.aliyun.com/repository/spring</url>
  </mirror>
  <mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云gradle-plugin</name>
    <url>https://maven.aliyun.com/repository/gradle-plugin</url>
  </mirror>
</mirrors>

如果该镜像需要认证，则去settings.xml中配置即可

的用法
* ：匹配所有远程仓库
external:* ：匹配所有远程仓库，但是 locolhost 和 file://协议的除外，即匹配所有不在本机上的远程仓库
repo1, repo2 ：匹配 repo1 和 repo2
*, !repo1 ：匹配所有远程仓库， repo1除外（感叹号表示排除）

9、快照版本

为何需要snapshot版本？快照版本的依赖，上传到仓库后，都会带着时间戳属性。当别人拉取依赖时，如果发现有更新时间戳的，Maven 就会重新拉取。默认更新频率是 1 天一次，可以修改仓库配置的 undatePolicy 调整。也可以使用命令 mvn clean install-U

插件

1、三套生命周期

maven的生命周期，可以理解为 Maven 为构建项目规定的动作，具体的动作由插件完成。
maven拥有3套相互独立的生命周期：分别是 clean（清理项目），default（构建项目），site（建立项目站点）

clean生命周期：主要用于清理项目

pre-clean：执行清理前需要完成的工作
clean：清理上一次构建生成的文件
post-clean：执行清理后需要完成的工作

default声明周期：三套生命周期中最核心的部分

• 验证和初始化
  • 2.1）validate
  • 2.2）initialize
• src/main/resources 处理和编译
  • 2.3）generate-sources
  • 2.4）process-sources：处理项目的主资源文件：一般来说，对src/main/resources 目录的内容进行变量替换等工作，复制到项目输出的主classpath目录中
  • 2.5）generate-resources
  • 2.6）process-resources
  • 2.7）compile：编译项目的主源码：一般来说，是编译 src/main/java 目录下的Java文件至项目输出的主classpath目录中
  • 2.8）process-classes
• src/test/resources 处理和编译
  • 2.9）generate-test-sources
  • 2.10）process-test-sources：处理项目的测试资源文件：一般来说，对src/test/resources 目录的内容进行变量替换等工作，复制到项目输出的测试classpath目录中
  • 2.11）generate-test-resources
  • 2.12）process-test-resources
  • 2.13）test-compile：编译项目的测试源码：一般来说，是编译 src/test/java 目录下的Java文件至项目输出的测试classpath目录中
  • 2.14）process-test-classes
• 运行测试代码
  • 2.15）test：使用单元测试框架进行测试，测试代码不会被打包或者部署
• 打包，安装，部署
  • 2.16）prepare-package
  • 2.17）package：接受编译好的代码，打包可发布的格式，比如jar
  • 2.18）pre-integration-test
  • 2.19）integration-test
  • 2.20）post-integration-test
  • 2.21）verify
  • 2.22）install：将包安装到Maven本地仓库，供本地其他Maven项目使用
  • 2.23）deploy：将包部署到远程仓库

site声明周期：主要目的是建立和发布项目站点
pre-site
site
post-site
site-deploy：将生成的项目站点发布到服务器上

2、Maven插件

Maven的核心仅仅是定义了生命周期，具体的任务由插件完成。

什么是插件目标
compiler:compile（maven-compiler-plugin的compile目标）
surefire:test（maven-surefire-plugin的test目标）

插件绑定

为了让用户不需要配置就能构建Maven项目，Maven在其主要生命周期绑定了很多插件的目标，比如常见的 clean，compile，package

插件配置参数
（1）命令行配置（常用）
常见形式：使用-D参数，伴随 key=value 形式

mvn install -Dmaven.test.skip=true

（2）pom.xml中全局配置

比如，配置compile时生成java1.8的字节码文件

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

3、常用插件

springboot 项目打包插件

<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

项目编译插件

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

docker 插件

jib-maven-plugin

<plugin>
                <groupId>com.google.cloud.tools</groupId>
                <artifactId>jib-maven-plugin</artifactId>
                <version>2.8.0</version>
                <configuration>
                    <allowInsecureRegistries>true</allowInsecureRegistries>
                    <!--from节点用来设置镜像的基础镜像，相当于Docerkfile中的FROM关键字-->
                    <from>
                        <!--使用openjdk官方镜像，tag是:8-jdk-alpine，表示镜像的操作系统是alpine,装好了jdk8-->
                        <image>openjdk:8-jdk-alpine</image>
                    </from>
                    <to>
                        <!--镜像名称和tag，使用了mvn内置变量${project.version}，表示当前工程的version-->
                        <image>${docker.registry.url}/${docker.registry.name}/${project.artifactId}:${project.version}
                        </image>
                        <tags>
                            <!--版本号-->
                            <tag>${project.version}</tag>
                        </tags>
                        <!--harbor的认证信息-->
                        <auth>
                            <username>${docker.registry.username}</username>
                            <password>${docker.registry.password}</password>
                        </auth>
                    </to>
                    <!--容器相关的属性-->
                    <container>
                        <jvmFlags>
                            <!--一些启动参数-->
                            <jvmFlag>-Djava.security.edg=file:/dev/./urandom</jvmFlag>
                        </jvmFlags>
                        <!--挂载volume的配置-->
                        <volumes>
                            <volume>/tmp</volume>
                            <volume>/logs</volume>
                        </volumes>
                        <ports>
                            <!--暴漏端口号-->
                            <port>8080</port>
                        </ports>
                        <!--微服务的启动类-->
                        <mainClass>com.heima.learn.storage.StorageApplication</mainClass>
                        <format>OCI</format>
                        <!--使用该参数将镜像的创建时间与系统时间对其-->
                        <creationTime>USE_CURRENT_TIMESTAMP</creationTime>
                    </container>
                </configuration>
                <executions>
                    <!--执行打包配置-->
                    <execution>
                        <id>jib-maven-plugin</id>
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
</plugin>

docker-maven-plugin

<plugin>
    <groupId>io.fabric8</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.33.0</version>
    <executions>
        <!--如果想在项目打包时构建镜像添加-->
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
</plugin>

打 war 包插件

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-war-plugin</artifactId>
  <version>2.6</version>
  <configuration>
    <warName>project_name</warName>
  </configuration>
</plugin>

tomcat 插件

本地不想安装 Tomcat 的可以使用这个插件

<plugin>
  <groupId>org.apache.tomcat.maven</groupId>
  <artifactId>tomcat7-maven-plugin</artifactId>
  <version>2.2</version>
  <configuration>
    <port>8088</port>
    <path>/</path>
    <server>tomcat-development-server</server>
    <useTestClasspath>true</useTestClasspath>
  </configuration>
</plugin>

聚合与继承

1、聚合：标签

比如：存在两个同级的子模块，可以用一个【主pom.xml】管理多个【子pom.xml】
例如来自zebra项目的主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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.dianping.zebra</groupId>
    <artifactId>zebra-all</artifactId>
    <packaging>pom</packaging>
    <version>2.9.1</version>
    <name>zebra-all</name>
    <organization>
        <name>Meituan Dianping</name>
        <url>http://www.dianping.com/</url>
    </organization>
    <modules>
        <module>zebra-dao</module>
        <module>zebra-sample</module>
        <module>zebra-admin-web</module>
        <module>zebra-cat-client</module>
        <module>zebra-client</module>
    </modules>
    <description>zebra</description>

需要用到的标签
：主pom文件必须声明为pom，否则无法构建（但子pom文件可以不声明packaging，因为默认为jar）
：内容为【子pom文件】中的 ，即子项目名称

父模块与子模块的结构
父子结构：最常用的目录结构
平行结构：不太常用，父pom中中的路径需要变化，子 pom中的 parent 中需要通过指定父 pom.xml 的位置

2、继承： 标签

为什么要聚合与继承：在所有子模块的【子pom】中，往往会写重复的依赖配置，比如spring-core, spring-beans等等
【子pom】如何继承【父pom】：标签

需要注意的是：一般采用【父子目录结构】无需声明，默认值是 …/pom.xml

3、父子pom的依赖管理：

默认情况下，父 pom 中定义的依赖，会被子 module 中完全继承。这样会存在问题，如果子 module 中不想完全继承父依赖，怎么处理？由此引入
能让子模块有选择的引用父模块的依赖
父模块的pom.xml：

<properties>
  <commons-beanutils.version>1.8.3</commons-beanutils.version>
  <fastjson.version>1.2.83</fastjson.version>
  <commons.codec.version>1.8</commons.codec.version>
</properties>
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils-core</artifactId>
      <version>${commons-beanutils.version}</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>${fastjson.version}</version>
    </dependency>
    <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>${commons.codec.version}</version>
    </dependency>
  </dependencies>
</dependencyManagement>

子模块的pom.xml：

<dependencies>
  <dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils-core</artifactId>
  </dependency>
</dependencies>

对于子模块
如果需要依赖：只需要配置groupId和artifactId。而version不需要写，只需要委托给父类管理就行了
如果不需要依赖：在子pom.xml中不写就行了，不写就不会引入

dependencyManagement中的依赖版本还会覆盖传递依赖版本
举个例子：项目中依赖的A，A依赖了B的1.0版本。如果在dependencyManagement中显示声明依赖B的2.0版本，那么A也会去依赖B的2.0版本

最佳实践：一般使用 dependencyManagement 统一管理项目依赖的版本

4、超级pom

超级pom的坐标：对于Maven3，超级pom的目录为：maven/lib/maven-model-builder-x.x.x.jar中
超级pom中定义了什么？
（1）定义了【默认中央仓库】和【插件仓库】
（2）定义了【主代码/测试 输出目录】，【主代码输出目录】，【最终构件的名称格式】等等
（3）定义了【Maven内置插件】的默认版本

5、约定优于配置

Maven提倡约定优于配置（Convention Over Configuration）：在maven中只需要简单的配置pom文件，就可以实现 清除构建目录、创建目录、编译代码、复制依赖至目标目录，最后打包
maven约定如下
源码目录为 src/main/java
编译输出目录为 target/classes
打包方式为jar
包输出目录为 target

参考链接：https://blog.csdn.net/qq_41157876/article/details/119117070

最佳实践

1、安装后，指定本次仓库位置，方便调整
2、某个依赖 jar 包，从远程仓库拉取过程中可能失败，可以进入到本地仓库文件夹，删除对应的jar 包目录
3、多模块项目，使用dependencyManagement
4、settings.xml 文件中，指定镜像，如果公司有私服，指定私服地址
5、注意依赖传递原则，防止引入不兼容的版本的 jar 包
6、给 IDE 安装 Maven Helper 插件

博主水平有限，欢迎留言，指正错误，交流技术