SpringBoot測試WebMVC的4種實現(xiàn)方案

更新時間：2025年04月23日 08:11:55 作者：風(fēng)象南

在項目開發(fā)中,測試是確保應(yīng)用質(zhì)量的關(guān)鍵環(huán)節(jié),對于基于SpringBoot構(gòu)建的Web應(yīng)用,高效測試MVC層可以極大提高開發(fā)及聯(lián)調(diào)效率,下面我們來看看SpringBoot中測試WebMVC的4種實現(xiàn)方案吧

在項目開發(fā)中，測試是確保應(yīng)用質(zhì)量的關(guān)鍵環(huán)節(jié)。對于基于SpringBoot構(gòu)建的Web應(yīng)用，高效測試MVC層可以極大提高開發(fā)及聯(lián)調(diào)效率。一個設(shè)計良好的測試策略不僅能發(fā)現(xiàn)潛在問題，還能提高代碼質(zhì)量、促進(jìn)系統(tǒng)穩(wěn)定性，并為后續(xù)的重構(gòu)和功能擴(kuò)展提供保障。

方案一：使用MockMvc進(jìn)行控制器單元測試

工作原理

MockMvc是Spring Test框架提供的一個核心類，它允許開發(fā)者在不啟動HTTP服務(wù)器的情況下模擬HTTP請求和響應(yīng)，直接測試控制器方法。這種方法速度快、隔離性好，特別適合純粹的單元測試。

實現(xiàn)步驟

引入依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

編寫待測試控制器

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUserById(@PathVariable Long id) {
        UserDto user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    
    @PostMapping
    public ResponseEntity<UserDto> createUser(@RequestBody @Valid UserCreateRequest request) {
        UserDto createdUser = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
    }
}

編寫MockMvc單元測試

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@ExtendWith(MockitoExtension.class)
public class UserControllerUnitTest {
    
    @Mock
    private UserService userService;
    
    @InjectMocks
    private UserController userController;
    
    private MockMvc mockMvc;
    
    private ObjectMapper objectMapper;
    
    @BeforeEach
    void setUp() {
        // 設(shè)置MockMvc實例
        mockMvc = MockMvcBuilders
                .standaloneSetup(userController)
                .setControllerAdvice(new GlobalExceptionHandler()) // 添加全局異常處理
                .build();
                
        objectMapper = new ObjectMapper();
    }
    
    @Test
    void getUserById_ShouldReturnUser() throws Exception {
        // 準(zhǔn)備測試數(shù)據(jù)
        UserDto mockUser = new UserDto(1L, "John Doe", "john@example.com");
        
        // 配置Mock行為
        when(userService.findById(1L)).thenReturn(mockUser);
        
        // 執(zhí)行測試
        mockMvc.perform(get("/api/users/1")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.name").value("John Doe"))
                .andExpect(jsonPath("$.email").value("john@example.com"));
                
        // 驗證交互
        verify(userService, times(1)).findById(1L);
    }
    
    @Test
    void createUser_ShouldReturnCreatedUser() throws Exception {
        // 準(zhǔn)備測試數(shù)據(jù)
        UserCreateRequest request = new UserCreateRequest("Jane Doe", "jane@example.com");
        UserDto createdUser = new UserDto(2L, "Jane Doe", "jane@example.com");
        
        // 配置Mock行為
        when(userService.createUser(any(UserCreateRequest.class))).thenReturn(createdUser);
        
        // 執(zhí)行測試
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").value(2))
                .andExpect(jsonPath("$.name").value("Jane Doe"))
                .andExpect(jsonPath("$.email").value("jane@example.com"));
                
        // 驗證交互
        verify(userService, times(1)).createUser(any(UserCreateRequest.class));
    }
    
    @Test
    void getUserById_WhenUserNotFound_ShouldReturnNotFound() throws Exception {
        // 配置Mock行為
        when(userService.findById(99L)).thenThrow(new UserNotFoundException("User not found"));
        
        // 執(zhí)行測試
        mockMvc.perform(get("/api/users/99")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isNotFound());
                
        // 驗證交互
        verify(userService, times(1)).findById(99L);
    }
}

優(yōu)點與局限性

優(yōu)點

運行速度快：不需要啟動Spring上下文或嵌入式服務(wù)器
隔離性好：只測試控制器本身，不涉及其他組件
可精確控制依賴行為：通過Mockito等工具模擬服務(wù)層行為
便于覆蓋邊界情況和異常路徑

局限性

不測試Spring配置和依賴注入機(jī)制
不驗證請求映射注解的正確性
不測試過濾器、攔截器和其他Web組件
可能不反映實際運行時的完整行為

方案二：使用@WebMvcTest進(jìn)行切片測試

工作原理

@WebMvcTest是Spring Boot測試中的一個切片測試注解，它只加載MVC相關(guān)組件（控制器、過濾器、WebMvcConfigurer等），不會啟動完整的應(yīng)用上下文。

這種方法在單元測試和集成測試之間取得了平衡，既測試了Spring MVC配置的正確性，又避免了完整的Spring上下文加載成本。

實現(xiàn)步驟

引入依賴

與方案一相同，使用spring-boot-starter-test依賴。

編寫切片測試

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(UserController.class)
public class UserControllerWebMvcTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Test
    void getUserById_ShouldReturnUser() throws Exception {
        // 準(zhǔn)備測試數(shù)據(jù)
        UserDto mockUser = new UserDto(1L, "John Doe", "john@example.com");
        
        // 配置Mock行為
        when(userService.findById(1L)).thenReturn(mockUser);
        
        // 執(zhí)行測試
        mockMvc.perform(get("/api/users/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.name").value("John Doe"))
                .andExpect(jsonPath("$.email").value("john@example.com"));
    }
    
