重走JAVA之路（一）：复盘ButterKnife-编译时注解

前言

其实一直想写这么个系列，虽然Android开发大部分是基于Java语言的，可是平常开发中基本涉及的都比较简单，当遇到一些疑难杂症的时候，很难去找到根因，本系列就针对一些日常开发比较少涉及的JAVA点，好比、注解、代理、并发等等，但愿能帮到一些朋友从新巩固下基础知识。

今天咱们主要来讲道说道注解中另外一种实现方式，编译时注解（CLASS），不一样于运行时注解（RUNTIME），你们比较熟悉的须要在代码运行时，反射拿到注解的参数值，而后再把值绑定回去，这样反射毕竟消耗性能。著名的ButterKnife就是用的编译时注解，利用APT在编译时生成文件，再去赋值，就不会有性能消耗问题啦~

1.编译时注解

由于编译时注解须要用到AbstractProcessor这个类，而这个是在JDK里面的，因此咱们须要Android Stuio中新建一个Java lib

建好以后，咱们新建一个注解类

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface InjectView {
    int value();
}
复制代码

而后咱们在新建一个java类，集成AbstractProcessor

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
@AutoService(Processor.class)
public class BuildProcess extends AbstractProcessor {
    private Filer mFiler;
    private Messager mMessager;
    @Override
    public synchronized void init(ProcessingEnvironment mProcessingEnvironment) {
         super.init(mProcessingEnvironment);

        //初始化咱们须要的基础工具
        mFiler = processingEnv.getFiler();
        mMessager = processingEnv.getMessager();
    }

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

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

    @Override
    public boolean process(Set<? extends TypeElement> mSet, RoundEnvironment mRoundEnvironment) {
        return false;
    }
}
复制代码

咱们主要关注这4个方法

• init方法做为一个初始化的入口，作一些初始化工具类的操做
• getSupportedAnnotationTypes()，这个方法要求咱们返回一个Set集合，从方法名咱们应该也能看出来是一组支持注解类型的集合元素，这里咱们把注解类加进去，后续若是要添加注解，这里须要手动再添加修改
• getSupportedSourceVersio()，返回支持的版本号，通常返回上次支持的版本号便可
• process()，大头来了，这个方法是整个类的核心，也是实现编译时注解最关键的地方，咱们这里从获取到注解参数的值供咱们调用，借鉴一波他人图来展现一下

  

@AutoService(Processor.class)也是google出品的一个开源库，省了咱们须要写配置文件META-INF的工做。添加依赖

implementation 'com.google.auto.service:auto-service:1.0-rc3'
复制代码

首先看看最终须要生成的类，是否是似曾相识的样子！：

接下来就是实现了，主要的代码固然就在process方法里面了

