Android 匕首2+；科特林的MVP

我正在研究Dagger2+MVP，并在Kotlin上进行研究。我在理解Dagger2或者MVP或者他们的组合时遇到了问题

应用程序的构造及其工作原理非常简单。该应用程序由带有左侧导航的

MenuActivity

和几个

片段组成，这些片段应该在
activity\u menu.xml中的
FrameLayout
中更改

我读过几篇文章，已经花了几天时间研究Dagger2。本文是我构建示例的教程：

在我看来，Dagger架构应该由三个组件组成：（1）AppComponent，（2）MenuActivityComponent和（3）AccountFragmentComponent。
从我的理解和文章中对架构的描述来看，我的架构可以是这样的：（3）依赖->（2）依赖->（1）

每个
@组件
都有一个
@模块
：（1）AppModule、（2）MenuActivityModule和（3）AccountFragmentModule。对于MVP依赖关系的更清晰的方式，据我所知，（2）MenuActivityModule和（3）AccountFragmentModule都应该
@提供MVP意识形态中的
演示者
注入
在
MenuActivity
和其他
片段，如
AccountFragment

AppModule

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

@Module
class MenuActivityModule(val activity : MenuActivity) {

    @Provides
    @ActivityScope
    fun provideMenuActivityPresenter() =
        MenuActivityPresenter(activity)

    @Provides
    fun provideActivity() = activity
}

@Module
class AccountsFragmentModule(val fragment: AccountsFragment){

    @FragmentScope
    @Provides
    fun provideAccountsFragmentPresenter() =
        AccountsFragmentPresenter(fragment)
}

@Scope
annotation class ActivityScope

@Scope
annotation class FragmentScope

AppComponent

@Singleton @Component(modules = arrayOf(AppModule::class))
interface AppComponent{

    fun inject(app : App)

    fun plus(menuActivityModule: MenuActivityModule): MenuActivityComponent
}

@ActivityScope
@Subcomponent(modules = arrayOf(MenuActivityModule::class))
interface MenuActivityComponent {

    fun inject(activity: MenuActivity)

    fun plus(accountsModule : AccountsFragmentModule) : AccountsFragmentComponent
}

@FragmentScope
@Subcomponent(modules = arrayOf(AccountsFragmentModule::class))
interface AccountsFragmentComponent {

    fun inject(fragment: AccountsFragment)
}

菜单活动模块

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

@Module
class MenuActivityModule(val activity : MenuActivity) {

    @Provides
    @ActivityScope
    fun provideMenuActivityPresenter() =
        MenuActivityPresenter(activity)

    @Provides
    fun provideActivity() = activity
}

@Module
class AccountsFragmentModule(val fragment: AccountsFragment){

    @FragmentScope
    @Provides
    fun provideAccountsFragmentPresenter() =
        AccountsFragmentPresenter(fragment)
}

@Scope
annotation class ActivityScope

@Scope
annotation class FragmentScope

MenuActivityComponent

@Singleton @Component(modules = arrayOf(AppModule::class))
interface AppComponent{

    fun inject(app : App)

    fun plus(menuActivityModule: MenuActivityModule): MenuActivityComponent
}

@ActivityScope
@Subcomponent(modules = arrayOf(MenuActivityModule::class))
interface MenuActivityComponent {

    fun inject(activity: MenuActivity)

    fun plus(accountsModule : AccountsFragmentModule) : AccountsFragmentComponent
}

@FragmentScope
@Subcomponent(modules = arrayOf(AccountsFragmentModule::class))
interface AccountsFragmentComponent {

    fun inject(fragment: AccountsFragment)
}

AccountsFragmentModule

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

@Module
class MenuActivityModule(val activity : MenuActivity) {

    @Provides
    @ActivityScope
    fun provideMenuActivityPresenter() =
        MenuActivityPresenter(activity)

    @Provides
    fun provideActivity() = activity
}

@Module
class AccountsFragmentModule(val fragment: AccountsFragment){

    @FragmentScope
    @Provides
    fun provideAccountsFragmentPresenter() =
        AccountsFragmentPresenter(fragment)
}

@Scope
annotation class ActivityScope

@Scope
annotation class FragmentScope

AccountsFragmentComponent

@Singleton @Component(modules = arrayOf(AppModule::class))
interface AppComponent{

    fun inject(app : App)

    fun plus(menuActivityModule: MenuActivityModule): MenuActivityComponent
}

@ActivityScope
@Subcomponent(modules = arrayOf(MenuActivityModule::class))
interface MenuActivityComponent {

    fun inject(activity: MenuActivity)

    fun plus(accountsModule : AccountsFragmentModule) : AccountsFragmentComponent
}

