Android组件化开发实践和案例分享

时间  2020-01-05
标签 android 组件 开发 实践 案例 分享 栏目 Android 繁體版
原文   原文链接

目录介绍

  • 1.为何要组件化php

    • 1.1 为何要组件化
    • 1.2 现阶段遇到的问题

  • 2.组件化的概念java

    • 2.1 什么是组件化
    • 2.2 区分模块化与组件化
    • 2.3 组件化优点好处
    • 2.4 区分组件化和插件化
    • 2.5 application和library

  • 3.建立组件化框架android

    • 3.1 传统APP架构图
    • 3.2 组件化须要考虑问题
    • 3.3 架构设计图
    • 3.4 组件通讯是经过路由转发
    • 3.5 解决考虑问题
    • 3.6 业务组件的生命周期
    • 3.7 Fragment通讯难点

  • 4.实际开发案例git

    • 4.1 组件化实践的开源项目
    • 4.1 如何建立模块
    • 4.2 如何创建依赖
    • 4.3 如何统一配置文件
    • 4.4 组件化的基础库
    • 4.5 组件模式和集成模式如何切换
    • 4.6 组件化解决重复依赖
    • 4.7 组件化注意要点
    • 4.8 组件化时资源名冲突
    • 4.9 组件化开发遇到问题

  • 5.组件间通讯程序员

    • 5.1 选择那个开源路由库
    • 5.2 阿里Arouter基础原理
    • 5.3 使用Arouter注意事项

  • 6.关于其余github

    • 6.1 参考博客连接
    • 6.2 个人博客介绍
    • 6.3 开源项目地址

1.为何要组件化

1.1 为何要组件化

  • APP迭代维护成本增高sql

    • 投资界，新芽，项目工厂等APP自身在飞速发展，版本不断迭代，新功能不断增长，业务模块数量不断增长，业务上的处理逻辑越变越复杂，同时每一个模块代码也变得愈来愈多，这就引起一个问题，所维护的代码成本愈来愈高，稍微一改动可能就牵一发而动全身，改个小的功能点就须要回归整个APP测试，这就对开发和维护带来很大的挑战。

  • 多人组合须要组件化数据库

    • APP 架构方式是单一工程模式，业务规模扩大，随之带来的是团队规模扩大，那就涉及到多人协做问题，每一个移动端软件开发人员势必要熟悉如此之多代码，若是不按照必定的模块组件机制去划分，将很难进行多人协做开发，随着单一项目变大，并且Andorid项目在编译代码方面就会变得很是卡顿，在单一工程代码耦合严重，每修改一处代码后都须要从新编译打包测试，致使很是耗时。

1.2 现阶段遇到的问题

  • 结合投资界，新芽客户端分析segmentfault

    • 代码量膨胀，不利于维护，不利于新功能的开发。项目工程构建速度慢，在一些电脑上写两句代码，从新编译整个项目，测试的话编译速度起码 10-20 分钟，有的甚至更长。
    • 不一样模块之间代码耦合严重，有时候修改一处代码而牵动许多模块。每一个模块之间都有引用第三方库，但有些第三方库版本不一致，致使打包APP时候代码冗余，容易引发版本冲突。
    • 现有项目基于之前其余人项目基础上开发，经手的人次过多，存在着不一样的代码风格，项目中代码规范乱，相似的功能写法却不同，致使不统一。

2.组件化的概念

2.1 什么是组件化

  • 什么是组件化呢？api

    • 组件（Component）是对数据和方法的简单封装，功能单一，高内聚，而且是业务能划分的最小粒度。
    • 组件化是基于组件可重用的目的上，将一个大的软件系统按照分离关注点的形式，拆分红多个独立的组件，使得整个软件系统也作到电路板同样，是单个或多个组件元件组装起来，哪一个组件坏了，整个系统可继续运行，而不出现崩溃或不正常现象，作到更少的耦合和更高的内聚。

2.2 区分模块化与组件化

  • 模块化

    • 模块化就是将一个程序按照其功能作拆分，分红相互独立的模块，以便于每一个模块只包含与其功能相关的内容，模块咱们相对熟悉,好比登陆功能能够是一个模块,搜索功能能够是一个模块等等。

  • 组件化

    • 组件化就是更关注可复用性，更注重关注点分离，若是从集合角度来看的话，能够说每每一个模块包含了一个或多个组件，或者说模块是一个容器，由组件组装而成。简单来讲，组件化相比模块化粒度更小，二者的本质思想都是一致的，都是把大往小的方向拆分，都是为了复用和解耦，只不过模块化更加侧重于业务功能的划分，偏向于复用，组件化更加侧重于单一功能的内聚，偏向于解耦。

