2.Android注解-编译时生成代码 APT(Annotation Processing Tool ) 实例说明

项目构建如下
建一个主工程，一个纯注解的anotation java工程，一个编译生成代码的compiler java工程，一个android library库。

compiler java工程不会打包入项目的，只是在编译的时候生成相关代码而已。

|—-
—app（主android项目）
—rulangtool-api（android library）
—rualngtool-annotation（java library）
—rulangtool-commpiler（java library）

工程如上（图片无法上传了，蛋疼啊 只能如此写结构图）

在app工程里面引入的是

    compile project(':rulangtool-annotation')
    compile project(':rulangtool-api')
   // apt project(':rulangtool-compiler') 
   // 刚开始我写的apt，后修改配置位annotationProcessor 
    annotationProcessor project(':rulangtool-compiler')

rulangtool-compiler只是用在编译时期生成代码，其他时间并无其他作用的。

rulangtool-annotation 是一个注解java library。

拿我们常用的android butterknife来做说明。举例BindView，Onclick（View）2个注解来说明。

rulangtool-annotation里的代码如下：
注解部分文章

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

rulangtool-commpiler来说明一下。

工程引入

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile project(':rulangtool-annotation')
    compile 'com.squareup:javapoet:1.7.0'
    compile 'com.google.auto.service:auto-service:1.0-rc2'
}

javax.lang.model.element 用于 Java 编程语言的模型元素的接口。

AnnotationMirror表示一个注释。

AnnotationValue 表示注释类型元素的值。

AnnotationValueVisitor<R,P>注释类型元素值的 visitor，使用 visitor 设计模式的变体。
Element 表示一个程序元素，比如包、类或者方法。

ElementVisitor<R,P> 程序元素的 visitor，使用 visitor 设计模式的样式。

ExecutableElement 表示某个类或接口的方法、构造方法或初始化程序（静态或实例），包括注释类型元素。

Name 字符的不可变序列。

PackageElement 表示一个包程序元素。

TypeElement 表示一个类或接口程序元素。

TypeParameterElement 表示一般类、接口、方法或构造方法元素的形式类型参数。

VariableElement 表示一个字段、enum 常量、方法或构造方法参数、局部变量或异常参数。

BindViewField


public class BindViewField {
    private VariableElement mVariableElement;
    private int mresId;

    public BindViewField(Element element) throws IllegalArgumentException{
        if (element.getKind() != ElementKind.FIELD) {
            throw new IllegalArgumentException(String.format("Only fields can be annotated with @%s",
                    BindView.class.getSimpleName()));
        }
        mVariableElement = (VariableElement) element;

        BindView bindView = mVariableElement.getAnnotation(BindView.class);
        mresId = bindView.value();
        if (mresId < 0) {
            throw new IllegalArgumentException(
                    String.format("value() in %s for field %s is not valid !", BindView.class.getSimpleName(),
                            mVariableElement.getSimpleName()));
        }
    }


    /**
     * 获取变量名称
     * @return
     */
    public Name getFieldName() {
        return mVariableElement.getSimpleName();
    }

    /**
     * 获取变量id
     * @return
     */
    public int getResId() {
        return mresId;
    }

    /**
     * 获取变量类型
     * @return
     */
    public TypeMirror getFieldType() {
        return mVariableElement.asType();
    }


}

---

OnClickMethod
public class OnClickMethod {

    private ExecutableElement mExecutableElement;
    private int[] resIds;
    private Name mMethodName;


    public OnClickMethod(Element element) throws IllegalArgumentException {
        if (element.getKind() != ElementKind.METHOD) {
            throw new IllegalArgumentException(
                    String.format("Only methods can be annotated with @%s",
                            OnClick.class.getSimpleName()));
        }

        mExecutableElement = (ExecutableElement) element;

        resIds = mExecutableElement.getAnnotation(OnClick.class).value();

        if (resIds == null) {
            throw new IllegalArgumentException(String.format("Must set valid ids for @%s",
                    OnClick.class.getSimpleName()));
        } else {
            for (int id : resIds) {
                if (id < 0) {
                    throw new IllegalArgumentException(String.format("Must set valid id for @%s",
                            OnClick.class.getSimpleName()));
                }
            }
        }
        mMethodName = mExecutableElement.getSimpleName();
        List<? extends VariableElement> parameters = mExecutableElement.getParameters();

        if (parameters.size() > 0) {
            throw new IllegalArgumentException(
                    String.format("The method annotated with @%s must have no parameters",
                            OnClick.class.getSimpleName()));
        }
    }

