现代应用架构最佳实践

锐湃

于 2024-09-14 13:33:14 发布

阅读量6

点赞数

分类专栏：程序设计文章标签：架构

原文链接：https://juejin.cn/post/7377220397403865142

版权

程序设计专栏收录该内容

315 篇文章 5 订阅

订阅专栏

Google其实从未推出过架构模式，MVX 的设计模式都是广大战友战出来的结果，架构总的目的就是“高内聚，低耦合”，只要满足这一点，项目就会满足：

好的阅读性
好的健壮性
好的扩展性
等等

近年来，Google推出了真正的自己的架构模式，当然只是建议以及强力建议。

比如他在官网写到：此现代应用架构鼓励采用以下方法及其他一些方法：

反应式分层架构是一种软件设计模式，结合了反应式编程和分层架构的优点，旨在构建响应式、高效且易于维护的应用。下面详细解释这个概念。

地址： developer.android.com/topic/archi…

我也是学习这个架构模式。

一、反应式编程

反应式编程是一种声明式编程范式，强调异步数据流和变化的传播。其核心思想是应用程序应该对数据和事件的变化做出反应，而不是依赖于手动处理这些变化。常用的反应式编程工具包括 ReactiveX（RxJava、RxJS 等）和 Kotlin 的 Flow。

二、分层架构

分层架构是一种将应用程序划分为若干层的设计模式，每一层专注于特定的功能或责任，通常包括：

表示层（Presentation Layer）：负责用户界面和用户交互。
业务逻辑层（Business Logic Layer）：处理应用的核心业务逻辑。
数据层（Data Layer）：管理数据存储和访问，通常包括数据库和网络请求。

三、反应式分层架构

反应式分层架构结合了反应式编程和分层架构的优点，使各层可以通过异步数据流进行通信和交互。这种架构设计可以更好地处理现代应用的复杂性和异步需求，尤其是在移动开发和高并发系统中。

3.1 核心概念和优势

模块化设计：
- 每一层都独立处理特定的功能，保持高内聚和低耦合。
- 易于开发、测试和维护。
异步数据流：
- 数据流动和事件处理采用异步方式，提高应用的响应性和性能。
- 各层通过数据流进行通信，减少了直接依赖和耦合。
分离关注点：
- 每一层关注不同的职责，例如表示层处理界面逻辑，业务逻辑层处理应用核心逻辑，数据层处理数据管理。
- 改善代码的可读性和可维护性。
灵活性和可扩展性：
- 新功能可以通过添加或修改独立的层或模块来实现，而无需大幅度改变现有代码。
- 容易适应需求变化和技术更新。

3.2 典型架构示例

表示层（Presentation Layer）：
- 包含 Activity、Fragment、ViewModel 等界面相关的组件。
- 通过 ViewModel 与业务逻辑层交互，并观察 LiveData 或 Flow 以获取数据更新。
业务逻辑层（Business Logic Layer）：
- 包含 UseCase、Interactor 等处理业务逻辑的组件。
- 接受表示层的请求，执行相应的业务逻辑，并通过异步流返回结果。
数据层（Data Layer）：
- 包含 Repository、DAO 等负责数据管理的组件。
- 通过网络或本地数据库获取数据，并将数据流提供给业务逻辑层。

简易分层架构图

四、举例

假设我们在开发一个新闻阅读应用：

表示层：
- Activity 显示新闻列表，用户可以点击查看新闻详情。
- ViewModel 观察新闻列表数据的变化，并更新界面。
业务逻辑层：
- UseCase 负责从数据层获取新闻列表，并进行必要的业务处理。
- 返回处理后的数据给 ViewModel。
数据层：
- Repository 负责从网络或本地数据库获取新闻数据。
- 使用 Retrofit 进行网络请求，使用 Room 管理本地数据库。

数据流示意：

用户在 Activity 中触发刷新新闻列表事件。
Activity 调用 ViewModel 的刷新方法。
ViewModel 调用 UseCase 以获取新闻数据。
UseCase 通过 Repository 获取新闻数据。
Repository 返回新闻数据流给 UseCase。
UseCase 处理数据后，将结果通过 LiveData 或 Flow 返回给 ViewModel。
ViewModel 更新 LiveData，Activity 观察到数据变化并更新界面。

数据流和状态反馈时序图

4.1 Demo

下面是一个简化的新闻阅读应用代码示例，采用反应式分层架构进行实现。该示例包括表示层、业务逻辑层和数据层，并使用了 Kotlin、ViewModel、LiveData 和 Retrofit。

4.1.1 依赖

首先，添加必要的依赖项到 build.gradle 文件中：

dependencies {
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.3.1"
    implementation "com.squareup.retrofit2:retrofit:2.9.0"
    implementation "com.squareup.retrofit2:converter-gson:2.9.0"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.1"
    implementation "androidx.room:room-runtime:2.3.0"
    kapt "androidx.room:room-compiler:2.3.0"
}

4.1.2 数据层

4.1.2.1 数据模型

定义新闻数据模型 NewsArticle：

data class NewsArticle(
    val id: Int,
    val title: String,
    val content: String
)

4.1.2.2 Retrofit API 接口

定义 Retrofit API 接口：

interface NewsApiService {
    @GET("news")
    suspend fun getNews(): List<NewsArticle>
}

4.1.2.3 Retrofit 实例

创建 Retrofit 实例：

object RetrofitInstance {
    private val retrofit by lazy {
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    val api: NewsApiService by lazy {
        retrofit.create(NewsApiService::class.java)
    }
}

4.1.2.4 Repository

定义 Repository 以管理数据获取逻辑：

class NewsRepository {
    private val api = RetrofitInstance.api