2.3 组件化优点好处

  • 简单来讲就是提升工做效率，解放生产力，好处以下：

    • 1.提升编译速度，从而提升并行开发效率。

      • 问题：那么如何提升编译速度的呢？组件化框架可使模块单独编译调试，能够有效地减小编译的时间。

    • 2.稳定的公共模块采用依赖库方式

      • 提供给各个业务线使用，减小重复开发和维护工做量。代码简洁，冗余量少，维护方便，易扩展新功能。

    • 3.每一个组件有本身独立的版本，能够独立编译、测试、打包和部署。

      • 针对开发程序员多的公司，组件化颇有必要，每一个人负责本身的模块，能够较少提交代码冲突。
      • 为新业务随时集成提供了基础，全部业务可上可下，灵活多变。
      • 各业务线研发能够互不干扰、提高协做效率，并控制产品质量。
    • 4.避免模块之间的交叉依赖，作到低耦合、高内聚。

    • 5.引用的第三方库代码统一管理，避免版本统一，减小引入冗余库。

      • 这个能够建立一个公共的gradle管理的文件，好比一个项目有十几个组件，想要改下某个库或者版本号，总不至于一个个修改吧。这个时候提取公共十分有必要
    • 6.定制项目可按需加载，组件之间能够灵活组建，快速生成不一样类型的定制产品。

2.4 区分组件化和插件化

  • 组件化和插件化的区别

    • 组件化不是插件化，插件化是在【运行时】，而组件化是在【编译时】。换句话说，插件化是基于多APK的，而组件化本质上仍是只有一个 APK。
    • 组件化和插件化的最大区别（应该也是惟一区别）就是组件化在运行时不具有动态添加和修改组件的功能，可是插件化是能够的。

  • 组件化的目标

    • 组件化的目标之一就是下降总体工程（app）与组件的依赖关系，缺乏任何一个组件都是能够存在并正常运行的。app主工程具备和组件进行绑定和解绑的功能。

2.5 application和library

  • 在studio中，对两种module进行区分，以下所示

    • 一种是基础库library，好比常见第三方库都是lib，这些代码被其余组件直接引用。
    • 另外一种是application，也称之为Component，这种module是一个完整的功能模块。好比分享module就是一个Component。
    • 为了方便，统一把library称之为依赖库，而把Component称之为组件，下面所讲的组件化也主要是针对Component这种类型。

  • 在项目的build.gradle文件中

    //控制组件模式和集成模式
if (rootProject.ext.isDouBanApplication) {
    //是Component，能够独立运行
    apply plugin: 'com.android.application'
} else {
    //是lib，被依赖
    apply plugin: 'com.android.library'
}

3.建立组件化框架

3.1 传统APP架构图

  • 传统APP架构图

    • 如图所示，从网上摘来的……
    • image

  • 存在的问题

    • 广泛使用的 Android APP 技术架构，每每是在一个界面中存在大量的业务逻辑，而业务逻辑中充斥着各类网络请求、数据操做等行为，整个项目中也没有模块的概念，只有简单的以业务逻辑划分的文件夹，而且业务之间也是直接相互调用、高度耦合在一块儿的。单一工程模型下的业务关系，总的来讲就是：你中有我，我中有你，相互依赖，没法分离。以下图：
    • image

3.2 组件化须要考虑问题

  • 考虑的问题

  • 分而治之，并行开发，一切皆组件。要实现组件化，不管采用什么样的技术方式，须要考虑如下七个方面问题：

    • 代码解耦。

      • 如何将一个庞大的工程分红有机的总体？这个须要一步步来了！
      • 对已存在的项目进行模块拆分，模块分为两种类型，一种是功能组件模块，封装一些公共的方法服务等，做为依赖库对外提供；另外一种是业务组件模块，专门处理业务逻辑等功能，这些业务组件模块最终负责组装APP。

    • 组件单独运行。

      • 由于每一个组件都是高度内聚的，是一个完整的总体，如何让其单独运行和调试？
      • 经过 Gradle脚本配置方式，进行不一样环境切换，我本身操做是添加一个boolean值的开关。好比只须要把 Apply plugin: 'com.android.library' 切换成Apply plugin: 'com.android.application' 就能够独立运行呢！
      • 须要注意：当切换到application独立运行时，须要在AndroidManifest清单文件上进行设置，由于一个单独调试须要有一个入口的Activity。

    • 组件间通讯。

      • 因为每一个组件具体实现细节都互相不了解，但每一个组件都须要给其余调用方提供服务，那么主项目与组件、组件与组件之间如何通讯就变成关键？
      • 这个我是直接用阿里开源的路由框架，固然你能够根据须要选择其余大厂的开源路由库。引用阿里的ARouter框架，经过注解方式进行页面跳转。

    • 组件生命周期。

      • 这里的生命周期指的是组件在应用中存在的时间，组件是否能够作到按需、动态使用、所以就会涉及到组件加载、卸载等管理问题。

    • 集成调试。

      • 在开发阶段如何作到按需编译组件？一次调试中可能有一两个组件参与集成，这样编译时间就会大大下降，提升开发效率。

    • 代码隔离。

      • 组件之间的交互若是仍是直接引用的话，那么组件之间根本没有作到解耦，如何从根本上避免组件之间的直接引用？目前作法是主项目和业务组件都会依赖公共基础组件库，业务组件经过路由服务依赖库按需进行查找，用于不一样组件之间的通讯。
    • 告别结构臃肿，让各个业务变得相对独立，业务组件在组件模式下能够独立开发，而在集成模式下又能够变为AAR包集成到“APP壳工程”中，组成一个完整功能的 APP。

