kotlin与MVVM的结合使用总结（二）

  在 MVVM（Model - View - ViewModel）架构中，M 层即 Model 层，主要负责数据的管理、存储和获取，它与业务逻辑和数据处理处罚相关。在 Kotlin 中实现 MVVM 的 M 层，通常会涉及数据类的界说、数据的本地存储与远程获取等操纵，以下是详细的实现讲解：
1. 界说数据类

数据类是 Kotlin 中非常方便的特性，用于简洁地界说数据模型。它会自动天生 equals()、hashCode()、toString() 等方法。以下是一个简单的用户数据类示例：

1. data class User(
2.     val id: Int,
3.     val name: String,
4.     val age: Int,
5.     val email: String
6. )

复制代码

这个数据类 User 表现一个用户的基本信息，包含 id、name、age 和 email 四个属性。
2. 本地数据存储

如果需要将数据存储在本地，可以使用 Android 的 Room 数据库。Room 是 Android 官方提供的一个抽象层，用于在 SQLite 数据库上举行对象映射，结合 Kotlin 可以更方便地操纵数据库。
2.1 界说实体类

首先，要确保数据类符合 Room 的实体类要求，添加 @Entity 注解：

1. import androidx.room.Entity
2. import androidx.room.PrimaryKey
4. @Entity(tableName = "users")
5. data class User(
6.     @PrimaryKey val id: Int,
7.     val name: String,
8.     val age: Int,
9.     val email: String
10. )

复制代码

这里的 @Entity 注解指定了该数据类对应数据库中的 users 表，@PrimaryKey 注解指定了 id 作为主键。
2.2 界说 DAO（数据访问对象）

DAO 用于界说数据库操纵的方法，使用 @Dao 注解：

1. import androidx.room.Dao
2. import androidx.room.Insert
3. import androidx.room.Query
5. @Dao
6. interface UserDao {
7.     @Insert
8.     suspend fun insertUser(user: User)
10.     @Query("SELECT * FROM users WHERE id = :id")
11.     suspend fun getUserById(id: Int): User?
12. }

复制代码

在这个 DAO 中，@Insert 注解表现插入操纵，@Query 注解用于自界说查询操纵。留意方法使用了 suspend 关键字，以便在协程中调用。
2.3 界说数据库

使用 @Database 注解界说数据库：

1. import androidx.room.Database
2. import androidx.room.RoomDatabase
4. @Database(entities = [User::class], version = 1)
5. abstract class AppDatabase : RoomDatabase() {
6.     abstract fun userDao(): UserDao
7. }

复制代码

这里指定了数据库包含的实体类为 User，版本号为 1，并提供了获取 UserDao 的抽象方法。
3. 远程数据获取

如果需要从网络获取数据，可以使用 Retrofit 库。Retrofit 是一个类型安全的 HTTP 客户端，结合 Kotlin 协程可以高效地举行网络请求。
3.1 界说 API 接口

1. import retrofit2.http.GET
2. import retrofit2.http.Path
4. interface UserApiService {
5.     @GET("users/{id}")
6.     suspend fun getUserById(@Path("id") id: Int): User
7. }

复制代码

这个接口界说了一个获取用户信息的方法，使用 @GET 注解指定请求的 URL，@Path 注解用于替换 URL 中的参数。
3.2 创建 Retrofit 实例

1. import retrofit2.Retrofit
2. import retrofit2.converter.gson.GsonConverterFactory
4. object RetrofitClient {
5.     private const val BASE_URL = "https://example.com/api/"
7.     val instance: Retrofit by lazy {
8.         Retrofit.Builder()
9.            .baseUrl(BASE_URL)
10.            .addConverterFactory(GsonConverterFactory.create())
11.            .build()
12.     }
14.     val userApiService: UserApiService by lazy {
15.         instance.create(UserApiService::class.java)
16.     }
17. }

复制代码

这里创建了一个 Retrofit 实例，并通过 create() 方法创建了 UserApiService 的实例。
4. 堆栈（Repository）模式

为了同一管理本地和远程数据的获取，通常会使用堆栈模式。堆栈类负责调和数据的来源，根据需要从本地数据库或远程服务器获取数据。

