以springboot3.0.2为例

在创建springboot项目时会默认添加spring-boot-starter-test依赖，其中已经包含了junit、mockito依赖，根据springboot版本的不同junit和mockito的版本也会有所不同

先说一下各自功能：

• junit只说一点，junt4和junit5的注解不同，使用方式略有差异，其他不赘述了，基本用法都懂。
• mockito是mock的一种框架，相比其他框架来说，mockito比较流行，并且springboot默认集成的就是mockito。主要用于模拟一些假数据，以完成单元测试。举例来说就是：A服务已经开发完成，但是A服务中存在需要调用B服务的代码，但是B服务还未开发完成，为了对A服务进行测试，可以使用Mock框架，当A服务中调用B服务时，就是用Mock框架返回一个模拟的假数据（返回的假数据的数据格式和B服务返回的数据格式一致），以实现对A服务业务逻辑代码的测试。
• jacoco：代码覆盖率检查，在idea中通过配置就可以使用，后面会说，还有一种方式就是在pom问价中添加jacoco插件也可以实现代码覆盖率检查，后面同样会介绍。

直接上代码

@RestController
public class UserController {
   @Resource
   private UserService userService;

   @RequestMapping(value = "/selectUser",method = RequestMethod.GET)
   public String selectUserById(@RequestParam String id){
       UserVO userVO = userService.selectUserById(id);
       return userVO.toString();
   }
}
@Service
public class UserServiceImpl implements UserService {

   @Resource
   private UserMapper userMapper;
   @Override
   public UserVO selectUserById(String id) {
       if(StringUtil.isEmpty(id)){
           throw new NullPointerException("id is null");
       }
       return userMapper.selectUserById(id);
   }
}

@SpringBootTest
public class UserControllerTest {
   @MockBean
   private UserMapper userMapper;
   @Resource
   private UserService userService;
   @Resource
   private UserController userController;
   @Test
   public void selectUserById() {
       UserVO user = new UserVO();
       user.setId("1001");
       user.setName("test01");
       Mockito.when(userMapper.selectUserById(Mockito.anyString())).thenReturn(user);
       String result = userController.selectUserById("1002");
       Assertions.assertEquals(user.toString(),result);
   }
}

简单解释一下：

@SpringBootTest 是一个组合注解，由spring提供，标注该类是一个测试类
@MockBean 被MockBean标注的类，表示会为该类创建一个模拟的假对象，这个模拟的假对象的方法的方法体和返回值都为空,该注解也是由spring提供的。
所以上面代码的意思是，当我的代码逻辑中用到UserMapper这个类中的方法时都返回null。但是因为我代码中存在 Mockito.when(userMapper.selectUserById(Mockito.anyString())).thenReturn(user); 这句代码的意思是，当我调用userMapper.selectUserById()时返回自定义的UserVO对象。

Mockito常用注解

@Mock 被@Mock标记的类会创建一个虚拟的对象，该对象的方法的方法体和返回值都为空
@Spy 被@Spy标记的类会创建这个类的真实实例，并且如果调用时没有打桩，则会执行该类的真实逻辑。
@InjectMocks 被@InjectMocks标记的类会创建该类的真实实例，并且该类中依赖注入的其他类会使用被@Mock 或者@Spy 标记的类注入

Spring中和Mock相关的注解

@MockBean 作用和@Mock相同，不同点是，被@MockBean标注的类会被Spring容器管理，而被@Mock标记的类不会。@MockBean是由Spring提供的注解，@Mock是Mockito框架的注解
@SpyBean 作用和@Spy相同。区别与 @MockBean和@Mock的区别一致。

常用的注解组合使用方式

1. @SpringBootTest + @MockBean / @SpyBean + @Resource / @Autowired

  @SpringBootTest  标注在测试类上。
  @MockBean  标注在被测试类中需要的注入的其他类上，表示该类如果在测试过程中遇到，不需要执行真实逻辑，直接返回空。
  @SpyBean  标注在被测试类中需要的注入的其他类上,表示该类如果在测试过程中遇到，如果没有打桩，则执行真实逻辑，返回真实的执行结果，如果打桩了，则返回打桩的值。

   @Service
   public class UserServiceImpl implements UserService {

 	    @Resource
 	    private UserMapper userMapper;
 	    
 	    @Override
 	    public UserVO selectUserById(String id) {
 	        if(StringUtil.isEmpty(id)){
 	            throw new NullPointerException("id is null");
 	        }
 	        UserVO user = userMapper.selectUserById(id);
 	        user.setName("change name");
 	        return user;
 	    }
 	    @Override
 	    public int insertUser(UserVO user) {
 	        return 0;
 	    }
 }

 @SpringBootTest
 public class UserControllerTest {
     @MockBean
     private UserMapper userMapper;
     @SpyBean
     private UserService userService;
     @Resource
     private UserController userController;
     @Test
     public void selectUserById() {
         UserVO user = new UserVO();
         user.setId("1001");
         user.setName("test01");
         //Mockito.when().thenReturn()  这句代码的意思就是 打桩
         Mockito.when(userMapper.selectUserById(Mockito.anyString())).thenReturn(user);
         String result = userController.selectUserById("1002");
         Assertions.assertEquals(user.toString(),result);
         int uid1 = userService.insertUser(user); //打桩前
         Mockito.when(userService.insertUser(Mockito.any(UserVO.class))).thenReturn(22);
         int uid2 = userService.insertUser(user); // 打桩后
         Assertions.assertEquals(uid1,uid2);
     }
 }

