组件化之如何实现模块生命周期自动管理

·  阅读 7663
组件化之如何实现模块生命周期自动管理

前言

每个应用在启动的时候都会初始化一个application类,我们可以在这个类中做一些初始化的操作,例如第三方sdk的初始化,在实施组件化工程后,不同的业务模块也需要在应用启动的时候做一些初始化的操作,这个就涉及到了模块的生命周期问题,在应用启动时候,各个模块可以拿到application,在Application内部的生命周期方法被调用的时候,各个模块也有相应的生命周期方法被调用

初步实现

1.抽取一个IModuleLifeCycle类

代码如下

public interface IModuleLifeCycle {

    int MAX_PRIORITY = 12;
    int MIN_PRIORITY = 1;
    int DEFAULT_PRIORITY = 6;

    void onCreate(Application application);

    void onTerminate();

    /**
     * 返回组件的优先级,优先级范围为[1-12],12为最高,1为最低,默认优先级是1
     * @return
     */
    int getPriority();

}
复制代码

2.实现IModuleLifeCycle类

各个模块内新建一个类实现IModuleLifeCycle类,我们把这个当作模块的application类,在这个类可以做一些初始化的操作,还可以获取application对象,做一些初始化全局变量的工作

3.如何管理组件的生命周期

假如现在有moduleA, moduleB, moduleC,然后这三个模块分别对应有ModuleALifeCycle,ModuleBLifeCycle,ModuleCLifeCycle实现了IModuleLifeCycle类,用于实现模块的生命周期,为了实现这三个模块的生命周期,简单的做法是在application类中获取这个三个类的实例,然后在application的onCreate方法中调用ModuleALifeCycle,ModuleBLifeCycle,ModuleCLifeCycle的onCreate方法,代码如下:

@Override
public void onCreate() {
    super.onCreate();
    IModuleLifeCycle moduleA = new ModuleALifeCycle();
    IModuleLifeCycle moduleB = new ModuleBLifeCycle();
    IModuleLifeCycle moduleC = new ModuleCLifeCycle();
    moduleA.onCreate(this);
    moduleB.onCreate(this);
    moduleC.onCreate(this);
}        
复制代码

这种方式很简单,有多少个模块,就初始化多少个模块生命周期类,然后调用onCreate()即可,但是这种做法是不利于维护的,每次新加一个模块,就需要新建一个模块类,然后在application中调用这个类。而且,在模块化的开发模式下,各个模块独立运行的时候,壳工程对各个模块是没有依赖的,这就会导致上面的代码编译报错,所以是非常不可取的,因此,有两种方法可以优化:

  • 1.在配置文件中定义各个模块生命周期类的路径, 在assets中配置一个json文件,其中定义着各个模块的生命周期类的路径,然后在application初始化的时候通过反射获取这些类,然后调用其中生命周期方法,从而完成模块的生命周期的初始化,但是这种方法还是不够灵活,因为需要维护配置文件,所以更好的方法是连配置文件都不需要维护

  • 2.使用APT+javaPoet的方式实现,给模块生命周期类添加注解,然后使用APT扫描特定注解,然后借助javaPoet生成生命周期代理类,放在特定的目录下,这些代理类拥有模块生命周期类的实例,每次application初始化的时候,就会扫描dex下面特定路径的类,获得这些类的路径,然后通过反射获取类的实例,这些类就是javaPoet生成的代理类,我们会调用这些代理类的内部方法,从而调用到模块生命周期类的方法,完成各个模块生命周期的初始化

最终实现

使用APT+javaPoet的方式实现

1. 实现思路

  1. 在工程中新建一个类实现IModuleLifeCycle类,并且添加特定的注解,代码如下
@ModuleLifeCycle(moduleName = "main", desc = "主模块")
public class MainLifeCycle implements IModuleLifeCycle {
    @Override
    public void onCreate(Application application) {
       //.. 初始化主工程的Application的时候会调用到这里
       //.. application是整个应用的application
       // ..在这里完成自身module的初始化
        System.out.println("====>onCreate:"+application);
    }
    @Override
    public void onTerminate() {
       //.. Application被销毁
    }
    @Override
    public int getPriority() {
        return DEFAULT_PRIORITY;
    }
}
复制代码
  1. APT在编译的时候会扫描这个特定的注解,然后利用javaPoet生成模块生命周期的代理类,放在特定的路径下,代理类代码如下:
public class MainLifeCycleProxy implements IModuleLifeCycle {
  public MainLifeCycle mModuleLifeCycle;

  public MainLifeCycleProxy() {
    mModuleLifeCycle = new MainLifeCycle();
  }

