王学岗移动架构16————组件化(一)

(上)

一：android Library可以打包为jar和aar,java library只能打包为jar

二：模块化，组件化，与插件化的区别

模块化：根据不同的关注点，将一个项目的可以共享的部分抽取出来，形成独立的Module，这就是模块化。模块化不只包含公共部分，当然也可以是业务模块。比如：图片加载模块
组件化：组件化是建立在模块化思想上的一次演进，一个变种。组件化本来就是模块化的概念。核心是模块角色的可转化换性，在打包时，是library；调试时，时application。组件化的单位是组件
插件化：严格意义来讲，其实也算是模块化的观念。将一个完整的工程，按业务划分为不同的插件，来化整为零，相互配合。插件化的单位是apk(一个完成的应用)。可以实现apk 的动态加载，动态更新，比组件化更灵活。
组件化在编译时，插件化在运行时。

三：组件化在gradle中的配置

1，简介: gradle 是一个构建工具。负责管理项目依赖，组织项目结构，完成项目构建的工作。基于Groovy语言（Groovy是一种基于JVM的敏捷开发语言，可以简单的理解为强类型语言java的弱类型版本）。
2，build.gradle // 构建脚本文件，主要的构建配置都在这里写
gradle // 存放gradle wrapper 执行配置和工具的文件夹，
gradlew // gradle wrapper 执行脚本文件，用来在没有安装 gradle 的情况下执行 gradle 命令。当然，第一次执行时会下载 gradle。
gradlew.bat // gradle wrapper 执行脚本文件的 windows 版
settings.gradle // 项目配置，指明根项目名字和引入的 module
3，config.gradle配置工程下所有module配置

ext {  //extend
    // false: 组件模式
    // true ：集成模式
    isModule = false
    android = [
            compileSdkVersion: 28,
            minSdkVersion    : 15,
            targetSdkVersion : 28,
            versionCode      : 1,
            versionName      : "1.0"
    ]

    appId = ["app"  : "com.dn_alan.myapplication",
             "module1": "com.dn_alan.module1",
             "module2" : "com.dn_alan.module2" ]

    supportLibrary = "28.0.0"
    dependencies = [
            "appcompat-v7"     : "com.android.support:appcompat-v7:${supportLibrary}",
    ]
}

在项目的build.gradle中进行配置

// Top-level build file where you can add configuration options common to all sub-projects/modules.

//相当于引入头文件 将 config中的内容引入进来
apply from: "config.gradle"



buildscript {
    repositories {
        google()
        jcenter()
        
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.0'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        google()
        jcenter()
        
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
}

在app的build.gradle中使用

apply plugin: 'com.android.application'

//赋值与引用
def cfg = rootProject.ext.android
def appId = rootProject.ext.appId

android {
    compileSdkVersion cfg.compileSdkVersion
    defaultConfig {
        applicationId appId["app"]
        minSdkVersion cfg.minSdkVersion
        targetSdkVersion cfg.targetSdkVersion
        versionCode cfg.versionCode
        versionName cfg.versionName
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [moduleName: project.getName()]
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'

    annotationProcessor project(':router_compiler')
    implementation project(':base')

    if (isModule){
        implementation project(':module2')
        implementation project(':module1')
    }

}

isModel这里，如果不明白就看下modul2的gradle。

//根据isModule标签动态的切换 集成/组件模式
if (isModule){
    apply plugin: 'com.android.library'
}else{
    apply plugin: 'com.android.application'
}

def cfg = rootProject.ext.android
def appId = rootProject.ext.appId

android {
    compileSdkVersion cfg.compileSdkVersion


    defaultConfig {
        minSdkVersion cfg.minSdkVersion
        targetSdkVersion cfg.targetSdkVersion
        versionCode cfg.versionCode
        versionName cfg.versionName

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [ moduleName : project.getName() ]
            }
        }

        //添加一条 boolean类型的变量
        buildConfigField("boolean","isModule",String.valueOf(isModule))

        //组件模式下
        if (!isModule){
            applicationId appId['module2']
        }

        //资源配置
        sourceSets{
            main{
                //在组件模式下 使用不同的manifest文件
                if(!isModule){
                    manifest.srcFile 'src/main/module/AndroidManifest.xml'
                    java.srcDirs 'src/main/module/java','src/main/java'

                }else{
                    manifest.srcFile 'src/main/AndroidManifest.xml'
                }
            }
        }

    }

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

}

dependencies {
    implementation 'com.android.support:appcompat-v7:28.0.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'

    annotationProcessor project(':router_compiler')
    implementation project(':base')
}

注意module2添加了app与library的切换，所以module2有两个AndroidManifest，一个有main入口，一个没有。
我们把module的build.gradle中也贴出来

apply plugin: 'com.android.library'

def cfg = rootProject.ext.android
def appId = rootProject.ext.appId

android {
    compileSdkVersion cfg.compileSdkVersion
    defaultConfig {
        minSdkVersion cfg.minSdkVersion
        targetSdkVersion cfg.targetSdkVersion
        versionCode cfg.versionCode
        versionName cfg.versionName

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [ moduleName : project.getName() ]
            }
        }
    }

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

}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'com.android.support:appcompat-v7:28.0.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'

    annotationProcessor project(':router_compiler')
    implementation project(':base')
}

module1并没有添加module2的依赖，但依然可以跳转，是因为我们在这里用到了路由。
路由会用到注解处理器和javapoet代码生成器

(下)

我们创建router_compiler（注解处理器） 和router_annotation (注解模块)两个module,两个module都是java library
给router_compiler添加依赖router_annotation

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation project(path: ':router_annotation')
}

sourceCompatibility = "7"
targetCompatibility = "7"

在router_annotation中创建两个注释

package com.example.router_annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author writing
 * @time 2019/10/28 17:33
 * @note
 */
@Target(ElementType.TYPE)//表示注解作用域是一个类
@Retention(RetentionPolicy.CLASS)//注解存在的时间，这里表示编译时候
public @interface Route {
    //路由的路径，标识路由的节点
    String path();
    //将路由节点进行分组，可以实现按组动态加载
    //注意default，有default的时候在注入使用的地方可以为空，没有的话必须传参
    String group() default "";
}

package com.example.router_annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author writing
 * @time 2019/10/28 17:43
 * @note
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.CLASS)//编译时
public @interface Extra {
    String name() default "";
}

在router_compiler中，引入如下的夹包

   implementation 'com.google.auto.service:auto-service:1.0-rc4'

创建类RouterProcessor 继承类AbstractProcessor，
在app的build.gradle文件中添加router_compiler的依赖

implementation project(':router_annotation')
annotationProcessor project(':router_compiler')

注意：要去掉path，因为要使用javaport