Android

[Android] Componentized Development Architecture(组件化)

Posted by xiuyuantech on 2022-03-11

在Android开发中，组件化‌是将一个大型应用程序拆分成多个独立的组件，每个组件都是一个相对独立、可复用的单元。
组件化强调的是减少组件之间的耦合，提高代码的可维护性和可测试性。
每个组件可以独立开发、测试和编译，组件之间通过定义接口和调用API的方式进行通信和交。
组件化的优势包括：
‌提高开发效率‌：解耦，多个小团队可以并行开发不同的组件。
‌提高代码复用性‌：不同的组件可以通过接口和API进行通信和交互。
‌提高系统稳定性‌：每个组件可以独立运行，一个组件的崩溃不会影响整个系统‌。

模块化、插件化区别

1.‌模块化‌是将一个应用程序按照功能或业务领域划分为多个相互独立、低耦合的模块。每个模块专注于实现特定的功能或解决特定的问题。模块化强调的是功能的分离和模块之间的独立性。

模块化的优势包括：
‌清晰的结构‌：使得代码结构更清晰、易于理解和维护。
‌促进重用和扩展‌：模块化的设计可以促进代码的重用和扩展‌。

2.插件化‌是将一个应用程序拆分成多个独立的插件，每个插件可以独立开发、测试、编译和发布。插件化强调的是功能的动态加载和卸载，以及功能的动态更新。

插件化的优势包括：
‌功能扩展‌：通过加载和卸载插件，可以动态地扩展宿主应用程序的功能。
‌灵活性‌：插件可以独立开发和测试，不需要修改宿主应用程序的代码。
‌动态更新‌：插件可以在运行时动态加载和卸载，实现功能的动态更新‌。

企业大多常用组件化架构进行开发，也仅有国内部分企业使用插件化开发。不过随着Android版本迭代更新，权限越来越严格插件化将受到限制。

需要解决的问题

  • 组件分层：怎么将一个项目分成多个组件、组件间的依赖关系是怎么样的?

  • 组件单独运行和集成调试：组件是如何独立运行和集成调试的？

  • 组件间通信:主项目与组件、组件与组件之间如何通信的?

  • 业务组件不能反向依赖壳工程，如何获取Application实例、如何获取Application onCreate()回调（用于任务初始化）?

组件划分

组件化架构图

根据上面的组件化架构图，组件分为 基础组件、业务功能组件、业务组件。

  • 基础组件，不用多说，就是基础功能，例如网络请求、日志框架、图片加载，这些与业务毫无关联，可用于公司所有项目，是底层最稳定的组件。

  • 业务功能组件，主要是供业务组件依赖使用，例如 分享、支付组件，通常是一个完整的功能，是较为最稳定的组件。

  • 业务组件，完整的业务块，例如前面提到京东的 “首页”、“分类”、“发现”、“购物车”、“我的”。

项目搭建

  1. 单工程方案
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// gradle.properties / 新增config.gradle 中配置 
isDebug = true 独立调试

//app/library build.gradle中配置,若在config.gradle中配置则需要添加 apply from:"config.gradle"
if(isDebug.toBoolean()){
    //构建后输出一个 APK 安装包
    apply plugin: 'com.android.application'
}else{
    //构建后输出 ARR 包
    apply plugin: 'com.android.library'
}

android {
     defaultConfig {
        if(isDebug.toBoolean()){
            //独立调试的时候才能设置applicationId
            applicationId "com.demo.module.collect"
        }
    }
    sourceSets {
        main {
            if (isDebug.toBoolean()) {
                //独立调试
                manifest.srcFile 'src/main/debug/AndroidManifest.xml'
            } else {
                //集成调试
                manifest.srcFile 'src/main/AndroidManifest.xml'
            }
        }
    }
}
  1. 多工程方案

多工程方案，业务组件以library module形式存在于独立的工程。再新增独立工程引入组件就可以独立调试了，不再需要进行上面那些配置了。

1
2
3
// settings.gradle 中配置 
include ":app"，
include ":app_pay"，

项目结构图

  1. 选择合适的库或框架
    组件间的跳转和通信: ARouter, TheRouter, WMRouter
    依赖注入框架: Hilt, Dagger等。
    架构模式: MVI、MVVM、MVP。
    Jetpack库：ViewModel、LiveData、Room等。
    服务暴露组件：新建服务继承IProvider、EventBus等。

  2. Application生命周期分发
    使用AppLifeCycle插件，它专门用于在Android组件化开发中，Application生命周期主动分发到组件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
//common组件 build.gradle
dependencies {
    ...
    //AppLifecycle
    api 'com.github.hufeiyang.Android-AppLifecycleMgr:applifecycle-api:1.0.4'
}

 //业务组件 build.gradle
 //这里Common:1.0.2内依赖了applifecycle-api
 implementation 'com.github.hufeiyang:Common:1.0.2'
 annotationProcessor 'com.github.hufeiyang.Android-AppLifecycleMgr:applifecycle-compiler:1.0.4'

//组件的实现
/**
 * 组件的AppLifecycle
 * 1、@AppLifecycle
 * 2、实现IApplicationLifecycleCallbacks
 */
@AppLifecycle
public class ModuleApplication implements IApplicationLifecycleCallbacks {

    public  Context context;

    /**
      * 用于设置优先级，即多个组件onCreate方法调用的优先顺序
      * @return
     */
    @Override
    public int getPriority() {
        return NORM_PRIORITY;
    }

    @Override
    public void onCreate(Context context) {
        //可在此处做初始化任务，相当于Application的onCreate方法
        this.context = context;
    }

    @Override
    public void onTerminate() {
    }

    @Override
    public void onLowMemory() {
    }

    @Override
    public void onTrimMemory(int level) {
    }
}


//宿主壳工程引入新的common组件、业务组件，以及 引入AppLifecycle插件：
//宿主壳工程根目录的 build.gradle

buildscript {
   
    repositories {
        google()
        jcenter()

        //applifecycle插件仓也是jitpack
        maven { url 'https://jitpack.io' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.6.1'

        //加载插件applifecycle
        classpath 'com.github.hufeiyang.Android-AppLifecycleMgr:applifecycle-plugin:1.0.3'
    }
}

//宿主 module 的build.gradle
/使用插件applifecycle
apply plugin: 'com.hm.plugin.lifecycle'
...
dependencies {
    ...
    //宿主壳工程内 也需要依赖Common组件，因为要触发生命周期分发
    implementation 'com.github.hufeiyang:Common:1.0.2'
}

//最后在Application中触发生命周期的分发
//宿主壳工程 MyApplication
public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ...
        ApplicationLifecycleManager.init();
        ApplicationLifecycleManager.onCreate(this);
    }

    @Override
    public void onTerminate() {
        super.onTerminate();
        ApplicationLifecycleManager.onTerminate();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        ApplicationLifecycleManager.onLowMemory();
    }

    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        ApplicationLifecycleManager.onTrimMemory(level);
    }
}

新增组件的话，只需要实现IApplicationLifecycleCallbacks并添加了@AppLifecycle注解即可，无需修改宿主壳工程。

总结

总之Android开发组件化，是在项目发展到一定规模后必定要使用的技术，学习至完全掌握是非常必要的。

FEATURED TAGS
Android
FRIENDS