  @Override
  public void onCreate(Application application) {
    mModuleLifeCycle.onCreate(application);
  }

  @Override
  public int getPriority() {
    return mModuleLifeCycle.getPriority();
  }

  @Override
  public void onTerminate() {
    mModuleLifeCycle.onTerminate();
  }
}
复制代码
  1. application在初始化的时候可以扫描dex下特定路径下的类,获取类的路径,然后通过反射获取代理类实例, 调用 代理类的onCreate方法,从而调用到各个模块的生命周期类的onCreate方法,实现模块生命周期,扫描代码如下所示:
/**
 * 通过指定包名,扫描包下面包含的所有的ClassName
 *
 * @param context     U know
 * @param packageName 包名
 * @return 所有class的集合
 */
public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
    final Set<String> classNames = new HashSet<>();

    List<String> paths = getSourcePaths(context);
    final CountDownLatch parserCtl = new CountDownLatch(paths.size());

    for (final String path : paths) {
        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()) {
                        String className = dexEntries.nextElement();
                        if (className.startsWith(packageName)) {
                            classNames.add(className);
                        }
                    }
                } catch (Throwable ignore) {
                    Log.e("ARouter", "Scan map file in dex files made error.", ignore);
                } finally {
                    if (null != dexfile) {
                        try {
                            dexfile.close();
                        } catch (Throwable ignore) {
                        }
                    }

                    parserCtl.countDown();
                }
            }
        });
    }

    parserCtl.await();

    return classNames;
}

复制代码

2. 实现过程

1. 定义注解

在androidStudio中新建一个Java Library module,然后新建一个注解类,命名为ModuleLifeCycle,工程结构如下所示:

image.png

ModuleLifeCycle代码如下所示,

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface ModuleLifeCycle {
    String moduleName();
    String desc();
}
复制代码

2. 新建一个android module lib,命名为module-lifecycle-api,工程结构如下所示:

image.png

IModuleLifeCycle是模块生命周期的接口,代码如下:

public interface IModuleLifeCycle {

    int MAX_PRIORITY = 12;
    int MIN_PRIORITY = 1;
    int DEFAULT_PRIORITY = 6;

    void onCreate(Application application);

    void onTerminate();

    /**
     * 返回组件的优先级,优先级范围为[1-10],10为最高,1为最低,默认优先级是5
     * @return
     */
    int getPriority();

}
复制代码

其中getPriority()方法表示模块加载的优先级,在多模块工程中,优先级越高的模块,越先初始化生命周期, ModuleLifeCycleManager是生命周期的管理类,用于按照优先级初始化各个模块

3.新建一个 java lib module,命名为module-lifecycle-apt,代码结构如下

image.png

在这个模块中,我们将使用apt扫描注解,并且用javaPoet生成代理类,module-lifecycle-apt库的build.gradle 配置代码如下:

plugins {
    id 'java-library'
}

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

java {
    sourceCompatibility = JavaVersion.VERSION_1_7
    targetCompatibility = JavaVersion.VERSION_1_7
}
复制代码

ModuleLifeCycleProcessor调用了apt的api来扫描特定注解,代码如下:

@AutoService(Processor.class)
public class ModuleLifeCycleProcessor extends AbstractProcessor {

    public Filer filer; //文件相关的辅助类
    public Elements elements; //元素相关的辅助类
    public Messager messager; //日志相关的辅助类

    private Map<String, CodeCreateFactory> codeCreateFactoryMap = new HashMap<>();

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);

        filer = processingEnv.getFiler();
        elements = processingEnv.getElementUtils();
        messager = processingEnv.getMessager();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> set = new LinkedHashSet<>();
        set.add(ModuleLifeCycle.class.getCanonicalName());
        return set;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();//改成这个后process方法会进来两次,查一下去为什么
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        Set<? extends Element> elementSet = roundEnvironment.getElementsAnnotatedWith(ModuleLifeCycle.class);
        for (Element element : elementSet) {
            if (!element.getKind().isClass()) {
                throw new RuntimeException("ModuleLifeCycle注解只能用在类上");
            }
            TypeElement typeElement = (TypeElement) element;
            if (codeCreateFactoryMap.containsKey(typeElement.getSimpleName().toString())) {
                codeCreateFactoryMap.get(typeElement.getSimpleName().toString()).generateCode();
            } else {
                CodeCreateFactory codeCreateFactory = new CodeCreateFactory(typeElement, processingEnv);
                codeCreateFactoryMap.put(typeElement.getSimpleName().toString(), codeCreateFactory);
                codeCreateFactory.generateCode();
            }
        }
        return true;
    }
}
复制代码

CodeCreateFactory调用了javaPoet的api来生成指定的代码,并且保存到特定路径下,代码如下:

public class CodeCreateFactory {
    TypeElement typeElement;
    ProcessingEnvironment processingEnv;

    public CodeCreateFactory(TypeElement typeElement, ProcessingEnvironment processingEnv) {
        this.typeElement = typeElement;
        this.processingEnv = processingEnv;
    }

    public void generateCode() {
        TypeSpec ModuleFeedLifeCycleManger = TypeSpec
                .classBuilder(typeElement.getSimpleName().toString() + "Proxy")
                .addModifiers(Modifier.PUBLIC)
                .addSuperinterface(ClassName.get("com.quwan.moduleLifecycleApi", "IModuleLifeCycle"))
                .addField(FieldSpec
                        .builder(ClassName.get(typeElement.getQualifiedName().toString().replace("." + typeElement.getSimpleName().toString(), ""),
                                typeElement.getSimpleName().toString()), "mModuleLifeCycle", Modifier.PUBLIC)
                        .build())
                .addMethod(MethodSpec
                        .constructorBuilder()
                        .addModifiers(Modifier.PUBLIC)
                        .addStatement("mModuleLifeCycle = new $T()", ClassName.get(typeElement.getQualifiedName().toString().replace("." + typeElement.getSimpleName().toString(), ""),
                                typeElement.getSimpleName().toString()))
                        .build())
                .addMethod(MethodSpec
                        .methodBuilder("onCreate")
                        .addAnnotation(ClassName.get("java.lang", "Override"))
                        .addModifiers(Modifier.PUBLIC)
                        .addParameter(
                                ParameterSpec
                                        .builder(ClassName.get("android.app", "Application"), "application")
                                        .build()
                        )
                        .addStatement("mModuleLifeCycle.onCreate(application)")
                        .build())
                .addMethod(MethodSpec
                        .methodBuilder("getPriority")
                        .returns(INT)
                        .addAnnotation(ClassName.get("java.lang", "Override"))
                        .addModifiers(Modifier.PUBLIC)
                        .addStatement("return mModuleLifeCycle.getPriority()")
                        .build())
                .addMethod(MethodSpec
                        .methodBuilder("onTerminate")
                        .returns(VOID)
                        .addAnnotation(ClassName.get("java.lang", "Override"))
                        .addModifiers(Modifier.PUBLIC)
                        .addStatement("mModuleLifeCycle.onTerminate()")
                        .build())
                .build();

        JavaFile javaFile = JavaFile.builder("com.component.lifeCycle", ModuleFeedLifeCycleManger).build();
        try {
            // 生成文件
            javaFile.writeTo(processingEnv.getFiler());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
复制代码

以上就完成了实现过程,其实还是挺简单的

3. 如何使用

1. 在application的onCreate()方法中调用ModuleLifeCycleManager的方法,代码如下:

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ModuleLifeCycleManager.init(this);
    }

    @Override
    public void onTerminate() {
        super.onTerminate();
        ModuleLifeCycleManager.terminate();
    }
}
复制代码

2. 在模块中新建一个生命周期类,实现IModuleLifeCycle接口,并且添加注解,代码如下

@ModuleLifeCycle(moduleName = "main", desc = "主模块")
public class MainLifeCycle implements IModuleLifeCycle {

    @Override
    public void onCreate(Application application) {
       //.. 初始化主工程的Application的时候会调用到这里
       //.. application是整个应用的application
       // ..在这里完成自身module的初始化
        System.out.println("====>onCreate:"+application);
    }

    @Override
    public void onTerminate() {
       //.. Application被销毁
    }

    @Override
    public int getPriority() {
        return DEFAULT_PRIORITY;
    }
}
复制代码

3. rebuild一下工程,生成模块生命周期代理类,代码如下:

package com.component.lifeCycle;

import android.app.Application;
import com.quwan.moduleLifecycleApi.IModuleLifeCycle;
import com.quwan.modulelifecycle.MainLifeCycle;
import java.lang.Override;

public class MainLifeCycleProxy implements IModuleLifeCycle {
  public MainLifeCycle mModuleLifeCycle;

  public MainLifeCycleProxy() {
    mModuleLifeCycle = new MainLifeCycle();
  }

  @Override
  public void onCreate(Application application) {
    mModuleLifeCycle.onCreate(application);
  }

  @Override
  public int getPriority() {
    return mModuleLifeCycle.getPriority();
  }

  @Override
  public void onTerminate() {
    mModuleLifeCycle.onTerminate();
  }
}
复制代码

以上就完成了模块生命周期的初始化过程了

github链接

分类:
Android
标签:
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改