很多开发者把物理上的分层,当成了架构

做 Android 久了,经常会看到这样的项目:

text 复制代码
:app
:common
:network
:database
:user
:order
:payment

Module 拆得非常细。

打开 :user,里面还有:

text 复制代码
ui/
viewmodel/
repository/
data/

再看看项目结构:

text 复制代码
:app
  ↓
:user
  ↓
:network

一眼看过去,很有架构的样子。

但这里有一个很容易被忽略的问题:

代码分开了,架构就真的形成了吗?

不一定。

因为:

物理上的分层,不等于架构上的分层。

一、物理分层,只是把代码放到了不同的地方

最常见的物理分层:

text 复制代码
activity/
fragment/
viewmodel/
repository/
api/
database/
utils/

Activity 放 Activity。

ViewModel 放 ViewModel。

Repository 放 Repository。

API 放 API。

Database 放 Database。

看起来非常整齐。

但这套结构真正回答的只有一个问题:

代码应该放在哪里?

它没有回答:

  • 谁可以依赖谁?
  • 谁负责什么?
  • 哪些依赖是不应该存在的?
  • 变化发生以后,影响应该停在哪里?

所以,一个项目完全可以拥有非常漂亮的目录结构,同时内部充满循环依赖、反向依赖和职责混乱。

目录可以很干净,架构可以很混乱。

二、Module 越多,不代表架构越好

这是另一个容易产生错觉的地方。

例如:

text 复制代码
:app
:common
:network
:database
:user
:order
:payment

很多人看到这样的项目,会下意识认为模块化做得很好。

但 Module 只是物理隔离手段。

真正重要的是:

text 复制代码
:user 为什么依赖 :network?

:order 为什么依赖 :user?

:payment 为什么依赖 :order?

:common 为什么谁都能依赖?

如果最后变成:

text 复制代码
:user ─────→ :network
   ↓
:order ────→ :user
   ↓
:payment ──→ :order

甚至出现循环依赖、反向依赖和万能 common。

那么 Module 再多,也只是把混乱拆到了更多地方。

所以:

Module 多,不等于架构好。

真正的架构不是墙有多少,而是墙之间有什么规则。

三、真正的架构,核心是依赖倒置

再看一个简单的业务场景。

ViewModel 需要加载用户信息。

一种设计是:

text 复制代码
ViewModel
    ↓
Retrofit API
    ↓
Network

ViewModel 直接知道 Retrofit、HTTP、网络异常等底层实现细节。

假设有一天,我们需要把 Retrofit 换成 Ktor,或者替换成其他数据服务。

上层可能也要跟着修改。

另一种设计:

text 复制代码
UI / ViewModel
       ↓
Repository 抽象
       ↑
Repository 实现
       ↓
Network / Database

这里需要特别注意:

Repository 抽象由上层业务所需要的能力定义,Data 层负责提供具体实现。

例如:

kotlin 复制代码
interface UserRepository {
    suspend fun getUser(): User
}

Data 层实现:

kotlin 复制代码
class UserRepositoryImpl(
    private val api: UserApi
) : UserRepository {
    override suspend fun getUser(): User {
        return api.getUser().toDomain()
    }
}

ViewModel 只依赖 UserRepository,不需要知道底层使用 Retrofit 还是 Ktor。

这才是依赖倒置真正想解决的问题。

它不是为了多创建几个 Interface,而是为了:

让上层业务不再依赖底层技术实现。

四、架构的价值,是让变化有明确的边界

这也是图中右侧最值得关注的地方。

假设底层发生变化:

text 复制代码
Retrofit → Ktor

Room → 其他数据库

第三方 SDK → 自研 SDK

如果架构边界清晰,这些变化应该尽可能被限制在 Data 层。

text 复制代码
UI / ViewModel
       │
       │ 业务抽象
       │
───────┼───────
       │
Data Layer / Repository
       │
       │
Network / Database

底层实现发生变化,上层不应该跟着变化。

当然,这不是说所有变化都能被 Repository 隔离。

如果业务契约本身发生变化,上层自然也可能需要调整。

但底层技术实现的变化,不应该无缘无故传播到业务层。

这就是边界的价值:

变化应该被限制在它所属的范围内。

五、放到 Android 项目中,边界具体体现在哪里?

依赖边界不是一个抽象概念。

它会直接影响日常开发中的很多设计。

1. IO 调度应该属于 Data 层

如果每个 ViewModel 都需要这样写:

kotlin 复制代码
viewModelScope.launch {
    withContext(Dispatchers.IO) {
        repository.loadData()
    }
}

那么调用方就必须知道数据访问需要在哪个线程执行。

这意味着底层实现细节已经泄漏到了上层。

更合理的方式是:

kotlin 复制代码
interface UserRepository {
    suspend fun loadData(): User
}

Data 层内部负责 IO 调度,向上提供 Main-safe API。

调用方不需要关心底层使用哪个 Dispatcher。

2. 异常转换应该属于明确的边界

底层可能出现:

text 复制代码
IOException
HttpException
SocketException

这些属于具体技术实现的异常。

