Android MVVM的实现

Android MVVM的实现

前言：

在我们写一些项目的时候，通常会对一些常用的一些常用功能进行抽象封装，简单例子：比如BaseActivity，BaseFragment等等…一般这些Base会去承载一些比如标题栏，主题之类的工作，方便Activity的一些风格的统一，也是预留一些函数方便进行HOOK进而实现一些功能。除此之外，一个网络请求也会根据项目采用的技术进行一些封装，比如OkHttp的全局的单例呀，网络请求的成功与失败的回调呀，把相应的状态进行上抛给View，这些都是我们在新建一个项目，采用不同技术方案时需要考虑的问题。

下面我就分享一下比较常用的一些技术方案去实现的一个MVVM的一个基础架构组件。

Find View

在Android项目中，因为传统的View布局的方式采用的是通过xml进行控件的布局，那么不可避免的我们需要在代码中进行view的操作，那么我们就需要findViewById，这个方法可能是每一个Android的开发人员都非常熟悉的一个方法，它的作用那我们就不必说，就是发现一个view并获取对应的实例，那么当我们布局文件越来越复杂的时候，我们需要每一个view都find一遍的话，那么明显重复代码冗长且易出错，但是不写又不行。当时你可以说用compose呀，抛掉XML，可是技术的普及总是需要一定的时间，在这之前传统的xml也是不能抛弃的。

在Android中用来代替的findViewById的方法有很多，但是大多已经过时了，或者说已经不推荐了，方案主要有以下几种。

方案	状态	优缺点
Butter Knife	停止更新，库作者已不推荐	-
kotlin-android-extensions	谷歌已不推荐	-
Data Binding	可用	优点：可以直接实现双向绑定，在XML中支持表达式 缺点：1.BUG比较难定位 2.根标签必须是layout 3.对构建速度和性能有部分影响
View Binding	可用	优点：避免findViewById大量重复代码同时精剪了部分功能，避免了Data Binding存在的问题 缺点：不支持双向绑定

一般情况下，推荐采用View Binding，View Binding一般使用方法如下：

val binding = ActivityLoginBinding.inflate(layoutInflater)
// val binding = ActivityLoginBinding.inflate(layoutInflater, parent, false)
// val binding = ActivityLoginBinding.bind(view)
binding.tv.text = "Hello Android!"

可能你会觉得如果每个使用这个布局的地方都要inflate一遍，那么我们可以借助kotlin的委托和反射，进一步简化代码。
最终呈现的效果，如下面代码所示：

class TestActivity : AppCompatActivity() {
    
    

    private val binding: ActivityLoginBinding by binding()
    
    override fun onCreate(savedInstanceState: Bundle?) {
    
    
        super.onCreate(savedInstanceState)
        binding.edName.setText("hello")
    }

}

上述代码通过就通过委托和反射的方式，减少inflate和setContentView的代码。
具体实现可以参考：
https://github.com/DylanCaiCoding/ViewBindingKTX

Base类

在这部分，我觉得每个项目在Base中封装是不一样的，所以在本文章中，Base这一块反而是比较简单的一块，简单的有个继承关系即可

open class BaseActivity : AppCompatActivity()

open class BaseApplication : Application() 

open class BaseViewModel : ViewModel()

有一点需要说明的是，在Base Activity中我们需要尽量不去修改activity的生命周期，或者说添加而外的生命周期，如果是在多人合作的项目中，开发人员错误地理解部分代码，那么就有可能出现问题。所以我们在Base中尽量不要修改对应的生命周期，减少学习成本。

依赖注入

依赖注入或许在Java开发中很常见，其实也是可以应用在Android中用来减少一些重复代码，也可以方便开发人员对代码进行一些简单的测试，只需要替换对应的实现类即可。

那么Android常见的依赖注入方案有

方案	优缺点
Dagger	优点：功能强大 缺点：学习成本高，在Android上应用需要一定的熟练程度
Hilt	谷歌根据Android平台的特点，在 Dagger 的基础上构建而成，减少了一定的学习成本
koin	根据委托实现，学习成本低

