如何用JUnit和Mockito测试含私有静态final Logger的Java类？

针对你遇到的private static final Logger难以在单元测试中验证的问题，仅用JUnit 5和Mockito 5.1有两种主要方案，其中重构代码是更安全的长期方案，静态Mock则是不改动原有代码的临时解决方式：

1. 使用Mockito静态Mock（无需修改业务代码） #

Mockito从3.4版本开始支持静态方法Mock，通过这种方式可以拦截LoggerFactory.getLogger()的调用，返回一个Mock的Logger实例，进而验证日志行为。注意必须用try-with-resources包裹静态Mock，避免污染其他测试用例。

测试代码示例：

import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.mockito.Mockito.*;

class YorkieTest {

    @Test
    void bark_whenFetchFails_logsError() {
        // 拦截LoggerFactory的静态方法调用，返回Mock Logger
        try (MockedStatic<LoggerFactory> mockedLoggerFactory = mockStatic(LoggerFactory.class)) {
            Logger mockLogger = mock(Logger.class);
            mockedLoggerFactory.when(() -> LoggerFactory.getLogger(Yorkie.class))
                               .thenReturn(mockLogger);

            // Spy Yorkie实例，让fetchFavoriteToy方法强制抛出异常
            Yorkie yorkie = spy(new Yorkie());
            doThrow(new Exception("Favorite toy not found!"))
                .when(yorkie)
                .fetchFavoriteToy();

            // 执行待测试方法
            yorkie.bark();

            // 验证Logger的error方法是否按预期调用
            verify(mockLogger)
                .error(contains("Unable to bark: Favorite toy not found!"));
        }
    }
}

注意事项 #

• 静态Mock的作用域仅限try-with-resources块内，离开块后会自动重置，避免影响其他测试
• 仅针对当前测试类的LoggerFactory.getLogger(Yorkie.class)调用进行Mock，不要全局Mock所有LoggerFactory行为

2. 重构代码注入Logger（更安全的长期方案） #

直接Mock静态字段本质是绕过封装，长期来看会让测试变得脆弱。更推荐的方式是通过构造函数注入Logger，保留生产环境的默认实现，同时给测试留入口：

重构后的Yorkie类：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Yorkie {

    private final Logger LOGGER;
    private String favoriteToy = "Ball";

    // 生产环境使用的默认构造函数
    public Yorkie() {
        this(LoggerFactory.getLogger(Yorkie.class));
    }

    // 测试专用构造函数，注入Mock Logger
    Yorkie(Logger logger) {
        this.LOGGER = logger;
    }

    private String fetchFavoriteToy() throws Exception {
        if (Math.random() < 0.5) {
            throw new Exception("Favorite toy not found!");
        }
        return favoriteToy;
    }

    private void bark() {
        try {
            String toy = fetchFavoriteToy();
        } catch (Exception e) {
            LOGGER.error(LoggingFacade.formatError("ERROR-Dog", null, null,
                    null, "Unable to bark: " + e.getMessage()));
        }
    }

    public static void main(String[] args) {
        Yorkie yorkie = new Yorkie();
        yorkie.bark();
    }
}

对应的测试代码（无需静态Mock，更简洁安全）：

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import static org.mockito.Mockito.*;

class YorkieTest {

    @Test
    void bark_whenFetchFails_logsError() {
        // 直接创建Mock Logger并注入
        Logger mockLogger = mock(Logger.class);
        Yorkie yorkie = spy(new Yorkie(mockLogger));

        // 强制fetch方法抛出异常
        doThrow(new Exception("Favorite toy not found!"))
            .when(yorkie)
            .fetchFavoriteToy();

        yorkie.bark();

        // 验证日志调用
        verify(mockLogger)
            .error(contains("Unable to bark: Favorite toy not found!"));
    }
}

总结 #

• 如果不能修改现有业务代码，Mockito静态Mock是可行的临时方案，但必须严格控制Mock作用域
• 从测试稳定性和代码设计角度，重构注入Logger是更安全、更符合依赖注入原则的选择

内容的提问来源于stack exchange，提问作者Shawn Armstrong