AwesomeGithub组件化探索之旅

原创 Rouse Android补给站

Rouse

读完需要

分钟

速读仅需 13 分钟

之前一直听说过组件化开发，而且面试也有这方面的提问，但都未曾有涉及具体的项目。所以就萌生了基于 Github 的开放 Api，并使用组件化的方式来从零搭建一个 Github 客户端，起名为AwesomeGithub。

在这里对组件化开发进行一个总结，同时也希望能够帮助别人更好的理解组件化开发。

先来看下项目的整体效果

下面是项目的结构

为何要使用组件化

对于传统的开发模式，一个 app 下面是包含项目的全部页面模块与逻辑。这样项目一旦迭代时间过长，业务模块逐渐增加，相应的业务逻辑复杂度也成指数增加。模块间的互相调用频繁，这样必定会导致模块间的耦合增加，业务逻辑嵌套程度加深。一旦修改其中一个模块，可能就牵一发动全身了。
传统的开发模式不利于团队的集体开发合作，因为每个开发者都是在同一个 app 模块下开发。这样导致的问题是，不能预期每个开发者所会修改到的具体代码部分，即所能够修改的代码区域。因为模块耦合在一起，涉及的区域不可预期，导致不同开发者会修改同一个文件或者同一段代码逻辑，从而导致异常冲突。
传统开发模式不利于测试，每次迭代都要将项目整体测试一遍。因为在同一个 app 下面代码是缺乏约束的，你不能保证只修改了迭代过程中所涉及的需求逻辑。

以上问题随着项目的迭代周期的增大，会表现的越来越明显。那么使用组件化又能够解决什么问题了？

组件化能够解决的问题

组件化开发是将各个相关功能进行分离，分别独立成一个单独可运行的 app，并且组件之间不能相互直接引用。这样就减少了代码耦合，达到业务逻辑分层效果。
组件化可以提高团队协作能力，不同的人员可以开发不同的组件，保证不同开发人员互不影响。
组件化将 app 分成多个可单独运行的子项目，可以用自己独立的版本，可以独立编译，打包、测试与部署。这样不仅可以提高单个模块的编译速度，同时也可以提高测试的效率。
组件化可以提高项目的灵活性，app 可以按需加载所要有的组件，提高 app 的灵活性，可以快速生成可定制化的产品。

现在我们已经了解了组件化的作用，但要实现组件化，达到其作用，必须解决实现组件化过程中所遇到的问题。

组件化需要解决的问题

组件单独运行
组件间数据传递
主项目使用组件中的 Fragment
组件间界面的跳转
组件解耦

以上是实现组件化时所遇到的问题，下面我会结合AwesomeGithub来具体说明解决方案。

3.1

组件单独运行

组件的创建，可以直接使用 library 的方式进行创建。只不过在创建完之后，要让组件达到可以单独运行调试的地步，还需要进行相关配置。

运行方式动态配置

首先，当创建完 library 时，在 build.gradle 中可以找到这么一行代码

1apply plugin: 'com.android.library'

这是 gradle 插件所支持的一种构建类型，代表可以将其依赖到主项目中，构建后输出 aar 包。这种方式对于我们将组件依赖到主项目中完全吻合的。

而 gradle 插件的另一种构建方式，可以在主项目的 build.gradle 中看到这么一行代码

1apply plugin: 'com.android.application'

这代表在项目构建后会输出 apk 安装包，是一个独立可运行的项目。

明白了 gradle 的这两种构建方式之后，我们接下需要做的事也非常明了：需要将这两种方式进行动态配置，保证组件在主项目中以 library 方式存在，而自己单独的时候，则以 application 的方式存在。

下面我以AwesomeGithub中的 login 组件为例。

首先我们在根项目的 gradle.properties 中添加 addLogin 变量

1addLogin = true

然后在 login 中的 build.gradle 通过 addLogin 变量来控制构建方式

1if (addLogin.toBoolean()) {
2    apply plugin: 'com.android.library'
3} else {
4    apply plugin: 'com.android.application'
5}

这样就实现了对 login 的构建控制，可单独运行，也可依赖于 app 项目。

ApplicationId 与 AndroidManifest

除了修改 gradle 的构建方式，还需要动态配置 ApplicationId 与 AndroidManifest 文件。

有了上面的基础，实现方式也很简单。

