Android的MVVM架构的单Activity应用实践

前言

谈Android架构大家很容易想到MVC、MVP和MVVM。

1、MVC

首先分析一下上面各层之前对应的Android代码，layout.xml里面的xml文件就对应于MVC的view层，里面都是一些view的布局代码，而各种Java bean，还有一些类似repository类就对应于model层，至于controller层嘛，当然就是各种activity。理论上应该是这么分，但是实际开发中Activity实际也承担View的责任，这样就出了上面我提到Activity把该做的不该做的都做了的问题，最直接的表现就是Activity类的代码量庞大，逻辑不清晰，维护困难，单元测试也就很难进行(纯Java代码和Android代码杂糅在一起)。

2、MVP

最明显的差别就是view层和model层不再相互可知，完全的解耦，取而代之的presenter层充当了桥梁的作用，用于操作view层发出的事件传递到presenter层中，presenter层去操作model层，并且将数据返回给view层，整个过程中view层和model层完全没有联系。看到这里大家可能会问，虽然view层和model层解耦了，但是view层和presenter层不是耦合在一起了吗？其实不是的，对于view层和presenter层的通信，我们是可以通过接口实现的，具体的意思就是说我们的activity，fragment可以去实现实现定义好的接口，而在对应的presenter中通过接口调用方法。不仅如此，我们还可以编写测试用的View，模拟用户的各种操作，从而实现对Presenter的测试。这就解决了MVC模式中测试，维护难的问题。

谷歌给出Android架构演示项目：https://github.com/android/architecture-samples/tree/master

3、MVVM

根据Android应用架构指南可以看出google也是比较推荐使用MVVM架构，而且采用MVVM能够更好使用 Android Jetpack组件，具体事例可以看sunflower和architecture-components-samples。

上图显示了设计应用后所有模块应如何彼此交互，下面文章就围绕这个图展开。

正文

1、管理组件之间的依赖关系

我这里用的是Dagger2，github地址：https://github.com/google/dagger

这里简单的介绍一下Dagger的依赖注入如何实现，然后再说说再Android项目中如何做。

Dagger2提供依赖的步骤:

步骤1：查找Module中是否存在创建该类的方法。
步骤2：若存在创建类方法，查看该方法是否存在参数
步骤2.1：若存在参数，则按从步骤1开始依次初始化每个参数
步骤2.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束
步骤3：若不存在创建类方法，则查找Inject注解的构造函数，看构造函数是否存在参数
步骤3.1：若存在参数，则从步骤1开始依次初始化每个参数
步骤3.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束

有2种方法可以提供被依赖的对象，一种是使用@Inject注解，另一种是在Module中用@Provides注解。

@Inject提供被依赖对象

class Father @Inject constructor() {
    val name = "老王"
}

@Component
interface FatherComponent {
    fun inject(runner: Runner)
}


class Runner {
    init {
        DaggerFatherComponent.builder().build().inject(this)
    }

    @Inject
    lateinit var father: Father

    fun runner() {
        println(father.name)
    }
}

fun main() {
   Runner().runner()
}

@Provides提供被依赖对象

class Father {
    val name = "老王"
}

@Module
class FatherModule {
    @Provides
    fun providerFather() = Father()
}

@Component(modules = [FatherModule::class])
interface FatherComponent {
    fun inject(runner: Runner)
}


class Runner {
    init {
        DaggerFatherComponent.builder().build().inject(this)
    }

    @Inject
    lateinit var father: Father

    fun runner() {
        println(father.name)
    }
}

fun main() {
    Runner().runner()
}

@Component注解用来将被依赖的类和依赖的类连接起来。

将Dagger2用于Android需要增加：

  implementation("com.google.dagger:dagger-android:2.x")
  implementation("com.google.dagger:dagger-android-support:2.x")
  kapt("com.google.dagger:dagger-compiler:2.x")
  kapt("com.google.dagger:dagger-android-processor:2.x")

