Java业务层单元测试通用编写流程（Junit4+Mockito实战）

Java业务层单元测试通用编写流程（Junit4+Mockito实战）

在Java后端开发中，单元测试是保障代码质量、减少线上Bug的关键环节。尤其是业务层（Service层），依赖DAO、其他Manager等组件，直接测试易受外部环境（数据库、第三方服务）影响，稳定性差。本文将基于主流的「Junit4+Mockito」组合，总结业务层单元测试的通用编写流程，搭配完整示例，新手也能快速上手。

核心原则先明确：单元测试只聚焦当前类的业务逻辑，对所有依赖组件做"模拟"（Mock），排除外部依赖干扰。简单说，就是"测自己的代码，让别人的代码'假装运行'"。

一、通用编写流程（5步闭环，直接套用）

无论测试哪个Service类，都可遵循"环境准备→类与字段声明→前置初始化→测试方法编写→执行验证"这5步流程，形成闭环，确保测试覆盖完整、逻辑清晰。

步骤1：环境准备（引入依赖）

首先需要引入Junit4（测试框架，负责测试用例的执行与管理）和Mockito（模拟框架，负责创建依赖的假对象），依赖仅在测试环境生效，不影响生产包。

Maven依赖（pom.xml中添加）：

<!-- Junit4 核心依赖 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope> <!-- 测试环境专属 -->
</dependency>
<!-- Mockito 核心依赖 -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.12.4</version>
    <scope>test</scope>
</dependency>

步骤2：创建测试类与字段声明

按规范创建测试类，并通过注解声明"被测对象"和"依赖的模拟对象"，这是Mockito的核心用法。

• 测试类命名：被测类名+Test（如PaymentBillServiceImpl → PaymentBillServiceTest），包名与被测类一致（src/test/java下对应路径）。

• 类注解：@RunWith(MockitoJUnitRunner.class)，作用是让Junit4兼容Mockito注解，否则模拟对象无法生效。

• 字段注解：

  • @InjectMocks：创建被测对象的真实实例，并自动将@Mock标记的模拟对象注入到被测对象中（一个测试类仅一个）。

  • @Mock：创建依赖组件的模拟对象（假对象），替代真实的DAO、Manager等，避免调用真实接口/数据库。

步骤3：前置初始化（@Before方法）

用@Before注解标记前置方法，该方法会在每个@Test测试方法执行前自动运行，用于做统一初始化工作，避免代码重复。核心要完成3件事：

1. 初始化测试入参：准备调用被测方法时需要传入的参数（如查询条件、请求对象）。

2. 初始化预设数据：准备模拟对象需要返回的测试数据（如DAO查询的结果列表、接口返回的信息）。

3. Mock打桩：通过when(模拟对象.方法(参数)).thenReturn(预设数据)，告诉模拟对象"被调用时该返回什么数据"，这是Mockito的核心操作。

步骤4：编写测试方法（@Test方法）

每个@Test方法对应一个测试场景（如成功场景、空数据场景、参数错误场景），命名规范建议为"test+被测方法名+场景"（如testQryPaymentBill_Success）。每个测试方法必须遵循"执行→断言→验证"3个子步骤：

1. 执行被测方法：调用@InjectMocks标记的被测对象的目标方法，传入测试入参，获取返回结果。

2. 结果断言：用Junit的Assert工具类验证返回结果是否符合预期（这是单元测试的灵魂，断言失败则测试不通过）。

3. 调用验证（可选但推荐）：用Mockito的verify方法，验证被测方法是否正确调用了依赖的模拟对象（如是否调用了DAO的查询方法、调用次数是否正确）。

步骤5：执行测试与问题排查

运行测试类（IDE中直接右键运行或通过Maven命令mvn test），根据测试结果排查问题：

• 测试通过（绿色）：说明被测方法在该场景下逻辑正常。

• 测试失败（红色）：根据报错信息排查，可能是断言预期值错误、被测方法逻辑有Bug、Mock打桩不完整等。

二、完整实操示例（可直接复制套用）

以"账单查询服务（PaymentBillService）"为例，完整演示上述流程的落地代码，包含成功场景的测试，标注关键步骤说明。

1. 被测类（简化版）

@Service
public class PaymentBillServiceImpl implements PaymentBillService {
    // 依赖的DAO和Manager
    @Autowired
    private PaymentBillDao paymentBillDao;
    @Autowired
    private StaffMgr staffMgr;
    @Autowired
    private ProductOfferMgr productOfferMgr;

    // 被测方法：查询账单列表
    @Override
    public Map<String, Object> qryPaymentBill(Map<String, Object> qryParams) {
        // 1. 调用DAO查询原始数据
        List<OnceItemT> onceItemTList = paymentBillDao.qryPaymentBill(qryParams);
        // 2. 调用依赖组件补充信息（员工、组织、产品名称）
        List<PaymentBillDto> dtoList = onceItemTList.stream().map(item -> {
            PaymentBillDto dto = new PaymentBillDto();
            // 复制基础字段（省略get/set）
            dto.setAccNbr(item.getAccNbr());
            dto.setProductOfferId(item.getProductOfferId());
            // 调用staffMgr获取员工、组织信息
            Map<String, Object> staffInfo = staffMgr.getStaffInfoFromCtgCache(item.getCrmStaffId());
            Map<String, Object> orgInfo = staffMgr.getOrgInfoFromCtgCache(staffInfo.get("userOrgId").toString());
            dto.setOrgName(orgInfo.get("orgName").toString());
            // 调用productOfferMgr获取产品名称
            String offerName = productOfferMgr.getOfferNameByProductOfferId(Constant.REGION_ID_USE, item.getProductOfferId());
            dto.setProductOfferName(offerName);
            return dto;
        }).collect(Collectors.toList());
        // 3. 组装返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("paymentBillList", dtoList);
        return result;
    }
}

2. 测试类（完整流程落地）

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

// 步骤2：类注解+测试类命名
@RunWith(MockitoJUnitRunner.class)
public class PaymentBillServiceTest {

    // 步骤2：字段声明（被测对象+模拟依赖）
    @InjectMocks
    private PaymentBillServiceImpl paymentBillService; // 被测对象
    @Mock
    private PaymentBillDao paymentBillDao; // 模拟DAO依赖
    @Mock
    private StaffMgr staffMgr; // 模拟员工管理依赖
    @Mock
    private ProductOfferMgr productOfferMgr; // 模拟产品管理依赖

    // 测试用例数据（全局变量，供@Before和@Test使用）
    private Map<String, Object> qryParams;
    private List<OnceItemT> onceItemTList;

    // 步骤3：前置初始化（@Before方法）
    @Before
    public void setUp() {
        // 3.1 初始化测试入参（查询条件）
        qryParams = new HashMap<>();
        qryParams.put("beginDate", "2024-01-01");
        qryParams.put("endDate", "2024-01-31");
        qryParams.put("accNbr", "0");

        // 3.2 初始化预设数据（DAO查询返回的原始数据）
        onceItemTList = new ArrayList<>();
        OnceItemT item = new OnceItemT();
        item.setPayIndentId("PI20240101001");
        item.setCrmStaffId("STAFF001");
        item.setAccNbr("0");
        item.setProductOfferId(888);
        onceItemTList.add(item);

        // 3.3 Mock打桩（预设依赖的返回值）
        // 模拟DAO查询返回预设数据
        when(paymentBillDao.qryPaymentBill(qryParams)).thenReturn(onceItemTList);
        // 模拟员工信息查询返回
        Map<String, Object> staffInfo = new HashMap<>();
        staffInfo.put("userOrgId", "ORG001");
        when(staffMgr.getStaffInfoFromCtgCache(anyString())).thenReturn(staffInfo);
        // 模拟组织信息查询返回
        Map<String, Object> orgInfo = new HashMap<>();
        orgInfo.put("orgName", "测试部门");
        when(staffMgr.getOrgInfoFromCtgCache(anyString())).thenReturn(orgInfo);
        // 模拟产品名称查询返回
        when(productOfferMgr.getOfferNameByProductOfferId(anyInt(), anyInt())).thenReturn("华为Mate60 Pro套餐");
    }