3.3 架构设计图

  • 组件化架构图

    • 业务组件之间是独立的，互相没有关联，这些业务组件在集成模式下是一个个 Library，被 APP 壳工程所依赖，组成一个具备完整业务功能的 APP 应用，可是在组件开发模式下，业务组件又变成了一个个Application，它们能够独立开发和调试，因为在组件开发模式下，业务组件们的代码量相比于完整的项目差了很远，所以在运行时能够显著减小编译时间。
    • image

3.4 组件通讯是经过路由转发

  • 传统之前工程下模块

    • 记得刚开始进入Android开发工做时，只有一个app主工程，后期几乎全部的需求都写在这个app主工程里面。只有简单的以业务逻辑划分的文件夹，而且业务之间也是直接相互调用、高度耦合在一块儿的。
    • 致使后期改项目为组件化的时候十分痛苦，不一样模块之间的业务逻辑实在关联太多，但仍是没办法，因而目录4步骤一步步实践。终极目标是，告别结构臃肿，让各个业务变得相对独立，业务组件在组件模式下能够独立开发。

  • 组件化模式下如何通讯

    • 这是组件化工程模型下的业务关系，业务之间将再也不直接引用和依赖，而是经过“路由”这样一个中转站间接产生联系。在这个开源项目中，我使用的阿里开源的路由框架。关于Arouter基础使用和代码分析，能够看我这篇博客：Arouter使用与代码解析
    • image

3.6 业务组件的生命周期

  • 按照理想状态的来看待的话

    • 各个业务组件之间没有任何依赖关系，这时咱们能够把每一个独立的业务组件当作一个可运行的app，因此业务组件的生命周期和应与独立的app保持一致。

3.7 Fragment通讯难点

  • 在网上看到不少博客说，如何拆分组件，按模块拆分，或者按照功能拆分。但不多有提到fragment在拆分组件时的疑问，这个让我很奇怪。
  • 先来讲一个业务需求，好比一个购物商城app，有4个模块，作法通常是一个activity+4个fragment，这个你们都很熟悉，这四个模块分别是：首页，发现，购物车，个人。而后这几个页面是用fragment写的，共用一个宿主activity，那么在作组件化的时候，我想把它按照业务拆分红首页，发现，购物车和个人四个独立的业务模块。

  • 遇到疑问：

    • 若是是拆分红四个独立的业务模块，那么对应的fragment确定要放到对应的组件中，那么这样操做，当主工程与该业务组件解绑的状况下，如何拿到fragment和传递参数进行通讯。
    • Fragment 中 开启Activity带requestCode，开启的Activity关闭后,不会回调Fragment中的onActivityResult。只会调用Fragment 所在Activity的onActivityResult。
    • 多fragment单activity拦截器无论用，难道只能用于拦截activity的跳转？那若是是要实现登陆拦截的话，那不是只能在PathReplaceService中进行了？

  • 网络解决办法

    • 第一个疑问：因为我使用阿里路由，因此我看到zhi1ong大佬说：用Router跳转到这个Activity，而后带一个参数进去，比方说tab=2，而后本身在onCreate里面自行切换。但后来尝试，仍是想问问广大程序员有没有更好的办法。
    • 第二个疑问：仍是zhi1ong大佬说，经过广播，或者在Activity中转发这个事件，比方说让Fragment统一依赖一个接口，而后在Activity中转发。

4.实际开发案例

4.1 组件化实践的开源项目

  • 关于组件化开发一点感想

    • 关于网上有许多关于组件化的博客，讲解了什么是组件化，为什么要组件化，以及组件化的好处。大多数文章提供了组件化的思路，给我着手组件化开发提供了大量的便利。感谢前辈大神的分享！虽然有一些收获，可是不多有文章可以给出一个总体且有效的方案，或者一个具体的Demo。
    • 可是毕竟看博客也是为了实践作准备，当着手将以前的开源案例改版成组件化案例时，出现了大量的问题，也解决了一些问题。主要是学些了组件化开发流程。
    • 大多数公司慢慢着手组件化开发，在小公司，有的人因为以前没有作过组件化开发，尝试组件化也是挺好的；在大公司，有的人一去只是负责某个模块，可能刚开始组件化已经有人弄好了，那学习实践组件化那更快一些。业余实践，改版以前开源项目，写了这篇博客，耗费我很多时间，要是对你有些帮助，那我就很开心呢。因为我也是个小人物，因此写的很差，勿喷，欢迎提出建议！

  • 关于组件化开源项目

    • 项目总体架构模式采用：组件化+MVP+Rx+Retrofit+design+Dagger2+VLayout+X5
    • 包含的模块：wanAndroid【kotlin】+干货集中营+知乎日报+番茄Todo+精选新闻+豆瓣音乐电影小说+小说读书+简易记事本+搞笑视频+经典游戏+其余更多等等
    • 此项目属于业余时间练手的项目，接口数据来源均来自网络，若是存在侵权状况，请第一时间告知。本项目仅作学习交流使用，API数据内容全部权归原做公司全部，请勿用于其余用途。
    • 关于开源组件化的项目地址：https://github.com/yangchong2...

4.1 如何建立模块

  • 根据3.3 架构设计图能够知道

  • 主工程：

    • 除了一些全局配置和主 Activity 以外，不包含任何业务代码。有的也叫作空壳app，主要是依赖业务组件进行运行。

  • 业务组件：

    • 最上层的业务，每一个组件表示一条完整的业务线，彼此之间互相独立。原则上来讲：各个业务组件之间不能有直接依赖！全部的业务组件均须要能够作到独立运行的效果。对于测试的时候，须要依赖多个业务组件的功能进行集成测试的时候。可使用app壳进行多组件依赖管理运行。
    • 该案例中分为：干活集中营，玩Android，知乎日报，微信新闻，头条新闻，搞笑视频，百度音乐，个人记事本，豆瓣音乐读书电影，游戏组件等等。

  • 功能组件：

    • 该案例中分为，分享组件，评论反馈组件，支付组件，画廊组件等等。同时注意，可能会涉及多个业务组件对某个功能组件进行依赖！

  • 基础组件：

    • 支撑上层业务组件运行的基础业务服务。此部分组件为上层业务组件提供基本的功能支持。
    • 该案例中：在基础组件库中主要有，网络请求，图片加载，通讯机制，工具类，分享功能，支付功能等等。固然，我把一些公共第三方库放到了这个基础组件中！

4.2 如何创建依赖

  • 关于工程中组件依赖结构图以下所示

    • image

  • 业务模块下完整配置代码

    //控制组件模式和集成模式
if (rootProject.ext.isGankApplication) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

android {
    compileSdkVersion rootProject.ext.android["compileSdkVersion"]
    buildToolsVersion rootProject.ext.android["buildToolsVersion"]


    defaultConfig {
        minSdkVersion rootProject.ext.android["minSdkVersion"]
        targetSdkVersion rootProject.ext.android["targetSdkVersion"]
        versionCode rootProject.ext.android["versionCode"]
        versionName rootProject.ext.android["versionName"]

        if (rootProject.ext.isGankApplication){
            //组件模式下设置applicationId
            applicationId "com.ycbjie.gank"
        }
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }

    //jdk1.8
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    sourceSets {
        main {
            if (rootProject.ext.isGankApplication) {
                manifest.srcFile 'src/main/module/AndroidManifest.xml'
            } else {
                manifest.srcFile 'src/main/AndroidManifest.xml'
            }
            jniLibs.srcDirs = ['libs']
        }
    }

}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation project(':library')
    annotationProcessor rootProject.ext.dependencies["router-compiler"]
}