这里比较推荐Hilt，那么Hilt的用法比较简单，主要分为两部分，一部分为使用注解表明什么地方需要注入以及注入的对象的作用域。另外一部分就是被注入的对象如何产生。

Hilt接入：
首先，将 hilt-android-gradle-plugin 插件添加到项目的根级 build.gradle 文件中

plugins {
    
    
  ...
  id 'com.google.dagger.hilt.android' version '2.44' apply false
}

然后，应用 Gradle 插件并在 app/build.gradle 文件中添加以下依赖项：

...
plugins {
    
    
  id 'kotlin-kapt'
  id 'com.google.dagger.hilt.android'
}

android {
    
    
  ...
}

dependencies {
    
    
  implementation "com.google.dagger:hilt-android:2.44"
  kapt "com.google.dagger:hilt-compiler:2.44"
}

// Allow references to generated code
kapt {
    
    
  correctErrorTypes true
}

所有使用 Hilt 的应用都必须包含一个带有 @HiltAndroidApp 注解的 Application 类。

@HiltAndroidApp 会触发 Hilt 的代码生成操作，生成的代码包括应用的一个基类，该基类充当应用级依赖项容器。

@HiltAndroidApp
class ExampleApplication : Application() {
    
     ... }

Hilt使用如下：

//被注入的对象如何产生

//标记这是一个module.可以通过module模块向 Hilt 提供绑定信息。
@Module
//标记绑定作用域限定到ViewModel
@InstallIn(ViewModelComponent::class)
object RepositoryModule {
    
    

    //标记方法，提供依赖返回值，即产生对象
    @Provides
    fun provideTasksRepository(): UserRepository {
    
    
        return DefaultUserRepository()
    }
}

//表明什么地方需要注入

//表明这是一个被注入ViewModel
@HiltViewModel
//注入到构造函数的repository
class TestViewModel @Inject constructor(
    private val repository: UserRepository
) : BaseViewModel()

更多Hilt的使用方法参考链接：
https://developer.android.google.cn/training/dependency-injection/hilt-android?hl=zh-cn

网络实现

一般而言，如果没有特殊情况的话，Android网络请求一般采用的都是OkHttp来实现Http请求，数据格式一般采用Json。当然也有些项目为了性能采用RPC和Protobuf来进行数据通讯。

这里我们采用OkHttp ，Retrofit ， Flow 来构建我们的数据传输，模拟的接口就采用玩Android的开放API来举例，接口文档地址：
https://www.wanandroid.com/blog/show/2

第一步导入依赖：

dependencies {
    
    
	...
    //OkHttp
    implementation(platform("com.squareup.okhttp3:okhttp-bom:4.10.0"))
    implementation("com.squareup.okhttp3:okhttp")
    implementation("com.squareup.okhttp3:logging-interceptor")

    //retrofit
    implementation "com.squareup.retrofit2:retrofit:2.9.0"
    implementation "com.squareup.retrofit2:converter-gson:2.9.0"
}

第二步构建OkHttp和Retrofit实例，结合Hilt实现

object NetUrlConst {
    
    

    const val BASE_URL = "https://www.wanandroid.com"