可以在 defaultConfig 中增加对 applicationId 的动态配置

 1    defaultConfig {
 2        if (!addLogin.toBoolean()) {
 3            applicationId "com.idisfkj.awesome.login"
 4        }
 5        minSdkVersion Versions.min_sdk
 6        targetSdkVersion Versions.target_sdk
 7        versionCode Versions.version_code
 8        versionName Versions.version_name
 9
10        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
11    }

而 AndroidManifest 文件可以通过 sourceSets 来配置

1    sourceSets {
2        main {
3            if (addLogin.toBoolean()) {
4                manifest.srcFile 'src/main/AndroidManifest.xml'
5            } else {
6                manifest.srcFile 'src/main/manifest/AndroidManifest.xml'
7            }
8        }
9    }

同时 addLogin 也可以作用于 app，让 login 组件可配置依赖

这样 login 组件就可以独立于 app 进行单独构建、打包、调试与运行。

3.2

组件间的数据传递

由于组件与组件、项目间是不能直接使用类的相互引用来进行数据的传递，所以为了解决这个问题，这里通过一个公共库来做它们之间调用的桥梁，它们不直接拿到具体的引用对象，而是通过接口的方式来获取所需要的数据。

在AwesomeGithub中我将其命名为 componentbridge，各个组件都依赖于该公共桥梁，通过该公共桥梁各个组件间可以轻松的实现数据传递。

上图圈起来的部分都是 componentbridge 的重点，也是公共桥梁实现的基础。下面来分别详细说明。

BridgeInterface

这是公共桥梁的底层接口，每一个组件要向外实现自己的桥梁都要实现这个接口。

1interface BridgeInterface {
2
3    fun onClear() {}
4}

内部很简单，只有一个方式 onClear(), 用来进行数据的释放。

BridgeStore

用来做数据存储，对桥梁针对不同的 key 进行缓存。避免桥梁内部的实例多次创建。具体实现方式如下：

 1class BridgeStore {
 2
 3    private val mMap = HashMap<String, BridgeInterface>()
 4
 5    fun put(key: String, bridge: BridgeInterface) {
 6        mMap.put(key, bridge)?.onClear()
 7    }
 8
 9    fun get(key: String): BridgeInterface? = mMap[key]
10
11    fun clear() {
12        for (item in mMap.values) {
13            item.onClear()
14        }
15        mMap.clear()
16    }
17}

Factory

桥梁的实例构建工厂，默认提供通过反射的方式来实例化不同的类。Factory 接口只提供一个 create 方法，实现方式由子类自行解决

1interface Factory {
2
3    fun <T : BridgeInterface> create(bridgeClazz: Class<T>): T
4}

在AwesomeGithub中提供了通过反射方式来实例化不同类的具体实现 NewInstanceFactory

 1class NewInstanceFactory : Factory {
 2
 3    companion object {
 4        val instance: NewInstanceFactory by lazy { NewInstanceFactory() }
 5    }
 6
 7    override fun <T : BridgeInterface> create(bridgeClazz: Class<T>): T = try {
 8        bridgeClazz.newInstance()
 9    } catch (e: InstantiationException) {
10        throw RuntimeException("Cannot create an instance of $bridgeClazz", e)
11    } catch (e: IllegalAccessException) {
12        throw RuntimeException("Cannot create an instance of $bridgeClazz", e)
13    }
14
15}

Factory 的作用是通过抽象的方式来获取所需要类的实例，至于该类如何实例化，将通过 create 方法自行实现。

Provider

Provider 是提供桥梁的注册与获取各个组件暴露的接口实现。通过 register 来统一各个组件向外暴露的桥梁类，最后再通过 getBridge 来获取具体的桥梁类，然后调用所需的相关方法，最终达到组件间的数据传递。

