Android-AppLifecycleMgr

Project Url: houjinyun/Android-AppLifecycleMgr
Introduction: 在 Android 应用组件化开发中，每个组件都有自己的类似 Application 的生命周期，如何通过 APT、gradle 插件来自动化注册
More: Author   ReportBugs   
Tags:

1. 前言

前面有一章讲过组件生命周期管理，参见Android 组件化开发实践（五）：组件生命周期管理。之前只是为了讲解组件生命周期的概念，以及这样做的原因，但是这样实施过程中，会发现在壳工程里会出现很多硬编码，如果你引入的一个组件里有实现 BaseAppLike 的类，那么你就得在壳工程的 Application.onCreate()方法里手动实例化该类，如果你删除一个类似的组件，同样你也得删除与之相应的代码。这显然是不灵活的，因为这要求壳工程的维护者必须知道，该工程引入的组件里有多少类是实现了 BaseAppLike 的，如果忘记一个或若干个，应用就可能出现问题。所以我们现在的目标就是，怎么去自动识别所有组件的 BaseAppLike 类，增加或删除组件时，不用修改任何代码。

2. 实现的思路

那么应用运行时怎么去识别所有实现了 BaseAppLike 的类，先讲讲我自己的思路，思路理清了之后我们再一步步去技术实现。

初步思路：

  1. 定义一个注解来标识实现了 BaseAppLike 的类。
  2. 通过 APT 技术，在组件编译时扫描和处理前面定义的注解，生成一个 BaseAppLike 的代理类，姑且称之为 BaseAppLikeProxy，所有的代理类都在同一个包名下，这个包名下必须只包含代理类，且类名由固定的规则来生成，保证不同组件生成的代理类的类名不会重复。
  3. 需要有一个组件生命周期管理类，初始化时能扫描到固定包名下有多少个类文件，以及类文件的名称，这个固定包名就是前面我们生成的 BaseAppLikeProxy 的包名，代理类都放在同一个包名下，是为了通过包名找到我们所有的目标类。
  4. 组件集成后在应用的 Application.onCreate()方法里，调用组件生命周期管理类的初始化方法。
  5. 组件生命周期管理类的内部，扫描到所有的 BaseAppLikeProxy 类名之后，通过反射进行类实例化。

初步技术难点：

  1. 需要了解 APT 技术，怎么在编译时动态生成 java 代码；
  2. 应用在运行时，怎么能扫描到某个包名下有多少个 class，以及他们的名称呢；

更进一步的思考： 前面的思路里，应用在运行时，可能需要扫描所有的 class，然后通过 class 文件的包名来判断是不是我们的目标类，但是我们的要用到的可能只有几个，这显然效率是不高的。能不能在运行时，不扫描所有 class 文件，就已经知道了所有的 BaseAppLikeProxy 类名呢？首先想到的就是采用 gradle 插件技术，在应用打包编译时，动态插入字节码来实现。这里又会碰到几个技术难点：

  1. 怎么制作 gradle 插件。
  2. 怎么在打包时动态插入字节码。

3. 从 0 开始实现

接下来我们按照步骤来一步步实现，碰到问题就解决问题，看怎么来实现组件生命周期自动注册管理。这里面用到的技术会有：APT、groovy 语言、gradle 插件技术、ASM 动态生成字节码，平时我们开发应用时一般不需要了解这些，所以会有一定的难度。

3.1 注解定义

在 Android Studio 中，新建一个 Java Library module，我命名为 lifecycle-annotation，在该 module 中创建一个注解类，同时创建一个后面要生成代理类的相关配置，如下图所示：

相关代码如下：

//注解类，只能用来对类进行注解
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface AppLifeCycle {
}

public class LifeCycleConfig {

    /**
     * 要生成的代理类的包名，该包名下不要有其他不相关的业务类
     */
    public static final String PROXY_CLASS_PACKAGE_NAME = "com.hm.iou.lifecycle.apt.proxy";