    @Test
    void createUser_WithValidationError_ShouldReturnBadRequest() throws Exception {
        // 準(zhǔn)備無效請求數(shù)據(jù)（缺少必填字段）
        UserCreateRequest invalidRequest = new UserCreateRequest("", null);
        
        // 執(zhí)行測試
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(invalidRequest)))
                .andExpect(status().isBadRequest())
                .andDo(print()); // 打印請求和響應(yīng)詳情，便于調(diào)試
    }
    
    @Test
    void testSecurityConfiguration() throws Exception {
        // 測試需要認(rèn)證的端點
        mockMvc.perform(delete("/api/users/1"))
                .andExpect(status().isUnauthorized());
    }
}

測試自定義過濾器和攔截器

@WebMvcTest(UserController.class)
@Import({RequestLoggingFilter.class, AuditInterceptor.class})
public class UserControllerWithFiltersTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @MockBean
    private AuditService auditService;
    
    @Test
    void requestShouldPassThroughFiltersAndInterceptors() throws Exception {
        // 準(zhǔn)備測試數(shù)據(jù)
        UserDto mockUser = new UserDto(1L, "John Doe", "john@example.com");
        when(userService.findById(1L)).thenReturn(mockUser);
        
        // 執(zhí)行請求，驗證經(jīng)過過濾器和攔截器后成功返回數(shù)據(jù)
        mockMvc.perform(get("/api/users/1")
                .header("X-Trace-Id", "test-trace-id"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1));
                
        // 驗證攔截器調(diào)用了審計服務(wù)
        verify(auditService, times(1)).logAccess(anyString(), eq("GET"), eq("/api/users/1"));
    }
}

優(yōu)點與局限性

優(yōu)點

測試MVC配置的完整性：包括請求映射、數(shù)據(jù)綁定、驗證等
涵蓋過濾器和攔截器：驗證整個MVC請求處理鏈路
啟動速度較快：只加載MVC相關(guān)組件，不加載完整應(yīng)用上下文
支持測試安全配置：可以驗證訪問控制和認(rèn)證機(jī)制

局限性

不測試實際的服務(wù)實現(xiàn)：依賴于模擬的服務(wù)層
不測試數(shù)據(jù)訪問層：不涉及實際的數(shù)據(jù)庫交互
配置復(fù)雜度增加：需要模擬或排除更多依賴
啟動速度雖比完整集成測試快，但比純單元測試慢

方案三：基于@SpringBootTest的集成測試

工作原理

@SpringBootTest會加載完整的Spring應(yīng)用上下文，可以與嵌入式服務(wù)器集成，測試真實的HTTP請求和響應(yīng)。這種方法提供了最接近生產(chǎn)環(huán)境的測試體驗，但啟動速度較慢，適合端到端功能驗證。

實現(xiàn)步驟

引入依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- 可選：如果需要測試數(shù)據(jù)庫層 -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

