maven入门（8）maven的依赖管理

我们项目中用到的jar包可以通过依赖的方式引入，构建项目的时候从Maven仓库下载即可。

1. 依赖配置 
   依赖可以声明如下：

Xml代码  

  1. <project>
  2. ...
  3. <dependencies>
  4. <dependency>
  5. <groupId>group-a</groupId>
  6. <artifactId>artifact-a</artifactId>
  7. <version>1.0</version>
  8. <exclusions>
  9. <exclusion>
  10. <groupId>group-c</groupId>
  11. <artifactId>excluded-artifact</artifactId>
  12. </exclusion>
  13. </exclusions>
  14. </dependency>
  15. <dependency>
  16. <groupId>group-a</groupId>
  17. <artifactId>artifact-b</artifactId>
  18. <version>1.0</version>
  19. <type>bar</type>
  20. <scope>runtime</scope>
  21. </dependency>
  22. </dependencies>
  23. </project>

我们在Maven实战(二)中就遇到了依赖的概念，项目中测试需要依赖junit jar包，依赖配置如下：

Xml代码  

  1. <dependencies>
  2. <dependency>
  3. <groupId>junit</groupId>
  4. <artifactId>junit</artifactId>
  5. <version>3.8.1</version>
  6. <scope>test</scope>
  7. </dependency>
  8. </dependencies>

依赖会包含基本的groupId, artifactId,version等元素，根元素project下的dependencies可以包含一个或者多个dependency元素，以声明一个或者多个依赖。
 下面详细讲解每个依赖可以包含的元素：

groupId,artifactId和version：依赖的基本坐标，对于任何一个依赖来说，基本坐标是最重要的，Maven根据坐标才能找到需要的依赖

type: 依赖的类型，对应于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值是jar

scope: 依赖的范围，下面会进行详解

optional: 标记依赖是否可选

exclusions: 用来排除传递性依赖，下面会进行详解

大部分依赖声明只包含基本坐标。

2. 依赖范围

Maven在编译主代码的时候需要使用一套classpath,在编译和执行测试的时候会使用另一套classpath,实际运行项目的时候，又会使用一套classpath。

依赖范围就是用来控制依赖与这三种classpath(编译classpath、测试classpath、运行classpath)的关系，Maven有以下几种依赖范围：

compile: 编译依赖范围。如果没有指定，就会默认使用该依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种classpath都有效。

test: 测试依赖范围。使用此依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此类依赖。典型的例子就是JUnit，它只有在编译测试代码及运行测试的时候才需要。

provided: 已提供依赖范围。使用此依赖范围的Maven依赖，对于编译和测试classpath有效，但在运行时无效。典型的例子是servlet-api，编译和测试项目的时候需要该依赖，但在运行项目的时候，由于容器已经提供，就不需要Maven重复地引入一遍。

runtime: 运行时依赖范围。使用此依赖范围的Maven依赖，对于测试和运行classpath有效，但在编译主代码时无效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。

system: 系统依赖范围。该依赖与三种classpath的关系，和provided依赖范围完全一致。但是，使用system范围依赖时必须通过systemPath元素显式地指定依赖文件的路径。由于此类依赖不是通过Maven仓库解析的，而且往往与本机系统绑定，可能造成构建的不可移植，因此应该谨慎使用。systemPath元素可以引用环境变量，如：

Xml代码  

  1. <dependency>
  2. <groupId>javax.sql</groupId>
  3. <artifactId>jdbc-stdext</artifactId>
  4. <version>2.0</version>
  5. <scope></scope>
  6. <systemPath>${java.home}/lib/rt.jar</systemPath>
  7. </dependency>

import(Maven 2.0.9及以上): 导入依赖范围。该依赖范围不会对三种classpath产生实际的影响，稍后会介绍到。

3. 传递性依赖

下面我们看一个简单的项目，读者可从附件中下载源码

POM.xml配置如下：

Xml代码  

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.mycompany.app</groupId>
  5. <artifactId>my-app-simple</artifactId>
  6. <version>0.0.1-SNAPSHOT</version>
  7. <packaging>jar</packaging>
  8. <name>my-app-simple</name>
  9. <url>http://maven.apache.org</url>
  10. <properties>
  11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12. </properties>
  13. <dependencies>
  14. <dependency>
  15. <groupId>junit</groupId>
  16. <artifactId>junit</artifactId>
  17. <version>3.8.1</version>
  18. <scope>test</scope>
  19. </dependency>
  20. <dependency>
  21. <groupId>org.springframework</groupId>
  22. <artifactId>spring-core</artifactId>
  23. <version>2.5.6</version>
  24. </dependency>
  25. </dependencies>
  26. </project>

我们可以看到此项目引入依赖junit和spring-core，我们可以在Maven仓库中查找spring-core构件，如图：

点击POM我们会看到该文件包含了一个commons-logging依赖：

Xml代码  

  1. <dependency>
  2. <groupId>commons-logging</groupId>
  3. <artifactId>commons-logging</artifactId>
  4. <version>1.1.1</version>
  5. </dependency>

那么该依赖会传递到当前项目中，这就是依赖的传递性，打开项目查看Maven dependencies:

4. 可选依赖

有时候我们不想让依赖传递，那么可配置该依赖为可选依赖，将元素optional设置为true即可,例如：

Xml代码  

  1. <dependency>
  2. <groupId>commons-logging</groupId>
  3. <artifactId>commons-logging</artifactId>
  4. <version>1.1.1</version>
  5. <optional>true<optional>
  6. </dependency>

那么依赖该项目的另以项目将不会得到此依赖的传递

 5. 排除依赖

当我们引入第三方jar包的时候，难免会引入传递性依赖，有些时候这是好事，然而有些时候我们不需要其中的一些传递性依赖

比如上例中的项目，我们不想引入传递性依赖commons-logging，我们可以使用exclusions元素声明排除依赖，exclusions可以包含一个或者多个exclusion子元素，因此可以排除一个或者多个传递性依赖。需要注意的是，声明exclusions的时候只需要groupId和artifactId，而不需要version元素，这是因为只需要groupId和artifactId就能唯一定位依赖图中的某个依赖。换句话说，Maven解析后的依赖中，不可能出现groupId和artifactId相同，但是version不同的两个依赖。

如下是一个排除依赖的例子：

Xml代码  

  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-core</artifactId>
  4. <version>2.5.6</version>
  5. <exclusions>
  6. <exclusion>
  7. <groupId>commons-logging</groupId>
  8. <artifactId>commons-logging</artifactId>
  9. </exclusion>
  10. </exclusions>
  11. </dependency>

 5. 依赖归类

如果我们项目中用到很多关于Spring Framework的依赖，它们分别是org.springframework:spring-core:2.5.6, org.springframework:spring-beans:2.5.6,org.springframework:spring-context:2.5.6,它们都是来自同一项目的不同模块。因此，所有这些依赖的版本都是相同的，而且可以预见，如果将来需要升级Spring Framework，这些依赖的版本会一起升级。因此，我们应该在一个唯一的地方定义版本，并且在dependency声明引用这一版本，这一在Spring Framework升级的时候只需要修改一处即可。

Xml代码  

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.mycompany.app</groupId>
  5. <artifactId>my-app-simple</artifactId>
  6. <version>0.0.1-SNAPSHOT</version>
  7. <packaging>jar</packaging>
  8. <name>my-app-simple</name>
  9. <properties>
  10. <springframework.version>2.5.6</springframework.version>
  11. </properties>
  12. <dependencies>
  13. <dependency>
  14. <groupId>junit</groupId>
  15. <artifactId>junit</artifactId>
  16. <version>3.8.1</version>
  17. <scope>test</scope>
  18. </dependency>
  19. <dependency>
  20. <groupId>org.springframework</groupId>
  21. <artifactId>spring-core</artifactId>
  22. <version>${springframework.version}</version>
  23. </dependency>
  24. <dependency>
  25. <groupId>org.springframework</groupId>
  26. <artifactId>spring-beans</artifactId>
  27. <version>${springframework.version}</version>
  28. </dependency>
  29. </dependencies>
  30. </project>

6. 在Eclipse中管理依赖

安装好m2eclipse之后（第2课有详细讲解）就可以用eclipse来管理依赖。

如图，在该项目的pom.xml中点击Dependency Hierarchy可以看到依赖树:

点击Dependencies可以添加新的依赖，点击选择一个依赖，点击remove可以删除，点击Add可以新增一个依赖，如图：

如下图，搜素org.springframework（此处是从Maven中心仓库进行搜索），选择你想要的模块和版本，点击OK即可：

时间： 2024-10-27 14:15:55

maven入门（8）maven的依赖管理的相关文章

Maven学习（3）-依赖管理-POM文件中依赖的版本管理

pom.xml中依赖的定义样例: <dependencies> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.1</version> </dependency></dependencies>

Maven入门指南 Maven 快速入门及简单使用

Maven入门指南 :Maven 快速入门及简单使用 前言 Maven是一个Java语言编写的开源项目管理工具,是Apache软件基金会的顶级项目.主要用于项目构建,依赖管理,项目信息管理. maven项目在编译.测试.打包里,会需要从maven的中央仓库(即:maven组织公布在互联网上的一个站点,里面已经收录了目前绝大多数主流的jar包)下载jar包等文件, 如果使用代理服务器上网,需要配置代理服务器. 理解"仓库" 首次运行完mvn -version后,会在用户目录下创建一个.m

Maven学习（3）-依赖管理-POM文件中依赖的范围定义

来源: https://www.cnblogs.com/best/p/9676515.html#_lab2_1_2 https://www.cnblogs.com/kabi/p/8509049.html POM文件中的依赖可以通过<scope>标签定义依赖范围: <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.1

Maven学习（3）-依赖管理-项目依赖相关操作命令

1.查看项目所有依赖树: 在项目的pom.xml所在目录执行:mvn dependency:tree -Dincludes=[groupId]:[artifactId]:[type]:[version] 如:mvn dependency:tree -Dincludes=org.javassist:javassist:jar 详见Maven插件官网:http://maven.apache.org/plugins/maven-dependency-plugin/get-mojo.html#artif

Maven 入门——认识Maven结构

1.settings.xml 元素解读 localRepository 该元素表示本地 Maven 仓库的地址,不设置的话,默认为 ~/.m2/repository pluginGroups 将插件的信息注册到 Maven 中,是的执行 Maven plugin 命令的时候可以不指定 groupId 和 artifactId,比如: 这个生成源代码的插件,运行的时候不需要指定它的 groupId 和 artifactId,只需要执行mybatis-generator:generate 即可,因为

Maven入门使用（一）

一.什么是maven 一般认为maven是项目构建工具+依赖管理工具+项目信息管理工具. maven是一个强大的构建工具,能够帮助我们自动化构建过程. 清理.编译.测试.生成报告.打包.部署都是可以通过maven自定义的命令一步完成,不需要我们一步步去手动执行. 同时,maven也帮助我们标准化构建过程.如果手动构建,一千个程序员就有一千种构建方式,这给团队合作带来很大的不便. 最后,maven是跨平台的,对外它提供了一致的接口.不管你是在Windows 还是Linux下,使用的maven命令都

Spring Security 3.2.x与Spring 4.0.x的Maven依赖管理

原文链接: Spring Security with Maven原文日期: 2013年04月24日翻译日期: 2014年06月29日翻译人员: 铁锚 1. 概述 本文通过实例为您介绍怎样使用 Maven 管理 Spring Security 和 Spring 的依赖关系.最新的Spring Security公布版本号能够在 Maven Central仓库 中找到. 译者建议訪问MVNRespotory中org.springframework.security链接.本文是 使用Maven管理Spr

Java构建工具：如何用Maven，Gradle和Ant+Ivy进行依赖管理

原文来自:https://zeroturnaround.com/rebellabs/java-build-tools-how-dependency-management-works-with-maven-gradle-and-ant-ivy/ 编译的时候可以运行,运行时出问题 在当今java项目自动化构建的场景当中,依赖管理已经成为了项目构建自动化工具中的一个主要部分,但是在过去并总是这样. 回想以前那个很爽的时候,你的项目依赖性管理只需要将jar包导入到lib文件夹中,然后将其加入到你的版本控

4.Maven概念模型，maven的生命周期，Maven坐标，依赖管理（依赖范围，依赖声明），仓库管理，私服概念

 1 maven概念模型 2 maven的生命周期,项目构建过程 Maven生命周期就是为了对所有的构建过程进行抽象和统一 包括项目清理,初始化,编译,打包,测试,部署等几乎所有构建步骤 Maven有"三套"相互独立的生命周期,而且相互独立,这三套生命周期分别是: Maven三大生命周期 clean:清理项目的 在进行真正的构建之前进行一些清理工作. default:构建项目的 构建的核心部分,编译,测试,打包,部署等等. site:生成项目站点的 生成项目报告,站点,发布站点 要