Spring 整合 JUnit

一文搞懂Spring 整合 JUnit5 、JUnit4

环境：
jdk 17
Spring 6.0.2

Spring 整合 JUnit5

pom.xml 引入JUnit5 依赖

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>

        <!--spring对junit的支持相关依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>6.0.2</version>
        </dependency>
        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.10.0</version>
        </dependency>

    </dependencies>

创建UserService 类用于测试

/**
 * @Description:
 * @Author : wy
 * @Date : Created 2023/9/20 11:03 PM
 */
@Component
public class UserService {

    public void addUser(){
        System.out.println("addUser run...");
    }

}

resources 创建Spring 配置文件 beans.xml

注意beans 标签中的命名空间，开启组件扫描的 context 标签需要添加新的命名空间
<context:component-scan base-package=“com.yang.spring6.junit”/> 开启组件扫描扫描指定包路径下的组件交给容器管理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--   开启组件扫描     -->
    <context:component-scan base-package="com.yang.spring6.junit"/>
</beans>

进行测试

/**
 * @Description: spring 整合 junit5 测试
 * @Author : wy
 * @Date : Created 2023/9/20 11:05 PM
 */
//方式一
//@SpringJUnitConfig(locations = "classpath:beans.xml")

//方式二
@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:beans.xml")
public class SpringJUnit5Test {

    @Autowired
    private UserService userService;

    @Test
    public void  testAddUser(){
        userService.addUser();
    }
}

结果：

如上所述JUnit5 有两种方式进行测试

方式一：

@SpringJUnitConfig(locations = "classpath:beans.xml")

@SpringJUnitConfig 注解

@SpringJUnitConfig注解是 Spring 提供的一个用于测试的注解，它整合了 JUnit 5 和 Spring 测试框架，使得在测试中可以方便地使用 Spring 容器和依赖注入。
locations 属性 指定spring 配置类，将加载这个配置类来创建Spring 容器

方式二：

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:beans.xml")

@ExtendWith 注解

@ExtendWith 注解用于测试类，指定了一个自定义扩展 YourExtension。这个扩展会在测试运行期间被调用，允许你执行一些额外的操作或修改测试的行为。
在实际应用中，你可以根据需要编写自己的扩展，以满足特定的测试需求。JUnit 5 提供了许多内置的扩展，也可以创建自己的自定义扩展，以适应不同的测试场景。

常见的一些内置扩展包括：
@ExtendWith(SpringExtension.class)：用于 Spring Framework 集成测试。
@ExtendWith(MockitoExtension.class)：用于 Mockito 框架的测试。
@ExtendWith(ParameterResolver.class)：用于自定义参数解析器。

@ContextConfiguration 注解

@ContextConfiguration 注解定义如何加载 Spring 上下文以进行集成测试，无论是使用 Java 配置还是 XML 配置。

Spring 整合 JUnit4

pom.xml 引入 JUnit4 依赖

<?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>com.yang</groupId>
    <artifactId>spring6-junit</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>

        <!--spring对junit的支持相关依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>6.0.2</version>
        </dependency>
        <!--   junit4测试     -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>

    </dependencies>



</project>

测试

UserService 和 beans.xml 参考上面 junit5种的

package com.yang.spring6.junit.junit5;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @Description: spring 整合 junit4 测试
 * @Author : wy
 * @Date : Created 2023/9/20 11:05 PM
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class SpringJUnit4Test {

    @Autowired
    private UserService userService;

    @Test
    public void  testAddUser(){
        userService.addUser();
    }
}

结果：

@Runwith 注解

@RunWith 注解是 JUnit 框架提供的一个注解，用于指定测试运行器（Runner）。测试运行器决定了测试类的运行方式，例如如何初始化测试环境、执行测试方法等。JUnit 4 之后，可以使用 @RunWith 注解来自定义测试运行器，以便扩展测试框架的功能。
以下是 @RunWith 注解的常见用法：

1. 使用默认运行器：
   默认情况下，JUnit 使用 BlockJUnit4ClassRunner 作为测试运行器，你不需要显式指定 @RunWith 注解。

import org.junit.Test;
import static org.junit.Assert.*;

public class MyTest {

    @Test
    public void testSomething() {
        // 测试逻辑
    }
}

2. 自定义测试运行器：
   你可以创建自定义的测试运行器，实现更高级的测试控制。为了使用自定义的测试运行器，需要在测试类上使用 @RunWith 注解，并将自定义的运行器类作为参数传递给 @RunWith 注解。

import org.junit.runner.RunWith;
import org.junit.runners.MyCustomRunner;

@RunWith(MyCustomRunner.class)
public class MyTest {

    @Test
    public void testSomething() {
        // 测试逻辑
    }
}

3. 使用 Spring 提供的运行器：
   当你进行 Spring 集成测试时，通常使用 Spring 提供的测试运行器，如 SpringJUnit4ClassRunner 或 SpringRunner（JUnit 5）。这些运行器可以加载 Spring 上下文并进行依赖注入，以便测试 Spring Bean。

import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
public class SpringIntegrationTest {

    // 使用 Spring 上下文进行测试
}

总之，@RunWith 注解用于指定测试运行器，根据你的需求选择适当的运行器来控制测试的行为。不同的运行器提供了不同的功能，使测试更加灵活和强大。