4.3 如何统一配置文件

  • 因为组件化实践中模块比较多，所以配置gradle，添加依赖库时，须要考虑简化工做。那么究竟如何作呢？

  • 第一步，首先在项目根目录下建立一个yc.gradle文件。实际开发中只须要更改该文件中版本信息便可。

    • 我在网上看到的绝大多数案例，都是经过一个开关控件组件模式和集成模式的切换，可是这里我配置了多个组件的开关，分别控制对应的组件切换状态。
    ext {

    isApplication = false  //false:做为Lib组件存在， true:做为application存在
    isAndroidApplication = false  //玩Android模块开关，false:做为Lib组件存在， true:做为application存在
    isLoveApplication = false  //爱意表达模块开关，false:做为Lib组件存在， true:做为application存在
    isVideoApplication = false  //视频模块开关，false:做为Lib组件存在， true:做为application存在
    isNoteApplication = false  //记事本模块开关，false:做为Lib组件存在， true:做为application存在
    isBookApplication = false  //book模块开关，false:做为Lib组件存在， true:做为application存在
    isDouBanApplication = false  //豆瓣模块开关，false:做为Lib组件存在， true:做为application存在
    isGankApplication = false  //干货模块开关，false:做为Lib组件存在， true:做为application存在
    isMusicApplication = false  //音乐模块开关，false:做为Lib组件存在， true:做为application存在
    isNewsApplication = false  //新闻模块开关，false:做为Lib组件存在， true:做为application存在
    isToDoApplication = false  //todo模块开关，false:做为Lib组件存在， true:做为application存在
    isZhiHuApplication = false  //知乎模块开关，false:做为Lib组件存在， true:做为application存在
    isOtherApplication = false  //其余模块开关，false:做为Lib组件存在， true:做为application存在
    
    android = [
               compileSdkVersion       : 28,
               buildToolsVersion       : "28.0.3",
               minSdkVersion           : 17,
               targetSdkVersion        : 28,
               versionCode             : 22,
               versionName             : "1.8.2"    //必须是int或者float，不然影响线上升级
    ]

    version = [
               androidSupportSdkVersion: "28.0.0",
               retrofitSdkVersion      : "2.4.0",
               glideSdkVersion         : "4.8.0",
               canarySdkVersion        : "1.5.4",
               constraintVersion       : "1.0.2"
    ]

    dependencies = [
                //support
                "appcompat-v7"             : "com.android.support:appcompat-v7:${version["androidSupportSdkVersion"]}",
                "multidex"                 : "com.android.support:multidex:1.0.1",
                //network
                "retrofit"                 : "com.squareup.retrofit2:retrofit:${version["retrofitSdkVersion"]}",
                "retrofit-converter-gson"  : "com.squareup.retrofit2:converter-gson:${version["retrofitSdkVersion"]}",
                "retrofit-adapter-rxjava"  : "com.squareup.retrofit2:adapter-rxjava2:${version["retrofitSdkVersion"]}",
                //这里省略一部分代码
        ]
}

  • 第二步，而后在项目中的lib【注意这里是放到基础组件库的build.gradle】中添加代码，以下所示

    apply plugin: 'com.android.library'

android {
    compileSdkVersion rootProject.ext.android["compileSdkVersion"]
    buildToolsVersion rootProject.ext.android["buildToolsVersion"]


    defaultConfig {
        minSdkVersion rootProject.ext.android["minSdkVersion"]
        targetSdkVersion rootProject.ext.android["targetSdkVersion"]
        versionCode rootProject.ext.android["versionCode"]
        versionName rootProject.ext.android["versionName"]
    }
}


dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    api rootProject.ext.dependencies["appcompat-v7"]
    api rootProject.ext.dependencies["design"]
    api rootProject.ext.dependencies["palette"]
    api rootProject.ext.dependencies["glide"]
    api (rootProject.ext.dependencies["glide-transformations"]){
        exclude module: 'glide'
    }
    annotationProcessor rootProject.ext.dependencies["glide-compiler"]
    api files('libs/tbs_sdk_thirdapp_v3.2.0.jar')
    api "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    
    //省略部分代码
}

  • 第三步，在其余model中添加依赖

    • implementation project(':library')便可。

4.4 组件化的基础库

  • 基础库组件封装

    • 基础库组件封装库中主要包括开发经常使用的一些框架。能够直接看个人项目更加直观！
    • 一、网络请求(采用Retrofit+RxJava框架)，拦截器
    • 二、图片加载(策略模式，Glide与Picasso之间能够切换)
    • 三、通讯机制（RxBus），路由ARouter简单封装工具类(不一样model之间通讯)
    • 四、mvp框架，经常使用的base类，好比BaseActivity，BaseFragment等等
    • 五、通用的工具类，好比切割圆角，动画工具类等等
    • 六、自定义view(包括对话框，ToolBar布局，圆形图片等view的自定义)
    • 七、共有的shape，drawable，layout，color等资源文件
    • 八、全局初始化异步线程池封装库，各个组件都可以用到

  • 组件初始化

    • 好比，你将该案例中的新闻组件切换成独立运行的app，那么因为新闻跳转详情页须要使用到x5的WebView，所以须要对它进行初始化。最刚开始作法是，为每个能够切换成app的组件配置一个独立的application，而后初始化一些该组件须要初始化的任务。可是这么作，有一点很差，不是很方便管理。后来看了知乎组件化实践方案后，该方案提出，开发了一套多线程初始化框架，每一个组件只要新建若干个启动 Task 类，并在 Task 中声明依赖关系。可是具体怎么用到代码中后期有待实现！

  • 如何简化不熟悉组件化的人快速适应组件独立运行

    • 设置多个组件开关，须要切换那个组件就改那个。若是设置一个开关，要么把全部组件切成集成模式，要么把全部组件切成组件模式，有点容易出问题。更多能够往下看！

  • 严格限制公共基础组件的增加

    • 随着开发不断进行，要注意不要往基础公共组件加入太多内容。而是应该减少体积！假若是基础组件过于庞大，那么运行组件也是比较缓慢的！

4.5 组件模式和集成模式如何切换

  • 在玩Android组件下的build.gradle文件，其余组件相似。

    • 经过一个开关来控制这个状态的切换，module若是是一个库，会使用com.android.library插件；若是是一个应用，则使用com.android.application插件
    //控制组件模式和集成模式
if (rootProject.ext.isAndroidApplication) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

  • 集成模式以下所示

    • 首先须要在yc.gradle文件中设置 isApplication=false。Sync下后，发现该组件是library
    ext {
    isAndroidApplication = false  //false:做为Lib组件存在， true:做为application存在

  • 组件模式以下所示

    • 首先须要在yc.gradle文件中设置 isApplication=true。Sync下后，发现该组件是application，便可针对模块进行运行
    ext {
    isAndroidApplication = true  //false:做为Lib组件存在， true:做为application存在

  • 须要注意的地方，这个很重要

    • 首先看看网上绝大多数的做法，很是感谢这些大神的无私奉献！可是我以为多个组件用一个开关控制也能够，可是sourceSets里面切换成组件app时，能够直接不用下面这么麻烦，能够复用java和res文件。

      • image
    • 接下来看看个人作法：
    • 下面这个配置十分重要。也就是说当该玩Android组件从library切换到application时，因为能够做为独立app运行，因此序意设置applicationId，而且配置清单文件，以下所示！
    • 在 library 和 application 之间切换，manifest文件也须要提供两套
    android {
    defaultConfig {
        if (rootProject.ext.isAndroidApplication){
            //组件模式下设置applicationId
            applicationId "com.ycbjie.android"
        }
    }
    sourceSets {
        main {
            if (rootProject.ext.isAndroidApplication) {
                manifest.srcFile 'src/main/module/AndroidManifest.xml'
            } else {
                manifest.srcFile 'src/main/AndroidManifest.xml'
            }
            jniLibs.srcDirs = ['libs']
        }
    }
}
    • 具体在项目中以下所示
    • image

4.6 组件化解决重复依赖

  • 重复依赖问题说明

    • 重复依赖问题其实在开发中常常会遇到，好比项目 implementation 了一个A，而后在这个库里面又 implementation 了一个B，而后你的工程中又 implementation 了一个一样的B，就依赖了两次。
    • 默认状况下，若是是 aar 依赖，gradle 会自动帮咱们找出新版本的库而抛弃旧版本的重复依赖。可是若是使用的是project依赖，gradle并不会去去重，最后打包就会出现代码中有重复的类了。

  • 解决办法，举个例子

    api(rootProject.ext.dependencies["logger"]) { 
    exclude module: 'support-v4'//根据组件名排除 
    exclude group: 'android.support.v4'//根据包名排除 
}

4.7 组件化注意要点

  • 业务组件之间联动致使耦合严重

    • 好比，实际开发中，购物车和首页商品分别是两个组件。可是遇到产品需求，好比过节作个活动，发个购物券之类的需求，因为购物车和商品详情页都有活动，所以会形成组件常常会发生联动。假若前期准备不足，随着时间的推移，各个业务线的代码边界会像组件化以前的主工程同样逐渐劣化，耦合会愈来愈严重。
    • 第一种解决方式：使用 sourceSets 的方式将不一样的业务代码放到不一样的文件夹，可是 sourceSets 的问题在于，它并不能限制各个 sourceSet 之间互相引用，因此这种方式并不太友好！
    • 第二种解决方式：抽取需求为工具类，经过不一样组件传值而达到调用关系，这样只须要改工具类便可改需求。可是这种只是符合需求同样，可是用在不一样模块的场景。

  • 组件化开发之数据库分离

    • 好比，我如今开发的视频模块想要给别人用，因为缓存之类须要用到数据库，难道还要把这个lib还得依赖一个体积较大的第三方数据库？可是使用系统原生sql数据库又不太方便，怎么办？暂时我也没找到办法……

4.8 组件化时资源名冲突

  • 资源名冲突有哪些？

    • 好比，color，shape，drawable，图片资源，布局资源，或者anim资源等等，都有可能形成资源名称冲突。这是为什么了，有时候你们负责不一样的模块，若是不是按照统一规范命名，则会偶发出现该问题。
    • 尤为是若是string， color，dimens这些资源分布在了代码的各个角落，一个个去拆，很是繁琐。其实大可没必要这么作。由于android在build时，会进行资源的merge和shrink。res/values下的各个文件（styles.xml需注意）最后都只会把用到的放到intermediate/res/merged/../valus.xml，无用的都会自动删除。而且最后咱们可使用lint来自动删除。因此这个地方不要耗费太多的时间。

  • 解决办法

    • 这个问题也不是新问题了，第三方SDK基本都会遇到，能够经过设置 resourcePrefix 来避免。设置了这个值后，你全部的资源名必须以指定的字符串作前缀，不然会报错。可是 resourcePrefix 这个值只能限定 xml 里面的资源，并不能限定图片资源，全部图片资源仍然须要你手动去修改资源名。

  • 我的建议

    • 将color，shape等放到基础库组件中，由于全部的业务组件都会依赖基础组件库。在styles.xml需注意，写属性名字的时候，必定要加上前缀限定词。假如说不加的话，有可能会在打包成aar后给其余模块使用的时候，会出现属性名名字重复的冲突，为何呢？由于BezelImageView这个名字根本不会出如今intermediate/res/merged/../valus.xml里， 因此不要觉得这是属性的限定词！

4.9 组件化开发遇到问题

  • 如何作到各个组件化模块能获取到全局上下文

    • 情景再现

      • 好比，刚开始线上项目是在app主工程里建立的单利，那么在lib中或者后期划分的组件化，是没法拿到主工程的application类中的上下文。这个时候能够

    • 解决办法

      • 很容易，在lib里写一个Utils工具类，而后在主工程application中初始化Utils.init(this)，这样就能够在lib和全部业务组件[已经依赖公共基础组件库]中拿到全局上下文呢！

  • butterKnife使用问题

    • 尽管网上有很多博客说能够解决butterKnife在不一样组件之间的引用。可是我在实际开发时，遇到组件模式和集成模式切换状态时，致使出现编译错误问题。要是那位在组件化中解决butterKnife引用问题，能够告诉我，很是感谢！

  • 当组件化是lib时

    • 不能使用switch（R.id.xx）,须要使用if..else来代替。

  • 不要乱发bus消息

    • 若是项目中大量的使用eventbus，那么会看到一个类中有大量的onEventMainThread()方法，写起来很爽，阅读起来很痛苦。
    • 虽说，前期使用EventBus或者RxBus发送消息来实现组件间通讯十分方便和简单，可是随着业务增大，和后期不断更新，有的还通过多个程序员前先后后修改，会使代码阅读量下降。项目中发送这个Event的地方很是多，接收这个Event的地方也不少。在后期想要改进为组件化开发，而进行代码拆分时，都不敢轻举妄动，生怕哪些事件没有被接收。

  • 页面跳转存在问题

    • 若是一个页面须要登录状态才能够查看，那么会写if（isLogin()）{//跳转页面}else{//跳转到登陆页面}，每次操做都要写这些个相同的逻辑。
    • 原生startActivity跳转，没法监听到跳转的状态，好比跳转错误，成功，异常等问题。
    • 后时候，后台会控制从点击按钮【不一样场景下】跳转到不一样的页面，假如后台配置信息错误，或者少了参数，那么跳转可能不成功或者致使崩溃，这个也没有一个好的处理机制。
    • 阿里推出的开源框架Arouter，即可以解决页面跳转问题，能够添加拦截，或者即便后台配置参数错误，当监听到跳转异常或者跳转错误时的状态，能够直接默认跳转到首页。我在该开源案例就是这么作的！

  • 关于跳转参数问题

    • 先来看一下这种代码写法，这种写法本没有问题，只是在多人开发时，若是别人想要跳转到你开发模块的某个页面，那么就容易传错值。建议将key这个值，写成静态常量，放到一个专门的类中。方便本身，也方便他人。

      //跳转
intent.setClass(this,CommentActivity.class);
intent.putExtra("id",id);
intent.putExtra("allNum",allNum);
intent.putExtra("shortNum",shortNum);
intent.putExtra("longNum",longNum);
startActivity(intent);


//接收
Intent intent = getIntent();
int allNum = intent.getExtras().getInt("allNum");
int shortNum = intent.getExtras().getInt("shortNum");
int longNum = intent.getExtras().getInt("longNum");
int id = intent.getExtras().getInt("id");

5.组件间通讯

5.1 选择那个开源路由库

  • 比较有表明性的组件化开源框架有获得获得DDComponentForAndroid、阿里Arouter、聚美Router 等等。

    • 获得DDComponentForAndroid：一套完整有效的android组件化方案，支持组件的组件彻底隔离、单独调试、集成调试、组件交互、UI跳转、动态加载卸载等功能。
    • 阿里Arouter：对页面、服务提供路由功能的中间件，简单且够用好用，网上的使用介绍博客也不少，在该组件化案例中，我就是使用这个。
    • Router：一款单品、组件化、插件化全支持的路由框架

5.2 阿里Arouter基础原理

  • 这里只是说一下基础的思路

    • 在代码里加入的@Route注解，会在编译时期经过apt生成一些存储path和activityClass映射关系的类文件，而后app进程启动的时候会拿到这些类文件，把保存这些映射关系的数据读到内存里(保存在map里)，而后在进行路由跳转的时候，经过build()方法传入要到达页面的路由地址。

      • 添加@Route注解而后编译一下，就能够生成这个类，而后看一下这个类。以下所示：
      /**
 * DO NOT EDIT THIS FILE!!! IT WAS GENERATED BY AROUTER. */
public class ARouter$$Group$$video implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/video/VideoActivity", RouteMeta.build(RouteType.ACTIVITY, VideoActivity.class, "/video/videoactivity", "video", null, -1, -2147483648));
  }
}

    • ARouter会经过它本身存储的路由表找到路由地址对应的Activity.class(activity.class = map.get(path))，而后new Intent()，当调用ARouter的withString()方法它的内部会调用intent.putExtra(String name, String value)，调用navigation()方法，它的内部会调用startActivity(intent)进行跳转，这样即可以实现两个相互没有依赖的module顺利的启动对方的Activity了。

      • 看_ARouter类中的 _navigation方法代码，在345行。
      private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
    final Context currentContext = null == context ? mContext : context;

    switch (postcard.getType()) {
        case ACTIVITY:
            // Build intent
            final Intent intent = new Intent(currentContext, postcard.getDestination());
            intent.putExtras(postcard.getExtras());

            // Set flags.
            int flags = postcard.getFlags();
            if (-1 != flags) {
                intent.setFlags(flags);
            } else if (!(currentContext instanceof Activity)) {    // Non activity, need less one flag.
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            }

            // Set Actions
            String action = postcard.getAction();
            if (!TextUtils.isEmpty(action)) {
                intent.setAction(action);
            }

            // Navigation in main looper.
            runInMainThread(new Runnable() {
                @Override
                public void run() {
                    startActivity(requestCode, currentContext, intent, postcard, callback);
                }
            });

            break;
        case PROVIDER:
            //这里省略代码
        case BOARDCAST:
        case CONTENT_PROVIDER:
        case FRAGMENT:
            //这里省略代码
        case METHOD:
        case SERVICE:
        default:
            return null;
    }
    return null;
}

5.3 使用Arouter注意事项

  • 使用阿里路由抽取工具类，方便后期维护！

    • 首先看一下网络上有一种写法。

      //首先经过注解添加下面代码
@Route(path = "/test/TestActivity")
public class TestActivity extends BaseActivity {

}

//跳转
ARouter.getInstance().inject("/test/TestActivity");

    • 优化后的写法

      • 下面这种作法，是方便后期维护。
      //存放全部的路由路径常量
public class ARouterConstant {
    //跳转到视频页面
    public static final String ACTIVITY_VIDEO_VIDEO = "/video/VideoActivity";
    //省略部分diamagnetic
}

//存放全部的路由跳转，工具类
public class ARouterUtils {
    /**
     * 简单的跳转页面
     * @param string                string目标界面对应的路径
     */
    public static void navigation(String string){
        if (string==null){
            return;
        }
        ARouter.getInstance().build(string).navigation();
    }
}

//调用
@Route(path = ARouterConstant.ACTIVITY_VIDEO_VIDEO)
public class VideoActivity extends BaseActivity {

}
ARouterUtils.navigation(ARouterConstant.ACTIVITY_VIDEO_VIDEO);

06.关于其余内容介绍

6.1 关于博客汇总连接

6.1 参考博客连接

6.2 关于个人博客

6.3 开源项目地址

组件化实践项目开源地址：https://github.com/yangchong2...
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程