组件化一、组件化结构搭建_Android

组件化的配置，我们还是通过build.gradle文件来配置

一、config.gradle创建

创建config.gradle文件，并且使用变量 isRelease = true来判断到底是
将不同的Module单独打包测试，还是最终的发布版本（集成到一个apk）

ext {
    // 定义一个项目全局变量isRelease，用于动态切换：组件化模式 / 集成化模式
    // false: 组件化模式（子模块可以独立运行），true ：集成化模式（打包整个项目apk，子模块不可独立运行）
    isRelease = true

    // 建立Map存储，对象名、key可以自定义
    androidId = [
            compileSdkVersion: 29,
            buildToolsVersion: "29.0.2",
            minSdkVersion    : 19,
            targetSdkVersion : 29,
            versionCode      : 1,
            versionName      : "1.0"
    ]

    appId = [
            "app"     : "com.dh.componentproject",
            "order"   : "com.dh.componentproject.order",
            "personal": "com.dh.componentproject.personal"
    ]

    url = [
            "debug"  : "https://11.22.33.44/debug",
            "release": "https://55.66.77.88/release"
    ]

    appcompatVersion = "1.2.0"
    dependencies = [
            // ${appcompatVersion}表示引用一个变量
            "appcompat"       : "androidx.appcompat:appcompat:${appcompatVersion}",
            "constraintlayout": "androidx.constraintlayout:constraintlayout:2.0.1"
    ]
}

在Project的build.gradle文件中引入config.gradle的配置

// 非常重要，根目录的build.gradle头部加入自定义gradle，相当于layout布局中include
apply from: "config.gradle"

二、组件化配置

在其他Module中的配置

如果是正式发版，需要将Module打包成Library集成为一个apk

if (isRelease) {
    apply plugin: 'com.android.library'
} else {
    apply plugin: 'com.android.application'
}

在App Module中配置

如果是发布版本，就将Module编译为Library，并且引入App Module中

if (isRelease) {
        implementation project(":order")
        implementation project(":personal")
}

三、创建一个Common的Library，处理共有的操作

处理不同Module之间Activity的跳转，通过startActivity跳转

1、通过直接写全类名跳转

// 直接写全类名，但是容易出错
Class<?> aClass = Class.forName("com.dh.order.OrderMainActivity");
jumpActivity(aClass);

 private void jumpActivity(Class<?> clazz) {
        Intent intent = new Intent(this, clazz);
        intent.putExtra("key", "value");
        startActivity(intent);
    }

2、引入第二种方式，通过Map集合来保存需要实现跳转的Activity

2.1、创建一个保存需要跳转的Activity的实体类

/**
 * @author 86351
 * @date 2020/9/17
 * @description 路径对象（公共基础库中，所有子模块都可以调用）
 * path : ”order/OrderMainActivity”
 * clazz : OrderMainActivity.class
 */
public class PathBean {
    private String path;
    private Class clazz;

    public PathBean() {
    }

    public PathBean(String path, Class clazz) {
        this.path = path;
        this.clazz = clazz;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }
}

2.2、创建一个工具类来保存需要跳转的Activity

package com.dh.common_library;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 86351
 * @date 2020/9/17
 * @description 全局路径记录器（根据子模块分组）
 */
public class RecordPathManager {
    // key:"order"组     value:order子模块下，对应所有的Activity路径信息
    private static Map<String, List<PathBean>> groupMap = new HashMap<>();

    /**
     * 将路径信息加入Map
     *
     * @param groupName 组名 如：order
     * @param pathName  路径名 如：OrderMainActivity
     * @param clazz     类对象 如：OrderMainActivity.class
     */
    public static void joinGroup(String groupName, String pathName, Class<?> clazz) {
        List<PathBean> list = groupMap.get(groupName);
        if (list == null) {
            list = new ArrayList<>();
            list.add(new PathBean(pathName, clazz));
            groupMap.put(groupName, list);
        } else {
            for (PathBean pathBean : list) {
                if (!pathName.equals(pathBean.getPath())) {
                    list.add(new PathBean(pathName, clazz));
                    groupMap.put(groupName, list);
                }
            }
        }
    }

    /**
     * 根据组名和路径名，获取类对象
     *
     * @param groupName 组名
     * @param pathName 路径名
     * @return 返回目标类
     */
    public static Class<?> getTargetClass(String groupName, String pathName) {
        List<PathBean> list = groupMap.get(groupName);
        if (list == null) return null;
        for (PathBean pathBean : list) {
            if (pathName.equalsIgnoreCase(pathBean.getPath())) {
                return pathBean.getClazz();
            }
        }
        return null;
    }
}

2.3、在BaseApplication来实现Activity的保存

public class BaseAppApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // 如果Activity很多，我们手动这么添加太累
        RecordPathManager.joinGroup(RecordPathConstants.GROUP_APP, RecordPathConstants.MainActivity, MainActivity.class);
        RecordPathManager.joinGroup(RecordPathConstants.GROUP_ORDER, RecordPathConstants.OrderMainActivity, OrderMainActivity.class);
        RecordPathManager.joinGroup(RecordPathConstants.GROUP_PERSONAL, RecordPathConstants.PersonalMainActivity, PersonalMainActivity.class);
    }
}

2.4、实现跳转的代码，直接从保存的Map集合中取出需要跳转到的某一个Activity类名，这样就比写全类名好很多，保证更低的出错率

Class<?> targetClass = RecordPathManager.getTargetClass(
                        RecordPathConstants.GROUP_PERSONAL,
                        RecordPathConstants.PersonalMainActivity);
jumpActivity(targetClass);