ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

Maven

2022-08-25 19:32:57  阅读：170  来源： 互联网

标签：project 依赖 jar Maven test 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 插件：该插件可以列出同一个ｊａｒ包的不同版本
  3. 使用Maven 的 enforcer 插件：既可以检测同一个 jar 包的不同版本，又可以检测不同 jar 包中同名的类。

标签：project,依赖,jar,Maven,test,maven
来源： https://www.cnblogs.com/xiaocer/p/16625448.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有