来看下 BridgeProviders 的具体实现

 1class BridgeProviders {
 2
 3    private val mProvidersMap = HashMap<Class<*>, BridgeProvider>()
 4    private val mBridgeMap = HashMap<Class<*>, Class<*>>()
 5    private val mDefaultBridgeProvider = BridgeProvider(NewInstanceFactory.instance)
 6
 7    companion object {
 8        val instance: BridgeProviders by lazy { BridgeProviders() }
 9    }
10
11    fun <T : BridgeInterface> register(
12        clazz: Class<T>,
13        factory: Factory? = null,
14        replace: Boolean = false
15    ) = apply {
16        if (clazz.interfaces.isEmpty() || !clazz.interfaces[0].interfaces.contains(BridgeInterface::class.java)) {
17            throw RuntimeException("$clazz must implement BridgeInterface")
18        }
19        // 1. get contract interface as key, and save implement class to map value.
20        // 2. get contract interface as key, and save bridgeProvider of implement class instance
21        // to map value.
22        clazz.interfaces[0].let {
23            if (mProvidersMap[it] == null || replace) {
24                mBridgeMap[it] = clazz
25                mProvidersMap[it] = if (factory == null) {
26                    mDefaultBridgeProvider
27                } else {
28                    BridgeProvider(factory)
29                }
30            }
31        }
32    }
33
34    fun <T : BridgeInterface> getBridge(clazz: Class<T>): T {
35        mProvidersMap[clazz]?.let {
36            @Suppress("UNCHECKED_CAST")
37            return it.get(mBridgeMap[clazz] as Class<T>)
38        }
39        throw RuntimeException("$clazz subClass is not register")
40    }
41
42    fun clear() {
43        mProvidersMap.clear()
44        mBridgeMap.clear()
45        mDefaultBridgeProvider.bridgeStore.clear()
46    }
47}

每次 register 之后都会保存一个 BridgeProvider 实例，如果没有实现自定义的 Factory，将会使用默认是 mDefaultBridgeProvider，它内部使用的就是默认的 NewInstanceFactory

 1class BridgeProvider(private val factory: Factory) {
 2
 3    val bridgeStore = BridgeStore()
 4
 5    companion object {
 6        private const val DEFAULT_KEY = "com.idisfkj.awesome.componentbridge"
 7    }
 8
 9    fun <T : BridgeInterface> get(key: String, bridgeClass: Class<T>): T {
10        var componentBridge = bridgeStore.get(key)
11        if (bridgeClass.isInstance(componentBridge)) {
12            @Suppress("UNCHECKED_CAST")
13            return componentBridge as T
14        }
15        componentBridge = factory.create(bridgeClass)
16        bridgeStore.put(key, componentBridge)
17        return componentBridge
18    }
19
20    fun <T : BridgeInterface> get(bridgeClass: Class<T>): T =
21        get(DEFAULT_KEY + "@" + bridgeClass.canonicalName, bridgeClass)
22}

注册完之后就可以在任意的组件中通过调用桥梁的 getBridge 来获取组件向外暴露的方法，从而达到数据的传递。

我们来看下具体的使用示例。

AwesomeGithub 项目使用的是 Github Open Api，用到的接口基本都要 AuthorizationBasic 或者是 AccessToken，而为了让每一个组件在调用接口时都能够正常获取到 AuthorizationBasic 或者 AccessToken，所以提供了一个 AppBridge 与 AppBridgeInterface 来向外暴露这些数据，实现如下：

 1interface AppBridgeInterface: BridgeInterface {
 2
 3    /**
 4     * 获取用户的Authorization Basic
 5     */
 6    fun getAuthorizationBasic(): String?
 7
 8    fun setAuthorizationBasic(authorization: String?)
 9
10    /**
11     * 获取用户的AccessToken
12     */
13    fun getAccessToken(): String?
14
15    fun setAccessToken(accessToken: String?)
16}

 1class AppBridge : AppBridgeInterface {
 2
 3    override fun getAuthorizationBasic(): String? = App.AUTHORIZATION_BASIC
 4
 5    override fun setAuthorizationBasic(authorization: String?) {
 6        App.AUTHORIZATION_BASIC = authorization
 7    }
 8
 9    override fun getAccessToken(): String? = App.ACCESS_TOKEN
10
11    override fun setAccessToken(accessToken: String?) {
12        App.ACCESS_TOKEN = accessToken
13    }
14
15}

有了上面的桥梁接口，接下来需要做的是先在 App 主项目中进行注册

 1    private fun registerBridge() {
 2        BridgeProviders.instance.register(AppBridge::class.java, object : Factory {
 3            override fun <T : BridgeInterface> create(bridgeClazz: Class<T>): T {
 4                @Suppress("UNCHECKED_CAST")
 5                return AppBridge() as T
 6            }
 7        })
 8            .register(HomeBridge::class.java)
 9            .register(UserBridge::class.java)
10            .register(ReposBridge::class.java)
11            .register(FollowersBridge::class.java)
12            .register(FollowingBridge::class.java)
13            .register(NotificationBridge::class.java)
14            .register(SearchBridge::class.java)
15            .register(WebViewBridge::class.java)
16    }