Data 层应该根据业务契约,将需要向上暴露的异常转换成上层能够理解的错误类型。

例如:

text 复制代码
NetworkException
       ↓
Data Layer
       ↓
NetworkFailure
       ↓
ViewModel

当然,CancellationException 不能当成普通业务异常吞掉,协程取消语义必须得到保留。

3. 生命周期应该有明确的所有者

如果 Repository 内部启动协程、注册监听器、持有资源,却要求调用方手动执行:

kotlin 复制代码
repository.start()
repository.stop()

那么调用方就必须知道 Repository 内部的生命周期管理方式。

这也是一种职责泄漏。

应该明确资源由谁拥有,协程由谁管理,取消时如何清理。

结构化并发能够帮助我们建立清晰的生命周期关系,而不是到处手动管理任务。

4. 数据层不应该向上泄漏 Callback

如果底层 SDK 使用 Callback,上层业务却不得不理解它的注册、注销和回调时序,那么边界就不够干净。

Data 层可以将传统异步回调封装成 suspend 或 Flow:

kotlin 复制代码
interface UserRepository {
    suspend fun getUser(): User
    fun observeUser(): Flow<User>
}

底层使用什么异步机制,是 Data 层自己的实现细节。

上层只使用符合业务需求的异步 API。

这些看似是协程、异常和生命周期方面的问题,本质上都指向同一件事:

不要让一个层次承担不属于自己的责任,也不要让实现细节随意穿透边界。

六、不要为了架构而制造架构

这里还需要纠正一个常见误区。

很多人一谈 Clean Architecture,就开始:

text 复制代码
创建 Domain Module
创建 Repository
创建 UseCase
创建 DataSource
创建各种 Interface

仿佛组件越齐全,架构就越标准。

但这些东西本身并不代表架构质量。

一个三个人的小团队,为了符合某种架构模板:

text 复制代码
一个功能
→ 一个 Module
→ 一个 UseCase
→ 一个 Repository
→ 一个 DataSource
→ 一个 Factory
→ 一个 Manager

最后几十个类互相跳转。

这种设计未必比简单的 Package 组织更好。

Module、Package、Class、Interface 都是手段。

真正应该考虑的是:

  • 这个边界有没有存在的必要?
  • 这个依赖是否合理?
  • 这个职责应该由谁承担?
  • 这个抽象是否真正隔离了变化?

简单不是没有架构,而是没有制造不必要的复杂度。

七、AI 时代,更需要理解架构边界

现在 AI 可以非常快地生成:

text 复制代码
Module
Repository
UseCase
ViewModel
Flow
Coroutine
DI

代码看起来也非常标准。

但 AI 很容易告诉你:

这里应该增加一个 UseCase。

这里应该创建一个 Repository。

这里应该使用 withContext(Dispatchers.IO)。

这里应该创建一个 CoroutineScope。

真正需要开发者判断的是:

为什么?

这个 Repository 的边界是什么?

为什么是调用方负责 IO?

这个 Scope 谁拥有?

它的生命周期是什么?

AI 可以快速生成代码,但不能替代开发者对依赖关系、职责边界和变化成本的判断。

代码越来越便宜,判断力越来越贵。

结语

回到最开始的问题:

为什么一个 Module 拆得非常细、目录组织得非常漂亮的项目,依然可能是一套糟糕的架构?

因为物理分层只解决了代码组织问题。

它并没有自动解决依赖关系、职责归属和变化隔离问题。

所以,评价一个 Android 项目,不要只看:

text 复制代码
有多少 Module?
有多少 Repository?
有多少 UseCase?
目录结构是否漂亮?

更应该看:

text 复制代码
谁依赖谁?

谁负责什么?

哪些依赖应该被禁止?

底层变化以后,影响会停在哪里?

物理分层,是把代码分开。

架构分层,是把责任、依赖和变化边界分清楚。

真正的架构,从来不在目录里。

而在边界里。

相关推荐
FungLeo1 小时前
FengCMS · PHP+MySQL 升级实录 · MySQL DDL不能回滚:模型字段结构操作的失败续做
android·mysql·php·工程实践·fengcms
雨白2 小时前
Android 建造者模式实战:从 AlertDialog 源码到 TopBar 的两种实现
android
_祝你今天愉快5 小时前
Android 高级绘制:[五] 贝塞尔曲线与计算规则
android
FungLeo19 小时前
FengCMS · PHP+MySQL 升级实录 · 危险默认值之殇:root/123456、认证码 8888 写进配置加载器
android·mysql·php·安全加固·fengcms
yz_aiks19 小时前
Termux 使用教程:把安卓手机变成随身 Linux(装 Python、SSH 远程、跑自动化脚本)
android·linux·python·智能手机·ssh·termux
booboosui1 天前
编号没变,消息还是来了:Mac 端通知读取漏第二条的原因
android
雨白2 天前
单例设计模式:从 Java/Kotlin 实现到 Android 实战
android
hai_android2 天前
一行 asLiveData,背后是一座生命周期的桥
android·java·kotlin
阿杰m2 天前
Android源码第二十三章:Telephony、RIL 与 IMS——来电怎么到应用?
android