执行结果

2. @ExtendWith(MockitoExtension.class) + @Mock / @Spy + @InjectMocks

@ExtendWith(MockitoExtension.class)  标注在测试类上用于声明上下文环境。@SpringBootTest中也存在这个注解默认是 SpringExtension.class.
@Mock 和@MockBean作用一致
@Spy  和@SpyBean作用一致

@ExtendWith(MockitoExtension.class)
public class UserServiceImplTest {

    @Mock
    private UserMapper userMapper;

    @InjectMocks
    private UserServiceImpl userService;

    @Test
    public void selectUserById() {
        UserVO user = new UserVO();
        user.setName("test123");
        user.setId("20001");
        Mockito.when(userMapper.selectUserById(Mockito.anyString())).thenReturn(user);
        UserVO result = userService.selectUserById("30001");
        Assertions.assertEquals(user.toString(),result.toString());
    }
}

3. MockMvc模拟HTTP请求测试controller

@RestController
public class UserController {
    @Resource
    private UserService userService;

    @RequestMapping(value = "/selectUser",method = RequestMethod.GET)
    public String selectUserById(@RequestParam String id){
        UserVO userVO = userService.selectUserById(id);
        return userVO.toString();
    }

    @PostMapping("/insertUser")
    public int insertUser(@RequestBody UserVO userVO){
        userService.insertUser(userVO);
        return 12345;
    }
}

@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest3 {
    @MockBean
    private UserMapper userMapper;
    @SpyBean
    private UserService userService;
    @Resource
    private MockMvc mockMvc;
    @Test
    public void selectUserById() throws Exception {
        UserVO user = new UserVO();
        user.setId("1001");
        user.setName("test01");
        //Mockito.when().thenReturn()  这句代码的意思就是 打桩
        Mockito.when(userMapper.selectUserById(Mockito.anyString())).thenReturn(user);
        /* 模拟一次get请求*/
        RequestBuilder rb = MockMvcRequestBuilders.get("/selectUser")
                .contentType(MediaType.TEXT_HTML_VALUE)
                .param("id","123456");
        MvcResult result = mockMvc.perform(rb).andReturn();
        Assertions.assertEquals(user.toString(),result.getResponse().getContentAsString());
    }


    @Test
    public void insertUserTest() throws Exception {
        UserVO user = new UserVO();
        user.setId("1001");
        user.setName("test01");
        Gson gson = new Gson();
        String jsonStr = gson.toJson(user);
        Mockito.when(userService.insertUser(Mockito.any(UserVO.class))).thenReturn(789);
        /* 模拟一次POST请求*/
        RequestBuilder rb = MockMvcRequestBuilders.post("/insertUser")
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .content(jsonStr);
        MvcResult result = mockMvc.perform(rb).andReturn();
        Assertions.assertEquals("12345",result.getResponse().getContentAsString());
    }
}

运行截图

Jacoco 代码覆盖率

Jacoco有以下两种使用方式

1. Idea中配置Jacoco

运行结果

查看代码覆盖率

2. POM文件中引用Jacoco插件

pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wangkai</groupId>
    <artifactId>junitMockitoJacoco</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>junitMockitoJacoco</name>
    <description>junitMockitoJacoco</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.8</version>
                <!-- 可选配置，可以不写，默认运行所有包下的代码-->
                <configuration>
                    <includes>
                        <include>com/**/*</include>
                    </includes>
                </configuration>
                <executions>
                    <execution>
                        <id>pre-test</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>post-unit-test</id>
                        <phase>test</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                        <!-- 可选配置，指定文件输出路径。默认路径为：target/site/jacoco-->
<!--                        <configuration>-->
<!--                            <dataFile>target/jacoco.exec</dataFile>-->
<!--                            <outputDirectory>target/jacoco</outputDirectory>-->
<!--                        </configuration>-->
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

运行结果