在注册 AppBridge 时使用的是自定义的 Factory，这里只是为了简单展示自定义的 Factory 的使用，其实没有特殊需求可以与后面的 bridge 一样直接调用 regiser 进行注册。

注册完了之后就可以直接在需要的地方进行调用。首先在登录组件中将获取到的 AuthorizationBasic 或者 AccessToken 进行保存，以便被之后的组件进行调用。

以 AccessToken 为例，在 login 组件中的核心调用代码如下：

 1    fun getAccessTokenFromCode(code: String) {
 2        showLoading.value = true
 3        repository.getAccessToken(code, object : RequestCallback<Response<ResponseBody>> {
 4            override fun onSuccess(result: ResponseSuccess<Response<ResponseBody>>) {
 5                try {
 6                    appBridge.setAccessToken(
 7                        result.data?.body()?.string()?.split("=")?.get(1)?.split("&")?.get(
 8                            0
 9                        )
10                    )
11                    getUser()
12                } catch (e: IOException) {
13                    e.printStackTrace()
14                }
15            }
16
17            override fun onError(error: ResponseError) {
18                showLoading.value = false
19            }
20        })
21    }

如上所示，只需调用 appBridge.setAccessToken 将数据进行保存；而 appBridge 可以通过如下获取

1appBridge = BridgeProviders.instance.getBridge(AppBridgeInterface::class.java)

现在已经有了 AccessToken 数据，为了避免每次调用接口都手动加入 AccessToken，可以使用 okhttp 的 Interceptor，即在 network 组件中进行统一加入。

 1class GithubApiInterceptor : Interceptor {
 2
 3    override fun intercept(chain: Interceptor.Chain): Response {
 4        val request = chain.request()
 5
 6        val appBridge =
 7            BridgeProviders.instance.getBridge(AppBridgeInterface::class.java)
 8        Timber.d("intercept url %s %s %s", request.url(), appBridge.getAuthorizationBasic(), appBridge.getAccessToken())
 9
10        val builder = request.newBuilder()
11        val authorization =
12            if (!TextUtils.isEmpty(appBridge.getAuthorizationBasic())) "Basic " + appBridge.getAuthorizationBasic()
13            else "token " + appBridge.getAccessToken()
14        builder.addHeader("Authorization", authorization)
15        val response = chain.proceed(builder.build())
16        Timber.d("intercept url %s, response %s ,code %d", request.url(), response.body().toString(), response.code())
17        return response
18    }
19}

这样就完成了将 AccessToken 从 login 组件到 network 组件间的传递。

单个组件中调用

以上是主项目中集成了 login 组件，login 组件会提供 AuthorizationBasic 或者 AccessToken。那么对于单个组件(组件可以单独运行)，为了让组件单独运行时也能调通相关的接口，在调用的时候加入正确的 AuthorizationBasic 或者 AccessToken。需要提供默认的 AppBridgeInterface 实现类。我这里命名为 DefaultAppBridge

 1class DefaultAppBridge : AppBridgeInterface {
 2
 3    override fun getAuthorizationBasic(): String? = BuildConfig.AUTHORIZATION_BASIC
 4
 5    override fun setAuthorizationBasic(authorization: String?) {
 6
 7    }
 8
 9    override fun getAccessToken(): String? = BuildConfig.ACCESS_TOKEN
10
11    override fun setAccessToken(accessToken: String?) {
12
13    }
14}

里面具体的 AuthorizationBasic 与 AccessToken 值可以通过 BuildConfig 获取，而值的定义可以在 local.properities 中进行设置

1AuthorizationBasic="xxxx"
2AccessToken="xxx"

因为每个组件都会依赖与桥梁 componentbridge，所以将值配置到 componentbridge 的 build 中，具体如下：

 1android {
 2    compileSdkVersion Versions.target_sdk
 3    buildToolsVersion Versions.build_tools
 4
 5    defaultConfig {
 6        minSdkVersion Versions.min_sdk
 7        targetSdkVersion Versions.target_sdk
 8        versionCode Versions.version_code
 9        versionName Versions.version_name
10        buildConfigField "String", "AUTHORIZATION_BASIC", getProperties("AuthorizationBasic") + ""
11        buildConfigField "String", "ACCESS_TOKEN", getProperties("AccessToken") + ""
12
13        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
14
15    }
16
17    buildTypes {
18        release {
19            minifyEnabled false
20            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
21        }
22    }
23
24}