    /**
     * 登录
     */
    const val LOGIN = "/user/login"
}

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    
    

    private const val TAG = "NetworkModule"

    @Provides
    @Singleton
    fun providesOKHttpClient():OkHttpClient{
    
    
        Log.i(TAG,"providesOKHttpClient")
        val okHttpClient = OkHttpClient()
            .newBuilder()
            .addInterceptor(HttpLoggingInterceptor {
    
     message ->
                Log.i(TAG, message)
            }.setLevel(HttpLoggingInterceptor.Level.BODY))
            .build()
        return okHttpClient
    }

    @Provides
    @Singleton
    fun providesRetrofit(client: OkHttpClient):Retrofit{
    
    
        Log.i(TAG,"providesRetrofit")
        return Retrofit.Builder()
            .baseUrl(NetUrlConst.BASE_URL)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

上面代码就实现了OkHttp和Retrofit的单例，使用的话在需要的地方使用Hilt注入即可。
第三步定义错误码以及返回结果

/**错误码枚举*/
enum class NetCode(val value: Int){
    
    
    ERROR(-1),
    NORMAL(0)
}
/**返回实体基类*/
data class BaseEntity<T>(
    val data: T,
    val errorCode: Int,
    val errorMsg: String
) {
    
    
    val isSuccess
        get() = errorCode == NetCode.NORMAL.value
}
/**用户实体类*/
data class UserEntity(
    val id: Int,
    val nickname: String,
    val password: String,
    val publicName: String,
    val username: String
)

第四步生成Service

interface UserService {
    
    

    @POST(NetUrlConst.LOGIN)
    suspend fun login(
       @Query("username") username: String,
       @Query("password") password: String): BaseEntity<UserEntity>
}


@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    
    
	...
    @Provides
    fun providesNetUserService(retrofit: Retrofit):UserService{
    
    
        Log.i(TAG,"providesNetUserService")
        return retrofit.create(UserService::class.java)
    }
}

Repository

接下来我们需要定义，提供数据的Model层的实现形式。
一般而言在Model层会提供一个抽象的Repository来进行数据的提供，来源包括本地以及网络数据。在Repository中分别有不同的DataSource来提供数据，而Repository则屏蔽这些具体的细节统一封装数据返回给ViewModel。
如下图所示

同时由于我们数据流采用的是Flow，那么我们需要定义一个协程的返回基类，用于包含我们成功的信息以及错误的时候的异常信息。
代码如下：

/**
 * Author: huangtao
 * Date: 2023/1/19
 * Desc: 用于协程内容的封装类
 * Error用来处理程序异常，不处理业务错误
 */
sealed class Result<out R> {
    
    

    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()

    override fun toString(): String {
    
    
        return when (this) {
    
    
            is Success<*> -> "Success[data=$data]"
            is Error -> "Error[exception=$exception]"
        }
    }
}

val Result<*>.succeeded
    get() = this is Result.Success && data != null

有了Result之后我们就可以方便地定义Repository的接口了
我们这边只接入用户登录的功能，那么方法也就一个。

/**
 * Desc: 登录的数据接口
 */
interface UserRepository {
    
    

    /**
     * 登录
     */
    suspend fun signIn(username: String, password: String): Result<BaseEntity<UserEntity>>
}

/**
 * Desc: 登录的数据源接口
 */
interface UserDataSource {
    
    

    /**
     * 登录
     */
    suspend fun signIn(username: String, password: String): Result<BaseEntity<UserEntity>>
}

//由于登录功能只有远程的实现，所以这边本地实现略
/**
 * Desc: 网络数据源
 */
class RemoteDataSource(
    private val service: UserService,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
) : UserDataSource {
    
    

    override suspend fun signIn(username: String, password: String) = withContext(ioDispatcher) {
    
    
        try {
    
    
            return@withContext Result.Success(service.login(username, password))
        } catch (e: Exception) {
    
    
            return@withContext Result.Error(e)
        }
    }
}

/**
 * Desc: 默认LoginRepository实现
 */
class DefaultUserRepository(
    private val remoteDataSource: UserDataSource,
    private val localDataSource: UserDataSource = null,
) : UserRepository {
    
    

    override suspend fun signIn(username: String, password: String): Result<BaseEntity<UserEntity>> {
    
    
        val result = remoteDataSource.signIn(username, password)
        if (result is Result.Success && result.data.isSuccess) {
    
    
        	//TODO 一般而言登录成功后，会进行一些数据缓存的逻辑等
        }
        return result
    }
}

相关实现写好后，我们通过Hilt的依赖注入暴露出去

/**
 * Desc: 用户模块的依赖注入
 */
@Qualifier
@Retention(AnnotationRetention.RUNTIME)
annotation class Remote

