Question

我在Kotlin中有一个object类，它是一个管理器-我们称之为KManager-该管理器位于一个独立的模块（ moduleA ）中。我正在使用KManager的另一个模块（ moduleB ）。

规则： moduleB 知道有关 moduleA 的信息，但是 moduleA 不应该了解有关 moduleB的任何信息。

我创建了像桥接（接口）来与 moduleB 通信的 moduleA 的桥梁，因为双方都需要运行一些共享逻辑。该接口在KManager中声明为：

//moduleA
object KManager {

    var bridgeShared: BridgeShared? = null
    ....
}

接口：

interface BridgeShared {
    fun foo()
}

现在，我在 moduleB 中有一个实现BridgeShared的类。应用启动时，我将像这样初始化bridgeShared：

//moduleB
class BridgeSharedImpl : BridgeShared {

        KManager.bridgeShared = this
        ....
}

我在 moduleB 中获得了KManager.bridgeShared，并在另一个类中执行了接口的功能，例如：

KManager.bridgeShared.foo()

这里的问题是，在object Kotlin类中声明一个侦听器并在需要时获取它是否有害？

注意：这里没有用于描述场景的实名。

更新：

其他步骤：

moduleA 像外部事件一样接收，它被处理，然后由预订BridgeShared侦听器的“观察者”接收结果，即“观察者”是 moduleB ，但是 moduleA 不在乎（规则）。

模块B

class BridgeSharedImpl : BridgeShared {

   KManager.bridgeShared = this

   override fun eventProcessed() {
      //stuff
   }

   override fun fetchData() {
     //stuff
   }

   fun callAnotherFunction1() {
     KManager.anotherFunction1()
   }
}

模块A

interface BridgeShared {
    fun eventProcessed()
    fun fetchedData()
}

object KManager {

    var bridgeShared: BridgeShared? = null

    fun anotherFunction1() {
      //not-related to BridgeShared, called from outside
    }

    fun anotherFunction2() {
      //not-related to BridgeShared, called from outside
    }
}

class EventProcessor {

  fun eventReceived() {
    //stuff
    KManager.bridgeShared?.eventProcessed()
  }  

}

class DataFetcher {

  fun dataReceived() {
    //stuff
    KManager.bridgeShared?.fetchedData()
  }  

}

另一方面，我利用 moduleB 中的KManager.bridgeShared来调用同一 moduleB 中的相同函数，因为我没有可以随时随地访问BridgeSharedImpl实例的位置。

现在， moduleB 使用KManager单例来执行与BridgeShared不相关的其他功能。

Answer 1

根据建议，我应用了Factory解决方案，以避免将BridgeShared保存在Singleton中。

模块A

class BridgeFactory(private val bridgeShared: BridgeShared) {

    companion object {

        lateinit var bridgeFactory: BridgeFactory

        fun initialize(bridgeShared: BridgeShared) {
            bridgeFactory = BridgeFactory(emmaShared)
        }
    }

    fun eventProcessor(): EventProcessor {
        return EventProcessor(bridgeShared)
    }

    fun dataFetcher(): DataFetcher {
        return DataFetcher(bridgeShared)
    }

}

class EventProcessor(private val bridgeShared: BridgeShared) {

  fun eventReceived() {
    //stuff
    bridgeShared.eventProcessed()
  }  

}

class DataFetcher(private val bridgeShared: BridgeShared) {

  fun dataReceived() {
    //stuff
    bridgeShared.fetchedData()
  }  

}

模块B

class BridgeSharedImpl : BridgeShared {

    init {
        BridgeFactory.initialize(this)
    }

   override fun eventProcessed() {
      //stuff
   }

   override fun fetchData() {
     //stuff
   }

}

在Kotlin Object类中声明的监听器

1 个答案: