跳转至

第19章 模块化与组件化架构

模块化与组件化架构图

学习目标：掌握Android模块化开发，理解组件化架构设计，实现模块间解耦。

预计学习时间：3-5天 实践时间：1-2天

目录

  1. 模块化基础
  2. 组件化架构
  3. 模块间通信
  4. 路由框架
  5. 实践练习

1. 模块化基础

1.1 为什么模块化

  • 代码复用
  • 并行开发
  • 独立测试
  • 按需编译

1.2 模块类型

Text Only
app/                    # 主模块
├── feature-home/       # 首页模块
├── feature-profile/    # 个人中心模块
├── feature-settings/   # 设置模块
├── core-common/        # 公共模块
├── core-network/       # 网络模块
└── core-database/      # 数据库模块

1.3 Gradle配置

Kotlin
// settings.gradle.kts
include(":app")
include(":feature:home")
include(":feature:profile")
include(":core:network")

// build.gradle.kts (feature模块)
plugins {
    id("com.android.library")
    id("org.jetbrains.kotlin.android")
}

dependencies {
    implementation(project(":core:common"))
    implementation(project(":core:network"))
}

2. 组件化架构

2.1 组件化 vs 模块化

特性 模块化 组件化
编译 一起编译 独立编译
运行 一起运行 可独立运行
耦合 低耦合 完全解耦
适用 中小型项目 大型项目

2.2 组件化设计

Text Only
app/                    # 壳工程
├── module-home/        # 首页组件（可独立运行）
├── module-profile/     # 个人中心组件
├── module-login/       # 登录组件
├── library-base/       # 基础库
└── library-router/     # 路由库

2.3 组件切换

Kotlin
// build.gradle.kts 中根据 isModuleMode 切换插件
if (isModuleMode) {
    plugins {
        id("com.android.application")
    }
} else {
    plugins {
        id("com.android.library")
    }
}

android {
    sourceSets {
        getByName("main") {
            if (isModuleMode) {
                manifest.srcFile("src/main/module/AndroidManifest.xml")
            } else {
                manifest.srcFile("src/main/AndroidManifest.xml")
            }
        }
    }
}

3. 模块间通信

3.1 接口下沉

Kotlin
// library-base 定义接口
interface ILoginService {  // interface定义类型契约
    fun login(context: Context)
    fun isLoggedIn(): Boolean
    fun getUserId(): String?
}

// module-login 实现接口
class LoginServiceImpl : ILoginService {
    override fun login(context: Context) {
        // 实现登录
    }
    // ...
}

3.2 服务注册与发现

Kotlin
// 服务管理器
object ServiceManager {
    private val services = mutableMapOf<Class<*>, Any>()

    fun <T> register(serviceClass: Class<T>, impl: T) {  // 泛型<T>：类型参数化
        services[serviceClass] = impl as Any
    }

    fun <T> get(serviceClass: Class<T>): T? {
        return services[serviceClass] as? T
    }
}

// 注册
ServiceManager.register(ILoginService::class.java, LoginServiceImpl())

// 使用
val loginService = ServiceManager.get(ILoginService::class.java)
loginService?.login(context)

4. 路由框架

4.1 ARouter使用

Kotlin
// 添加依赖
dependencies {
    implementation("com.alibaba:arouter-api:1.5.2")
    kapt("com.alibaba:arouter-compiler:1.5.2")
}

// 初始化
ARouter.init(application)

// 声明路由
@Route(path = "/home/main")
class HomeActivity : AppCompatActivity()

// 跳转
ARouter.getInstance().build("/home/main").navigation()

// 带参数跳转
ARouter.getInstance()
    .build("/profile/detail")
    .withString("userId", "123")
    .navigation()

4.2 自定义路由

Kotlin
// 路由表
object Routes {
    const val HOME = "/home/main"
    const val PROFILE = "/profile/main"
    const val SETTINGS = "/settings/main"
}

// 路由跳转
object Router {
    fun navigate(context: Context, path: String, params: Bundle? = null) {
        val intent = Intent()
        intent.setClassName(context, getActivityName(path))
        params?.let { intent.putExtras(it) }
        context.startActivity(intent)
    }
}

5. 实践练习

练习1：模块化改造

任务：将单模块项目改造为多模块

要求： - 分离feature模块 - 提取core模块 - 解决依赖关系

练习2：组件化通信

任务：实现模块间通信

要求： - 接口下沉 - 服务注册 - 路由跳转

本章小结

核心要点

  1. 模块化提高代码复用和并行开发效率
  2. 组件化实现完全解耦，支持独立运行
  3. 接口下沉是模块通信的基础
  4. 路由框架简化页面跳转

下一步

完成本章学习后，请进入第20章：插件化与热修复技术。

本章完成时间：预计3-5天