@FragmentScope
@Subcomponent(modules = arrayOf(AccountsFragmentModule::class))
interface AccountsFragmentComponent {

    fun inject(fragment: AccountsFragment)
}

此外，我还有两个
@Scope
s:ActivityScope和FragmentScope，据我所知，这将保证在应用程序中需要每个组件的时候，只存在一个组件

活动范围

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

@Module
class MenuActivityModule(val activity : MenuActivity) {

    @Provides
    @ActivityScope
    fun provideMenuActivityPresenter() =
        MenuActivityPresenter(activity)

    @Provides
    fun provideActivity() = activity
}

@Module
class AccountsFragmentModule(val fragment: AccountsFragment){

    @FragmentScope
    @Provides
    fun provideAccountsFragmentPresenter() =
        AccountsFragmentPresenter(fragment)
}

@Scope
annotation class ActivityScope

@Scope
annotation class FragmentScope

碎片范围

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

@Module
class MenuActivityModule(val activity : MenuActivity) {

    @Provides
    @ActivityScope
    fun provideMenuActivityPresenter() =
        MenuActivityPresenter(activity)

    @Provides
    fun provideActivity() = activity
}

@Module
class AccountsFragmentModule(val fragment: AccountsFragment){

    @FragmentScope
    @Provides
    fun provideAccountsFragmentPresenter() =
        AccountsFragmentPresenter(fragment)
}

@Scope
annotation class ActivityScope

@Scope
annotation class FragmentScope

在应用程序类中，我创建了一个
@Singleton
依赖关系图

class App : Application(){

    val component : AppComponent by lazy {
        DaggerAppComponent
            .builder()
            .appModule(AppModule(this))
            .build()
    }

    companion object {
        lateinit var instance : App
            private set
    }

    override fun onCreate() {
        super.onCreate()
        component.inject(this)
    }

}

在菜单活动中：

class MenuActivity: AppCompatActivity()

    @Inject lateinit var presenter : MenuActivityPresenter

    val Activity.app : App
    get() = application as App

    val component by lazy {
        app.component.plus(MenuActivityModule(this))
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_menu)
        /* setup dependency injection */
        component.inject(this)
        /* setup UI */
        setupMenu()
        presenter.init()
    }

private fun setupMenu(){
    navigationView.setNavigationItemSelectedListener({
        menuItem: MenuItem -> selectDrawerItem(menuItem)
        true
    })

    /* Hamburger icon for left-side menu */
    supportActionBar?.setHomeAsUpIndicator(R.drawable.ic_menu_white_24dp)
    supportActionBar?.setDisplayHomeAsUpEnabled(true)

    drawerToggle = ActionBarDrawerToggle(this, drawerLayout, toolbar, R.string.drawer_open,  R.string.drawer_close);
    drawerLayout.addDrawerListener(drawerToggle as ActionBarDrawerToggle)
    }
private fun selectDrawerItem(menuItem: MenuItem){

    presenter.menuItemSelected(menuItem)

    // Highlight the selected item has been done by NavigationView
    menuItem.isChecked = true
    // Set action bar title
    title = menuItem.title
    // Close the navigation drawer
    drawerLayout.closeDrawers()
}

@SuppressLint("CommitTransaction")
override fun showFragment(fragment: Fragment, isReplace: Boolean,
                          backStackTag: String?, isEnabled: Boolean)
{
    /* Defining fragment transaction */
    with(supportFragmentManager.beginTransaction()){

        /* Select if to replace or add a fragment */
        if(isReplace)
            replace(R.id.frameLayoutContent, fragment, backStackTag)
        else
            add(R.id.frameLayoutContent, fragment)

        backStackTag?.let { this.addToBackStack(it) }

        commit()
    }

    enableDrawer(isEnabled)
}

private fun enableDrawer(isEnabled: Boolean) {
    drawerLayout.setDrawerLockMode(if(isEnabled) DrawerLayout.LOCK_MODE_UNLOCKED
                                    else DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
    drawerToggle?.onDrawerStateChanged(if(isEnabled) DrawerLayout.LOCK_MODE_UNLOCKED
                                        else DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
    drawerToggle?.isDrawerIndicatorEnabled = isEnabled
    drawerToggle?.syncState()
}

override fun onOptionsItemSelected(item: MenuItem?): Boolean {
  if (drawerToggle!!.onOptionsItemSelected(item)) {
      return true
  }
  return super.onOptionsItemSelected(item)
}

override fun onPostCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
    super.onPostCreate(savedInstanceState, persistentState)
    drawerToggle?.syncState()
}

override fun onConfigurationChanged(newConfig: Configuration?) {
    super.onConfigurationChanged(newConfig)
    drawerToggle?.onConfigurationChanged(newConfig)
}
}

