maven依赖排除插件 maven怎么解决依赖冲突

目录

一.Maven工程测试

1.测试概述

2.Junit使用步骤

3.Junit结果判定

4.@Before、@After

二.依赖冲突调解

1.最短路径优先原则

2.最先声明原则

3.排除依赖、锁定版本

---

一.Maven工程测试

1.测试概述

测试即在交付前对写好的代码进行评测，分为黑盒测试和白盒测试：

• 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
• 白盒测试：需要写代码的。关注程序具体的执行流程。

单元测试是指对软件中的最小可测试单元进行检查和验证， Java 里单元测试指一个类的功能。单元测试是在软件开发过程中要进行的 最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔 离的情况下进行测试。

Junit 是 Java 编程语言的单元测试框架，用于编写和运行可重复的自动化测试。从分类中属于白盒测试。 其实就是测试每一个方法是否好用。

2.Junit使用步骤

在Maven项目中引入依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

补充上面的代码之后，maven就会自动导入相应的jar包，可见maven真的很方便！

定义被测试的类

我们定义一个计算器工具类。

package com.first.util;

public class Calculator {
    //加法
    public int add(int a,int b){
        return a+b;
    }
    //除法
    public int div(int a,int b){
        return a/b;
    }
}

对定义的类进行测试

1

• 创建src/test/java包，并将改包设置为测试包。
• 在src/test/java中创建测试类的包，包名一般与被测试包名一致。
• 定义测试类，类名一般为被测试类+Test
• 测试类中编写测试方法。

 测试类：

package com.first.util;

import org.junit.Test;

public class CalculatorTest {
    /*
    测试方法是可以独立运行的(直接点左侧的绿色开关)
       1.方法名一般为test+被测试方法名
       2.在方法上方添加@Test
       3.测试方法没有参数和返回值
     */
    @Test
    public void testAdd(){
        Calculator calculator=new Calculator();
        int add=calculator.add(1,2);
        System.out.println(add);
    }

    @Test
    public void testDiv(){
        Calculator calculator=new Calculator();
        int div=calculator.div(2,0);
        System.out.println(div);
    }
}

项目结构：

3.Junit结果判定

点击测试方法边的三角运行测试方法，如果出现绿色对钩，证明方法能正常运行；如果出现红色感叹号，证明方法抛出异常，需要修 改方法。

也可以执行test命令

也可以点击Lifecycle的test

当然，不是能正常运行就代表方法一定没有问题，也有可能方法的结果和预期结果不一致，这时就需要使用断言操作。

修改testAdd方法：

如果预期结果和实际结果不一致，那么会报错

@Test
    public void testAdd(){
        Calculator calculator=new Calculator();
        int add=calculator.add(1,2);
        //System.out.println(add);
        /*
        断言
        参数1:预期结果参数2:实际结果
        */
        Assert.assertEquals(4,add);
    }

add是3，但是预期结果是4，报错如下：

如果断言符合的话，那么不会报错。

4.@Before、@After

@Before修饰前置方法
@After修饰后置方法

在测试类中， @Before 修饰的方法会在测试方法之前 自动执行 ，@After 修饰的方法会在测试方法执行之后 自动执行 。之后的学习 中，我们可以设置前置方法为获取资源，后置方法为释放资源。

 对上面的方法进行修改，使testAdd不报错，然后执行testAdd

package com.first.util;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    @Before
    public void before(){
        System.out.println("开始测试！");
    }
    @After
    public void after(){
        System.out.println("结束测试");
    }
    /*
    测试方法是可以独立运行的(直接点左侧的绿色开关)
       1.方法名一般为test+被测试方法名
       2.在方法上方添加@Test
       3.测试方法没有参数和返回值
     */
    @Test
    public void testAdd(){
        Calculator calculator=new Calculator();
        int add=calculator.add(1,2);
        System.out.println(add);
        /*
        断言
        参数1:预期结果参数2:实际结果
        */
        //Assert.assertEquals(3,add);
    }

    @Test
    public void testDiv(){
        Calculator calculator=new Calculator();
        int div=calculator.div(2,0);
        System.out.println(div);
    }
}

输出：

开始测试！
3
结束测试

二.依赖冲突调解

1.最短路径优先原则

依赖冲突产生的原因 —— 依赖传递

假设你的项目依赖 jar 包 A ， jar 包 A 又依赖 jar 包 B 。当添加 jar 包 A 时，Maven 会把 jar 包 B 也自动加入到项目中。比如刚刚我们添加了 junit 依赖， junit 又依赖 hamcrest ，所以 Maven 会将 junit 和 hamcrest 都

加入项目中。

 

这时就可能会产生依赖冲突问题，比如依赖 A 会引入依赖 C ，依赖 B也会引入依赖 C 。如果不进行调解则会引入两个依赖 C(且这两个依赖C版本不同) ，那么 Maven 是如何解决依赖冲突问题的呢？

 

依赖冲突调解

我们以 Spring 依赖为例， spring-webmvc 依赖 spring-aop ， spring-context 也依赖 spring-aop ，如果两个同时引入，会引入哪个版本的 spring-aop 呢？

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

Maven 调解依赖冲突的第一原则是最短路径优先原则：

也就是说项目依赖关系树中路径最短的版本会被使用。例如，假设有几个 jar 包之间的依赖关系是： A - >B - >C - >D(2.0) 和 E - >F - >D(1.0) ，如果同时 引入 A 和 E ，那么 D(1.0) 会被使用，因为 E 到 D 的路径更短。

查看依赖路径的方式如下：

 

spring-webmvc到spring-aop的路径如下：

对于上面的配置代码的的依赖图如下：

spring-webmvc 到 spring-aop 的路径如下：

spring-context到spring-aop的路径如下：

可以看到， spring-webmvc 到 spring-aop 的路径为：

spring - webmvc -> spring - context -> spring - aop

而 spring-context 到 spring-aop 的路径为：

spring - context -> spring - aop

spring-context 到 spring-aop 的路径更短，所以 spring-aop 会按照spring-context 的版本引入。

 

2.最先声明原则

最短路径优先原则不能解决所有问题，比如这样的依赖关系： A–>B–>C(1.0) 和 D–>E–>C(2.0) ，同时引入 A 和 D 之后， C(1.0) 和 C(2.0) 的依赖路径 长度都为 2 。此时第一原则将不能解决问题

Maven 调解依赖冲突的第二原则是最先声明原则：

在依赖路径长度相等的前提下，在 POM 中依赖声明的顺序靠前（ 即配置代码在上的 ）的会被解析使用。比如：以上案例中， spring-webmvc 和 spring -context 到 spring-core 的路径都为 1 。谁声明在上方， spring-core 会

按照谁的版本引入。

3.排除依赖、锁定版本

如果不想使用 Maven 默认的冲突调解方式，有两种方式可以手动进行冲突调解。

排除依赖

比如以上案例中，想使用 spring-webmvc 的 spring-aop 包，那么可以让 spring-context 引入时排除引入 spring-aop 包，这样就可以使 用 spring-webmvc 的 spring-aop 包了，写法如下：

锁定版本

在 Maven 中为某个 jar 包配置锁定版本后，不考虑依赖的声明顺序和依赖路径，以锁定的版本的为准添加到工程中，此方法在企业开发 中常用。以下可以直接配置 spring-aop 锁定的版本。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
    </dependencies>
</dependencyManagement>