    // 步骤4：编写测试方法（成功场景）
    @Test
    public void testQryPaymentBill_Success() {
        // 4.1 执行被测方法
        Map<String, Object> result = paymentBillService.qryPaymentBill(qryParams);
        List<PaymentBillDto> billList = (List<PaymentBillDto>) result.get("paymentBillList");

        // 4.2 结果断言（核心，验证返回结果符合预期）
        Assert.assertNotNull("查询结果Map不能为null", result);
        Assert.assertNotNull("账单列表不能为null", billList);
        Assert.assertEquals("账单列表应只有1条数据", 1, billList.size());
        PaymentBillDto dto = billList.get(0);
        Assert.assertEquals("账号应匹配", "0", dto.getAccNbr());
        Assert.assertEquals("产品套餐名称应匹配", "华为Mate60 Pro套餐", dto.getProductOfferName());
        Assert.assertEquals("组织名称应匹配", "测试部门", dto.getOrgName());

        // 4.3 调用验证（验证依赖被正确调用）
        verify(paymentBillDao).qryPaymentBill(qryParams); // 验证DAO查询被调用1次
        verify(staffMgr, org.mockito.Mockito.times(2)).getStaffInfoFromCtgCache(anyString()); // 验证员工查询被调用2次
        verify(productOfferMgr).getOfferNameByProductOfferId(anyInt(), anyInt()); // 验证产品名称查询被调用1次
    }
}

三、新手避坑指南（关键注意事项）

在实际编写中，新手容易踩一些坑，这里总结4个高频问题及解决方案：

坑1：@InjectMocks注入失败

现象：被测对象中的依赖字段为null，调用方法时报空指针异常。

解决方案：确保被测类的依赖字段名与@Mock标记的模拟对象字段名一致（Mockito优先按名称匹配注入）；若字段名不一致，可通过构造器注入或setter注入优化。

坑2：断言无意义，仅打印不验证

现象：测试方法中只调用被测方法并打印结果，没有写Assert断言，无论逻辑对错测试都通过。

解决方案：牢记"断言是单元测试的灵魂"，每个测试方法必须至少包含1个核心断言（验证返回结果、状态等），覆盖关键业务逻辑点。

坑3：Mock打桩参数匹配过严

现象：被测方法中调用依赖时的参数与打桩时的参数不完全一致，导致模拟对象返回null。

解决方案：灵活使用Mockito参数匹配器，如anyString()（任意字符串）、anyMap()（任意Map）、anyInt()（任意int），避免严格匹配非关键参数。

坑4：测试方法依赖外部环境

现象：测试方法中调用了真实的数据库查询、第三方接口，导致测试不稳定（有时通有时不通）、执行缓慢。

解决方案：严格遵循"所有依赖都Mock"的原则，不允许在单元测试中调用真实外部组件，确保测试独立、快速、稳定。

四、总结

Java业务层单元测试的核心，是通过Mockito隔离外部依赖，聚焦被测类的业务逻辑，再通过Junit4完成测试用例的执行与验证。记住"5步通用流程"+"3步测试方法规范"，就能应对绝大多数Service层的测试场景：

通用流程：环境准备→类与字段声明→前置初始化→测试方法编写→执行验证

测试方法规范：执行被测方法→结果断言→依赖调用验证

按照这个流程编写单元测试，既能保证代码质量，又能提高后续迭代的安全性（修改代码后，跑一遍测试用例就能快速发现问题），是后端开发者必备的核心技能之一。