MainActivityPresenter

class MenuActivityPresenter(val menuActivity: MenuActivity){

    fun init(){
        menuActivity.showFragment(AccountsFragment.newInstance(), isReplace = false)
    }

    fun menuItemSelected(menuItem: MenuItem){

        val fragment =  when(menuItem.itemId){
            R.id.nav_accounts_fragment -> {
                AccountsFragment.newInstance()
            }
            R.id.nav_income_fragment -> {
                IncomeFragment.newInstance()
            }
            R.id.nav_settings -> {
                IncomeFragment.newInstance()
            }
            R.id.nav_feedback -> {
                OutcomeFragment.newInstance()
            }
            else -> {
                IncomeFragment.newInstance()
            }
        }

        menuActivity.showFragment(fragment)
    }

}

活动菜单.xml

<android.support.v4.widget.DrawerLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/drawerLayout"
android:layout_width="match_parent"
android:layout_height="match_parent">

<!-- This LinearLayout represents the contents of the screen  -->
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <!-- The ActionBar displayed at the top -->
    <include
        layout="@layout/toolbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <!-- The main content view where fragments are loaded -->
    <FrameLayout
        android:id="@+id/frameLayoutContent"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

<!-- The navigation drawer that comes from the left -->
<!-- Note that `android:layout_gravity` needs to be set to 'start' -->
<android.support.design.widget.NavigationView
    android:id="@+id/navigationView"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:layout_gravity="start"
    android:background="@android:color/white"
    app:menu="@menu/main_menu"
    app:headerLayout="@layout/nav_header"
    />

</android.support.v4.widget.DrawerLayout>

我对
组件
值中最后一部分的误解。我遇到的情况是，我需要
加上MenuActivityComponent的
子组件，并将其作为构造函数变量MenuActivity给出，但我明白这是错误的，我无法创建另一个实例，即使我希望该实例应该是应用程序中的唯一实例

问题：我哪里出错了？在我的代码中，在体系结构中，在对依赖注入的理解中，还是在这三个方面？谢谢你的帮助
 我会在你的脑海中把这些概念分开，然后逐一处理。一旦你精通这两个概念，你可以尝试将它们结合起来

例如，尝试使用MVP设计模式构建一个简单的多活动/片段应用程序。使用MVP，您将在演示者（一个包含视图逻辑并控制视图以及处理视图收集和转发的行为的对象）和视图之间编写双向接口契约（视图对象，通常是一个本地组件，如片段或活动，负责显示视图和处理用户输入，如触摸事件）

使用Dagger2，您将学习依赖注入设计模式/架构风格。您将构建组合成组件的模块，然后使用这些组件注入对象

将两者结合起来首先要理解每个概念本身

查看谷歌架构蓝图库，了解MVP和Dagger2的示例

我还有两个@Scope：ActivityScope和FragmentScope，据我所知，这将保证在应用程序中需要每个组件的时候，只存在一个组件

Dagger的作用域不是一些神奇的仙尘，它可以为您管理生命周期。作用域的使用只是验证辅助，它可以帮助您避免将依赖项与不同的生命周期混合在一起。您仍然需要自己管理组件和模块对象，将正确的参数传递给它们的构造函数。依赖关系图由不同的nt组件实例是独立的，并绑定到它们的@component对象。请注意，我说的“绑定”在某种意义上是由它们（通过构造函数）创建的，并可选地存储在它们内部，绝对没有其他魔法在幕后工作。因此，如果您需要在应用程序的各个部分之间共享一组依赖项，您可能需要传递一些组件和模块实例

在片段的情况下，存在一个具有复杂生存期的严格依赖关系-活动。您在
onAttach
期间收到该依赖关系，并在
onDetach
期间丢失该依赖关系。因此，如果您真的想将一些依赖于活动的内容传递给片段，您必须传递这些依赖于活动的组件/模块，就像您在没有MVP的情况下，应该传递活动实例

同样，如果您的活动通过Intent接收到某些依赖项，则必须从中反序列化该依赖项，并基于Intent内容创建一个模块

活动和片段生命周期的复杂性加剧了使用匕首注入时经常遇到的问题。Android框架是基于这样一种假设构建的，即活动和片段以序列化形式接收其所有依赖项。最后，一个编写良好的应用程序不应该在模块之间有太多依赖项（查阅“紧耦合”）由于这些原因，如果你不遵循严格的单一活动范式，在你的项目中使用Dagger本地化活动/碎片范围可能根本不值得。许多人仍然这样做，即使不值得，但在我看来，这只是个人偏好的问题。
好的。经过数周的深入研究，我已经完成了github项目所以每个人都可以