@Qualifier
@Retention(AnnotationRetention.RUNTIME)
annotation class Local

@Module
@InstallIn(ViewModelComponent::class)
object RepositoryModule {
    
    

    @Provides
    fun provideTasksRepository(
        @Remote remoteDataSource: UserDataSource
    ): UserRepository {
    
    
        return DefaultUserRepository(remoteDataSource)
    }
}

@Module
@InstallIn(ViewModelComponent::class)
object DataSourceModule {
    
    

    @Remote
    @Provides
    fun provideUserRemoteDataSource(
        userService: UserService
    ): UserDataSource {
    
    
        return RemoteDataSource(userService)
    }

//	  本地数据源，如果有的话
//    @Local
//    @Provides
//    fun provideTasksLocalDataSource(): UserDataSource {
    
    
//        return LocalDataSource()
//    }
}

那么至此，Model层就算实现完成了。

View and ViewModel

通过上面的一系列工作，那么我们现在就可以愉快地写界面以及业务逻辑。
我们还是通过简单的用户登录这个界面来举例。
首先是我们的布局界面，简简单单一个按钮，两个输入框。
activity_login.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".LoginActivity">

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/gl"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintGuide_percent="0.33" />

    <EditText
        android:id="@+id/ed_name"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="68dp"
        android:layout_marginEnd="68dp"
        android:background="@null"
        android:hint="输入用户名"
        android:padding="6dp"
        android:textSize="18sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/gl" />

    <EditText
        android:id="@+id/ed_password"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="68dp"
        android:layout_marginTop="18dp"
        android:layout_marginEnd="68dp"
        android:background="@null"
        android:hint="输入密码"
        android:inputType="textPassword"
        android:padding="6dp"
        android:textSize="18sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/ed_name" />

    <Button
        android:id="@+id/bt_login"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="68dp"
        android:layout_marginTop="18dp"
        android:layout_marginEnd="68dp"
        android:padding="6dp"
        android:text="登录"
        android:textSize="18sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/ed_password" />

</androidx.constraintlayout.widget.ConstraintLayout>

View层activity

@AndroidEntryPoint
class LoginActivity : BaseActivity() {
    
    

    private val binding: ActivityLoginBinding by binding()

    private val mViewModel: LoginViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
    
    
        super.onCreate(savedInstanceState)

        lifecycleScope.launchWhenResumed {
    
    
            mViewModel.loginFlow.collect {
    
    
                if (it == null) return@collect
                Toast.makeText(this@LoginActivity, "返回的数据=$it", Toast.LENGTH_LONG).show()
            }
        }

        binding.btLogin.click {
    
    
            loginLogic()
        }

    }

    private fun loginLogic() {
    
    
        val name = binding.edName.text.toString().trim()
        val password = binding.edPassword.text.toString().trim()
        if (!CheckUtils.checkName(name)) {
    
    
            Toast.makeText(this, "用户名${
      
      Constant.NAME_LENGTH}位", Toast.LENGTH_LONG).show()
            return
        }
        if (!CheckUtils.checkPassWord(password)) {
    
    
            Toast.makeText(this, "密码${
      
      Constant.PASSWORD_LENGTH}位", Toast.LENGTH_LONG).show()
            return
        }
        mViewModel.login(name, password)
    }

}

ViewModel

@HiltViewModel
class LoginViewModel @Inject constructor(
    private val repository: UserRepository
) : BaseViewModel() {
    
    

    private val mLoginFlow = MutableStateFlow<Result<BaseEntity<UserEntity>>?>(null)
    val loginFlow: Flow<Result<BaseEntity<UserEntity>>?> get() = mLoginFlow

    fun login(name: String, password: String) {
    
    
        viewModelScope.launch {
    
    
            mLoginFlow.value = repository.signIn(name, password)
        }
    }
}

到此一个简单的MVVM架构就实现了

• 如果你有疑问或者更好的想法，欢迎进群讨论Android 学习交流群

源码传送门：
https://github.com/huangtaoOO/TaoComponent