Android组件化：stitch框架

时间 2019-11-16

原文原文链接

以前的文章【Android组件化开发框架】从总体上分析了要搭建一个组件化框架的技术原理。归纳性的对组件化进行了简单的分析。java

stitch 是在项目实践过程当中结合以前的理论进行完善后组织起来的框架。它完成了组件生命周期、页面路由、数据路由的基本功能，框架源码里也包含了搭建组件化可能须要的脚本示例。android

框架包含3个部分：组件生命周期管理、页面交互、数据交互。咱们依次对其进行解析。git

依赖

//AS 3.0以前使用
compile 'bamboo.component:stitcher:1.0'
//AS 3.0以后建议使用
implementation 'bamboo.component:stitcher:1.0'
复制代码

组件生命周期管理

每一个组件至关于1个Module，许多组件的业务是须要在App启动时进行初始化的，好比运营商支付sdk基本都须要在Application的onCreate方法中进行初始化。github

stitch 框架采用手动配置的方式，组件将本身注入到stitch 框架中，主工程再经过stitch框架对组件生命周期进行统一管理。bash

具体使用方法：app

1. 继承ComponentApplication

public abstract class ComponentApplication {
    //Application对象注入
    public void setApplication(Application application)； //控制组件的初始化顺序，参看ComponentPriority public int level();

    //代理Application的OnCreate方法
    public void onCreate();

    //延迟初始化生命周期，用来注入页面以及数据交互接口
    public void onCreateDelay(ComponentRouterRegistry routerRegistry, ActivityRouterRegistry activityRouterRegistry)； //代理Application的attachBaseContext方法 public void attachBaseContext(Context baseContext) ;

    //代理Application的onTrimMemory方法
    public void onTrimMemory(int level) ;

    //代理Application的onConfigurationChanged方法
    public void onConfigurationChanged(Configuration newConfig);

    //代理Application的onLowMemory方法
    public void onLowMemory();
}
复制代码

ComponentApplication是组件生命周期的代理类，代理了Application的经常使用关键方法。若是组件在App启动时进行某些初始化或须要监听生命周期，经过ComponentApplication便可实现。框架

2. 在Module的AndroidManifest.xml中进行配置

<application>
        ...
        <meta-data
            android:name="bamboo.sample.account.component.AccountComponentApp"
            android:value="ComponentApplication" />
    </application>
复制代码

特别要注意：meta-data的value是ComponentApplication，name才是咱们module的代理Application类。不要搞反了。组件化

3. 主工程里面的自定义Application修改

在主工程Application里面咱们须要主动调用组件的代理Application的方法，stitcher提供了两种方式：gradle

1. 直接继承StitcherApplicationui

public class MainApplication extends StitcherApplication {
}
复制代码

2. 经过StitcherHelper调用组件的生命周期。 参考StitcherApplication。

public class StitcherApplication{
    public void onCreate() {
        super.onCreate();
        StitcherHelper.onCreate();
    }

    public void onCreateDelay() {
        StitcherHelper.onCreateDelay();
    }

    public void attachBaseContext(Context baseContext) {
        super.attachBaseContext(baseContext);
        StitcherHelper.init(this);
        StitcherHelper.attachBaseContext(baseContext);
    }

    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        StitcherHelper. onTrimMemory(level);
    }

    public void onLowMemory() {
        super.onLowMemory();
        StitcherHelper.onLowMemory();
    }

    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        StitcherHelper.onConfigurationChanged(newConfig);
    }
}
复制代码

经过上面几步，就能对组件的生命周期进行管理。

在使用页面交互以及数据交互以前咱们先思考一个问题，这个问题是：

组件之间不能互相依赖，那若是要获取数据，咱们就必需要借助于第三方Module进行中转。咱们要怎么设计这个Module更方便呢？

没错，咱们确实须要一个额外的Module来作交互中转，也就是路由Module，若是以开发人员的角度来看，这个Module应该要具有如下几个因素： 1.方便Module管理本身的接口。 2.其余Module最好能实时看到咱们的修改。

因此在介绍交互功能以前，咱们须要先来实现这个路由Module的配置。

公用路由Module配置

1. 建立一个Module：sampleouter

2. 修改sampleouter的build.gradle文件，在里面加入如下代码：

这一步的目的是为了把全部Module的projectDir的router文件夹都加入到sampleouter的源码文件夹中，这样一来，咱们就能在本身的Module的router文件夹内管理本身对外公开的接口以及页面。

android {
    ...
    sourceSets {
        main {
            //将全部module里的router文件夹都做为路由module的源码文件夹，方便Module开发时的方便
            ArrayList<String> strings = new ArrayList<String>()
            File[] modules = rootDir.listFiles(new FileFilter() {
                boolean accept(File pathname) {
                    return (pathname.isDirectory()
                            && pathname.name != "gradle"
                            && pathname.name != "build"
                            && !pathname.name.startsWith("."))
                }
            })
            for (File f : modules) {
                strings.add(f.absolutePath + File.separator + "router")
            }
            //不要忘了把原始的源码目录添加进来
            strings.addAll(java.srcDirs)
            java.srcDirs = strings
        }
    }
}
复制代码

配置完后，点一下refresh按钮，在Module里面建立router文件夹你会看到这样的效果。

