Kotlin泛型静态工厂方法实现：Notifier类型不匹配问题求解

1. 修复类型不匹配问题 #

当前错误的核心是：工厂方法声明返回Notifier<T>，但实际返回的是Notifier<Debug>/Notifier<Info>这类具体类型，编译器无法确认它们和泛型参数T的一致性。

方案一：通过Reified泛型做类型校验

利用Kotlin的reified泛型获取实际类型，结合类型判断确保返回的Notifier与指定的T匹配：

interface Notifier<T> {
    fun issue(p: NotificationInput<T>): Notification

    companion object {
        inline fun <reified T> getNotifier(p: NotifierParameter): Notifier<T> = when(p.type) {
            "0" -> if (T::class == Debug::class) DebugNotifier() as Notifier<T> 
                   else throw IllegalArgumentException("Debug通知器仅支持Debug类型输入")
            "1" -> if (T::class == Info::class) InfoNotifier() as Notifier<T> 
                   else throw IllegalArgumentException("Info通知器仅支持Info类型输入")
            "2" -> if (T::class == Error::class) ErrorNotifier() as Notifier<T> 
                   else throw IllegalArgumentException("Error通知器仅支持Error类型输入")
            else -> throw IllegalArgumentException("未知的通知器类型")
        }
    }
}

调用时reified泛型会让编译器捕获T的实际类型，通过校验避免类型转换错误，同时强制type参数与泛型T对应。

方案二：直接通过类型映射获取Notifier

如果可以不用字符串参数，直接通过类型来匹配Notifier，可以去掉字符串判断的冗余：

interface Notifier<T> {
    fun issue(p: NotificationInput<T>): Notification

    companion object {
        // 预定义类型与Notifier实例的映射
        private val notifierRegistry = mapOf(
            Debug::class to DebugNotifier(),
            Info::class to InfoNotifier(),
            Error::class to ErrorNotifier()
        )

        inline fun <reified T> getNotifier(): Notifier<T> {
            return notifierRegistry[T::class] as? Notifier<T> 
                ?: throw IllegalArgumentException("找不到对应${T::class.simpleName}类型的通知器")
        }
    }
}

调用方式简化为：Notifier.getNotifier<Debug>().issue(notificationInput)，完全避免了字符串参数带来的错误风险。

2. 更优的类型安全设计 #

用密封类替代字符串类型标识

用密封类定义通知类型，限制输入的合法性，同时让编译器检查when语句的完整性：

// 密封类定义所有合法的通知类型
sealed class NotificationType {
    object Debug : NotificationType()
    object Info : NotificationType()
    object Error : NotificationType()
}

// 修改参数类用密封类代替字符串
data class NotifierParameter(val type: NotificationType)

interface Notifier<T> {
    fun issue(p: NotificationInput<T>): Notification

    companion object {
        inline fun <reified T> getNotifier(p: NotifierParameter): Notifier<T> = when(p.type) {
            NotificationType.Debug -> DebugNotifier() as Notifier<T>
            NotificationType.Info -> InfoNotifier() as Notifier<T>
            NotificationType.Error -> ErrorNotifier() as Notifier<T>
        }
    }
}

这种方式不会出现无效的类型字符串，编译器会强制覆盖所有NotificationType的分支，减少运行时异常。

泛型约束增强类型安全

如果Debug/Info/Error有共同父类，可以给Notifier添加泛型约束，确保T只能是合法的通知数据类型：

// 定义所有通知数据的父类
sealed class NotificationData
object Debug : NotificationData()
object Info : NotificationData()
object Error : NotificationData()

// 添加泛型约束
interface Notifier<T : NotificationData> {
    fun issue(p: NotificationInput<T>): Notification
}

这样可以避免传入非法的T类型，进一步提升代码的健壮性。

内容的提问来源于stack exchange，提问作者Mike Spike