1. class UserRepository(
2.     private val userDao: UserDao,
3.     private val userApiService: UserApiService
4. ) {
5.     suspend fun getUserById(id: Int): User? {
6.         // 先从本地数据库获取数据
7.         var user = userDao.getUserById(id)
8.         if (user == null) {
9.             // 如果本地没有数据，从网络获取
10.             user = userApiService.getUserById(id)
11.             if (user != null) {
12.                 // 将从网络获取的数据保存到本地数据库
13.                 userDao.insertUser(user)
14.             }
15.         }
16.         return user
17.     }
18. }

复制代码

 在这个堆栈类中，getUserById 方法首先尝试从本地数据库获取用户数据，如果本地没有则从网络获取，并将获取到的数据保存到本地数据库。
  总结（M层）

  通过以上步调，我们在 Kotlin 中实现了 MVVM 架构的 M 层。主要包罗数据类的界说、本地数据存储（使用 Room）、远程数据获取（使用 Retrofit）以及堆栈模式的应用，这样可以有效地管理数据的来源和流向，进步代码的可维护性和可测试性。
下一层：V层  
  以下将详细介绍在 Kotlin 中实现 MVVM 架构里 V 层（View 层）的完整步调，并给出相应代码示例。V 层主要负责展示 UI 以及处理处罚用户交互，通常由 Activity 或 Fragment 实现。
项目准备

确保在 build.gradle 文件中添加必要依赖：

1. dependencies {
2.     // ViewModel 和 LiveData
3.     implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2'
4.     implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.6.2'
5.     // ViewBinding
6.     android {
7.         buildFeatures {
8.             viewBinding = true
9.         }
10.     }
11.     // Kotlin 协程
12.     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
13. }

复制代码

界说布局文件

在 res/layout 目次下创建 activity_main.xml 文件，用于界说界面布局

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.     android:layout_width="match_parent"
4.     android:layout_height="match_parent"
5.     android:orientation="vertical"
6.     android:padding="16dp">
8.     <EditText
9.         android:id="@+id/et_input"
10.         android:layout_width="match_parent"
11.         android:layout_height="wrap_content"
12.         android:hint="请输入内容" />
14.     <Button
15.         android:id="@+id/btn_send"
16.         android:layout_width="wrap_content"
17.         android:layout_height="wrap_content"
18.         android:text="发送" />
20.     <TextView
21.         android:id="@+id/tv_result"
22.         android:layout_width="wrap_content"
23.         android:layout_height="wrap_content"
24.         android:textSize="18sp"
25.         android:paddingTop="16dp" />
26. </LinearLayout>

复制代码

创建 ViewModel

ViewModel 负责处理处罚业务逻辑和数据管理，以下是 MainViewModel 的实现：

1. import androidx.lifecycle.LiveData
2. import androidx.lifecycle.MutableLiveData
3. import androidx.lifecycle.ViewModel
5. class MainViewModel : ViewModel() {
6.     private val _result = MutableLiveData<String>()
7.     val result: LiveData<String> = _result
9.     fun processInput(input: String) {
10.         // 简单处理输入，这里只是将输入内容反转
11.         val processed = input.reversed()
12.         _result.value = processed
13.     }
14. }

复制代码

创建 Activity 作为 V 层

使用 Kotlin 实现 MainActivity 作为 View 层，通过 ViewBinding 绑定视图，观察 ViewModel 中的数据变革并处理处罚用户交互：

1. import android.os.Bundle
2. import androidx.appcompat.app.AppCompatActivity
3. import androidx.lifecycle.Observer
4. import androidx.lifecycle.ViewModelProvider
5. import com.example.mvvmexample.databinding.ActivityMainBinding
7. class MainActivity : AppCompatActivity() {
8.     private lateinit var binding: ActivityMainBinding
9.     private lateinit var viewModel: MainViewModel
11.     override fun onCreate(savedInstanceState: Bundle?) {
12.         super.onCreate(savedInstanceState)
13.         // 使用 ViewBinding 绑定布局
14.         binding = ActivityMainBinding.inflate(layoutInflater)
15.         setContentView(binding.root)
17.         // 获取 ViewModel 实例
18.         viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
20.         // 设置按钮点击事件监听器
21.         binding.btnSend.setOnClickListener {
22.             // 获取输入框中的内容
23.             val input = binding.etInput.text.toString()
24.             // 调用 ViewModel 的方法处理输入
25.             viewModel.processInput(input)
26.         }
28.         // 观察 ViewModel 中的数据变化
29.         viewModel.result.observe(this, Observer { result ->
30.             // 更新 UI 显示处理结果
31.             binding.tvResult.text = "处理结果: $result"
32.         })
33.     }
34. }

