我要评论引言
在现代企业级应用开发中，测试已成为确保软件质量的关键环节。springboot作为当前最流行的java开发框架，提供了完善的测试支持机制。本文将深入探讨springboot测试中两个核心工具：@springboottest注解与mockmvc测试框架的实战应用，帮助开发者构建更稳健的测试体系，提高代码质量与可维护性。
一、springboot测试基础
1.1 测试环境配置
springboot提供了丰富的测试支持，使开发者能够方便地进行单元测试和集成测试。在springboot项目中进行测试需要引入spring-boot-starter-test依赖，该依赖包含junit、spring test、assertj等测试相关库。测试环境的正确配置是高效测试的基础，确保测试用例能够在与生产环境相似的条件下运行，从而提高测试结果的可靠性。
// build.gradle配置
dependencies {
// springboot基础依赖
implementation 'org.springframework.boot:spring-boot-starter-web'
// 测试相关依赖
testimplementation 'org.springframework.boot:spring-boot-starter-test'
// junit 5支持
testimplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
testruntimeonly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
}
// 或者在maven中的pom.xml配置
/*
<dependencies>
<!-- springboot基础依赖 -->
<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>
</dependencies>
*/1.2 测试目录结构
一个规范的测试目录结构有助于测试用例的组织和管理。在springboot项目中，测试代码通常位于src/test/java目录下，测试资源文件位于src/test/resources目录。测试类的包结构应与主代码保持一致，便于关联和维护。测试配置文件可以覆盖主配置，为测试提供专用环境参数。
src
├── main
│ ├── java
│ │ └── com.example.demo
│ │ ├── controller
│ │ ├── service
│ │ └── repository
│ └── resources
│ └── application.properties
└── test
├── java
│ └── com.example.demo
│ ├── controller // 控制器测试类
│ ├── service // 服务测试类
│ └── repository // 数据访问测试类
└── resources
└── application-test.properties // 测试专用配置二、@springboottest注解详解
2.1 基本用法与配置选项
@springboottest注解是springboot测试的核心，它提供了加载完整应用程序上下文的能力。通过这个注解，可以创建接近真实环境的测试环境，使集成测试更加可靠。@springboottest支持多种配置选项，可以根据测试需求进行灵活调整，包括指定启动类、测试配置文件、web环境类型等。
package com.example.demo;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.context.springboottest;
import org.springframework.core.env.environment;
import static org.junit.jupiter.api.assertions.assertnotnull;
// 基本用法：加载完整的spring应用上下文
@springboottest
public class basicapplicationtests {
@autowired
private environment environment; // 注入环境变量
@test
void contextloads() {
// 验证上下文是否正确加载
assertnotnull(environment);
system.out.println("active profiles: " + string.join(", ", environment.getactiveprofiles()));
}
}
// 高级配置：自定义测试属性
@springboottest(
// 指定启动类
classes = demoapplication.class,
// 指定web环境类型
webenvironment = springboottest.webenvironment.random_port,
// 设置测试属性
properties = {
"spring.profiles.active=test",
"server.servlet.context-path=/api"
}
)
class customizedapplicationtest {
// 测试代码...
}2.2 不同webenvironment模式的应用场景
@springboottest注解的webenvironment属性定义了测试的web环境类型，有四种可选值：mock、random_port、defined_port和none。每种模式适用于不同的测试场景。正确选择web环境模式可以提高测试效率，减少资源消耗。
package com.example.demo;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.context.springboottest;
import org.springframework.boot.test.web.client.testresttemplate;
import org.springframework.boot.test.web.server.localserverport;
import static org.assertj.core.api.assertions.assertthat;
// mock模式：不启动服务器，适用于通过mockmvc测试控制器
@springboottest(webenvironment = springboottest.webenvironment.mock)
class mockwebenvironmenttest {
// 使用mockmvc测试...
}
// random_port模式：启动真实服务器，随机端口，适用于端到端测试
@springboottest(webenvironment = springboottest.webenvironment.random_port)
class randomportwebenvironmenttest {
@localserverport
private int port; // 获取随机分配的端口
@autowired
private testresttemplate resttemplate;
@test
void testhomeendpoint() {
// 发送真实http请求
string response = resttemplate.getforobject(
"http://localhost:" + port + "/api/home",
string.class
);
assertthat(response).contains("welcome");
}
}
// defined_port模式：使用application.properties中定义的端口
@springboottest(webenvironment = springboottest.webenvironment.defined_port)
class definedportwebenvironmenttest {
// 使用固定端口测试...
}
// none模式：不启动web环境，适用于纯业务逻辑测试
@springboottest(webenvironment = springboottest.webenvironment.none)
class nowebenvironmenttest {
// 仅测试服务层和存储层...
}三、mockmvc实战应用
3.1 mockmvc基本使用方法
mockmvc是spring mvc测试框架的核心组件，它模拟http请求和响应，无需启动真实服务器即可测试控制器。mockmvc提供了流畅的api，可以构建请求、执行调用、验证响应。这种方式的测试执行速度快，资源消耗少，特别适合控制器单元测试。使用mockmvc可以确保web层代码的正确性和稳定性。
package com.example.demo.controller;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.webmvctest;
import org.springframework.test.web.servlet.mockmvc;
import static org.springframework.test.web.servlet.request.mockmvcrequestbuilders.get;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.content;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.status;
// @webmvctest专注于测试控制器层，只加载mvc相关组件
@webmvctest(usercontroller.class)
public class usercontrollertest {
@autowired
private mockmvc mockmvc; // mockmvc由spring自动注入
@test
void testgetuserbyid() throws exception {
// 执行get请求并验证响应
mockmvc.perform(get("/users/1")) // 构建get请求
.andexpect(status().isok()) // 验证http状态码为200
.andexpect(content().contenttype("application/json")) // 验证内容类型
.andexpect(content().json("{\"id\":1,\"name\":\"john\"}")); // 验证json响应内容
}
}3.2 高级请求构建和响应验证
mockmvc提供了丰富的请求构建选项和响应验证方法，可以全面测试控制器的各种行为。通过高级api，可以模拟复杂的请求场景，包括添加请求头、设置参数、提交表单数据、上传文件等。同时，mockmvc还提供了详细的响应验证机制，可以检查http状态码、响应头、响应体内容等。
package com.example.demo.controller;
import com.fasterxml.jackson.databind.objectmapper;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.webmvctest;
import org.springframework.http.mediatype;
import org.springframework.test.web.servlet.mockmvc;
import org.springframework.test.web.servlet.result.mockmvcresulthandlers;
import static org.hamcrest.matchers.*;
import static org.springframework.test.web.servlet.request.mockmvcrequestbuilders.*;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.*;
@webmvctest(productcontroller.class)
public class productcontrolleradvancedtest {
@autowired
private mockmvc mockmvc;
@autowired
private objectmapper objectmapper; // 用于json转换
@test
void testcreateproduct() throws exception {
// 创建测试数据
product product = new product(null, "笔记本电脑", 6999.99, 10);
// 执行post请求
mockmvc.perform(
post("/products") // post请求
.contenttype(mediatype.application_json) // 设置content-type
.header("authorization", "bearer token123") // 添加自定义请求头
.content(objectmapper.writevalueasstring(product)) // 请求体json
)
.anddo(mockmvcresulthandlers.print()) // 打印请求和响应详情
.andexpect(status().iscreated()) // 期望返回201状态码
.andexpect(header().exists("location")) // 验证响应头包含location
.andexpect(jsonpath("$.id", not(nullvalue()))) // 验证id已生成
.andexpect(jsonpath("$.name", is("笔记本电脑"))) // 验证属性值
.andexpect(jsonpath("$.price", closeto(6999.99, 0.01))); // 验证浮点数
}
@test
void testsearchproducts() throws exception {
// 测试带查询参数的get请求
mockmvc.perform(
get("/products/search")
.param("keyword", "电脑") // 添加查询参数
.param("minprice", "5000")
.param("maxprice", "10000")
)
.andexpect(status().isok())
.andexpect(jsonpath("$", hassize(greaterthan(0)))) // 验证数组不为空
.andexpect(jsonpath("$[0].name", containsstring("电脑"))); // 验证结果包含关键词
}
}
// 简单的产品类
class product {
private long id;
private string name;
private double price;
private int stock;
// 构造函数、getter和setter略
public product(long id, string name, double price, int stock) {
this.id = id;
this.name = name;
this.price = price;
this.stock = stock;
}
// getter和setter略...
}四、模拟服务层与依赖
4.1 使用@mockbean模拟服务
在测试控制器时，通常需要模拟服务层的行为。spring boot提供了@mockbean注解，可以用来替换spring容器中的bean为mockito模拟对象。这种方式使得控制器测试可以专注于控制层逻辑，无需关心服务层的实际实现。通过配置模拟对象的返回值，可以测试控制器在不同场景下的行为。
package com.example.demo.controller;
import com.example.demo.model.user;
import com.example.demo.service.userservice;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.webmvctest;
import org.springframework.boot.test.mock.mockito.mockbean;
import org.springframework.test.web.servlet.mockmvc;
import java.util.arrays;
import java.util.optional;
import static org.mockito.argumentmatchers.anylong;
import static org.mockito.mockito.when;
import static org.springframework.test.web.servlet.request.mockmvcrequestbuilders.get;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.jsonpath;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.status;
@webmvctest(usercontroller.class)
public class usercontrollerwithmockservicetest {
@autowired
private mockmvc mockmvc;
@mockbean // 创建并注入userservice的模拟实现
private userservice userservice;
@test
void testgetuserbyid() throws exception {
// 配置模拟服务的行为
user mockuser = new user(1l, "张三", "zhangsan@example.com");
when(userservice.findbyid(1l)).thenreturn(optional.of(mockuser));
when(userservice.findbyid(99l)).thenreturn(optional.empty()); // 模拟用户不存在的情况
// 测试成功场景
mockmvc.perform(get("/users/1"))
.andexpect(status().isok())
.andexpect(jsonpath("$.id").value(1))
.andexpect(jsonpath("$.name").value("张三"));
// 测试用户不存在的场景
mockmvc.perform(get("/users/99"))
.andexpect(status().isnotfound()); // 期望返回404
}
@test
void testgetallusers() throws exception {
// 配置模拟服务返回用户列表
when(userservice.findall()).thenreturn(arrays.aslist(
new user(1l, "张三", "zhangsan@example.com"),
new user(2l, "李四", "lisi@example.com")
));
// 测试获取所有用户api
mockmvc.perform(get("/users"))
.andexpect(status().isok())
.andexpect(jsonpath("$").isarray())
.andexpect(jsonpath("$.length()").value(2))
.andexpect(jsonpath("$[0].name").value("张三"))
.andexpect(jsonpath("$[1].name").value("李四"));
}
}
// user模型类
class user {
private long id;
private string name;
private string email;
// 构造函数、getter和setter略
public user(long id, string name, string email) {
this.id = id;
this.name = name;
this.email = email;
}
// getter和setter略...
}4.2 测试异常处理和边界情况
全面的测试应该包括对异常情况和边界条件的处理。在springboot应用中，控制器通常会通过@exceptionhandler或@controlleradvice处理异常。通过mockmvc可以有效地测试这些异常处理机制，确保系统在异常情况下也能够正确响应。测试边界情况可以提高代码的健壮性。
package com.example.demo.controller;
import com.example.demo.exception.resourcenotfoundexception;
import com.example.demo.service.orderservice;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.webmvctest;
import org.springframework.boot.test.mock.mockito.mockbean;
import org.springframework.http.mediatype;
import org.springframework.test.web.servlet.mockmvc;
import static org.mockito.argumentmatchers.anylong;
import static org.mockito.mockito.dothrow;
import static org.mockito.mockito.when;
import static org.springframework.test.web.servlet.request.mockmvcrequestbuilders.get;
import static org.springframework.test.web.servlet.request.mockmvcrequestbuilders.post;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.jsonpath;
import static org.springframework.test.web.servlet.result.mockmvcresultmatchers.status;
@webmvctest(ordercontroller.class)
public class ordercontrollerexceptiontest {
@autowired
private mockmvc mockmvc;
@mockbean
private orderservice orderservice;
@test
void testresourcenotfoundexceptionhandling() throws exception {
// 配置模拟服务抛出异常
when(orderservice.getorderbyid(anylong()))
.thenthrow(new resourcenotfoundexception("order not found with id: 999"));
// 验证异常是否被正确处理
mockmvc.perform(get("/orders/999"))
.andexpect(status().isnotfound()) // 期望返回404
.andexpect(jsonpath("$.message").value("order not found with id: 999"))
.andexpect(jsonpath("$.timestamp").exists());
}
@test
void testinvalidinputhandling() throws exception {
// 测试无效输入的处理
mockmvc.perform(
post("/orders")
.contenttype(mediatype.application_json)
.content("{\"customername\":\"\",\"amount\":-10}") // 无效数据
)
.andexpect(status().isbadrequest()) // 期望返回400
.andexpect(jsonpath("$.fielderrors").isarray())
.andexpect(jsonpath("$.fielderrors[?(@.field=='customername')]").exists())
.andexpect(jsonpath("$.fielderrors[?(@.field=='amount')]").exists());
}
@test
void testunauthorizedaccess() throws exception {
// 测试未授权访问的处理
dothrow(new securityexception("unauthorized access")).when(orderservice)
.deleteorder(anylong());
mockmvc.perform(get("/orders/123/delete"))
.andexpect(status().isunauthorized()) // 期望返回401
.andexpect(jsonpath("$.error").value("unauthorized access"));
}
}五、测试最佳实践
5.1 测试数据准备与清理
良好的测试应当具有隔离性和可重复性。在springboot测试中，应当注意测试数据的准备和清理工作。使用@beforeeach和@aftereach注解可以在每个测试方法前后执行准备和清理操作。对于数据库测试，可以使用@sql注解执行sql脚本，或者配合@transactional注解自动回滚事务。
package com.example.demo.repository;
import com.example.demo.entity.employee;
import org.junit.jupiter.api.aftereach;
import org.junit.jupiter.api.beforeeach;
import org.junit.jupiter.api.test;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.datajpatest;
import org.springframework.test.context.jdbc.sql;
import java.time.localdate;
import java.util.list;
import static org.assertj.core.api.assertions.assertthat;
@datajpatest // 专用于jpa仓库层测试的注解
public class employeerepositorytest {
@autowired
private employeerepository employeerepository;
@beforeeach
void setup() {
// 测试前准备数据
employeerepository.saveall(list.of(
new employee(null, "张三", "开发", 12000.0, localdate.of(2020, 5, 1)),
new employee(null, "李四", "测试", 10000.0, localdate.of(2021, 3, 15)),
new employee(null, "王五", "开发", 15000.0, localdate.of(2019, 8, 12))
));
}
@aftereach
void teardown() {
// 测试后清理数据
employeerepository.deleteall();
}
@test
void testfindbydepartment() {
// 测试按部门查询
list<employee> developers = employeerepository.findbydepartment("开发");
assertthat(developers).hassize(2);
assertthat(developers).extracting(employee::getname)
.containsexactlyinanyorder("张三", "王五");
}
@test
@sql("/test-data/additional-employees.sql") // 执行sql脚本添加更多测试数据
void testfindbysalaryrange() {
// 测试按薪资范围查询
list<employee> employees = employeerepository.findbysalarybetween(11000.0, 14000.0);
assertthat(employees).hassize(2);
assertthat(employees).extracting(employee::getname)
.contains("张三");
}
}
// employee实体类
class employee {
private long id;
private string name;
private string department;
private double salary;
private localdate hiredate;
// 构造函数、getter和setter略
public employee(long id, string name, string department, double salary, localdate hiredate) {
this.id = id;
this.name = name;
this.department = department;
this.salary = salary;
this.hiredate = hiredate;
}
// getter略...
}5.2 测试覆盖率与持续集成
测试覆盖率是衡量测试质量的重要指标，高覆盖率通常意味着更少的未测试代码和更少的潜在bug。在springboot项目中，可以使用jacoco等工具统计测试覆盖率。将测试集成到ci/cd流程中，确保每次代码提交都会触发自动测试，可以尽早发现问题，提高开发效率。
// 在build.gradle中配置jacoco测试覆盖率插件
/*
plugins {
id 'jacoco'
}
jacoco {
toolversion = "0.8.7"
}
test {
finalizedby jacocotestreport // 测试完成后生成覆盖率报告
}
jacocotestreport {
dependson test // 确保测试已执行
reports {
xml.enabled true
html.enabled true
}
}
// 设置覆盖率阈值
jacocotestcoverageverification {
violationrules {
rule {
limit {
minimum = 0.80 // 最低80%覆盖率
}
}
}
}
*/
// 示例测试类 - 确保高覆盖率
package com.example.demo.service;
import org.junit.jupiter.api.test;
import org.junit.jupiter.params.parameterizedtest;
import org.junit.jupiter.params.provider.csvsource;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.context.springboottest;
import static org.assertj.core.api.assertions.assertthat;
import static org.assertj.core.api.assertions.assertthatthrownby;
@springboottest
public class taxcalculatorservicetest {
@autowired
private taxcalculatorservice taxcalculatorservice;
@parameterizedtest
@csvsource({
"5000.0, 0.0", // 不超过起征点
"8000.0, 90.0", // 第一档税率3%
"20000.0, 1590.0", // 第二档税率10%
"50000.0, 7590.0" // 第三档税率20%
})
void testcalculateincometax(double income, double expectedtax) {
double tax = taxcalculatorservice.calculateincometax(income);
assertthat(tax).isequalto(expectedtax);
}
@test
void testcalculateincometaxwithnegativeincome() {
// 测试边界情况：负收入
assertthatthrownby(() -> taxcalculatorservice.calculateincometax(-1000.0))
.isinstanceof(illegalargumentexception.class)
.hasmessagecontaining("income cannot be negative");
}
// 更多测试用例，确保高覆盖率...
}总结
本文详细介绍了springboot测试环境中@springboottest注解与mockmvc测试框架的实战应用。@springboottest提供了加载完整应用上下文的能力，支持不同的web环境模式，适用于各种集成测试场景。mockmvc则专注于控制器层测试，通过模拟http请求和响应，无需启动真实服务器即可验证控制器行为。在实际开发中，合理配置测试环境、准备测试数据、模拟服务依赖、处理异常和边界情况，对于构建健壮的测试体系至关重要。遵循最佳实践，如保持测试隔离性、追求高测试覆盖率、集成自动化测试流程等，能够显著提高代码质量和开发效率。通过本文介绍的技术和方法，开发者可以构建更加可靠和高效的springboot应用测试体系，为项目的长期稳定运行提供有力保障。
到此这篇关于springboot测试之@springboottest与mockmvc的实战应用小结的文章就介绍到这了,更多相关springboot测试@springboottest与mockmvc内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论