Question

我的目标是在Kotlin中实现非常简单的事件总线，而无需任何第三方库。我用下面的代码实现了这一点。

class EventListener<T>(
    val owner: Any,
    val event: Class<T>,
    val callback: (T) -> Unit
)

interface IEventBus {
    fun <T> subscribe(owner: Any, event: Class<T>, callback: (T) -> Unit)
    fun unsubscribe(owner: Any)
    fun <T> push(event: T)
}

class EventBus : IEventBus {
    private val _listeners = mutableListOf<EventListener<*>>()

    override fun <T> subscribe(owner: Any, event: Class<T>, callback: (T) -> Unit) {
        val listener = EventListener(owner, event, callback)
        _listeners.add(listener)
    }

    override fun unsubscribe(owner: Any) {
        _listeners.removeAll {
            it.owner == owner
        }
    }

    override fun <T> push(event: T) {
        _listeners.forEach { listener ->
            try {
                val l = listener as EventListener<T> // is always a success
                l.callback(event)                    // throws an exception if can't handle the event
            } catch (ex: Exception) { }
        }
    }
}

然后用法如下：

// register listener
bus.subscribe(this, String::class.java) {
    print(it)
}
// push an event (from somewhere else in the project)
bus.push("Hello world!")

它可以工作并且完全可用，但是我对此不满意...将侦听器转换为EventListener 将始终返回某些内容，然后如果 l.callback（event） >无法处理事件类型，它将引发异常。因此，如果订阅了许多侦听器，那么它将生成许多不需要的异常，这些异常将被忽略。

我希望先进行某种检查，例如：

if (listener is EventListener<T>)
    listener.callback(event)

但是我发现JVM在编译后会丢失有关泛型类型的信息。我还发现，可以使用kotlin的 inline 和 reified 绕过它，但是不能在来自接口的方法上使用它们。

所以我的问题是，您是否知道任何更优雅的方式来处理此类通用问题？

Answer 1

由于您已经公开了事件的类别（EventListener#event，因此可以使用isInstance()来检查该类别是否与事件的实例兼容。

所以，而不是：

if (listener is EventListener<T>)
    listener.callback(event)

您可以这样做：

if (listener.event.isInstance(event)) {
    // The cast is safe since you checked if the event can be received by the listener.
    (listener as EventListener<T>).callback(event)
}

原语

如果您也想支持基本类型的T，则可以将Class<T>更改为KClass<T>或手动检查每种基本类型的实例（例如event is Int，{ {1}}。

Answer 2

kotlinx.coroutines.flow.SharedFlow 的文档包含一个简单的例子：

<块引用>

SharedFlow 可用于广播发生在内部的事件可以来来去去的订阅者的应用程序。例如，以下类封装了一个将事件分发到的事件总线以集合方式所有订阅者，暂停直到所有订阅者处理每个事件：

class EventBus {
    private val _events = MutableSharedFlow<Event>() // private mutable shared flow
    val events = _events.asSharedFlow() // publicly exposed as read-only shared flow

    suspend fun produceEvent(event: Event) {
        _events.emit(event) // suspends until all subscribers receive it
    }
}

此外，corresponding Android documentation 也很有用。

处理Kotlin中事件总线的通用侦听器

2 个答案: