Spring boot 如何在Junit中使用slf4j模拟log4j2 logger对象

我有下面的代码，我正在使用slf4j工厂创建不同的log4j2 loggers对象，我需要根据输入参数写入特定的日志文件

@Service
class WriterService {

val logger1: Logger = LoggerFactory.getLogger("t_logger")
val logger2: Logger = LoggerFactory.getLogger("b_logger")
val labelKey = "Label"

fun writeLog(payload: Map<String, Any>){

    if(payload.containsKey(labelKey)) {

        val label = payload[labelKey].toString().toLowerCase()

        if (label == "t") {
            logger1.info("{}", payload)

        } else if (label == "b") {
            logger2.info("{}", payload)
        }
    }
}

@服务
类WriterService{
val logger1:Logger=LoggerFactory.getLogger（“t_Logger”）
val logger2:Logger=LoggerFactory.getLogger（“b_Logger”）
val labelKey=“标签”
趣味写作日志（有效负载：地图）{
if（有效载荷容器（labelKey））{
val label=payload[labelKey].toString（）.toLowerCase（）
如果（标签=“t”）{
logger1.info（“{}”，有效负载）
}否则，如果（标签=“b”）{
logger2.info（“{}”，有效负载）
}
}
}

---

我想知道如何使用MockitoJUnitRunner模拟记录器对象，以便模拟调用了哪个记录器对象？

我找到了使用Appender和ArgumentCaptor的解决方案。。。 下面是可能感兴趣的人的解决方案

import org.apache.logging.log4j.Level
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.core.Appender
import org.apache.logging.log4j.core.LogEvent
import org.apache.logging.log4j.core.Logger
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.ArgumentCaptor
import org.mockito.Captor
import org.mockito.InjectMocks
import org.mockito.Mock
import org.mockito.Mockito.*
import org.mockito.runners.MockitoJUnitRunner
import java.lang.StringBuilder

@RunWith(MockitoJUnitRunner::class)
class ServiceTest {

    @InjectMocks
    var service: WriterService 

    @Mock
    private val mockAppender: Appender? = null

    @Captor
    private val captorLoggingEvent: ArgumentCaptor<LogEvent>? = null

    private var logger1: Logger? = null
    private var logger2: Logger? = null

    @Before
    fun setup() {
        `when`(mockAppender!!.name).thenReturn("MockAppender")
        `when`(mockAppender.isStarted).thenReturn(true)
        `when`(mockAppender.isStopped).thenReturn(false)

        logger1 = LogManager.getLogger("t_logger") as Logger
        logger1!!.addAppender(mockAppender)
        logger1!!.level = Level.INFO

        logger2 = LogManager.getLogger("b_logger") as Logger
        logger2!!.addAppender(mockAppender)
        logger2!!.level = Level.INFO
    }

    @After
    fun tearDown() {
        logger1!!.removeAppender(mockAppender!!)
        logger2!!.removeAppender(mockAppender!!)
    }

    @Test
    fun writeLog_shouldWriteTransactionLogWhenLabelIs_T() {

        val payload = hashMapOf("Label" to "t")

        service.writeLog(payload)

        verify(mockAppender, times(1))!!.append(captorLoggingEvent!!.capture())
        assertEquals(captorLoggingEvent.value.level, Level.INFO)
        assertEquals(captorLoggingEvent.value.loggerName, "t_logger")
        assertEquals(captorLoggingEvent.value.message.formattedMessage, "{Label=t}")
    }

    @Test
    fun writeLog_shouldWriteBackendLogWhenLabelIs_B() {

        val payload = hashMapOf("Label" to "b")

        service.writeLog(payload)

        verify(mockAppender, times(1))!!.append(captorLoggingEvent!!.capture())
        assertEquals(captorLoggingEvent.value.level, Level.INFO)
        assertEquals(captorLoggingEvent.value.loggerName, "b_logger")
        assertEquals(captorLoggingEvent.value.message.formattedMessage, "{Label=b}")
    }
}

import org.apache.logging.log4j.Level
导入org.apache.logging.log4j.LogManager
导入org.apache.logging.log4j.core.Appender
导入org.apache.logging.log4j.core.LogEvent
导入org.apache.logging.log4j.core.Logger
导入org.junit.After
导入org.junit.Assert.assertEquals
导入org.junit.Before
导入org.junit.Test
导入org.junit.runner.RunWith
导入org.mockito.ArgumentCaptor
导入org.mockito.Captor
导入org.mockito.InjectMocks
导入org.mockito.Mock
导入org.mockito.mockito*
导入org.mockito.runners.MockitoJUnitRunner
导入java.lang.StringBuilder
@RunWith（MockitoJUnitRunner:：class）
类服务测试{
@注射模拟
var服务：WriterService
@嘲弄
私有val mockAppender:Appender？=null
@俘虏
私有val captorLoggingEvent:ArgumentCaptor？=null
专用变量记录器1:记录器？=null
专用变量记录器2:记录器？=null
@以前
趣味设置（）{
`当`（mockAppender！！.name）。然后返回（“mockAppender”）
`当`（mockAppender.isStarted）时，然后返回（true）
`当`（mockAppender.isStopped）。然后返回（false）
logger1=LogManager.getLogger（“t_logger”）作为记录器
logger1！！.addAppender（mockAppender）
logger1！！.level=level.INFO
logger2=LogManager.getLogger（“b_logger”）作为记录器
logger2！！.addAppender（mockAppender）
logger2！！.level=level.INFO
}
@之后
有趣的撕裂{
logger1！！.removeAppender（mockAppender！！）
logger2！！.removeAppender（mockAppender！！）
}
@试验
有趣的书写日志应该在标记时写入TransactionLog{
val payload=hashMapOf（“标签”到“t”）
服务写入日志（有效负载）
验证（mockAppender，times（1））！！.append（captorLoggingEvent！！.capture（））
assertEquals（captorLoggingEvent.value.level、level.INFO）
assertEquals（captorLoggingEvent.value.loggerName，“t_记录器”）
assertEquals（captorLoggingEvent.value.message.formattedMessage，“{Label=t}”）
}
@试验
有趣的写作日志应该在标签上写回日志{
val有效载荷=hashMapOf（“标签”到“b”）
服务写入日志（有效负载）
验证（mockAppender，times（1））！！.append（captorLoggingEvent！！.capture（））
assertEquals（captorLoggingEvent.value.level、level.INFO）
assertEquals（captorLoggingEvent.value.loggerName，“b_记录器”）
assertEquals（captorLoggingEvent.value.message.formattedMessage，“{Label=b}”）
}
}