WeiPeiYang阅读笔记（3）gradle学习以及模块化开发

导读

这篇真的不怎么会，，结构挺乱的，想到啥就写啥了

一、微北洋整体模块化设计

Q:为什么要模块化开发呢？
A:你把那一堆东西都堆到一块去看着不乱么2333

模块化开发目的

单独开发每个模块,用集成的方式把他们组合起来,就能拼出一个app

项目的结构

QQ截图20180212175712.png

app是最高一级别的模块，主要是welcomeActivity和进去以后的四个fragment
auth、bike、gpa2、schedule和library是四个小模块，分别对应一个功能需求。
common里面是widgets和network的配置等共用的东西，为上面模块的提供支持。

模块化开发的好处

1.可以每个人负责一个模块，共同开发一个项目
2.模块间解耦
3.可单独编译打包某一模块，提升开发效率

二、依赖的统一

apply plugin: 'com.android.library'
apply from: '../maven_push.gradle'

android {
    compileSdkVersion versions.compileSdk
    buildToolsVersion versions.buildTools

    defaultConfig {
        minSdkVersion versions.minSdk
        targetSdkVersion versions.targetSdk
        versionCode 1
        versionName '1.0'

        testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'

    }

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

        signingConfigs {
            debug {
                storeFile file('debug.keystore')
                storePassword 'android'
                keyAlias 'androiddebugkey'
                keyPassword 'android'
            }
        }
    }

    configurations.all {
        resolutionStrategy {
            force 'com.google.code.findbugs:jsr305:3.0.1'
        }
    }

    compileOptions {
        targetCompatibility 1.8
        sourceCompatibility 1.8
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    testImplementation 'junit:junit:4.12'
    androidTestImplementation('com.android.support.test.espresso:espresso-core:3.0.1', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })

    [*supportLibraries].each {
        implementation dependenciesMap[it]
    }


    api 'com.github.bumptech.glide:glide:3.8.0'

    api 'io.reactivex:rxjava:1.3.0'

    api 'com.trello:rxlifecycle:1.0'
    api 'com.trello:rxlifecycle-components:1.0'

    api 'com.squareup.retrofit2:retrofit:2.3.0'
    api 'com.squareup.retrofit2:converter-gson:2.3.0'
    api 'com.squareup.retrofit2:adapter-rxjava:2.3.0'

    api 'com.squareup.okhttp3:okhttp:3.9.0'
    api 'com.squareup.okhttp3:logging-interceptor:3.9.0'

    api 'com.github.VictorAlbertos.RxCache:runtime:1.7.0-1.x'
    api 'com.github.VictorAlbertos.Jolyglot:gson:0.0.3'

    api 'commons-codec:commons-codec:1.11'

    api 'com.orhanobut:logger:1.15'
    api 'com.orhanobut:hawk:2.0.1'

    api 'com.tencent.bugly:crashreport_upgrade:1.3.1'

    api 'com.annimon:stream:1.1.4'

    api 'com.tapadoo.android:alerter:1.0.3'

    api 'com.github.GrenderG:Toasty:1.2.3'

    api 'com.github.piasy:BigImageViewer:1.3.2'
    api 'com.github.piasy:GlideImageLoader:1.3.2'
    api 'com.github.piasy:ProgressPieIndicator:1.3.2'

//    compile files('libs/SocialSDK_QQ_Simplify.jar')
//    compile files('libs/SocialSDK_Sina_Simplify.jar')
//    compile files('libs/SocialSDK_WeChat_Simplify.jar')
//    compile files('libs/umeng_social_api.jar')
//    compile files('libs/umeng_social_net.jar')
//    compile files('libs/umeng_social_tool.jar')

}

观察了一下，common是最底下一层基础组件层的module，所以它的依赖也非常的多。而且它依赖的声明语法是api，于是上网搜了一下api和implementation的区别：
api相当于之前的compile
api具有依赖传递性，当一个模块依赖于另一个模块时，后者用api声明的依赖在前者也被声明了。
implementation不具有依赖的传递性，因此，它编译的速度比api要快。
而在需要用到commons模块里面东西的模块，也都写了如下代码对commons模块进行依赖

 implementation project(':commons')

所以在某个模块所需的依赖中，对于在commons模块中用到的依赖，用这句话就代替了，在commons模块中没有声明的依赖，再进行单独的声明。与此同时，该模块可以访问到commons模块中的类和属性等

emmm模块化开发肯定是多人进行，采取模块化开发就肯定会用到多个Library，如何处理每个人的版本统一问题呢？

