Android AOP三剑客之APT

AOP概念

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Android AOP三剑客: APT, AspectJ, Javassist

这是一张用烂了的图.jpg

项目地址：android-aop-samples

工程目录结构

.

• annotation 定义注解
• apt-library apt辅助工具类
• apt-processor 自定义注解解析器，生成辅助代码
• apt-plugin 自定义Gradle插件，实现切面和操作字节码的插件
• app 主目录

Android APT

APT(Annotation Processing Tool 的简称)，可以在代码编译期解析注解，并且生成新的 Java 文件，减少手动的代码输入。现在有很多主流库都用上了 APT，比如 Dagger2, ButterKnife, EventBus3 等

定义注解

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BindView {
int value();
}

创建一个Module，自定义AbstractProcessor，并且用@AutoService标记

• AutoService会自动在META-INF文件夹下生成Processor配置信息文件，该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，
  就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入

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

private Messager mMessager;
private Elements mElementUtils;
private Map<String, ClassFactory> mProxyMap = new HashMap<>();

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

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

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

@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
    mProxyMap.clear();
    //得到所有的注解
    Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
    for (Element element : elements) {
        VariableElement variableElement = (VariableElement) element;
        TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
        String fullClassName = classElement.getQualifiedName().toString();
        //elements的信息保存到mProxyMap中
        ClassFactory proxy = mProxyMap.get(fullClassName);
        if (proxy == null) {
            proxy = new ClassFactory(mElementUtils, classElement);
            mProxyMap.put(fullClassName, proxy);
        }
        BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
        int id = bindAnnotation.value();
        proxy.putElement(id, variableElement);
    }

    //通过javapoet生成
    for (String key : mProxyMap.keySet()) {
        ClassFactory proxyInfo = mProxyMap.get(key);
        JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(), proxyInfo.generateJavaCode()).build();
        try {
            //　生成文件
            javaFile.writeTo(processingEnv.getFiler());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
    return true;
}

}

process方法，处理我们自定义的注解，生成代码，这里使用的squareup公司的javapoet库辅助生成代码

public class ClassFactory {
private String mBindingClassName;
private String mPackageName;
private TypeElement mTypeElement;
private Map<Integer, VariableElement> mVariableElementMap = new HashMap<>();

public ClassFactory(Elements elementUtils, TypeElement classElement) {
    this.mTypeElement = classElement;
    PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
    String packageName = packageElement.getQualifiedName().toString();
    String className = mTypeElement.getSimpleName().toString();
    this.mPackageName = packageName;
    this.mBindingClassName = className + "_ViewBinding";
}

public void putElement(int id, VariableElement element) {
    mVariableElementMap.put(id, element);
}

public TypeSpec generateJavaCode() {
    TypeSpec bindingClass = TypeSpec.classBuilder(mBindingClassName)
            .addModifiers(Modifier.PUBLIC)
            .addMethod(generateMethods())
            .build();
    return bindingClass;

}

    private MethodSpec generateMethods() {
    ClassName activity = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
    MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("bind")
            .addModifiers(Modifier.PUBLIC)
            .returns(void.class)
            .addParameter(activity, "activity");

    for (int id : mVariableElementMap.keySet()) {
        VariableElement element = mVariableElementMap.get(id);
        String name = element.getSimpleName().toString();
        String type = element.asType().toString();

        methodBuilder.addCode("activity." + name + " = " + "(" + type + ")(((android.app.Activity)activity).findViewById( " + id + "));\n\n");
    }

    return methodBuilder.build();
}


public String getPackageName() {
    return mPackageName;
}
}

generateMethods方法通过for循环构建代码，findViewById绑定view

我们先看下原本的MainActivity有什么东东

public class MainActivity extends AppCompatActivity {

@BindView(R.id.button)
Button button;

@BindView(R.id.tv)
TextView textView;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    BindViewTools.bind(this);
    textView.setText("bind Button success");
    button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            doMarkDown();
        }
    });
}
}

这个BindViewTools.bind(this)传送门进去看看

public class BindViewTools {
public static void bind(Activity activity) {
    Class clazz = activity.getClass();
    try {
        Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
        Method method = bindViewClass.getMethod("bind", activity.getClass());
        method.invoke(bindViewClass.newInstance(), activity);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

}
我们可以看到他是通过反射寻找的是MainActivity_ViewBinding的类，并进行Id绑定的

可以在build/intermediates/classes/debug/包名/MainActivity_ViewBinding.class看到生成的代码

这下就很清晰了

1.首先定义注解
2.BindViewProcessor里的process 解析注解，生成辅助类MainActivity_ViewBinding
3.在入口BindViewTools.bind(this)，反射找到生成的MainActivity_ViewBinding类并进行findViewById。

总结

本章节主要说了APT的简单使用，从使用角度来说，APT技术并没有难度，重点是怎么设计，在实际项目中可以把很多繁琐重复性的工作，通过APT来生成各种代码，作为老司机，这是弯道超车的必备秘籍，天下武功、唯快不破！