    /**
     * 生成代理类统一的后缀
     */
    public static final String PROXY_CLASS_SUFFIX = "$$Proxy";

    /**
     * 生成代理类统一的前缀
     */
    public static final String PROXY_CLASS_PREFIX = "Heima$$";

}
3.2 重新定义 IAppLike 接口

新建一个 Android Library module，命名为 lifecycle-api，在这个 module 里定义 IAppLike 接口，以及一个生命周期管理类。

为了生成代理类，我们这里定义了一个接口 IAppLike，组件只需实现该接口即可，同时定义了一个组件生命周期管理类 AppLifeCycleManager，该类负责加载应用内所有实现了 IAppLike 的类。

public interface IAppLike {

    int MAX_PRIORITY = 10;
    int MIN_PRIORITY = 1;
    int NORM_PRIORITY = 5;

    int getPriority();
    void onCreate(Context context);
    void onTerminate();
}

再来看看生命周期管理类，逻辑很简单，通过一个 List 来存储所有的 IAppLike，初始化时会根据优先级排序：

public class AppLifeCycleManager {

    private static List<IAppLike> APP_LIKE_LIST = new ArrayList<>();

    /**
     * 注册 IAppLike 类
     */
    public static void registerAppLike(IAppLike appLike) {
        APP_LIKE_LIST.add(appLike);
    }

    /**
     * 初始化，需要在 Application.onCreate()里调用
     *
     * @param context
     */
    public static void init(Context context) {
        Collections.sort(APP_LIKE_LIST, new AppLikeComparator());
        for (IAppLike appLike : APP_LIKE_LIST) {
            appLike.onCreate(context);
        }
    }

    public static void terminate() {
        for (IAppLike appLike : APP_LIKE_LIST) {
            appLike.onTerminate();
        }
    }

    /**
     * 优先级比较器，优先级大的排在前面
     */
    static class AppLikeComparator implements Comparator<IAppLike> {

        @Override
        public int compare(IAppLike o1, IAppLike o2) {
            int p1 = o1.getPriority();
            int p2 = o2.getPriority();
            return p2 - p1;
        }
    }

}
3.3 使用 APT 来生成 IAppLike 的代理类

新建一个 Java Library module，命名为 lifecycle-apt，在该 module 里实现我们自己的注解处理器。

在 build.gradle 里修改配置为：

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    //这是谷歌提供的一个自动服务注册框架，需要用到
    implementation 'com.google.auto.service:auto-service:1.0-rc2'
    implementation project(':lifecycle-annotation')
}

sourceCompatibility = "1.7"
targetCompatibility = "1.7"

接下来就是实现我们自己的注解处理器了，工程结构如下图所示：

主要代码如下，代码逻辑加在注释里：

//核心的注解处理类，在这里我们可以扫描源代码里所有的注解，找到我们需要的注解，然后做出相应处理
@AutoService(Processor.class)
public class AppLikeProcessor extends AbstractProcessor {

    private Elements mElementUtils;
    private Map<String, AppLikeProxyClassCreator> mMap = new HashMap<>();

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        mElementUtils = processingEnvironment.getElementUtils();
    }

    /**
     * 返回该注解处理器要解析的注解
     *
     * @return
     */
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> set = new LinkedHashSet<>();
        //返回注解类的全限定类名，我们这里要识别的注解类是 AppLifeCycle
        set.add(AppLifeCycle.class.getCanonicalName());
        return set;
    }

    //支持的源代码 java 版本号
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.RELEASE_7;
    }

    //所有逻辑都在这里完成
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        //这里返回所有使用了 AppLifeCycle 注解的元素
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(AppLifeCycle.class);
        mMap.clear();
        //遍历所有使用了该注解的元素
        for (Element element : elements) {
            //如果该注解不是用在类上面，直接抛出异常，该注解用在方法、字段等上面，我们是不支持的
            if (!element.getKind().isClass()) {
                throw new RuntimeException("Annotation AppLifeCycle can only be used in class.");
            }
            //强制转换为 TypeElement，也就是类元素，可以获取使用该注解的类的相关信息
            TypeElement typeElement = (TypeElement) element;

            //这里检查一下，使用了该注解的类，同时必须要实现 com.hm.lifecycle.api.IAppLike 接口，否则会报错，因为我们要实现一个代理类
            List<? extends TypeMirror> mirrorList = typeElement.getInterfaces();
            if (mirrorList.isEmpty()) {
                throw new RuntimeException(typeElement.getQualifiedName() + " must implements interface com.hm.lifecycle.api.IAppLike");
            }
            boolean checkInterfaceFlag = false;
            for (TypeMirror mirror : mirrorList) {
                if ("com.hm.lifecycle.api.IAppLike".equals(mirror.toString())) {
                    checkInterfaceFlag = true;
                }
            }
            if (!checkInterfaceFlag) {
                throw new RuntimeException(typeElement.getQualifiedName() + " must implements interface com.hm.lifecycle.api.IAppLike");
            }

            //该类的全限定类名
            String fullClassName = typeElement.getQualifiedName().toString();
            if (!mMap.containsKey(fullClassName)) {
                System.out.println("process class name : " + fullClassName);
                //创建代理类生成器
                AppLikeProxyClassCreator creator = new AppLikeProxyClassCreator(mElementUtils, typeElement);
                mMap.put(fullClassName, creator);
            }
        }

        System.out.println("start to generate proxy class code");
        for (Map.Entry<String, AppLikeProxyClassCreator> entry : mMap.entrySet()) {
            String className = entry.getKey();
            AppLikeProxyClassCreator creator = entry.getValue();
            System.out.println("generate proxy class for " + className);

            //生成代理类，并写入到文件里，生成逻辑都在 AppLikeProxyClassCreator 里实现
            try {
                JavaFileObject jfo = processingEnv.getFiler().createSourceFile(creator.getProxyClassFullName());
                Writer writer = jfo.openWriter();
                writer.write(creator.generateJavaCode());
                writer.flush();
                writer.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return true;
    }
}

public class AppLikeProxyClassCreator {

    private Elements mElementUtils;
    private TypeElement mTypeElement;
    private String mProxyClassSimpleName;

    public AppLikeProxyClassCreator(Elements elements, TypeElement typeElement) {
        mElementUtils = elements;
        mTypeElement = typeElement;
        //代理类的名称，用到了之前定义过的前缀、后缀
        mProxyClassSimpleName = LifeCycleConfig.PROXY_CLASS_PREFIX +
                mTypeElement.getSimpleName().toString() +
                LifeCycleConfig.PROXY_CLASS_SUFFIX;
    }

    /**
     * 获取要生成的代理类的完整类名
     *
     * @return
     */
    public String getProxyClassFullName() {
        String name = LifeCycleConfig.PROXY_CLASS_PACKAGE_NAME + "."+ mProxyClassSimpleName;
        return name;
    }

    /**
     * 生成 java 代码，其实就是手动拼接，没有什么技术含量，比较繁琐，且容易出错
     * 可以采用第三方框架 javapoet 来实现，看自己需求了
     */
    public String generateJavaCode() {
        StringBuilder sb = new StringBuilder();
        //设置包名
        sb.append("package ").append(LifeCycleConfig.PROXY_CLASS_PACKAGE_NAME).append(";\n\n");

        //设置 import 部分
        sb.append("import android.content.Context;\n");
        sb.append("import com.hm.lifecycle.api.IAppLike;\n");
        sb.append("import ").append(mTypeElement.getQualifiedName()).append(";\n\n");

        sb.append("public class ").append(mProxyClassSimpleName)
                .append(" implements ").append("IAppLike ").append(" {\n\n");

        //设置变量
        sb.append("  private ").append(mTypeElement.getSimpleName().toString()).append(" mAppLike;\n\n");

        //构造函数
        sb.append("  public ").append(mProxyClassSimpleName).append("() {\n");
        sb.append("  mAppLike = new ").append(mTypeElement.getSimpleName().toString()).append("();\n");
        sb.append("  }\n\n");

        //onCreate()方法
        sb.append("  public void onCreate(Context context) {\n");
        sb.append("    mAppLike.onCreate(context);\n");
        sb.append("  }\n\n");

        //getPriority()方法
        sb.append("  public int getPriority() {\n");
        sb.append("    return mAppLike.getPriority();\n");
        sb.append("  }\n\n");

        //onTerminate 方法
        sb.append("  public void onTerminate() {\n");
        sb.append("    mAppLike.onTerminate();\n");
        sb.append("  }\n\n");


        sb.append("\n}");
        return sb.toString();
    }

}