@Override
    public boolean process(Set<? extends TypeElement> mSet, RoundEnvironment mRoundEnvironment) {
        Map<TypeElement, List<InjectViewField>> parseHashMap = getParseHashMap(mRoundEnvironment);
        for (Map.Entry<TypeElement, List<InjectViewField>> entry : parseHashMap.entrySet()) {
            TypeElement typeElement = entry.getKey();
            List<InjectViewField> list = entry.getValue();
            if (list == null || list.size() == 0) {
                continue;
            }


            // 获取包名
            String packageName = mElementUtils.getPackageOf(typeElement).getQualifiedName().toString();
            // 根据旧Java类名建立新的Java文件
            String className = typeElement.getQualifiedName().toString().substring(packageName.length() + 1);
            String newClassName = className + "_ViewBinding";

            //生成方法
            MethodSpec.Builder methodBuilder = MethodSpec.constructorBuilder()
                    .addModifiers(Modifier.PUBLIC)
                    .addParameter(ClassName.bestGuess(className), "target");
            for (InjectViewField injectViewField : list) {
                String packageNameString = injectViewField.getFieldType().toString();
                ClassName viewClass = ClassName.bestGuess(packageNameString);
                methodBuilder.addStatement
                        ("target.$L=($T)target.findViewById($L)", injectViewField.getFieldName()
                                , viewClass, injectViewField.getId());
            }


            TypeSpec typeBuilder = TypeSpec.classBuilder(newClassName)
                    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                    .addMethod(methodBuilder.build())
                    .build();


            JavaFile javaFile = JavaFile.builder(packageName, typeBuilder)
                    .addFileComment("Generated code from Butter Knife. Do not modify!")
                    .build();
            try {
                javaFile.writeTo(mFiler);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return true;
    }
复制代码

private Map<TypeElement,List<InjectViewField>> getParseHashMap(RoundEnvironment mRoundEnvironment) {
        Map<TypeElement,List<InjectViewField>> map = new HashMap<>();
        List<InjectViewField> injectViewFields = new ArrayList<>();
        for (Element element :mRoundEnvironment.getElementsAnnotatedWith(InjectView.class)) {
            InjectViewField injectViewField = new InjectViewField(element);
            injectViewFields.add(injectViewField);
            map.put((TypeElement) element.getEnclosingElement(),injectViewFields);
        }
        return map;
    }
复制代码

InjectViewField做为一个简单的实体类封装一些属性

public class InjectViewField {
    private int id;
    private TypeElement mTypeElement;
    private String fieldName;
    private TypeMirror fieldType;
    public InjectViewField(Element element) {
        //获取成员变量名称mTextView
        fieldName = element.getSimpleName().toString();
        //获取成员变量类型 TextView
        fieldType = element.asType();
        //获取成员变量具体value R.id.textView
        id = element.getAnnotation(InjectView.class).value();
       //获取完整类名
        mTypeElement = (TypeElement) element.getEnclosingElement();
    }

    public int getId() {
        return id;
    }

    public TypeElement getTypeElement() {
        return mTypeElement;
    }

    public String getFieldName() {
        return fieldName;
    }

    public TypeMirror getFieldType() {
        return fieldType;
    }
}
复制代码

这里生成文件用到了javapoet，这样就不用本身手动去拼接字符串，具体API使用方法，能够进去瞅瞅，也是出自square之手，很是简便 而后再动动咱们的小手，build一下，就能获得咱们想要的文件了~，而后咱们看看怎么使用

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @InjectView(R.id.textView)
    TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        InjectManager.init(this);
        mTextView.setText("i have changed");
    }
}
复制代码

很简单吧！，看着和butterknife很相似，实际原理差很少，固然butterknife里面涉及的仍是蛮复杂的，但基本是通的，有兴趣的能够去看看源码，butterknife，而后咱们的InjectManager

public class InjectManager  {
    private static final String TAG = "InjectManager";
    public static void init(Activity mActivity){
        //一、获取全限定类名
        String name = mActivity.getClass().getName();
        try {
            //二、 根据全限定类名获取经过注解解释器生成的Java类
            Class<?> clazz = mActivity.getClass().getClassLoader().loadClass(name + "_ViewBinding");
            //三、 经过反射获取构造方法并建立实例完成依赖注入
            clazz.getConstructor(mActivity.getClass()).newInstance(mActivity);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
复制代码

有朋友要说了，你这个不也是反射嘛？emmm...确实是经过反射生成对应的文件对象，可是起码每一个文件只涉及到了一次反射，而不是像运行时注解，每一个注解都须要反射拿到，因此 不要太苛刻了~~忽略忽略。。

大概基本就是这么多，再来总结一波！

• 新建java lib库，自定义类，继承AbstractProcessor，最少复写3个函数（init不须要的能够不复写）
• 在process方法里面获取对应注解的变量、方法等等，存到Map里，后续能够作必定的缓存，减小消耗，使用javapoet，生成java文件
• 经过反射拿到对应类的对象，执行赋值代码

好了，基本大概如此了，固然也有不少须要优化的地方，缓存，设计结构等等，有兴趣的朋友能够去尝试尝试，也是一个好的锻炼机会

有疑问的能够留言讨论，感谢观看 谢谢~~