編寫集成測試（使用模擬端口）

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository.deleteAll();
        
        // 準(zhǔn)備測試數(shù)據(jù)
        User user = new User();
        user.setId(1L);
        user.setName("John Doe");
        user.setEmail("john@example.com");
        userRepository.save(user);
    }
    
    @Test
    void getUserById_ShouldReturnUser() throws Exception {
        mockMvc.perform(get("/api/users/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.name").value("John Doe"))
                .andExpect(jsonPath("$.email").value("john@example.com"));
    }
    
    @Test
    void createUser_ShouldSaveToDatabase() throws Exception {
        UserCreateRequest request = new UserCreateRequest("Jane Doe", "jane@example.com");
        
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.name").value("Jane Doe"));
                
        // 驗證數(shù)據(jù)是否實際保存到數(shù)據(jù)庫
        Optional<User> savedUser = userRepository.findByEmail("jane@example.com");
        assertTrue(savedUser.isPresent());
        assertEquals("Jane Doe", savedUser.get().getName());
    }
}

編寫集成測試（使用真實端口）

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserControllerServerIntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository.deleteAll();
        
        // 準(zhǔn)備測試數(shù)據(jù)
        User user = new User();
        user.setId(1L);
        user.setName("John Doe");
        user.setEmail("john@example.com");
        userRepository.save(user);
    }
    
    @Test
    void getUserById_ShouldReturnUser() {
        ResponseEntity<UserDto> response = restTemplate.getForEntity("/api/users/1", UserDto.class);
        
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertEquals("John Doe", response.getBody().getName());
    }
    
    @Test
    void createUser_ShouldReturnCreatedUser() {
        UserCreateRequest request = new UserCreateRequest("Jane Doe", "jane@example.com");
        
        ResponseEntity<UserDto> response = restTemplate.postForEntity(
                "/api/users", request, UserDto.class);
                
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertNotNull(response.getBody().getId());
        assertEquals("Jane Doe", response.getBody().getName());
    }
    
    @Test
    void testCaching() {
        // 第一次請求
        long startTime = System.currentTimeMillis();
        ResponseEntity<UserDto> response1 = restTemplate.getForEntity("/api/users/1", UserDto.class);
        long firstRequestTime = System.currentTimeMillis() - startTime;
        
        // 第二次請求（應(yīng)該從緩存獲?。?
        startTime = System.currentTimeMillis();
        ResponseEntity<UserDto> response2 = restTemplate.getForEntity("/api/users/1", UserDto.class);
        long secondRequestTime = System.currentTimeMillis() - startTime;
        
        // 驗證兩次請求返回相同數(shù)據(jù)
        assertEquals(response1.getBody().getId(), response2.getBody().getId());
        
        // 通常緩存請求會明顯快于首次請求
        assertTrue(secondRequestTime < firstRequestTime, 
                   "第二次請求應(yīng)該更快（緩存生效）");
    }
}

使用測試配置覆蓋生產(chǎn)配置

創(chuàng)建測試專用配置文件src/test/resources/application-test.yml:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: create-drop

# 禁用某些生產(chǎn)環(huán)境組件
app:
  scheduling:
    enabled: false
  external-services:
    payment-gateway: mock

在測試類中指定配置文件：

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles("test")
class UserControllerConfiguredTest {
    // 測試內(nèi)容
}

優(yōu)點與局限性

優(yōu)點

全面測試：覆蓋從HTTP請求到數(shù)據(jù)庫的完整流程
真實行為驗證：測試實際的服務(wù)實現(xiàn)和組件交互
發(fā)現(xiàn)集成問題：能找出組件集成時的問題
適合功能測試：驗證完整的業(yè)務(wù)功能

局限性

啟動速度慢：需要加載完整Spring上下文
測試隔離性差：測試可能相互影響
配置和設(shè)置復(fù)雜：需要管理測試環(huán)境配置
調(diào)試?yán)щy：出錯時定位問題復(fù)雜
不適合覆蓋全部場景：不可能覆蓋所有邊界情況

方案四：使用TestRestTemplate/WebTestClient進(jìn)行端到端測試

工作原理

此方法使用專為測試設(shè)計的HTTP客戶端，向?qū)嶋H運行的嵌入式服務(wù)器發(fā)送請求，接收并驗證響應(yīng)。TestRestTemplate適用于同步測試，而WebTestClient支持反應(yīng)式和非反應(yīng)式應(yīng)用的測試，并提供更流暢的API。

實現(xiàn)步驟