ext.kotlin_version = '1.2.21'

    ext {
        versions = [
                minSdk      : 19,
                targetSdk   : 27,
                compileSdk  : 27,
                buildTools  : '27.0.2',
                support     : '27.0.2',
                kotlin      : '1.2.21',
                anko        : '0.10.1',
                butterknife : '8.5.1',
                retrolambda : '3.7.0',
        ]

        dependenciesMap = [
                'mvvmkit'              : 'com.twt.service:mvvmkit:1.2.0',
                'commons'              : 'com.twt.service:commons:1.2.0',
                'network'              : 'com.twt.service:network:1.0.1',
                'news'                 : 'com.twt.service:news:1.1.0',
                'fragmentation'        : 'com.twt.service:fragmentation:1.1.0',
                'circleprogress'       : 'com.twt.service:circleprogress:1.0.0',
                'tjulibrary'           : 'com.twt.service:tjulibrary:1.1.0',
                'one'                  : 'com.twt.service:one:1.0.0',
                'yellowpages'          : 'com.twt.service:yellowpages:1.0.0',
                'auth'                 : 'com.twt.service:auth:1.1.0',
                'schedule'             : 'com.twt.service:schedule:1.0.0',
                'party'                : 'com.twt.service:party:1.0.0',
                'gpa'                  : 'com.twt.service:gpa:1.1.1-SNAPSHOT',
                'bike'                 : 'com.twt.service:bike:1.1.0',
                'classroom'            : 'com.twt.service:classroom:1.0.0',
                'classroomquery'       : 'com.twt.service:classroomquery:1.0.0',
                'fellowsearch'         : 'com.twt.service:fellowsearch:1.0.0',
                'lostfound'            : 'com.twt.service:lostfound:1.0.1',

                'support-v4'           : "com.android.support:support-v4:${versions.support}",
                'appcompat-v7'         : "com.android.support:appcompat-v7:${versions.support}",
                'recyclerview-v7'      : "com.android.support:recyclerview-v7:${versions.support}",
                'cardview-v7'          : "com.android.support:cardview-v7:${versions.support}",
                'design'               : "com.android.support:design:${versions.support}",

                'multidex'             : 'com.android.support:multidex:1.0.2',
                'constraint-layout'    : 'com.android.support.constraint:constraint-layout:1.0.2',

                'lifecycle-extensions' : 'android.arch.lifecycle:extensions:1.1.0',
                'lifecycle-compiler'   : 'android.arch.lifecycle:compiler:1.1.0',

                'kotlin-stdlib'        : "org.jetbrains.kotlin:kotlin-stdlib-jre7:${versions.kotlin}",
                'anko-coroutines'      : "org.jetbrains.anko:anko-coroutines:${versions.anko}",

                'butterknife'          : "com.jakewharton:butterknife:${versions.butterknife}",
                'butterknife-compiler' : "com.jakewharton:butterknife-compiler:${versions.butterknife}",
        ]

在Project下的gradle添加如上代码，再在后面进行相关操作即可统一
如果以后有版本变动，在这里修改一次即可

以app模块的依赖为例

...
android {
    compileSdkVersion versions.compileSdk
    buildToolsVersion versions.buildTools

    defaultConfig {
        minSdkVersion versions.minSdk
        targetSdkVersion versions.targetSdk
        ...
        }
        ...
        }

        ...
    }

    ...
dependencies {
    ...
    [':auth', ':bike', ':commons', ':gpa2', ':schedule', ':tjulibrary'].each {
        implementation project(it)
    }
    implementation 'com.twt.service:fragmentation:1.1.0'

    [*supportLibraries, 'constraint-layout', 'multidex', *archLibraries, 'kotlin-stdlib', 'butterknife'].each {
        implementation dependenciesMap[it]
    }
    ['lifecycle-compiler', 'butterknife-compiler'].each {
        annotationProcessor dependenciesMap[it]
    }

    ...
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

}
...

各种version的设置用versions.(versionType)访问得到

    compileSdkVersion versions.compileSdk
    buildToolsVersion versions.buildTools

    defaultConfig {
        minSdkVersion versions.minSdk
        targetSdkVersion versions.targetSdk
        ...
        }

在dependencies中添加对各个模块和各个Library的依赖

    [':auth', ':bike', ':commons', ':gpa2', ':schedule', ':tjulibrary'].each {
        implementation project(it)
    }
[*supportLibraries, 'constraint-layout', 'multidex', *archLibraries, 'kotlin-stdlib', 'butterknife'].each     
   {
        implementation dependenciesMap[it]
    }

三、implementation的好处

implementation不会向外部暴露其依赖的 module 内容。

就比如我更改了微北洋common模块的一个依赖
如果我用的是compile（api），该操作会修改外部接口，那么common模块和所有依赖于common模块的模块都需要重新编译
如果我用的是implementation，该操作只会让Gradle对common进行重新编译。所以，我们可以为特定 module 选择 implementation 关键字来加快 gradle 构建速度。