    suspend fun getNews(): List<NewsArticle> {
        return api.getNews()
    }
}

4.1.3 业务逻辑层

4.1.3.1 UseCase

定义 UseCase 以处理业务逻辑：

class GetNewsUseCase(private val repository: NewsRepository) {
    suspend operator fun invoke(): List<NewsArticle> {
        return repository.getNews()
    }
}

4.1.4 表示层

4.1.4.1 ViewModel

定义 ViewModel 以管理界面相关的数据：

class NewsViewModel(private val getNewsUseCase: GetNewsUseCase) : ViewModel() {
    private val _news = MutableLiveData<List<NewsArticle>>()
    val news: LiveData<List<NewsArticle>> get() = _news

    fun fetchNews() {
        viewModelScope.launch {
            try {
                val newsList = getNewsUseCase()
                _news.postValue(newsList)
            } catch (e: Exception) {
                // 处理异常，例如显示错误消息
            }
        }
    }
}

4.1.4.2 Activity

在 Activity 中使用 ViewModel 和 LiveData：

class NewsActivity : AppCompatActivity() {
    private lateinit var viewModel: NewsViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_news)

        // 初始化 Repository 和 UseCase
        val repository = NewsRepository()
        val getNewsUseCase = GetNewsUseCase(repository)

        // 初始化 ViewModel
        val factory = NewsViewModelFactory(getNewsUseCase)
        viewModel = ViewModelProvider(this, factory).get(NewsViewModel::class.java)

        // 观察 LiveData
        viewModel.news.observe(this, Observer { newsList ->
            // 更新 UI，例如显示新闻列表
            // recyclerView.adapter = NewsAdapter(newsList)
        })

        // 获取新闻
        viewModel.fetchNews()
    }
}

4.1.5 说明

数据层：包括数据模型 NewsArticle、Retrofit API 接口 NewsApiService、Retrofit 实例 RetrofitInstance 和数据仓库 NewsRepository。
业务逻辑层：包括 GetNewsUseCase，负责调用仓库获取新闻数据。
表示层：包括 NewsViewModel 和 NewsActivity。NewsViewModel 通过 fetchNews() 方法获取新闻数据并使用 LiveData 将数据暴露给 Activity。NewsActivity 观察 ViewModel 中的 LiveData，并在数据更新时更新界面。

通过这种分层架构，可以将不同层次的职责分开，使代码更易于维护、测试和扩展。

五、所有层中的单向数据流（略微改动代码主要说明问题）

我们需要确保数据和状态在各层之间的流动方向是单向的，从数据层到表示层，并通过事件从表示层回到数据层。具体来说，数据从数据源流向界面，界面中的事件再流向业务逻辑层，最终流向数据层

5.1 引入单向数据流（UDF）

我们将通过以下方式实现单向数据流：

数据流向界面：通过 LiveData 将数据从 ViewModel 传递到界面。
事件流向数据层：通过 ViewModel 捕获界面事件，并调用 UseCase 和 Repository 处理业务逻辑和数据操作。

5.2 修改后的代码示例

数据层和业务逻辑层保持不变

5.3 表示层

5.3.1 ViewModel

更新 ViewModel 以实现单向数据流：

class NewsViewModel(private val getNewsUseCase: GetNewsUseCase) : ViewModel() {
    private val _news = MutableLiveData<List<NewsArticle>>()
    val news: LiveData<List<NewsArticle>> get() = _news

    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> get() = _loading

    private val _error = MutableLiveData<String>()
    val error: LiveData<String> get() = _error

    fun fetchNews() {
        _loading.value = true
        viewModelScope.launch {
            try {
                val newsList = getNewsUseCase()
                _news.postValue(newsList)
                _loading.postValue(false)
            } catch (e: Exception) {
                _error.postValue(e.message)
                _loading.postValue(false)
            }
        }
    }
}

5.3.2 Activity

更新 Activity 以实现单向数据流：

class NewsActivity : AppCompatActivity() {
    private lateinit var viewModel: NewsViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_news)

        // 初始化 Repository 和 UseCase
        val repository = NewsRepository()
        val getNewsUseCase = GetNewsUseCase(repository)

        // 初始化 ViewModel
        val factory = NewsViewModelFactory(getNewsUseCase)
        viewModel = ViewModelProvider(this, factory).get(NewsViewModel::class.java)

        // 观察 LiveData
        viewModel.news.observe(this, Observer { newsList ->
            // 更新 UI，例如显示新闻列表
            // recyclerView.adapter = NewsAdapter(newsList)
        })

        viewModel.loading.observe(this, Observer { isLoading ->
            // 显示或隐藏加载指示器
        })

        viewModel.error.observe(this, Observer { errorMessage ->
            // 显示错误消息
        })

        // 获取新闻
        viewModel.fetchNews()
    }
}

5.4 说明

引入了以下改动以实现单向数据流：

ViewModel 中的 LiveData 将数据流向界面，包括新闻数据、加载状态和错误信息。
Activity 观察 ViewModel 中的 LiveData 以更新界面，包括新闻列表、加载指示器和错误消息。
事件流向数据层：当用户触发刷新事件时，Activity 调用 ViewModel 的 fetchNews() 方法，ViewModel 再调用 UseCase 和 Repository 以获取新闻数据。

通过这种方式，我们确保数据和状态的流动方向是单向的，从数据源到界面，并通过事件从界面流向数据层。这种架构设计提高了应用的数据一致性和可维护性。