有了默认的组件桥梁实现，现在只需在对应的组件 Application 中进行注册即可。

例如项目中的 followers 组件，单独运行时使用 DefaultAppBridge 来达到接口的正常调用。

 1class FollowersApp : Application() {
 2
 3    override fun onCreate() {
 4        super.onCreate()
 5        SPUtils.init(this)
 6        initTimber()
 7        initRouter()
 8        // register bridges
 9        BridgeProviders.instance.register(DefaultAppBridge::class.java)
10            .register(DefaultWebViewBridge::class.java)
11    }
12
13    private fun initTimber() {
14        if (BuildConfig.DEBUG) {
15            Timber.plant(Timber.DebugTree())
16        }
17    }
18
19    private fun initRouter() {
20        if (BuildConfig.DEBUG) {
21            ARouter.openLog()
22            ARouter.openDebug()
23        }
24        ARouter.init(this)
25    }
26}

在组件单独运行时的 Application 中注册之后，单独运行时调用的就是 local.properities 中设置的值。即保证了组件正常单独运行。

以上是组件间数据传递的全部内容，即解决了组件间的数据传递也解决了组件单独运行时的默认数据调用问题。如需了解全部代码可以查看AwesomeGithub项目。

3.3

主项目使用组件中的 Fragment

AwesomeGithub 主页有三个 tab，分别是三个组件。这个三个组件是主页 viewpager 中的三个 fragment。前面已经说了，在主项目中不能直接调用各个组件，那么组件中的 fragment 又该如何加入到主项目中呢？

其实也很简单，可以将获取 fragment 的实例当作为组件间的数据传递的一种特殊形式。那么有了上面的组件间数据传递的基础，实现在主项目中调用组件的 fragment 也瞬间简单了许多。借助的还是桥梁 componentbridge。

下面以主页的 search 为例

SearchBridgeInterface

首先在 componentbridge 中创建 SearchBridgeInterface 接口，并且实现默认的桥梁的 BridgeInterface 接口。

1interface SearchBridgeInterface : BridgeInterface {
2
3    fun getSearchFragment(): Fragment
4}

其中就一个方法，用来向外提供 SearchFragment 的获取

接下来在 search 组件中实现 SearchBridgeInterface 的具体实现类

1class SearchBridge : SearchBridgeInterface {
2
3    override fun getSearchFragment(): Fragment = SearchFragment.getInstance()
4
5}

然后回到主项目的 Application 中进行注册

1BridgeProviders.instance.register(SearchBridge::class.java)

注册完之后，就可以在主项目的 ViewPagerAdapter 中进行获取 SearchFragment 实例

 1class MainViewPagerAdapter(fm: FragmentManager?) : FragmentPagerAdapter(fm) {
 2
 3    override fun getItem(position: Int): Fragment = when (position) {
 4        0 -> BridgeProviders.instance.getBridge(SearchBridgeInterface::class.java).getSearchFragment()
 5        1 -> BridgeProviders.instance.getBridge(NotificationBridgeInterface::class.java)
 6            .getNotificationFragment()
 7        else -> BridgeProviders.instance.getBridge(UserBridgeInterface::class.java).getUserFragment()
 8    }
 9
10    override fun getCount(): Int = 3
11}

主项目中调用组件中的 Fragment 就是这么简单，基本上与之前的数据传递时一致的。

3.4

组件间界面的跳转

有了上面的基础，可能会联想到使用处理 Fragment 方式来进行组件间页面的跳转。的确这也是一种解决方式，不过接下来要介绍的是另一种更加方便与高效的跳转方式。

项目中使用的是ARouter，它是一个帮助 App 进行组件化改造的框架，支持模块间的路由、通信与解藕。下面简单的介绍下它的使用方式。

首先需要去官网找到版本依赖，并进行导入。这里不多说，然后需要在你所有用到的模块中的 build.gradle 中添加以下配置

1kapt {
2    arguments {
3        arg("AROUTER_MODULE_NAME", project.getName())
4    }
5}

