Maven

2022/8/25 23:22:56

本文主要是介绍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。如下图所示:
    image.png
    补充:还有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>
  1. 依赖范围为runtime表示编译时不需要,但运行时需要
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.48</version>
    <scope>runtime</scope>
</dependency>
  1. 依赖范围为provided表示编译时需要,但运行时不需要
<!--此处的依赖项由Tomcat提供,所以依赖范围为provided-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>
  1. 依赖范围为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>
  1. 依赖范围为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 生成项目报告,站点,发布站点。
  1. 每套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
  1. Clean生命周期一共包含了三个阶段:
1. pre-clean  执行一些需要在clean之前完成的工作
2. clean  移除所有上一次构建生成的文件
3. post-clean  执行一些需要在clean之后立刻完成的工作
  1. 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的方法
image.png

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

  1. packaging标签:指定Maven工程的打包方式
<!-- jar:表示这个工程是一个Java工程  -->
<!-- war:表示这个工程是一个Web工程 -->
<!-- pom:表示这个工程是“管理其他工程”的工程 -->
  1. project.build.sourceEncoding属性
<properties>
    <!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
  1. 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>
  1. dependencyManagement标签:在父工程中配置依赖的统一管理
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
	<dependencies>
	    ...
	</dependencies>
</dependencyManagement>
  1. 自定义属性:可以在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>
  1. 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 -->
  1. 超级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
  1. 项目中依赖安装到Maven仓库的jar包

jar包冲突问题的解决

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


这篇关于Maven的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程