3.在Module中配置samplerouter的依赖

implementation 'bamboo.component:stitcher:1.0'
    implementation project(":samplerouter")
复制代码

OK，sampleouter Module就配置好了，如今咱们继续看页面交互要怎么实现。

页面交互

咱们在讲述组件的生命周期管理时，可能你已经看到了组件生命周期代理类内有一个方法

//延迟初始化生命周期，用来注入页面以及数据交互接口
    public void onCreateDelay(ComponentRouterRegistry routerRegistry, ActivityRouterRegistry activityRouterRegistry)；
复制代码

其中ActivityRouterRegistry就是咱们进行页面交互的注册表，咱们只须要将咱们须要公开的页面注入到这里面就能够进行交互了。具体的实现步骤：

1. 在router文件夹里建立一个TaskInfoPage.class并继承ActivityPage

package bamboo.sample.tasksrouter;

//每一个对外公开的页面都对应一个ActivityPage的子类
public class TaskInfoPage extends ActivityPage {
    public final String taskId;
    public TaskInfoPage(Context context, String taskId) {
        super(context);
        this.taskId = taskId;
    }
}
复制代码

2. 建立一个TasksPageConsumer.class

public class TasksPageConsumer {
    //这个方法将会与TaskInfoPage进行链接。
    //全部的TaskInfoPage的页面交互请求都会最终调用到该方法中。
    public void consume(TaskInfoPage page) {
        Intent intent = new Intent(page.context, TaskInfoActivity.class);
        intent.putExtra("TaskInfoPage", page);
        page.context.startActivity(intent);
    }
}
复制代码

3. 在Module的ComponentApplication实现类中注册

public class TasksComponentApp extends ComponentApplication {

    public void onCreateDelay(ComponentRouterRegistry routerRegistry, ActivityRouterRegistry activityRouterRegistry) {
        //将TasksPageConsumer注入到页面路由注册表中
        activityRouterRegistry.regiest(new TasksPageConsumer());
    }
复制代码

4. 交互调用

//在须要调用TaskInfoPage的地方经过StitcherHelper使用
StitcherHelper.start(new TaskInfoPage(this, "taskId"));
StitcherHelper.start(new TaskInfoPage(this, "taskId"),1000/*requestCode*/);
复制代码

5. 更简单的使用方式(PageConsumer注解)

实际上咱们还有简单的方式进行页面注入，为何我要先说常规模式呢？由于若是万一简单的方式没办法知足你的需求的时候，你依然须要使用常规方式进行开发。

咱们在继承实现ActivityPage时，还能够经过PageConsumer直接配置Activity或Action来进行Activity<->ActivityPage的链接。

@PageConsumer(clasz = "bamboo.sample.tasks.ui.TaskCountActivity")
public class TaskListPage extends ActivityPage {
    public TaskListPage(Context context) {
        super(context);
    }
}
复制代码

这种方式是不须要在TaskPageConsumer中注册的，框架会自动搜索。

6. 特殊Intent参数配置

在页面交互时咱们有时会须要对Intent设置Flag，或须要经过Action或Data方式进行交互，这个时候咱们能够经过ActivityPage的targetIntent进行传递，并暂时关闭ActivityPage的链接，stitch会在这种状况下放弃PageConsumer注解中class的参数连接，直接尝试启动Activity。

public void onActionTest(View view) {
        ActionTestPage page = new ActionTestPage(this);
        Intent targetIntent = new Intent();
        targetIntent.setAction("bamboo.sample.actiontest");
        targetIntent.addCategory(Intent.CATEGORY_DEFAULT);
        page.setTargetIntent(targetIntent);
        page.setAutoLink(false);
        StitcherHelper.start(page);
    }
复制代码

优先级： TaskPageConsumer > unAutolink > PageConsumer

数据交互

组件之间的数据交互与页面交互原理是类似的。在onCreateDelay方法中的ComponentRouterRegistry就是数据交互的路由注册表，咱们经过它来进行注册。具体使用参看如下步骤：

1.在router文件夹定义Module的ComponentOutput

package bamboo.sample.tasksrouter;
public interface ITaskComponent extends ComponentOutput{
    int getTaskCount();
}
复制代码

2. 在Module 实现该接口

public class TasksComponentOutput implements ITaskComponent {
    public int getTaskCount() {
        return 1000;
    }
复制代码

3. 在onCreateDelay方法中进行注册

public class TasksComponentApp extends ComponentApplication {

    public void onCreateDelay(ComponentRouterRegistry routerRegistry, ActivityRouterRegistry activityRouterRegistry) {
        //将TasksComponentOutput注入到数据路由注册表中
        routerRegistry.regiest(registerComponentOutput，new TasksPageConsumer());
    }
}
复制代码

4.使用

public class ComponentInput {
    public int getTaskCount() {
        ITaskComponent taskComponent = StitcherHelper.searchComponentOutput(ITaskComponent.class);
        return taskComponent == null ? -1 : taskComponent.getTaskCount();
    }
}

复制代码

具体的数据交互流程入下图：

到这里，stitcher的使用方式就介绍完了。

组件化脚本配置请看：Android组件化：build.gradle配置

组件化基本概念请看：Android组件化开发框架

详细示例请移步： stitch 源码及示例

欢迎你们转发及使用。