做 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
谁依赖谁?
谁负责什么?
哪些依赖应该被禁止?
底层变化以后,影响会停在哪里?
物理分层,是把代码分开。
架构分层,是把责任、依赖和变化边界分清楚。
真正的架构,从来不在目录里。
而在边界里。