精华内容
下载资源
问答
  • 主要给大家介绍了关于Android Studio Gradle依赖冲突解决的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Android Studio具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要介绍了maven依赖冲突以及解决方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 为了方便看效果,我们改下gradle解决策略为有版本冲突时自动失败,如下: configurations.all { resolutionStrategy { failOnVersionConflict() } } 当我们同时依赖不同版本rxjava时编译会报错如下: 解决...
  • 主要介绍了通过IDEA快速定位和排除依赖冲突问题,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 基于 yarn 自动收集依赖冲突,可视化给出 resolutions 建议,以此得到产物减小的收益 version: 1.0.4 为什么要使用 yarn resolutions ? 安装 yarn global add yarn-resolutions 使用 在项目根目录执行: yarn-...
  • 什么是Maven依赖冲突? 在解决冲突之前首先我们要知道什么是依赖冲突,这样可以更好的去锁定bug原因。下面通过一个代码示例来真正展示出依赖冲突。 1、添加依赖 <dependency> <groupId>org.spring...

    在解决冲突之前首先我们要知道什么是依赖冲突,这样可以更好的去锁定bug原因。下面通过一个代码示例来真正展示出依赖冲突。

    依赖冲突代码演示

    1、添加依赖

    <dependencies>
    	 <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.0.2.RELEASE</version>
        </dependency>
    </dependency>
    

    2、观察依赖的层次结构

    这里以core包来示例,spring和spring mvc都会依赖core包,这里我们会发现虽然我只导入了spring和spring mvc,但是maven却帮我们导入了,他所需要的相关jar包,这就是依赖的传递性。

    3、运行项目jra包冲突直接报错

    大概错误应该是找不到方法什么的,因为springmvc用的版本是5.0.2,而spring用的是4.2.4,依赖的传递他有一个就近原则,就是我spring依赖在上面所以他传递下来的就都是以spring的依赖版本为主的,也就是springmvc当中的core包相关包都会是4.2.4版本。版本之间肯定会有差异,所以有时候会报一些找不到方法或者类之类的错误。

    解决Maven依赖冲突的思路

    下面简单讲一下当我们出现依赖冲突的时候,我们解决依赖冲突的思路。针对于上面的报错,经测试只能采用第一种方式可行。

    1、版本号统一

    当我们能版本号统一的时候尽量版本号统一,这样可以直接的避免一些版本之间差异的问题。这里我们让spring和spring mvc统一版本,两个都用5.0.2版本的,再次运行成功解决报错。

      <dependencies>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.0.2.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.0.2.RELEASE</version>
        </dependency>
    <dependencies>
    

    2、路径最短者优先

    这里我们还是以context包下的core包来做示例

    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>4.2.4.RELEASE</version>
     </dependency>
    
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-core</artifactId>
       <version>5.0.2.RELEASE</version>
     </dependency>
    

    从这里可以看出5.0.2取代了4.2.4,这就是我们所说的路劲最短者优先,因为context的依赖虽然会自动导入core包,但是那就是属于下级依赖了,而5.0.2这个依赖和context这个依赖为同级,所以最终会取这个版本。

    3、路径相同时先声明者优先

    当我们把两个依赖顺序颠倒一下,会发现core包相关包都会是5.0.2版本,当然针对于上面问题,使用该方法仍然报错,因为有的时候版本之间是无法互相替代的,这个时候只能采用第一种版本号统一。

    <dependencies>
    	 <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.0.2.RELEASE</version>
         </dependency>
    	 <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
    </dependency>
    

    当调换顺序之后我们会发现他会都引用5.0.2

    4、排除依赖

    jar包他是存在相互依赖的,就比如spring-context他依赖aop,和core包等,当他和别的jar包产生冲突的时候,我们可以考虑在保证项目在排除他的冲突jar包还可以正常运行和使用的情况下进行排除,从而解决依赖冲突的问题。
    下面以core包为例,进行排除,首先打开pom然后打开依赖层次结构找到要排除的jar包以及层次,然后右键打开pom

    打开pom之后我们可以找到他的坐标和模块名称

    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context</artifactId>
    	<version>5.0.2.RELEASE</version>
    	<exclusions>
    		<exclusion>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    		</exclusion>
    	</exclusions>
    </dependency>
    

    总结

    总体来说解决冲突的方案就是以上几种,我们需要根据实际场景来进行选择性解决,看看哪一种方案更适合。

    展开全文
  • maven依赖冲突以及解决方法

    千次阅读 2020-06-23 11:38:53
    什么是依赖冲突 依赖冲突是指项目依赖的某一个jar包,有多个不同的版本,因而造成类包版本冲突 依赖冲突的原因 依赖冲突很经常是产类包之间的间接依赖引起的。每个显式声明的类包都会依赖于一些其它的隐式类包,这些...

    什么是依赖冲突

    依赖冲突是指项目依赖的某一个jar包,有多个不同的版本,因而造成类包版本冲突

    依赖冲突的原因

    依赖冲突很经常是类包之间的间接依赖引起的。每个显式声明的类包都会依赖于一些其它的隐式类包,这些隐式的类包会被maven间接引入进来,从而造成类包冲突

    如何解决依赖冲突

    首先查看产生依赖冲突的类jar,其次找出我们不想要的依赖类jar,手工将其排除在外就可以了。具体执行步骤如下

    1、查看依赖冲突

    a、通过dependency:tree是命令来检查版本冲突

    mvn -Dverbose dependency:tree
    

    当敲入上述命令时,控制台会出现形如下内容

    [INFO] org.example:hello:jar:1.0-SNAPSHOT
    [INFO] +- org.springframework:spring-context:jar:5.2.7.RELEASE:compile
    [INFO] |  +- (org.springframework:spring-aop:jar:5.2.7.RELEASE:compile - omitted for conflict with 5.2.0.RELEASE)
    [INFO] |  +- org.springframework:spring-beans:jar:5.2.7.RELEASE:compile
    [INFO] |  |  \- (org.springframework:spring-core:jar:5.2.7.RELEASE:compile - omitted for duplicate)
    [INFO] |  +- org.springframework:spring-core:jar:5.2.7.RELEASE:compile
    [INFO] |  |  \- org.springframework:spring-jcl:jar:5.2.7.RELEASE:compile
    [INFO] |  \- org.springframework:spring-expression:jar:5.2.7.RELEASE:compile
    [INFO] |     \- (org.springframework:spring-core:jar:5.2.7.RELEASE:compile - omitted for duplicate)
    [INFO] \- org.springframework:spring-aop:jar:5.2.0.RELEASE:compile
    [INFO]    +- (org.springframework:spring-beans:jar:5.2.0.RELEASE:compile - omitted for conflict with 5.2.7.RELEASE)
    [INFO]    \- (org.springframework:spring-core:jar:5.2.0.RELEASE:compile - omitted for conflict with 5.2.7.RELEASE)
    

    其中omitted for duplicate表示有jar包被重复依赖,最后写着omitted for conflict with xxx的,说明和别的jar包版本冲突了,而该行的jar包不会被引入。比如上面有一行最后写着omitted for conflict with 5.2.7.RELEASE,表示spring-core 5.2.0版本不会被项目引用,而spring-core 5.2.7版本会被项目引用

    b、如果是idea,可以安装maven helper插件来检查依赖冲突

    maven helper插件安装成功,点开pom.xml会发现多了一个Dependency Analyzer视图,如下
    Dependency Analyzer.png
    上面按钮的图标含义如下

    • Conflicts(查看冲突)
    • All Dependencies as List(列表形式查看所有依赖)
    • All Dependencies as Tree(树形式查看所有依赖)

    上图说明有3个jar存在冲突,点击冲突的jar,可以查看和哪个jar产生冲突,如下图
    查看冲突.png

    2、解决冲突

    项目的pom.xml形如下

     <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
    
    
        </dependencies>
    
    

    通过查看依赖树,我们知道项目会引用5.2.7.RELEASE的spring core jar包,而不会引用5.2.0的jar包,如果我们想用5.2.0版本的spring core包,我们该如何做?

    a、使用第一声明者优先原则

    谁先定义的就用谁的传递依赖,即在pom.xml文件自上而下,先声明的jar坐标,就先引用该jar的传递依赖。因此我们如果要使用5.2.0版本的spring core包,我们可以改成如下声明

      <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
        </dependencies>
    
    

    查看依赖树

    [INFO] org.example:hello:jar:1.0-SNAPSHOT
    [INFO] +- org.springframework:spring-aop:jar:5.2.0.RELEASE:compile
    [INFO] |  +- org.springframework:spring-beans:jar:5.2.0.RELEASE:compile
    [INFO] |  |  \- (org.springframework:spring-core:jar:5.2.0.RELEASE:compile - omitted for duplicate)
    [INFO] |  \- org.springframework:spring-core:jar:5.2.0.RELEASE:compile
    [INFO] |     \- org.springframework:spring-jcl:jar:5.2.0.RELEASE:compile
    [INFO] \- org.springframework:spring-context:jar:5.2.7.RELEASE:compile
    [INFO]    +- (org.springframework:spring-aop:jar:5.2.7.RELEASE:compile - omitted for conflict with 5.2.0.RELEASE)
    [INFO]    +- (org.springframework:spring-beans:jar:5.2.7.RELEASE:compile - omitted for conflict with 5.2.0.RELEASE)
    [INFO]    +- (org.springframework:spring-core:jar:5.2.7.RELEASE:compile - omitted for conflict with 5.2.0.RELEASE)
    [INFO]    \- org.springframework:spring-expression:jar:5.2.7.RELEASE:compile
    [INFO]       \- (org.springframework:spring-core:jar:5.2.7.RELEASE:compile - omitted for conflict with 5.2.0.RELEASE)
    
    

    通过依赖树,我们可以看到项目已经引入5.2.0版本的spring core包

    b、使用路径近者优先原则

    即直接依赖级别高于传递依赖。因此我们可以在最先的pom.xml添加如下内容

     <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
    
    
    
        </dependencies>
    

    路径近者优先.png通过上图可以看到项目引入是 spring core 5.2.0的包

    c、排除依赖

    排除依赖如果是idea,可以使用maven helper插件进行排除。点开pom.xml,切换到Dependency Analyzer视图,选择All Dependencies as Tree,点击要排除的jar,右键会出现Execlude选项,如下
    去除依赖.png
    它产生的效果和如下配置是一样

     <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.7.RELEASE</version>
                <exclusions>
                    <exclusion>
                        <artifactId>spring-core</artifactId>
                        <groupId>org.springframework</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
    
        </dependencies>
    
    

    查看依赖.png
    通过上图可以看到项目引入是 spring core 5.2.0的包

    4、版本锁定

    使用dependencyManagement 进行版本锁定,dependencyManagement可以统一管理项目的版本号,确保应用的各个项目的依赖和版本一致。

    如果我们项目中只想使用spring core 5.2.0的包,pom.xml可以改为如下

    <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>5.2.0.RELEASE</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.7.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
    
        </dependencies>
    
    

    版本锁定.png
    通过上图可以看到项目引入是 spring core 5.2.0的包

    总结

    综上就是maven如何排查依赖冲突以及解决方法,对于排查依赖个人比较推荐使用maven helper插件,至于解决依赖冲突个人推荐使用版本锁定的方法,此外dependencyManagement只是声明依赖,并不自动实现引入,因此子项目需要显示的声明需要用的依赖

    展开全文
  • idea 解决包依赖冲突

    2020-08-28 18:04:01
    小G昨天发现idea一个比较好的工具,可以解决关于解决包依赖冲突所以写下来 首先我们找到我们maven 中pom,然后右键打开鼠标在maven,然后点击show dependencies 2、查看包依赖冲突,点击标识,鼠标点击后显示...

    小G昨天发现idea一个比较好的工具,可以解决关于解决包依赖冲突所以写下来

    1. 首先我们找到我们maven 中pom,然后右键打开鼠标在maven,然后点击show dependencies
      在这里插入图片描述

    2、查看包依赖冲突,点击标识,鼠标点击后显示conflicts/dupclicatess,
    看下红色的标识就是标识依赖包冲突,然后大家查询下,然后再pom.xml注解掉就可以,这个是我加一个分页导致版本不一致,详细的内容小G在下面一句标注

    <!--			<exclusions>-->
    <!--				<exclusion>-->
    <!--					<groupId>org.mybatis</groupId>-->
    <!--					<artifactId>mybatis</artifactId>-->
    <!--				</exclusion>-->
    <!--				<exclusion>-->
    <!--					<groupId>org.mybatis</groupId>-->
    <!--					<artifactId>mybatis-spring</artifactId>-->
    <!--				</exclusion>-->
    <!--			</exclusions>-->
    

    在这里插入图片描述

    展开全文
  • 1、maven自动解决依赖冲突的规则是什么? 2、如何查看当前项目的maven的依赖树? 3、如何从依赖树中找到自己预期的版本,是被那个jar给覆盖了? 4、如何人工进行依赖冲突解决,达到使用目的? 二、解决问题 1、...

    一、问题

    项目开发过程中,经常会遇到jar冲突,然后maven根据自己的规则进行冲突解决,导致项目在运行的过程中报错。

    1、maven自动解决依赖冲突的规则是什么?

    2、如何查看当前项目的maven的依赖树?

    3、如何从依赖树中找到自己预期的版本,是被那个jar给覆盖了?

    4、如何人工进行依赖冲突解决,达到使用目的?

    二、解决问题

    1、maven自动解决依赖冲突的规则是什么?

    第一原则:路径最近者优先

    项目A有如下的依赖关系:

    A->B->C->X(1.0)

    A->D->X(2.0)

    则该例子中,X的版本是2.0

    第二原则:路径相等,先声明者优先

    项目A有如下的依赖关系:

    A->B->Y(1.0)

    A->C->Y(2.0)

    若pom文件中B的依赖坐标先于C进行声明,则最终Y的版本为1.0

    2、如何查看当前项目的maven依赖树?

     
    1. //进入项目的pom.xml文件的目录下,运行如下命令
    2. //这个是正常依赖的树
    3. mvn dependency:tree
    4. //这个命令是查看maven是如何解决依赖冲突的依赖树
    5. mvn -Dverbose dependency:tree
    6. //如果想将依赖树打印到指定文件中,则命令如下
    7. mvn -Dverbose dependency:tree -Doutput=/Users/shangxiaofei/sxfoutput.txt

    3、如何从依赖树中找到自己预期的版本,是被那个jar给覆盖了?

    例子:

     

     

    递归依赖的关系列的算是比较清楚了,每行都是一个jar包,根据缩进可以看到依赖的关系。
    最后写着compile的就是编译成功的。
    最后写着omitted for duplicate的就是有jar包被重复依赖了,但是jar包的版本是一样的。
    最后写着omitted for conflict with xxxx的,说明和别的jar包版本冲突了,而该行的jar包不会被引入。比如上面有一行最后写着omitted for conflict with 3.4.6,那么该行的zookeeper:jar:3.4.8不会被引入,会引入3.4.6版本

    最后写着version managed from 2.3 ;omitted for duplicate ,表示最终使用commons-pool2最终会使用2.4.2,拒绝使用<dependencyManagement></dependencyManagement>中声明的2.3版本

    最后写着version managed from 1.16.8 ;表示最终使用lombok:jar:1.16.22版本

    4、如何人工进行依赖冲突解决,达到使用目的?

    解决重复依赖和冲突的方法:

    1,修改pom文件中两个dependency元素的位置。如果两个dependency都引用了一个jar包,但是版本不同,classloader只会加载jar包在pom文件中出现的第一个版本,以后出现的其他版本的jar包会被忽略。

    不建议使用该方法,因为引用不同版本的jar包本身就是很危险的。

    2,使用<exclusions>标签来去掉某个dependency依赖中的某一个jar包或一堆jar包,<exclusion>中的jar包或者依赖的相关jar包都会被忽略,从而在两个dependency都依赖某个jar包时,可以保证只使用其中的一个。

    可以这么写:

     
    1. <dependency>
    2. <groupId>com.alibaba</groupId>
    3. <artifactId>dubbo</artifactId>
    4. <version>2.8.3.2</version>
    5. <exclusions>
    6. <exclusion>
    7. <artifactId>guava</artifactId>
    8. <groupId>com.google.guava</groupId>
    9. </exclusion>
    10. <exclusion>
    11. <artifactId>spring</artifactId>
    12. <groupId>org.springframework</groupId>
    13. </exclusion>
    14. </exclusions>
    15. </dependency>

    ====================Maven坐标基础知识===================

    1、maven的依赖基础

     
    1. <dependency>
    2. <groupId>com.alibaba.share</groupId>
    3. <artifactId>test</artifactId>
    4. <version>1.4</version>
    5. </dependency>
    6.  
    7. 依赖库命名规则:
    8. ${groupId.part1}/${groupId.part2}/${version}
    9. 例:com/alibaba/share/1.4
    10.  
    11. 依赖库文件命名规则:
    12. ${artifactId}-${version}-${classifier}.${type}
    13. 例:test-1.4-source.jar
    14.  
    15. 注:classfier即分类器,多数的时候是用不到的,不过有写情况需要,例:
    16. TestNG强制需要你提供分类器,以区别jdk14和jdk15
    17. <dependency>
    18. <groupId>org.testng</groupId>
    19. <artifactId>testng</artifactId>
    20. <version>5.7</version>
    21. <classifier>jdk15</classifier>
    22. </dependency>

    2、maven依赖范围

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

    上面的scope即约定依赖范围。 
    compile:默认值,一直可用,最后会被打包 
    provided:编译期间可用,不会被传递依赖,不会被打包。例:依赖于web容器中的提供的一个jar包,在编译的时候需要加入依赖(web容器还没有介入),运行的时候由web容器来提供。 
    test:执行单元测试时可用,不会被打包,不会被传递依赖 
    runtime:运行和测试时需要,但编译时不需要 
    system:不推荐使用

    3、maven依赖管理

    避免不同子模块中依赖版本冲突 
    在父pom中配置依赖

     
    1. <dependencyManagement>
    2. <dependencies>
    3. <dependency>
    4. <groupId>mysql</groupId>
    5. <artifactId>mysql-connector-java</artifactId>
    6. <version>5.1.2</version>
    7. </dependency>
    8. ...
    9. <dependencies>
    10. </dependencyManagement>

    在子pom中添加依赖

     
    1. <dependencies>
    2. <dependency>
    3. <groupId>mysql</groupId>
    4. <artifactId>mysql-connector-java</artifactId>
    5. </dependency>
    6. </dependencies>

    dependencyManagement实际上不会真正引入任何依赖,在子pom中添加之后才会。在父pom中配置了之后,子模块只需使用简单groupId和artifactId就能自动继承相应的父模块依赖配置。如果子pom中定义了version,则覆盖management中的。

    4、可选依赖

     
    1. <dependency>
    2. <groupId>mysql</groupId>
    3. <artifactId>mysql-connector-java</artifactId>
    4. <version>1.5</version>
    5. <optional>true</optional>
    6. </dependency>

    5、依赖版本界限

    要求的依赖版本>=3.8且<4.0

     
    1. <version>[3.8,4.0)</version>

    要求的依赖版本<=3.8.1

     
    1. <version>[,3.8.1]</version>

    要求必须是3.8.1版本,如果不是的话会构建失败,提示版本冲突。原来的写法<version>3.8.1</version>的意思是所有版本都可以,但最好是3.8.1

     
    1. <version>[3.8.1]</version>

    6、排除依赖

    依赖project-a但是排除掉对project-a中引入的project-b的依赖 

     
    1. <dependency>
    2. <groupId>org.sonatype.mavenbook</groupId>
    3. <artifactId>project-a</artifactId>
    4. <version>1.0</version>
    5. <exclusions>
    6. <exclusion>
    7. <groupId>org.sonatype.mavenbook</groupId>
    8. <artifactId>project-b</artifactId>
    9. </exclusion>
    10. </exclusions>
    11. </dependency>

    替换依赖 
    直接使用上一步中的排除掉,然后添加要替换进来的依赖就可以了,没有什么特殊的标志来标志这个是替换进来的。

    7、版本冲突仲裁

     
    1. 版本仲裁规则(在maven 2.2.1版本上测试验证)
    2. • 按照项目总POM的DependencyManager版本声明进行仲裁(覆盖),但无警告。
    3. • 如无仲裁声明,则按照依赖最短路径确定版本。
    4. • 若相同路径,有严格区间限定的版本优先。
    5. • 若相同路径,无版本区间,则按照先入为主原则。

    8、依赖冲突解决办法

    查看那些jar包依赖了冲突包的命令

     
    1. mvn dependency:tree -Dverbose -Dincludes=被依赖的包

    刚才吹嘘dependency:tree时,我用到了“无处遁形”,其实有时你会发现简单地用dependency:tree往往并不能查看到所有的传递依赖。不过如果你真的想要看所有的,必须得加一个-Dverbose参数,这时就必定是最全的了。
    全是全了,但显示出来的东西太多,头晕目眩,有没有好法呢?当然有了,加上Dincludes或者Dexcludes说出你喜欢或讨厌,dependency:tree就会帮你过滤出来:
    引用
    Dincludes=org.springframework:spring-tx
    过滤串使用groupId:artifactId:version的方式进行过滤,可以不写全啦,如:

    mvn dependency:tree -Dverbose -Dincludes=asm:asm

    就会出来asm依赖包的分析信息:

    [INFO] --- maven-dependency-plugin:2.1:tree (default-cli) @ ridge-test ---
    [INFO] com.ridge:ridge-test:jar:1.0.2-SNAPSHOT
    [INFO] +- asm:asm:jar:3.2:compile
    [INFO] \- org.unitils:unitils-dbmaintainer:jar:3.3:compile
    [INFO]    \- org.hibernate:hibernate:jar:3.2.5.ga:compile
    [INFO]       +- cglib:cglib:jar:2.1_3:compile
    [INFO]       |  \- (asm:asm:jar:1.5.3:compile - omitted for conflict with 3.2)
    [INFO]       \- (asm:asm:jar:1.5.3:compile - omitted for conflict with 3.2)
    [INFO] ------------------------------------------------------------------------

    对asm有依赖有一个直接的依赖(asm:asm:jar:3.2)还有一个传递进入的依赖(asm:asm:jar:1.5.3)

    第二板斧:将不想要的传递依赖剪除掉

    承上,假设我们不希望asm:asm:jar:1.5.3出现,根据分析,我们知道它是经由org.unitils:unitils-dbmaintainer:jar:3.3引入的,那么在pom.xml中找到这个依赖,做其它的调整:

    <dependency>  
            <groupId>org.unitils</groupId>  
            <artifactId>unitils-dbmaintainer</artifactId>  
            <version>${unitils.version}</version>  
            <exclusions>  
                <exclusion>  
                    <artifactId>dbunit</artifactId>  
                    <groupId>org.dbunit</groupId>  
                </exclusion>  
                <!-- 这个就是我们要加的片断 -->  
                <exclusion>  
                    <artifactId>asm</artifactId>  
                    <groupId>asm</groupId>  
                </exclusion>  
            </exclusions>  
        </dependency>

    再分析一下,你可以看到传递依赖没有了:

    [INFO]  
        [INFO] --- maven-dependency-plugin:2.1:tree (default-cli) @ ridge-test ---  
        [INFO] com.ridge:ridge-test:jar:1.0.2-SNAPSHOT  
        [INFO] \- asm:asm:jar:3.2:compile  
        [INFO] ------------------------------------------------------------------------  
        [INFO] BUILD SUCCESS

    展开全文
  • Gradle dependencies 解决项目依赖冲突

    千次阅读 2021-01-24 23:43:50
    检查依赖并编译打包 gradle build 编译跳过测试 gradle build -x test 编译打包tgz包,跳过测试类 gradle releaseTarGz -x signArchives -x test 这里注意的是 gradle build 命令把debug、release环境的包...
  • Python依赖冲突

    千次阅读 2019-02-10 11:28:49
    笔者在安装scikit-image包时发现tensorflow import时直接崩溃,后发现scikit-image(后简称skimage)和tensorflow-gpu(后简称tensorflow)都依赖于numpy包,不幸的是,最新版本的scikit-image和tensorflow依赖的numpy包...
  • 通过IDEA快速定位和排除依赖冲突

    千次阅读 2019-07-07 20:10:34
    1、前言 我们程序员在开发的时候经常会遇到各种各样的 BUG 问题,其中大部分是业务逻辑异常,...但是还有一些运行时异常定位起来是特别头疼的,那就是 jar 包冲突引起的异常。 一般程序在运行时发生类似于 java.la...
  • 解决方案: 以idea 操作为例, 打开maven依赖的图,确定要使用的jar的版本,将冲突的jar包给exclude maven版本以来的缘由 . 软件工程是多人合作的结果,我们在开发软件的时候经常会使用一些别人编写好的,比较成熟的...
  • 一文看懂怎么解决Maven依赖冲突问题

    千次阅读 2019-08-20 17:33:11
    在本文中,我们将讲到如何处理Maven的依赖冲突 不知道你在使用Maven时是否遇到过诸如"NoSuchMethodError"或"ClassNotFoundException"之类的问题,甚至发生这些问题的Java类你没都没有听说过。要搞清楚这里面的缘由,...
  • 在日常开发中,maven依赖经常会产生冲突,一般没什么问题,项目可以正常运行,但是如果是因为maven依赖导致的项目不能跑了,很多人都会束手无策,然后上百度搜一大堆东西,最后花费很长时间才解决。所以了解依赖产生...
  • maven依赖冲突解决办法

    千次阅读 2018-10-24 13:39:40
    一般的开发,maven依赖冲突基本不存在,但是如果项目多,依赖复杂,就说不定了。依赖冲突说明项目依赖的某一个jar包,有多个不同的版本,至少两个或两个以上,对于这种问题,最直接的就是通过修改项目依赖的版本为...
  • Gradle 依赖&解决依赖冲突

    万次阅读 2018-09-18 11:37:16
    解决依赖冲突 如何定义一个依赖。 DependencyHandler,Dependency,Dependencies,Configuration,ConfigurationContainer 的关系。 什么是传递依赖? 如何定位依赖冲突? 如何解决依赖冲突? provided ,runtime 和...
  • 1.依赖冲突原因详解 依赖冲突的根源是Maven的依赖机制会导致Jar包的冲突。举个栗子,在我们目前的项目中使用了A和B两个Jar包,A包在依赖中依赖了C包,而B包在依赖中也同时依赖了C包,但是A包依赖的C的版本的1.0,B...
  • 在项目开发中使用Maven管理Jar包时,常常会遇到Jar包依赖冲突。其根本原因是不同Jar包引用了同一Jar包的不同版本,从而在代码调用时,无法确定使用的是哪个版本的Jarba包。 二、解决办法 解决这一问题的方法有...
  • idea解决maven依赖冲突

    千次阅读 2020-06-19 16:25:25
    最近在一个老spring项目上面需要适配一个新功能,过程中也需要升级spring的版本,然后最后就导致maven的依赖包很乱,同一个包存在多个版本,本文就记录下使用idea解决maven的依赖冲突,同时记录下assembly打包插件的...
  • 背景: android工程接入第三方SDK(google 推送 + google登录+google admob...查看引入的google依赖库发现,引入的google依赖库为17+ 没有 com.google.android.gms.auth.api.signin.GoogleSignInClient 这个类,导致
  • Android使用gradle依赖管理、依赖冲突终极解决方案 在Android开发中,相信遇到关于版本依赖的问题的同学有不少。虽然Android Studio一般都会自动帮我们去重,但是有时候去重失败了还是需要手动处理。在这里总结下...
  • 一,依赖冲突是什么意思? Maven是个很好用的依赖管理工具,但是再好的东西也不是完美的。Maven的依赖机制会导致Jar包的冲突。举个例子,现在你的项目中,使用了两个Jar包,分别是A和B。现在A需要依赖另一个Jar包C...
  • Jar 包依赖冲突排查思路和解决方法

    千次阅读 2021-01-02 18:05:00
    提交代码,重新打包,部署一条龙,顺利启动~ 思考 包冲突解决是简单的,通过 maven 插件可以精确找到依赖,然后进行 Exclude,可是在本地开发、测试环境都没有出现的问题,却在预发环境出现了,所以排除了业务逻辑...
  • maven 检查依赖冲突和版本冲突

    千次阅读 2018-12-27 19:07:36
    当maven搭建的项目发生jar包依赖冲突时,可以使用下面命令进行处理:   mvn -U dependency:tree -Dverbose 在项目发布的时候,一般都需要进行依赖冲突检查或者重复类的检查,上面tree命令只能检查jar依赖的...
  • android依赖冲突处理方案

    千次阅读 2019-04-16 09:43:45
    首先看到这些带transformDex,Unable to merge dex字眼的异常时不要一下子就下判断是属于依赖冲突。首先是重复执行几次clean,或者同步项目;或者可以尝试重启下AS。这种方式能解决属于那种项目原本就是没有问题,...
  • 查看gradle 依赖冲突

    2020-03-24 16:49:58
    gradle -q standardApp:dependencies 在网上搜的东西在我的电脑中没有效果
  • 解决pom文件依赖冲突

    2020-12-01 22:53:13
    maven依赖就近原则,如果需要移除冲突依赖,类似于如下将某个依赖的某一项移除 “ctrl+shift+alt+U”快捷键输出pom依赖框架,右击冲突依赖,选择移除。效果相当于给dependency中加了exclusion <dependency>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 249,332
精华内容 99,732
关键字:

依赖冲突