复制代码

代码表明

• ViewBinding 的使用：
  
  
  
  • ActivityMainBinding.inflate(layoutInflater) 用于实例化绑定类，通过 setContentView(binding.root) 设置布局，之后可直接使用 binding 对象访问布局中的视图组件，如 binding.etInput、binding.btnSend 等。
    
  
  
• ViewModel 的获取：
  
  
  
  • ViewModelProvider(this).get(MainViewModel::class.java) 用于获取 MainViewModel 的实例，确保在 Activity 的生命周期内使用同一个 ViewModel 实例。
    
  
  
• 用户交互处理处罚：
  
  
  
  • 通过 binding.btnSend.setOnClickListener 为按钮设置点击事件监听器，当按钮被点击时，获取输入框中的内容并调用 ViewModel 的 processInput 方法举行处理处罚。
    
  
  
• 数据观察：
  
  
  
  • viewModel.result.observe(this, Observer { ... }) 用于观察 LiveData 的数据变革，当 LiveData 的值发生改变时，会触发 Observer 中的代码块，从而更新 UI。
    
  
  

使用 Fragment 作为 V 层（可选）

如果使用 Fragment 作为 V 层，实现方式类似：
创建布局文件 fragment_main.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.     android:layout_width="match_parent"
4.     android:layout_height="match_parent"
5.     android:orientation="vertical"
6.     android:padding="16dp">
8.     <EditText
9.         android:id="@+id/et_input_fragment"
10.         android:layout_width="match_parent"
11.         android:layout_height="wrap_content"
12.         android:hint="请输入内容" />
14.     <Button
15.         android:id="@+id/btn_send_fragment"
16.         android:layout_width="wrap_content"
17.         android:layout_height="wrap_content"
18.         android:text="发送" />
20.     <TextView
21.         android:id="@+id/tv_result_fragment"
22.         android:layout_width="wrap_content"
23.         android:layout_height="wrap_content"
24.         android:textSize="18sp"
25.         android:paddingTop="16dp" />
26. </LinearLayout>

复制代码

 创建 Fragment

1. import android.os.Bundle
2. import android.view.LayoutInflater
3. import android.view.View
4. import android.view.ViewGroup
5. import androidx.fragment.app.Fragment
6. import androidx.lifecycle.Observer
7. import androidx.lifecycle.ViewModelProvider
8. import com.example.mvvmexample.databinding.FragmentMainBinding
10. class MainFragment : Fragment() {
11.     private var _binding: FragmentMainBinding? = null
12.     private val binding get() = _binding!!
13.     private lateinit var viewModel: MainViewModel
15.     override fun onCreateView(
16.         inflater: LayoutInflater,
17.         container: ViewGroup?,
18.         savedInstanceState: Bundle?
19.     ): View? {
20.         // 使用 ViewBinding 绑定布局
21.         _binding = FragmentMainBinding.inflate(inflater, container, false)
22.         return binding.root
23.     }
25.     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
26.         super.onViewCreated(view, savedInstanceState)
28.         // 获取 ViewModel 实例
29.         viewModel = ViewModelProvider(requireActivity()).get(MainViewModel::class.java)
31.         // 设置按钮点击事件监听器
32.         binding.btnSendFragment.setOnClickListener {
33.             val input = binding.etInputFragment.text.toString()
34.             viewModel.processInput(input)
35.         }
37.         // 观察 ViewModel 中的数据变化
38.         viewModel.result.observe(viewLifecycleOwner, Observer { result ->
39.             binding.tvResultFragment.text = "处理结果: $result"
40.         })
41.     }
43.     override fun onDestroyView() {
44.         super.onDestroyView()
45.         _binding = null
46.     }
47. }

复制代码

总结（V层）

通过以上步调，我们可以在 Kotlin 中使用 Activity 或 Fragment 作为 MVVM 架构的 V 层，借助 ViewBinding 绑定视图，使用 ViewModelProvider 获取 ViewModel 实例，处理处罚用户交互并观察 ViewModel 中的数据变革以更新 UI，实现视图和业务逻辑的分离，进步代码的可维护性和可测试性。
因为太多了，我就先讲解前两个层，下一节我将阐述最重要的VM层
谢谢观看！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。