    /**
     * 获取方法名称
     * @return
     */
    public Name getMethodName() {
        return mMethodName;
    }

    /**
     * 获取id数组
     * @return
     */
    public int[] getResIds() {
        return resIds;
    }



}

同一个类里面的注解处理

AnnotatedClass

public class AnnotatedClass {

    private TypeElement mTypeElement;
    private ArrayList<BindViewField> mFields;
    private ArrayList<OnClickMethod> mMethods;
    private Elements mElements;

    public AnnotatedClass(TypeElement typeElement, Elements elements) {
        mTypeElement = typeElement;
        mElements = elements;
        mFields = new ArrayList<>();
        mMethods = new ArrayList<>();
    }

    public String getFullClassName() {
        return mTypeElement.getQualifiedName().toString();
    }

    public void addField(BindViewField field) {
        mFields.add(field);
    }

    public void addMethod(OnClickMethod method) {
        mMethods.add(method);
    }

    public JavaFile generateFile() {
        //generateMethod
        MethodSpec.Builder injectMethod = MethodSpec.methodBuilder("inject")
                .addModifiers(Modifier.PUBLIC)
                .addAnnotation(Override.class)
                .addParameter(TypeName.get(mTypeElement.asType()), "host", Modifier.FINAL)
                .addParameter(TypeName.OBJECT, "source")
                .addParameter(TypeUtil.PROVIDER,"provider");

        for(BindViewField field : mFields){
            // find views
            injectMethod.addStatement("host.$N = ($T)(provider.findView(source, $L))",
                    field.getFieldName(),
                    ClassName.get(field.getFieldType()), field.getResId());
        }

        for(OnClickMethod method :mMethods){
            TypeSpec listener = TypeSpec.anonymousClassBuilder("")
                    .addSuperinterface(TypeUtil.ANDROID_ON_CLICK_LISTENER)
                    .addMethod(MethodSpec.methodBuilder("onClick")
                            .addAnnotation(Override.class)
                            .addModifiers(Modifier.PUBLIC)
                            .returns(TypeName.VOID)
                            .addParameter(TypeUtil.ANDROID_VIEW, "view")
                            .addStatement("host.$N()", method.getMethodName())
                            .build())
                    .build();
            injectMethod.addStatement("View.OnClickListener listener = $L ", listener);
            for (int id : method.getResIds()) {
                // set listeners
                injectMethod.addStatement("provider.findView(source, $L).setOnClickListener(listener)", id);
            }
        }

        //generaClass
        TypeSpec injectClass = TypeSpec.classBuilder(mTypeElement.getSimpleName() + "$$RuLang")
                .addModifiers(Modifier.PUBLIC)
                .addSuperinterface(ParameterizedTypeName.get(TypeUtil.INJET, TypeName.get(mTypeElement.asType())))
                .addMethod(injectMethod.build())
                .build();

        String packgeName = mElements.getPackageOf(mTypeElement).getQualifiedName().toString();

        return JavaFile.builder(packgeName, injectClass).build();
    }

}

真正的编译器生成代码咋这个里面：

@AutoService(Processor.class)
public class ViewInjectProcesser extends AbstractProcessor {
 @Override
  public boolean process(Set<? extends TypeElement>annotations, RoundEnvironment roundEnv) {

    }
}

这句代码非常重要 TypeSpec injectClass = TypeSpec.classBuilder(mTypeElement.getSimpleName() + “

$$RuLang")，这是生成java文件的名字：mTypeElement.getSimpleName()+“$$ RuLang”.java

在rulangtool-api里面开始

  private static void inject(Object host, Object object, Provider provider) {
        String className = host.getClass().getName();
        try {
            Inject inject = injectMap.get(className);

            if (inject == null) {
            //利用反射实例话生成的对象，通过注入实例化相关字段或者关联方法。
                Class<?> aClass = Class.forName(className + "$$RuLang");
                inject = (Inject) aClass.newInstance();
                injectMap.put(className, inject);
            }
            inject.inject(host, object, provider);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }