Question

我正在研究Dagger2 + MVP并在Kotlin上进行。我在理解Dagger2或MVP或其组合方面存在问题。

构建应用程序并了解它应该如何工作非常简单。该应用包含request.open('GET', file, false);左侧导航和多个MenuActivity（假设3），应在Fragments FrameLayout中进行更改。

我已经阅读了几篇文章，花了几天时间研究Dagger2。我将这篇文章用作构建我的示例的教程：https://proandroiddev.com/dagger-2-part-ii-custom-scopes-component-dependencies-subcomponents-697c1fa1cfc

在我的想法中，Dagger架构应该包含三个activity_menu.xml :( 1）AppComponent，（2）MenuActivityComponent和（3）AccountFragmentComponent。根据我的理解和文章中的架构图片，我的架构可以是这样的：（3）取决于 - ＆gt; （2）取决于 - ＆gt; （1）

每个@Component分别有一个@Component :( 1）AppModule，（2）MenuActivityModule和（3）AccountFragmentModule。对于更清晰的MVP依赖方式，据我所知，（2）MenuActivityModule和（3）AccountFragmentModule应该@Module @Provide来自MVP意识形态Presenter {{1} }和其他@Inject，例如MenuActivity。

的AppModule

Fragment

AppComponent

AccountFragment

MenuActivityModule

@Module
class AppModule(val app : App){

    @Provides @Singleton
    fun provideApp() = app

}

MenuActivityComponent

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

    fun inject(app : App)

    fun plus(menuActivityModule: MenuActivityModule): MenuActivityComponent
}

AccountsFragmentModule

@Module
class MenuActivityModule(val activity : MenuActivity) {

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

    @Provides
    fun provideActivity() = activity
}

AccountsFragmentComponent

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

    fun inject(activity: MenuActivity)

    fun plus(accountsModule : AccountsFragmentModule) : AccountsFragmentComponent
}

我还有两个@Module class AccountsFragmentModule(val fragment: AccountsFragment){ @FragmentScope @Provides fun provideAccountsFragmentPresenter() = AccountsFragmentPresenter(fragment) }：ActivityScope和FragmentScope，据我了解，这将保证在应用程序中每个组件都需要时只存在一个Component。

ActivityScope

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

    fun inject(fragment: AccountsFragment)
}

FragmentScope

@Scope

在Application类中，我创建了一个@Scope annotation class ActivityScope依赖项图。

@Scope
annotation class FragmentScope

在MenuActivity中：

@Singleton

MainActivityPresenter

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)
    }

}

activity_menu.xml

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)
}
}

在我的理解中，我有一个突破点的地方：

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)
    }

}

我对<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">  <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical">  <include layout="@layout/toolbar" android:layout_width="match_parent" android:layout_height="wrap_content" />  <FrameLayout android:id="@+id/frameLayoutContent" android:layout_width="match_parent" android:layout_height="match_parent" /> </LinearLayout>   <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>价值的最后部分的误解。我遇到了需要class AccountsFragment : Fragment() { companion object { fun newInstance() = AccountsFragment() } val Activity.app : App get() = application as App val component by lazy { app.component .plus(MenuActivityModule(activity as MenuActivity)) .plus(AccountsFragmentModule(this)) } override fun onCreateView(inflater: LayoutInflater?, container: ViewGroup?, savedInstanceState: Bundle?): View? { val view = inflater?.inflate(R.layout.fragment_accounts, container, false) setHasOptionsMenu(true) component.inject(this) return view } } MenuActivityComponent的子组件的情况，并给出构造函数变量MenuActivity，但我明白这是错误的，即使我希望实例应该只是我也不能创建另一个实例一个在申请中。

问题：我哪里有错误？在我的代码中，在体系结构中，在依赖注入的理解中还是在所有三个中？谢谢你的帮助！

Answer 1

我会将你的想法分开并单独处理它们。一旦你在这两个概念中变得流利/熟练，你可以尝试将它们组合起来。

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

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

将两者结合起来就是理解每个概念。

查看Google Architectural Blueprint存储库，了解MVP和Dagger2的示例。 https://github.com/googlesamples/android-architecture

Answer 2

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

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

如果碎片存在复杂的生命周期 - 活动。您在onAttach期间收到该依赖关系，并在onDetach期间丢失该依赖关系。因此，如果你真的想将一些与Activity相关的东西传递给Fragments，你必须传递那些与Activity相关的组件/模块，就像你在没有MVP时传递Activity实例一样。

同样，如果您的Activity通过Intent收到某些依赖项，您将不得不从中反序列化该依赖项，并根据Intent内容创建一个Module ...

活动和碎片生命周期的复杂性加剧了使用Dagger注射时常见的问题。 Android框架是围绕假设构建的，活动和片段以序列化形式接收所有依赖项。最后，一个编写良好的应用程序不应该在模块之间有太多的依赖关系（查找“紧耦合”）。由于这些原因，如果您不遵循严格的单活动范例，则在项目中使用Dagger对本地化的Activity / Fagment范围可能根本不值得。许多人仍然这样做，即使它不值得，但IMO，这只是个人偏好的问题。

Answer 3

确定。经过数周的深入研究。我已经完成了github项目的基础知识，所以每个人都可以查看并有一个有效的例子。

https://github.com/Belka1000867/Dagger2Kotlin

Kotlin上的Dagger2 + MVP

3 个答案: