全局扫描代理类

在BaseApplication初始化时扫描出所有组件的代理类，再通过反射加载并初始化。这里也有个问题，所有组件的代理类散落在各个不同的组件中，包名各不相同，当扫描到class文件后判断条件就必须是【class文件全类命.equal(组件1代理类全类命) || class文件全类命.equal(组件2代理类全类命) || …】,是不是很麻烦，这里我们可以采取apt技术，通过编译时注解动态生成这些代理类的辅助文件，在辅助文件中调用代理类的方法，而这些辅助文件的包名一样，这样我们只需要扫描辅助文件就可以了，判断条件就变成【class文件包名.startWith(辅助文件包名)】，是不是简单多了。

初步思路：

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

在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.example.lifecycle.apt.proxy";      
/*** 生成代理类统一的后缀      */     
public static final String PROXY_CLASS_SUFFIX = "$$Proxy";      
/*** 生成代理类统一的前缀      */     
public static final String PROXY_CLASS_PREFIX = "Watson$$";  }

新建一个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.8" 
targetCompatibility = "1.8"  

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

接下来就是实现我们自己的注解处理器了：

@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();
    }

    /*** 支持解析的注解      */
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> set = new LinkedHashSet<>();
        set.add(AppLifeCycle.class.getCanonicalName());
        return set;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.RELEASE_8;
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        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) element;
            //这里检查一下，使用了该注解的类，同时必须要实现com.example.lifecycle.api.IAppLike接口，否则会报错，因为我们要实现一个代理类             
            List<? extends TypeMirror> mirrorList = typeElement.getInterfaces();
            if (mirrorList.isEmpty()) {
                throw new RuntimeException(typeElement.getQualifiedName() + " must implements interface com.example.lifecycle.api.IAppLike");
            }
            boolean checkInterfaceFlag = false;
            for (TypeMirror mirror : mirrorList) {
                if ("com.example.lifecycle.api.IAppLike".equals(mirror.toString())) {
                    checkInterfaceFlag = true;
                }
            }
            if (!checkInterfaceFlag) {
                throw new RuntimeException(typeElement.getQualifiedName() + " must implements interface com.example.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);
            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代码
     */
    public String generateJavaCode() {
        StringBuilder sb = new StringBuilder();
        //设置包名         
        sb.append("package ").append(LifeCycleConfig.PROXY_CLASS_PACKAGE_NAME).append(";nn");
        //设置import部分         
        sb.append("import android.content.Context;n");
        sb.append("import com.example.lifecycle.api.IAppLike;n");
        sb.append("import ").append(mTypeElement.getQualifiedName()).append(";nn");
        sb.append("public class ").append(mProxyClassSimpleName).append(" implements ").append("IAppLike ").append(" {nn");
        //设置变量         
        sb.append("  private ").append(mTypeElement.getSimpleName().toString()).append(" mAppLike;nn");
        //构造函数         
        sb.append("  public ").append(mProxyClassSimpleName).append("() {n");
        sb.append("  mAppLike = new ").append(mTypeElement.getSimpleName().toString()).append("();n");
        sb.append("  }nn");
        //getPriority()方法         
        sb.append("  public int getPriority() {n");
        sb.append("    return mAppLike.getPriority();n");
        sb.append("  }nn");
        //onCreate()方法         
        sb.append("  public void onCreate() {n");
        sb.append("    mAppLike.onCreate();n");
        sb.append("  }nn");
        //onTerminate方法         
        sb.append("  public void onTerminate() {n");
        sb.append("    mAppLike.onTerminate();n");
        sb.append("  }nn");
        //onTerminate方法         
        sb.append("  public void onLowMemory() {n");
        sb.append("    mAppLike.onLowMemory();n");
        sb.append("  }nn");
        //onTerminate方法        
        sb.append("  public void onTrimMemory(int level) {n");
        sb.append("    mAppLike.onTrimMemory(level);n");
        sb.append("  }nn");
        sb.append("n}");
        return sb.toString();
    }
}

新建一个Android Library module，命名为lifecycle-api，在这个module里定义IAppLike接口，以及一个生命周期管理类。现在工程目录差不多是这样的：

public interface IAppLike {
    int MAX_PRIORITY = 10;
    int MIN_PRIORITY = 1;
    int NORM_PRIORITY = 5;

    default int getPriority() {
        return NORM_PRIORITY;
    }

    void onCreate();

    void onTerminate();

    void onLowMemory();

    void onTrimMemory(int level);
}

生命周期管理类，初始化的时候扫描所有的代理辅助类，并在相应方法中调用组件生命周期方法。

public class AppLifeCycleManager {
    /**
     * 初始化
     */
    public static void init(Context context) {
        scanClassFile(context);
        Log.d("hx", "代理子模块数目：" + APP_LIKE_LIST.size());
        Collections.sort(APP_LIKE_LIST, new AppDelegateComparator()); //优先级排序    
    }

    public static void onCreate() {
        for (IAppLike delegate : APP_LIKE_LIST) {
            delegate.onCreate();
        }
    }

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

    public static void onLowMemory() {
        for (IAppLike delegate : APP_LIKE_LIST) {
            delegate.onLowMemory();
        }
    }

    public static void onTrimMemory(int level) {
        for (IAppLike delegate : APP_LIKE_LIST) {
            delegate.onTrimMemory(level);
        }
    }

    /**
     * 扫描出固定包名下，实现了