记住只要该模块需要调用 ARouter，就需要添加以上代码。配置完之后就可以开始使用。

下面我以项目中的 webview 组件为例，跳转到组件中的 WebViewActivity

上面已经将相关依赖配置好了，首先需要在 Application 中进行 ARouter 初始化

1    private fun initRouter() {
2        if (BuildConfig.DEBUG) {
3            ARouter.openLog()
4            ARouter.openDebug()
5        }
6        ARouter.init(this)
7    }

再为 WebViewActivity 进行 path 定义

1object ARouterPaths {
2    const val PATH_WEBVIEW_WEBVIEW = "/webview/webview"
3}

因为每一个 ARouter 进行路由的时候，都需要配置一个包含两级的路径，然后将定义的路径配置到 WebViewActivity 中

 1@Route(path = ARouterPaths.PATH_WEBVIEW_WEBVIEW)
 2class WebViewActivity : BaseActivity<WebviewActivityWebviewBinding, WebViewVM>() {
 3
 4    @Autowired
 5    lateinit var url: String
 6    @Autowired
 7    lateinit var requestUrl: String
 8
 9    override fun getVariableId(): Int = BR.vm
10
11    override fun getLayoutId(): Int = R.layout.webview_activity_webview
12
13    override fun getViewModelInstance(): WebViewVM = WebViewVM()
14
15    override fun getViewModelClass(): Class<WebViewVM> = WebViewVM::class.java
16
17    override fun onCreate(savedInstanceState: Bundle?) {
18        super.onCreate(savedInstanceState)
19        ARouter.getInstance().inject(this)
20        viewModel.url.value = url
21        viewModel.request(requestUrl)
22    }
23
24    override fun addObserver() {
25        super.addObserver()
26        viewModel.backClick.observe(this, Observer {
27            finish()
28        })
29    }
30
31    override fun onBackPressed() {
32        if (viewDataBinding.webView.canGoBack()) {
33            viewDataBinding.webView.goBack()
34            return
35        }
36        super.onBackPressed()
37    }
38
39}

如上所示，在进行配置时，只需在类上添加@Route 注解，然后再将定义的路径配置到 path 上。其中的@Autowired 注解代表 WebViewActivity 在使用 ARouter 进行跳转时，接收两个参数，分别为 url 与 requestUrl。

ARouter本质是解析注解，然后定位到参数，再通过原始的Intent中获取到传递过来的参数值。

有了上面的准备过程，最后剩下的就是调用 ARouter 进行页面跳转。这里为了统一调用方式，将其调加到桥梁中。

1class WebViewBridge : WebViewBridgeInterface {
2
3    override fun toWebViewActivity(context: Context, url: String, requestUrl: String) {
4        ARouter.getInstance().build(ARouterPaths.PATH_WEBVIEW_WEBVIEW).with(
5            bundleOf("url" to url, "requestUrl" to requestUrl)
6        ).navigation(context)
7    }
8
9}

前面是定义的跳转路径，后面紧接的是页面传递的参数值。剩下的就是在别的组件中调用该桥梁，例如 followers 组件中的 contentClick 点击:

 1class FollowersVHVM(private val context: Context) : BaseRecyclerVM<FollowersModel>() {
 2
 3    var data: FollowersModel? = null
 4
 5    override fun onBind(model: FollowersModel?) {
 6        data = model
 7    }
 8
 9    fun contentClick() {
10        BridgeProviders.instance.getBridge(WebViewBridgeInterface::class.java)
11            .toWebViewActivity(context, data?.html_url ?: "", "")
12    }
13}

更多ARouter的使用方式，读者可以自行查阅官方文档

在AwesomeGithub项目中，组件化过程中的主要难点与解决方案已经分析的差不多了。最后我们来聊聊组件间的解藕优化。

3.5

组件解耦

组件化本身就是对项目进行解藕，所以如果要进一步进行优化，主要是对组件间的依赖或者资源等方面进行解藕。而对于组件间的依赖，尝试过在依赖的时候使用 runtimeOnly。因为 runtimeOnly 可以避免依赖的组件在运行之前进行引用调用，它只会在项目运行时才能够正常的引用，这样就可以防止主项目中进行开发时直接引用依赖的组件。

但是，在实践的过程中，如果项目中使用了 DataBinding，此时使用 runtimeOnly 进行依赖组件，通过该方式依赖的组件在运行的过程中会出现错误。