大家可能都用過Butterknife，今天就從0到1寫一個Butterknife，首先通過反射的方式實現(xiàn)，接著再改為注解處理器實現(xiàn)，通過這個例子進(jìn)而掌握注解處理器的使用。完整代碼參考：AnnotationProcessor

其中也會涉及一些比較有用的知識：
1、注解相關(guān)，在運行時通過反射獲取注解信息
2、通過 javapoet 生成代碼，生成代碼這個功能如果運用好了，可以解決很多繁瑣的重復(fù)工作

先看一個示例代碼：

public class MainActivity extends AppCompatActivity {
    @BindView(R.id.text_view1)
    TextView textView1;

    @BindView(R.id.text_view2)
    TextView textView2;

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

//        textView1 = findViewById(R.id.text_view1);
//        textView2 = findViewById(R.id.text_view2);
        Butterknife.bind(this);

        textView1.setText("Hello Annotation1");
        textView2.setText("Hello Annotation2");
    }
}

布局里面有兩個TextView，分別是textView1和textView2，正常來說我們需要通過以下代碼來獲取這兩個對象

textView1 = findViewById(R.id.text_view1);
textView2 = findViewById(R.id.text_view2);

現(xiàn)在我們用Butterknife.bind(this)加上反射注解的方式來實現(xiàn)。

首先我們需要新建一個注解：

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

@Retentio @Target 是注解的注解，即元注解。

@Retention 有三個值，分別是SOURCE、CLASS和RUNTIME ，指定注解信息保留到哪個階段，原碼中、編譯的字節(jié)碼、或者運行時仍然保留，使用原則上應(yīng)盡量早丟棄注解信息。這個例子需要在運行時通過反射拿到注解信息，因此指定為為RetentionPolicy.RUNTIME。

@Target 指定注解可以修飾哪些元素，例如方法，成員變量，本地變量等，這個例子中需要修飾的是成員變量，即Field。

首先拿到Activity中聲明的所有成員屬性，然后判斷該成員屬性是否有@BindView 注解修飾，如果有，就通過反射調(diào)用設(shè)置屬性的值。

public class Butterknife {

    public static void bind(Activity activity) {
        Class clazz = activity.getClass();
        //拿到Activity中聲明的所有成員屬性
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field: declaredFields) {
            BindView annotation = field.getAnnotation(BindView.class);
            //成員屬性是否有@BindView注解
            if (annotation != null) {
                try {
                    field.setAccessible(true);
                    //如果有注解，通過反射調(diào)用設(shè)置屬性的值
                    field.set(activity, activity.findViewById(annotation.value()));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 }

這個例子通過反射的方式，替我們寫了findViewById()，但是我們知道，反射有一定的性能損耗，如果一個Activity中有幾十個上百個View要查找，那反射帶來的性能問題將不容忽視。方便是方便了，如果因此而引起比較大的性能問題，在工程實踐上是不能夠被接受的，因此我們需要尋找其他出路-注解處理器。

新建一個注解處理module（Java Library），它大概長這個樣子。

lib-processor

注意一個文件javax.annotation.processing.Processor ，它的目錄是固定的，文件名也是固定的。/src/main/resources/META-INF/services/javax.annotation.processing.Processor，它的內(nèi)容很簡單，就是注解處理的類名

com.jdqm.lib.processor.BindingProcessor

來看看注解處理器類如何寫。

本例子中使用square出品的開源項目 javapoet 來生成代碼，其API也比較簡單易用，有興趣可參考官方文檔：javapoet

public class BindingProcessor extends AbstractProcessor {
    private Filer filer;

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

        filer = processingEnv.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {

        for (Element element : roundEnvironment.getRootElements()) {
            String packageStr = element.getEnclosingElement().toString();
            String classStr = element.getSimpleName().toString();
            
            //要生成.java文件的類名：com.example.annotationprocessor.MainActivityBinding
            ClassName className = ClassName.get(packageStr, classStr + "Binding");
            
            //構(gòu)造器 public MainActivityBinding(MainActivity activity
            MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder()
                    .addModifiers(Modifier.PUBLIC)
                    .addParameter(ClassName.get(packageStr, classStr), "activity");
            
            //標(biāo)記類中是否有@BindView注解修飾字段，如果沒有就沒必要生成類了
            boolean hasBinding = false;

            for (Element enclosedElement : element.getEnclosedElements()) {
                if (enclosedElement.getKind() == ElementKind.FIELD) {
                    BindView bindView = enclosedElement.getAnnotation(BindView.class);
                    if (bindView != null) {
                        hasBinding = true;
                        
                        //在構(gòu)造器內(nèi)添加代碼段
                        // activity.textView1 = activity.findViewById(2131231096);
                        // activity.textView2 = activity.findViewById(2131231097);
                        constructorBuilder.addStatement("activity.$N = activity.findViewById($L)",
                                enclosedElement.getSimpleName(), bindView.value());
                    }
                }
            }

            //生成 com.example.annotationprocessor.MainActivityBinding 類
            TypeSpec builtClass = TypeSpec.classBuilder(className)
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(constructorBuilder.build())
                    .build();

            if (hasBinding) {
                try {
                    //生成 MainActivityBinding.java文件
                    JavaFile.builder(packageStr, builtClass)
                            .build().writeTo(filer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Collections.singleton(BindView.class.getCanonicalName());
    }

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

注意我們要回去原先的注解，將它的@Retention 改為RetentionPolicy.SOURCE，因為注解處理器是在源碼階段工作，沒必要將注解信息保留到字節(jié)碼或者運行時。

然后我們需要在app/build.gradle中添加依賴注解處理器

annotationProcessor project(':lib-processor')

看看注解處理器生成的代碼

public class MainActivityBinding {
  public MainActivityBinding(MainActivity activity) {
    //這里的id已經(jīng)被替換為R文件中具體值
    activity.textView1 = activity.findViewById(2131231096);
    activity.textView2 = activity.findViewById(2131231097);
  }
}

接著修改一下Butterknife.bind(this)方法的實現(xiàn)

public class Butterknife {

    public static void bind(Activity activity) {
        try {
            //拼接成注解處理器中生產(chǎn)的類名
            String className = activity.getClass().getCanonicalName() + "Binding";
            
            //通過放射創(chuàng)建對象，此時會調(diào)用注解處理器生成類的構(gòu)造方法，在構(gòu)造方法中調(diào)用activity.findViewById(id)
            Class<?> clazz = Class.forName(className);
            Constructor<?> constructor = clazz.getDeclaredConstructor(activity.getClass());
            constructor.newInstance(activity);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
 }

使用注解處理器后，每個Butterknife.bind(this)就只會涉及一次反射（不管對應(yīng)的Activity有多少個View），一次的性能損耗是可以忽略的。

好了，今天的總結(jié)就到這，謝謝大家。

完整代碼參考：AnnotationProcessor