Dagger的文档上面给出比较详细的集成说明：戳这里

注入Activity对象

a、在您的 application component中添加AndroidInjectionModule,以确保这些基本类型所需要的所有绑定均可用。

 @dagger.Component(
      modules = {AndroidInjectionModule.class, MainActivity.Module.class, BuildModule.class})
  /* @ApplicationScoped and/or @Singleton */
  interface Component extends AndroidInjector {
    @dagger.Component.Builder
    abstract class Builder extends AndroidInjector.Builder {}
  }

b、编写一个继承AndroidInjector 并且@Subcomponent标识的interface。interface带有一个继承AndroidInjector.Factory 的并且@ Subcomponent.Factory标识的interface：

@Subcomponent(modules = ...)
public interface YourActivitySubcomponent extends AndroidInjector {
  @Subcomponent.Factory
  public interface Factory extends AndroidInjector.Factory {}
}

c、定义Subcomponect之后，通过定义的一个绑定subcomponect factory的Module将其添加到注入应用程序的component，进而添加到组件层次结构中。

@Module(subcomponents = YourActivitySubcomponent.class)
abstract class YourActivityModule {
  @Binds
  @IntoMap
  @ClassKey(YourActivity.class)
  abstract AndroidInjector.Factory
      bindYourAndroidInjectorFactory(YourActivitySubcomponent.Factory factory);
}

@Component(modules = {..., YourActivityModule.class})
interface YourApplicationComponent {}

tips:如果在你的Subcomponect和它的factory中没有步骤2中提到的方法(methods)和超类型(supertypes)以外的内容。则可以使用@ContributesAndroidInjector为您生成它们。代替步骤2和3，添加一个返回您的Activity的抽象模块方法，用@ContributesAndroidInjector对其进行注释，然后指定要安装到子组件中的模块。如果子组件需要范围(Scope)，则也将范围注释应用于方法。

@ActivityScope
@ContributesAndroidInjector(modules = { /* modules to install into the subcomponent */ })
abstract YourActivity contributeYourAndroidInjector();

d、

如果你像我一样用的：

  implementation("com.google.dagger:dagger-android:2.22.1")
  implementation("com.google.dagger:dagger-android-support:2.22.1")
  kapt("com.google.dagger:dagger-compiler:2.22.1")
  kapt("com.google.dagger:dagger-android-processor:2.22.1")

使你的Application 实现HasActivityInjector接口，然后声明一个DispatchingAndroidInjector变量用@Inject标识它，并且在activityInjector()方法中返回。

public class YourApplication extends Application implements HasActivityInjector{
  @Inject DispatchingAndroidInjector activityInjector;

  @Override
  public void onCreate() {
    super.onCreate();
    DaggerYourApplicationComponent.create()
        .inject(this);
  }

  @Override
  public AndroidInjector activityInjector() {
    return activityInjector;
  }
}

e、在您的Activity的onCreate()方法中在调用super.onCreate();之前调用AndroidInjection.inject(this);

public class YourActivity extends Activity {
  public void onCreate(Bundle savedInstanceState) {
    AndroidInjection.inject(this);
    super.onCreate(savedInstanceState);
  }
}

f、Congratulations!

注入Fragment对象

注入Fragment和注入Activity的方式差不多

 不像Activity那样在onCreated注入，在Fragment中应该在onAttach()注入。

与为“Activity”定义的modules不同，您可以选择在何处安装Fragments的modules。您可以将Fragment组件(component)设为另一个Fragment组件(component)，Activity组件(component)或Application组件(component)的子组件(subcomponent)，这都取决于您的Fragment需要哪些其他的绑定。确定组件位置后，使相应的类型实现HasAndroidInjector（如果尚未实现）。例如，如果您的Fragment需要来自YourActivitySubcomponent的绑定，则您的代码将如下所示：

public class YourActivity extends Activity
    implements HasAndroidInjector {
  @Inject DispatchingAndroidInjector