精华内容
下载资源
问答
  • optional可选依赖,表示当一个项目依赖添加上optional=true的选项后,子项目中将不会包含这个依赖。常用于解决jar包冲突问题,和exclusion排除jar有异曲同工之妙,假设a项目引入了以下依赖: <!--伪代码...

    optional可选依赖,表示当一个项目中的依赖添加上optional=true的选项后,子项目中将不会包含这个依赖。常用于解决jar包冲突问题,和exclusion排除jar有异曲同工之妙,假设a项目中引入了以下依赖:

    <!--伪代码写法-->
    <project>
    	<groupId>com.xxx.test</groupId>
    	<artifactId>test-a</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>pom</packaging>
        <dependency>
    	    <groupId>org.springframework.boot</groupId>
    	    <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>
    </project>

    b项目引入了a项目后发现spring-boot-configuration-processor和当前项目存在版本冲突问题,解决方式:

    一、b项目中使用exclusion排除

    <dependency>
      <groupId>com.xxx.test</groupId>
      <artifactId>test-a</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <exclusions>
         <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
         </exclusion>
      </exclusions>
    </dependency>

    二、a项目中使用optional选项

    <project>
    	<groupId>com.xxx.test</groupId>
    	<artifactId>test-a</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>pom</packaging>
            <dependency>
    	    <groupId>org.springframework.boot</groupId>
    	    <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
    </project>

    推荐阅读:一文带你了解maven依赖中的scope选项

                      一文带你了解maven中的dependencyManagement

     

    展开全文
  • maven中的项目依赖默认是可传递的,所以会添加很多不必要的依赖 比如A->B、B->C、那么A自动依赖C。 Maven 依赖排除(Exclusions) maven构建的项目具有依赖可传递的特性,添加某个依赖的时候,可能会引入不...

    依赖传递

    maven中的项目依赖默认是可传递的,所以会添加很多不必要的依赖
    比如A->B、B->C、那么A自动依赖C。

    Maven 依赖排除(Exclusions)

    maven构建的项目具有依赖可传递的特性,添加某个依赖的时候,可能会引入不需要的依赖
    会导致:
    • Jar包版本冲突,如老版本Jar包缺失某个方法;
    • JDK 版本不兼容;
    • 老版本存在安全漏洞;

    Maven 容许你通过exclusions标签来排除你不想要的依赖。这样,在你构建项目时,这些个排除依赖,将不会被打包进你的项目中。

    <dependencies>
        <dependency>
          <groupId>sample.ProjectA</groupId>
          <artifactId>Project-A</artifactId>
          <version>1.0</version>
          <scope>compile</scope>
          <exclusions>
            <exclusion>  <!-- 在这里声明,将项目A中的项目B依赖排除 -->
              <groupId>sample.ProjectB</groupId>
              <artifactId>Project-B</artifactId>
            </exclusion>
          </exclusions> 
        </dependency>
      </dependencies>
    
    Maven 可选依赖 (Optional)

    或者通过把依赖设置为可选依赖来让依赖传递关闭
    比如A->B、B->C、但是B->C是可选依赖,那么A就不会依赖C,如果想要使用C就要手动添加依赖。

      <dependencies>
      	  <!-- 将 mysql 驱动包依赖设置为可选依赖 -->
       	<dependency>
      	 	<groupId>mysql</groupId>
       		<artifactId>mysql-connector-java</artifactId>
       		<version>5.1.45</version>
        	<optional>true</optional> <!-- optional 的值有 true 和 false 可选 -->
      	</dependency>
      </dependencies>
    
    展开全文
  • Optional定义后,该依赖只能在本项目传递,不会传递到引用该项目的父项目,父项目需要主动引用该依赖才行。 Exclusions则是主动排除子项目传递过来的依赖。 假如有三个项目分别为A项目、B项目、C项目,依赖...

    前面必读的话

    Optional和Exclusions都是用来排除jar包依赖使用的,两者在使用上却是相反。Optional表示可选择的,Exclusions表示排除

    Optional定义后,该依赖只能在本项目中传递,不会传递到引用该项目的父项目中,父项目需要主动引用该依赖才行。

    Exclusions则是主动排除子项目传递过来的依赖。

    假如有三个项目分别为A项目、B项目、C项目,依赖引用关系是:A引用B的依赖、C引用A的依赖,当在B中设置某个依赖 <optional>true</optional>时,A项目中不会将这个依赖引用过来,由于依赖的传递性,C引用A项目时,C项目也不会将这个依赖引用过来,如果C项目想引用这个依赖,需要显示的申明(见下面例子),才可以引用过来;true表示不传递,false即可传递;

     1、Exclusions,主动排除子项目传递过来的依赖

    <dependencies>
        <dependency>
          <groupId>sample.ProjectA</groupId>
          <artifactId>Project-A</artifactId>
          <version>1.0</version>
          <scope>compile</scope>
          <exclusions>
            <exclusion>
              <groupId>sample.ProjectB</groupId>
              <artifactId>Project-B</artifactId>
            </exclusion>
          </exclusions> 
        </dependency>
    </dependencies>

    2、optional用法

      新建两个Maven工程,分别为maven-projectA和maven-projectB

      2.1. 在maven-projectA项目中贴出pom依赖如下:

    <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/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.thinkingcao</groupId>
    	<artifactId>maven-projectA</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>maven-project1</name>
    	<url>http://maven.apache.org</url>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
    
    		<!-- fastjson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.60</version>
    		</dependency>
    
    
    	</dependencies>
    </project>
    

    2.2. 在maven-projectB项目中贴出pom依赖如下:

    <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/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.thinkingcao</groupId>
      <artifactId>maven-projectB</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
    
      <name>maven-projectB</name>
      <url>http://maven.apache.org</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    </project>
    

      2.3. 以上是新建两个Maven工程的项目配置信息,这里假设maven-projectB项目要使用maven-projectA项目中的fastjson依赖包,这时候, maven-projectB项目配置如下:

    <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/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.thinkingcao</groupId>
      <artifactId>maven-projectB</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
    
      <name>maven-projectB</name>
      <url>http://maven.apache.org</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
        <dependency>
              <groupId>com.thinkingcao</groupId>
    	  <artifactId>maven-projectA</artifactId>
    	  <version>0.0.1-SNAPSHOT</version>
        </dependency>
      </dependencies>
    </project>
    


    在这种情况下,maven-projectA项目中的fastjson依赖信息会被maven-projectB项目所依赖引用,从Maven的依赖包存放的仓库路径就可以看出来,如图所示:

     

    那么, 如何让fastjson依赖变成可选依赖呢,这时候就要用到可选依赖(Optional)这个属性了,我们在maven-projectA项目的fastjson依赖中加入optional属性,加入之后,这时候你就发现你的maven-projectB工程刚才的fastjson依赖没有了

    	    <!-- fastjson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.60</version>
    			<optional>true</optional>
    		</dependency>
    

     那么问题来了,我怎么才能可选择性的在maven-projectB项目中使用maven-projectA项目的fastjson依赖呢,就是像项目比较庞大的情况下,依赖关系很多,使用Optional属性就可以自由的在依赖和不依赖两者中切换了,如果我们想要使用maven-projectA项目中的fastjson依赖,需要在maven-projectA项目中设optional为false或者去除optional,或者说在B项目中显式调用。


     

    2.4. 关于parent 继承的情况

     如果maven-projectA的配置是下面这种形式

    <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/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.thinkingcao</groupId>
    	<artifactId>maven-projectA</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>maven-project1</name>
    	<url>http://maven.apache.org</url>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
    
    		<!-- fastjson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.60</version>
    			<optional>true</optional>
    		</dependency>
    
    
    	</dependencies>
    </project>
    


    maven-projectB项目再去引用的话,还是可以正常引用fastjson包,optional选项在统一控制版本的情况下会失效。

    <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/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.thinkingcao</groupId>
      <artifactId>maven-projectB</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
    
      <name>maven-projectB</name>
      <url>http://maven.apache.org</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
        
                    <dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    		</dependency>
    
      </dependencies>
    </project>
    

     

    展开全文
  • 在一些项目,我们知道用exclusion排除一些依赖包,这属于依赖排除(Dependency Exclusions),还有一种就是今天所说的可选依赖Optional Dependencies)。主要还是讲怎么用。 准备工作 准备两个工程,简单点...

    在一些项目中,我们知道用exclusion排除一些依赖包,这属于依赖排除(Dependency Exclusions),还有一种就是今天所说的可选依赖(Optional Dependencies)。主要还是讲怎么用。

    准备工作

    准备两个工程,简单点,就是A和B

    只看POM文件,这是A的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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>A</groupId>
        <artifactId>A</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>2.9.9</version>
            </dependency>
        </dependencies>
    </project>

    这是B的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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>B</groupId>
        <artifactId>B</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>A</groupId>
                <artifactId>A</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </project>

    在这种情况下,joda-time包在B工程会被正常引用。

    加入optional

    在A工程对joda-time添加optional选项,这时在B工程中,joda-time依赖包会消失.

        <dependencies>
            <dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>2.9.9</version>
                <optional>true</optional>
            </dependency>
        </dependencies>

    如果想引这个包,需要在A项目中设optional为false或者去除optional,或者在B项目中显式调用。

    parent 继承的情况

    如果A的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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>A</groupId>
        <artifactId>A</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>joda-time</groupId>
                    <artifactId>joda-time</artifactId>
                    <version>2.9.9</version>
                    <optional>true</optional>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>

    B再去引用的话,还是可以正常引用joda-time包,optional选项在统一控制版本的情况下会失效。

    <?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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>B</groupId>
        <artifactId>B</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>A</groupId>
            <artifactId>A</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
            </dependency>
        </dependencies>
    </project>
    展开全文
  • 本节介绍Maven中的可选依赖依赖性排除功能。 【原文链接】 Optional 依赖 如果明确一个 project 无论出于什么原因考虑都不可能继续分割成子项目,则其依赖可以使用 optional。 如果其他 project 依赖了 使用 ...
  • maven依赖管理,有两种方式可以对依赖关系进行,分别是可选依赖Optional Dependencies)以及依赖排除(Dependency Exclusions)。 一、可选依赖 当一个项目A依赖另一个项目B时,项目A可能很少一部分功能...
  • 1、父模块的依赖中不添加<optional>true</optional> 父模块pom文件: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...
  • maven依赖管理,有两种方式可以对依赖关系进行,分别是 可选依赖Optional Dependencies)以及依赖排除(...
  • maven依赖管理,有两种方式可以对依赖关系进行,分别是可选依赖Optional Dependencies)以及依赖排除(Dependency Exclusions)。 一、可选依赖 当一个项目A依赖另一个项目B时,项目A...
  • 举例如下: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId>...scope的值有以下几种可能,进行分
  • 1.Maven中依赖概述 Maven中依赖关系是有传递性的。例如:项目B依赖项目C(B —> C),如果有一个项目A依赖项目B(A —> B)的话,那么项目A也会依赖项目C(A —> C)。虽然,这种依赖的自动传递性给我们...
  • Maven 依赖关系是有传递性的。Maven 为我们提供了两种管理解决方案,分别是可选依赖Optional Dependencies)和依赖排除(Dependency Exclusions)。
  • Maven中optional和scope元素 optional元素 optional:可选的,用来控制依赖是否向下传递;默认为false,表示依赖向下传递,如果设置为true,表示不向下传递; 例如热部署依赖: <!--devtools 热部署--> <...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 189
精华内容 75
关键字:

maven依赖中optional