那我们来实践一下，看看效果如何。 在 app module 里，创建 2 个类 ModuleAAppLike、ModuleBAppLike，分别实现 IAppLike 接口，并采用 AppLifeCycle 注解。 在 build.gradle 里增加依赖引用：

dependencies {
    //---------其他依赖------------
    implementation project(':lifecycle-annotation')
    implementation project(':lifecycle-api')
    //需要注意这里是使用 annotationProcessor，即我们刚定义的注解处理器
    annotationProcessor project(':lifecycle-apt')
}

//实现了 IAppLike 接口，并且采用了 AppLifeCycle 注解，二者缺一不可，否则 APT 处理时会报错
@AppLifeCycle
public class ModuleAAppLike implements IAppLike {

    @Override
    public int getPriority() {
        return NORM_PRIORITY;
    }

    @Override
    public void onCreate(Context context) {
        Log.d("AppLike", "onCreate(): this is in ModuleAAppLike.");
    }

    @Override
    public void onTerminate() {
        Log.d("AppLike", "onTerminate(): this is in ModuleAAppLike.");
    }
}

将整个工程编译一下，可以看到在 build 目录下已经生成了我们定义的注解类，具体路径如下所示：

看看代码是不是如我们所定义的一样：

package com.hm.iou.lifecycle.apt.proxy;

import android.content.Context;
import com.hm.lifecycle.api.IAppLike;
import com.hm.iou.lifecycle.demo.ModuleAAppLike;

public class Heima$$ModuleAAppLike$$Proxy implements IAppLike  {

  private ModuleAAppLike mAppLike;

  public Heima$$ModuleAAppLike$$Proxy() {
  mAppLike = new ModuleAAppLike();
  }

  public void onCreate(Context context) {
    mAppLike.onCreate(context);
  }

  public int getPriority() {
    return mAppLike.getPriority();
  }

  public void onTerminate() {
    mAppLike.onTerminate();
  }

}

关于 APT 技术，我这里不详解了，不了解的需要自行搜索相关资料来学习。

3.4 扫描固定包下面的所有 class

现在终于到了比较关键的一步了，在组件化开发过程中，如果有十多个组件里都有实现 IAppLike 接口的类，最终我们也会生成 10 多个代理类，这些代理类都是在同一个包下面。在组件集成到一个工程后，实际上只有一个 apk 安装包，所有编译后的 class 文件都被打包到 dex 文件里，应用运行时实际上是 dalvik 虚拟机(或者是 ART)从 dex 文件里加载出 class 信息来运行的。

所以我们的思路是，运行时读取手机里的 dex 文件，从中读取出所有的 class 文件名，根据我们前面定义的代理类包名，来判断是不是我们的目标类，这样扫描一遍之后，就得到了固定包名下面所有类的类名了。具体实现，我采用了Arouter框架里的代码，节选出部分核心代码说下：

public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
    final Set<String> classNames = new HashSet<>();
    //获取所有的 class 源文件，通常为 classes.dex 文件
    List<String> paths = getSourcePaths(context);
    final CountDownLatch parserCtl = new CountDownLatch(paths.size());

    for (final String path : paths) {
        //如果有多个 dex 文件，我们开启多个线程并发扫描
        DefaultPoolExecutor.getInstance().execute(new Runnable() {
            @Override
            public void run() {
                DexFile dexfile = null;
                try {
                    if (path.endsWith(EXTRACTED_SUFFIX)) {
                        //NOT use new DexFile(path), because it will throw "permission error in /data/dalvik-cache"
                        dexfile = DexFile.loadDex(path, path + ".tmp", 0);
                    } else {
                        dexfile = new DexFile(path);
                    }

                    Enumeration<String> dexEntries = dexfile.entries();
                    while (dexEntries.hasMoreElements()) {
                        //遍历读取出所有的 class 名称，类的全限定名称
                        String className = dexEntries.nextElement();
                        //如果以我们指定的包名开头，则表示是我们的目标类
                        if (className.startsWith(packageName)) {
                            classNames.add(className);
                        }
                    }
                } catch (Throwable ignore) {
                } finally {
                    if (null != dexfile) {
                        try {
                            dexfile.close();
                        } catch (Throwable ignore) {
                        }
                    }
                    parserCtl.countDown();
                }
            }
        });
    }
    parserCtl.await();
    return classNames;
}

接下来，我们看看效果如何，修改AppLifeCycleManager类，在初始化时，增加扫描 class 的逻辑，主要代码逻辑如下：

    private static void scanClassFile(Context context) {
        try {
            //扫描到所有的目标类
            Set<String> set = ClassUtils.getFileNameByPackageName(context, LifeCycleConfig.PROXY_CLASS_PACKAGE_NAME);
            if (set != null) {
                for (String className : set) {
                    try {
                        //通过反射来加载实例化所有的代理类
                        Object obj = Class.forName(className).newInstance();
                        if (obj instanceof IAppLike) {
                            APP_LIKE_LIST.add((IAppLike) obj);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void init(Context context) {
        scanClassFile(context);

        Collections.sort(APP_LIKE_LIST, new AppLikeComparator());
        for (IAppLike appLike : APP_LIKE_LIST) {
            appLike.onCreate(context);
        }
    }

到这里基本的功能已经实现了，我们可以自动加载注册所有组件的 IAppLike 类了，但是这里有个明显的性能问题，需要扫描 dex 文件里的所有 class，通常一个安装包里，加上第三方库，class 文件可能数以千计、数以万计，这让人有点杀鸡用牛刀的感觉。

每次应用冷启动时，都要读取一次 dex 文件并扫描全部 class，这个性能损耗是很大的，我们可以做点优化，在扫描成功后将结果缓存下来，下次进来时直接读取缓存文件。

3.5 通过 gradle 插件来动态插入字节码

前面介绍到的方法，不管怎样都需要在运行时读取 dex 文件，全量扫描所有的 class。那么我们能不能在应用编译成 apk 时，就已经全量扫描过一次所有的 class，并提取出所有实现了 IAppLike 接口的代理类呢，这样在应用运行时，效率就大大提升了。答案是肯定的，这就是 gradle 插件、动态插入 java 字节码技术。

关于 gradle 插件技术，具体实现请接着看下一章。

Android 组件化开发实践（九）：自定义 Gradle 插件

系列文章 Android 组件化开发实践（一）：为什么要进行组件化开发？
Android 组件化开发实践（二）：组件化架构设计
Android 组件化开发实践（三）：组件开发规范
Android 组件化开发实践（四）：组件间通信问题
Android 组件化开发实践（五）：组件生命周期管理
Android 组件化开发实践（六）：老项目实施组件化
Android 组件化开发实践（七）：开发常见问题及解决方案
Android 组件化开发实践（八）：组件生命周期如何实现自动注册管理
Android 组件化开发实践（九）：自定义 Gradle 插件

Highly Recommended：Google Play 4.7 Star Android Developer Tools, Decompile, View Manifest, Open Debug Options Quickly

Apps
Android Developer Tools
Android Developer Tools Pro
About Me
Tools: TimeShining
GitHub: Trinea
Facebook: Dev Tools