使用TestRestTemplate（同步測試）

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserControllerE2ETest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void testCompleteUserLifecycle() {
        // 1. 創(chuàng)建用戶
        UserCreateRequest createRequest = new UserCreateRequest("Test User", "test@example.com");
        ResponseEntity<UserDto> createResponse = restTemplate.postForEntity(
                "/api/users", createRequest, UserDto.class);
                
        assertEquals(HttpStatus.CREATED, createResponse.getStatusCode());
        Long userId = createResponse.getBody().getId();
        
        // 2. 獲取用戶
        ResponseEntity<UserDto> getResponse = restTemplate.getForEntity(
                "/api/users/" + userId, UserDto.class);
                
        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
        assertEquals("Test User", getResponse.getBody().getName());
        
        // 3. 更新用戶
        UserUpdateRequest updateRequest = new UserUpdateRequest("Updated User", null);
        restTemplate.put("/api/users/" + userId, updateRequest);
        
        // 驗證更新成功
        ResponseEntity<UserDto> afterUpdateResponse = restTemplate.getForEntity(
                "/api/users/" + userId, UserDto.class);
                
        assertEquals("Updated User", afterUpdateResponse.getBody().getName());
        assertEquals("test@example.com", afterUpdateResponse.getBody().getEmail());
        
        // 4. 刪除用戶
        restTemplate.delete("/api/users/" + userId);
        
        // 驗證刪除成功
        ResponseEntity<UserDto> afterDeleteResponse = restTemplate.getForEntity(
                "/api/users/" + userId, UserDto.class);
                
        assertEquals(HttpStatus.NOT_FOUND, afterDeleteResponse.getStatusCode());
    }
}

使用WebTestClient（支持反應(yīng)式測試）

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserControllerWebClientTest {
    
    @Autowired
    private WebTestClient webTestClient;
    
    @Test
    void testUserApi() {
        // 創(chuàng)建用戶并獲取ID
        UserCreateRequest createRequest = new UserCreateRequest("Reactive User", "reactive@example.com");
        
        UserDto createdUser = webTestClient.post()
                .uri("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(createRequest)
                .exchange()
                .expectStatus().isCreated()
                .expectBody(UserDto.class)
                .returnResult()
                .getResponseBody();
                
        Long userId = createdUser.getId();
        
        // 獲取用戶
        webTestClient.get()
                .uri("/api/users/{id}", userId)
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.name").isEqualTo("Reactive User")
                .jsonPath("$.email").isEqualTo("reactive@example.com");
                
        // 驗證查詢API
        webTestClient.get()
                .uri(uriBuilder -> uriBuilder
                        .path("/api/users")
                        .queryParam("email", "reactive@example.com")
                        .build())
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(UserDto.class)
                .hasSize(1)
                .contains(createdUser);
    }
    
    @Test
    void testPerformance() {
        // 測試API響應(yīng)時間
        webTestClient.get()
                .uri("/api/users")
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .consumeWith(response -> {
                    long responseTime = response.getResponseHeaders()
                            .getFirst("X-Response-Time") != null
                            ? Long.parseLong(response.getResponseHeaders().getFirst("X-Response-Time"))
                            : 0;
                            
                    // 驗證響應(yīng)時間在可接受范圍內(nèi)
                    assertTrue(responseTime < 500, "API響應(yīng)時間應(yīng)小于500ms");
                });
    }
}

優(yōu)點與局限性

優(yōu)點

完整測試：驗證應(yīng)用在真實環(huán)境中的行為
端到端驗證：測試從HTTP請求到數(shù)據(jù)庫的全流程
符合用戶視角：從客戶端角度驗證功能
支持高級場景：可測試認(rèn)證、性能、流量等

局限性

運行慢：完整上下文啟動耗時長
環(huán)境依賴：可能需要外部服務(wù)和資源
維護(hù)成本高：測試復(fù)雜度和脆弱性增加
不適合單元覆蓋：難以覆蓋所有邊界情況
調(diào)試?yán)щy：問題定位和修復(fù)復(fù)雜

方案對比與選擇建議

特性	MockMvc單元測試	@WebMvcTest切片測試	@SpringBootTest集成測試	TestRestTemplate/WebTestClient
上下文加載	不加載	只加載MVC組件	完整加載	完整加載
啟動服務(wù)器	否	否	可選	是
測試速度	最快	快	慢	最慢
測試隔離性	最高	高	中	低
覆蓋范圍	控制器邏輯	MVC配置和組件	全棧集成	全棧端到端
配置復(fù)雜度	低	中	高	高
適用場景	控制器單元邏輯	MVC配置驗證	功能集成測試	用戶端體驗驗證
模擬依賴	完全模擬	部分模擬	少量或不模擬	少量或不模擬