Maven

参考

参考

概述

1. 概念：Maven就是是专门为Java项目打造的依赖管理和构建管理工具
2. Maven使用pom.xml定义项目内容，并使用预设的目录结构
3. 在Maven中声明一个依赖项可以自动下载并导入classpath
4. Maven使用groupId，artifactId和version唯一定位一个依赖

Maven的配置

Maven的核心配置文件conf/settings.xml

1. 主要配置如下信息

1. 指定本地仓库位置
<localRepository>E:/IDEA/Maven/apache-maven-3.8.3/my_repos</localRepository>
2. 配置阿里云提供的镜像仓库，mirrors标签下
<mirror>
	<id>nexus-aliyun</id>
	<mirrorOf>central</mirrorOf>
	<name>Nexus aliyun</name>
	<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
3. 配置 Maven 工程的基础 JDK 版本，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>

Maven中的依赖管理

概述

1. 概念：比如我们的项目依赖abc这个jar包，而abc又依赖xyz这个jar包。不考虑依赖范围的话，当我们声明了abc的依赖时，Maven自动把abc和xyz都加入了我们的项目依赖，不需要我们自己去研究abc是否需要依赖xyz。

依赖关系

1. Maven定义了几种依赖关系，分别是compile、test、runtime和provided。如下图所示：
   
   补充：还有import，system。
2. 依赖范围为test表示仅在测试时使用，正常运行时并不需要

// 例如junit依赖
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.3.2</version>
    <scope>test</scope>
</dependency>

3. 依赖范围为runtime表示编译时不需要，但运行时需要

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

4. 依赖范围为provided表示编译时需要，但运行时不需要

<!--此处的依赖项由Tomcat提供，所以依赖范围为provided-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>

5. 依赖范围为import表示继承该依赖表示的父工程，而且可以继承多个。

<!--依赖范围为import的使用要求：-->
<!--打包类型必须是 pom-->
<!--必须放在 dependencyManagement 中-->
<dependencyManagement>
    <dependencies>

        <!-- SpringCloud 依赖导入 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR9</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- SpringCloud Alibaba 依赖导入 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.2.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

6. 依赖范围为system表示引入某某系统环境下某个磁盘下的jar包

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.0</version>
    <systemPath>E:/IDEA/Tomcat/apache-tomcat-8/apache-tomcat-8.5.71/lib/servlet-api.jar</systemPath>
    <scope>system</scope>
</dependency>

Maven如何知道从何处下载所需的依赖？也就是相关的jar包?
如果用户主目录下的.m2目录下（默认情况下本地仓库的位置）没有需要的jar包就到中央仓库下载。

Maven镜像

如果访问Maven的中央仓库非常慢，我们可以选择一个速度较快的Maven的镜像仓库。解决办法参考

唯一id

对于某个依赖，Maven只需要3个变量即可唯一确定某个jar包.

1. groupId：属于组织的名称，类似Java的包名；
2. artifactId：该jar包自身的名称，类似Java的类名；
3. version：该jar包的版本。

注：只有以-SNAPSHOT结尾的版本号会被Maven视为开发版本，开发版本每次都会重复下载，这种SNAPSHOT版本只能用于内部私有的Maven repo，公开发布的版本不允许出现SNAPSHOT。

搜索第三方组件

如果我们要引用一个第三方组件，比如okhttp，如何确切地获得它的groupId、artifactId和version？方法是通过search.maven.org网址搜索关键字，找到对应的组件后，直接复制

<dependency>
  <groupId>com.avito.android</groupId>
  <artifactId>okhttp</artifactId>
  <version>2021.36</version>
</dependency>

Maven的Lifecycle和Phase

1. Maven有三套相互独立的生命周期

1. Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
2. Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。
3. Site Lifecycle 生成项目报告，站点，发布站点。

2. 每套Maven的生命周期由一系列阶段（phase）构成，以内置的生命周期default为例，它包含以下phase：

1. validate
2. initialize
3. generate-sources
4. process-sources
5. generate-resources
6. process-resources
7. compile
8. process-classes
9. generate-test-sources
10. process-test-sources
11. generate-test-resources
12. process-test-resources
13. test-compile
14. process-test-classes
15. test
16. prepare-package
17. package
18. pre-integration-test
19. integration-test
20. post-integration-test
21. verify
22. install
23. deploy

3. Clean生命周期一共包含了三个阶段：

1. pre-clean  执行一些需要在clean之前完成的工作
2. clean  移除所有上一次构建生成的文件
3. post-clean  执行一些需要在clean之后立刻完成的工作

4. Site生命周期的各个阶段：

1. pre-site     执行一些需要在生成站点文档之前完成的工作
2. site    生成项目的站点文档
3. post-site     执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
4. site-deploy     将生成的站点文档部署到特定的服务器上

mvn phaseMaven自动根据生命周期运行到指定的phase。 如果我们运行mvn package，Maven就会执行default生命周期，它会从开始一直运行到package这个phase为止。运行任何一个阶段的时候，它所在周期的前面的所有阶段都会被运行

实际开发中常用的命令

# 这个clean是Clean生命周期的一个阶段
mvn clean：清理所有生成的class和jar；（即删除target目录）

mvn test-compile: 测试程序编译

测试程序编译结果存放的目录：target/test-classes
主体程序编译结果存放的目录：target/classes   
mvn clean compile：先清理，再执行到compile；

mvn clean test：先清理，再执行到test，因为执行test前必须执行compile，所以这里不必指定compile；

mvn clean package：先清理，再执行到package。

使用插件

自定义插件在pom.xml中声明

Maven Wrapper的使用

Maven Wrapper就是给一个项目提供一个独立的，指定版本的Maven给它使用。

发布Artifact

将自己的库发布到Maven的repo的方法

pom.xml中可以配置的重要信息

1. packaging标签：指定Maven工程的打包方式

<!-- jar：表示这个工程是一个Java工程  -->
<!-- war：表示这个工程是一个Web工程 -->
<!-- pom：表示这个工程是“管理其他工程”的工程 -->

2. project.build.sourceEncoding属性

<properties>
    <!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

3. excludes标签配置依赖的排除，用于避免jar包的冲突

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
  <!-- 使用excludes标签配置依赖的排除	-->
  <exclusions>
    <!-- 在exclusion标签中配置一个具体的排除 -->
    <exclusion>
      <groupId>org.hamcrest</groupId>
      <artifactId>hamcrest-core</artifactId>
    </exclusion>
  </exclusions>
</dependency>

4. dependencyManagement标签：在父工程中配置依赖的统一管理

<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
	<dependencies>
	    ...
	</dependencies>
</dependencyManagement>

5. 自定义属性：可以在properties标签下自定义标签

<!--自定义属性spring.version-->
<properties>
    <spring.version>1.2.6</spring.version>
</properties>

<!--自定义属性的引用-->
<dependency>
  <groupId>springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>${spring.version}</version>
</dependency>

6. build标签：自定义配置构建过程

<!--build标签定制Maven的构建行为-->
<build>
    <!--Maven构建的时候使用到的插件-->
    <plugins>
        <!-- plugin 标签：这是我要指定的一个具体的插件 -->
        <plugin>
            <!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            
            <!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
            <configuration>
                <!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

超级POM

1. 项目中定义的POM默认继承了超级POM（Maven也是单继承的）。

<!-- START SNIPPET: superpom -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <build>
    <!--定义约定的目录结构-->
    <directory>${project.basedir}/target</directory>
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <finalName>${project.artifactId}-${project.version}</finalName>
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
    <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>
    <pluginManagement>
      <!-- NOTE: These plugins will be removed from future versions of the super POM -->
      <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
      <plugins>
        <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <version>1.3</version>
        </plugin>
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <version>2.2-beta-5</version>
        </plugin>
        <plugin>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.8</version>
        </plugin>
        <plugin>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.5.3</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

  <reporting>
    <outputDirectory>${project.build.directory}/site</outputDirectory>
  </reporting>

  <profiles>
    <!-- NOTE: The release profile will be removed from future versions of the super POM -->
    <profile>
      <id>release-profile</id>

      <activation>
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>

      <build>
        <plugins>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar-no-fork</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-javadoc-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>
<!-- END SNIPPET: superpom -->

2. 超级POM的位置
   

导入体系外jar包

项目中引入不是用Maven的方式发布的jar包。

1. 将该jar包安装到Maven本地仓库：使用 install 插件的 install-file 目标

// Windows 系统下使用 ^ 符号换行；Linux 系统用 /
mvn install:install-file -Dfile=[体系外 jar 包路径] /
-DgroupId=[给体系外 jar 包强行设定坐标] /
-DartifactId=[给体系外 jar 包强行设定坐标] /
-Dversion=1 /
-Dpackage=jar

// 示例：
mvn install:install-file -Dfile=E:/spring/java_pro/out/artifacts/java_pro/java_pro.jar ^-DgroupId=com.nrvcer ^-DartifactId=java_pro ^-Dversion=1 ^-Dpackaging=jar

2. 项目中依赖安装到Maven仓库的jar包

jar包冲突问题的解决

1. 在pom文件中通过exclusions排除依赖，或是明确声明依赖。
2. 使用IDEA的Maven Helper 插件：该插件可以列出同一个ｊａｒ包的不同版本
3. 使用Maven 的 enforcer 插件：既可以检测同一个 jar 包的不同版本，又可以检测不同 jar 包中同名的类。