APT
APT （Annotation Processing Tool）
是一种处理注释的工具，它对源代码文件进行检测并找出其中的 Annotation，根据注解自动生成代码，如果想要自定义的注解处理器能够运行，必须要通过 APT 工具来处理。
简单说：根据规则，帮我们生成代码、生成类文件
编译时注解就是通过 APT 来通过注解信息生成代码来完成某些功能，典型代表有 ButterKnife、Dagger、ARouter 等 ButterKnife 原理分析
使用 ButterKnife :
① 添加依赖 :
dependencies {
implementation 'com.jakewharton:butterknife:10.2.3'
annotationProcessor 'com.jakewharton:butterknife-compiler:10.2.3'
}
② Activity 中使用 ButterKnife :
package kim.hsl.apt;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
public class MainActivity extends AppCompatActivity {
@BindView(R.id.hello)
TextView hello;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
hello.setText("ButterKnife");
}
}
BindView 注解分析 : 在 TextView hello 成员变量处添加了 @BindView(R.id.hello) 注解 ;
@Target(FIELD) 元注解 : 表示其作用与类的成员字段 ;
@Retention(RUNTIME) 元注解 : 表示该注解保留到运行时阶段 ;
int value() 注解属性 : 只有一个注解属性 , 并且属性名是 value , 则使用注解时 “value =” 可省略 ;
@Retention(RUNTIME) @Target(FIELD)
public @interface BindView {
/** View ID to which the field will be bound. */
@IdRes int value();
}
TextView hello 需要使用 findViewById 进行赋值 , 在上述代码中没有写 findViewById 相关的代码 ; 肯定是在某个地方执行了 findViewById 的方法 ;
ButterKnife.bind(this) 代码就是执行了 findViewById 方法 ;
ButterKnife 用到了编译时技术会 , 在项目编译时 , 会生成 MainActivity_ViewBinding 类 , 在该类中 , 会查找添加了 @BindView 直接的成员变量 , 再获取 注解属性 value 的值 , 然后调用 findViewById 方法获取组件并为成员变量赋值 ;
// Generated code from Butter Knife. Do not modify!
package kim.hsl.apt;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.CallSuper;
import androidx.annotation.UiThread;
import butterknife.Unbinder;
import butterknife.internal.Utils;
import java.lang.IllegalStateException;
import java.lang.Override;
public class MainActivity_ViewBinding implements Unbinder {
private MainActivity target;
@UiThread
public MainActivity_ViewBinding(MainActivity target) {
this(target, target.getWindow().getDecorView());
}
@UiThread
public MainActivity_ViewBinding(MainActivity target, View source) {
this.target = target;
target.hello = Utils.findRequiredViewAsType(source, R.id.hello, "field 'hello'", TextView.class);
}
@Override
@CallSuper
public void unbind() {
MainActivity target = this.target;
if (target == null) throw new IllegalStateException("Bindings already cleared.");
this.target = null;
target.hello = null;
}
}
ButterKnife 涉及到的源码 :
public final class ButterKnife {
/**
* BindView annotated fields and methods in the specified {@link Activity}. The current content
* view is used as the view root.
*
* @param target Target activity for view binding.
*/
@NonNull @UiThread
public static Unbinder bind(@NonNull Activity target) {
View sourceView = target.getWindow().getDecorView();
return bind(target, sourceView);
}
/**
* BindView annotated fields and methods in the specified {@code target} using the {@code source}
* {@link View} as the view root.
*
* @param target Target class for view binding.
* @param source View root on which IDs will be looked up.
*/
@NonNull @UiThread
public static Unbinder bind(@NonNull Object target, @NonNull View source) {
Class<?> targetClass = target.getClass();
if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);
if (constructor == null) {
return Unbinder.EMPTY;
}
//noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
try {
return constructor.newInstance(target, source);
} catch (IllegalAccessException e) {
throw new RuntimeException("Unable to invoke " + constructor, e);
} catch (InstantiationException e) {
throw new RuntimeException("Unable to invoke " + constructor, e);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
}
if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException("Unable to create binding instance.", cause);
}
}
@Nullable @CheckResult @UiThread
private static Constructor<? extends Unbinder> findBindingConstructorForClass(Class<?> cls) {
Constructor<? extends Unbinder> bindingCtor = BINDINGS.get(cls);
if (bindingCtor != null || BINDINGS.containsKey(cls)) {
if (debug) Log.d(TAG, "HIT: Cached in binding map.");
return bindingCtor;
}
String clsName = cls.getName();
if (clsName.startsWith("android.") || clsName.startsWith("java.")
|| clsName.startsWith("androidx.")) {
if (debug) Log.d(TAG, "MISS: Reached framework class. Abandoning search.");
return null;
}
try {
Class<?> bindingClass = cls.getClassLoader().loadClass(clsName + "_ViewBinding");
//noinspection unchecked
bindingCtor = (Constructor<? extends Unbinder>) bindingClass.getConstructor(cls, View.class);
if (debug) Log.d(TAG, "HIT: Loaded binding class and constructor.");
} catch (ClassNotFoundException e) {
if (debug) Log.d(TAG, "Not found. Trying superclass " + cls.getSuperclass().getName());
bindingCtor = findBindingConstructorForClass(cls.getSuperclass());
} catch (NoSuchMethodException e) {
throw new RuntimeException("Unable to find binding constructor for " + clsName, e);
}
BINDINGS.put(cls, bindingCtor);
return bindingCtor;
}
}
实战APT实现Butterknife
在开始之前，我们先做个假设，要是我们可以把以下代码摘出来到另一个文件，通过某种方式自动生成这种代码会发生什么事。
package com.calm.baseknowledge02;
import com.calm.annotations.IBind;
import android.view.View;
public class MainActivity_ViewBinding implements IBind<com.calm.baseknowledge02.MainActivity> {
@Override
public void bind(com.calm.baseknowledge02.MainActivity target) {
target.tvInfo = (android.widget.TextView) target.findViewById(2131231077);
target.btnChange = (android.widget.Button) target.findViewById(2131230807);
target.findViewById(2131230807).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
target.onClick(view);
}
});
target.findViewById(2131230807).setOnLongClickListener(new View.OnLongClickListener() {
@Override
public boolean onLongClick(View view) {
target.onLongClick(view);
return true;
}
});
}
}
我们将findViewById、setOnClickListener、setOnLongClickListener这种代码摘到另一个文件，然后实例化该类与原始的Activity进行绑定。由于这些代码非常类似，我们可以通过模板化处理，就不需要我们在一行行去写了，只需要一个注解就搞定。那么关键来了，这份代码如何生成，这时候我们的APT就该上场了。 先将我们的注解写出来，由于这次的注解只需要在源码期存在即可，因此我们的作用域有一定变化，且较上篇会简单些。
/**
* 绑定控件
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.SOURCE)
public @interface BindView {
int value();
}
/**
* 单击事件
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface OnClick {
int[] value() default -1;
}
/**
- 长按事件 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface OnLongClick {
int[] value() default -1;
}
为了做绑定和注入，我们统一一个公共的接口。
public interface IBind<T> {
void bind(T target);
}
注解处理器需要用到的相关插件，已经有现成的了就不需要我们从头去弄了。
dependencies {
implementation project(path: ':annotations')
annotationProcessor 'com.google.auto.service:auto-service:1.0-rc4'
compileOnly 'com.google.auto.service:auto-service:1.0-rc4'
}
关键的类就是注解处理器的类，请看代码
/**
* 注解处理器
*/
@AutoService(Processor.class)
public class AnnotationsCompiler extends AbstractProcessor {
private Filer filer;
private Messager messager;
private static String END_WITH = "_ViewBinding";
private static String BIND_VIEW = "BindView";
private static String ON_CLICK = "OnClick";
private static String ON_LONG_CLICK = "OnLongClick";
/**
* 初始化
* @param processingEnv
*/
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
filer = processingEnv.getFiler();
messager = processingEnv.getMessager();
}
/**
* 支持的版本
* @return
*/
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> types = new HashSet<>();
types.add(BindView.class.getCanonicalName());
types.add(OnClick.class.getCanonicalName());
types.add(OnLongClick.class.getCanonicalName());
return types;
}
/**
* 真正做事的都在这个方法里
* @param set
* @param roundEnvironment
* @return
*/
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
if(set.size() == 0){
return false;
}
//getElementsAnnotatedWith 搜索对应注解的元素
//ExecutableElement 注解在方法节点
//VariableElement 注解在成员变量节点
//TypeElement 注解在类节点
//PackageElement 注解在包节点
Set<? extends Element> bindViewElement = roundEnvironment.getElementsAnnotatedWith(BindView.class);
Set<? extends Element> onClickElement = roundEnvironment.getElementsAnnotatedWith(OnClick.class);
Set<? extends Element> onLongClickElement = roundEnvironment.getElementsAnnotatedWith(OnLongClick.class);
//存储节点的容器 结构为 <com.calm.baseknowledge02.MainActivity,<BindView,List<>>>
Map<String,Map<String, List<Element>>> map = new HashMap<>();
//将BindView注解的成员变量节点进行分类存储
for (Element element : bindViewElement) {
//得到成员变量节点
VariableElement variableElement = (VariableElement) element;
String activityName = variableElement.getEnclosingElement().getSimpleName().toString();
TypeElement typeElement = (TypeElement) variableElement.getEnclosingElement();
String packageName = processingEnv.getElementUtils().getPackageOf(typeElement).toString();
String canonicalName = packageName+"."+activityName;
Map<String, List<Element>> annotationMap = map.get(canonicalName);
if(annotationMap == null){
annotationMap = new HashMap<>();
map.put(canonicalName,annotationMap);
List<Element> bindViewAnnotations = new ArrayList<>();
annotationMap.put(BIND_VIEW,bindViewAnnotations);
bindViewAnnotations.add(element);
}else {
List<Element> bindViewAnnotations = annotationMap.get(BIND_VIEW);
if(bindViewAnnotations == null){
bindViewAnnotations = new ArrayList<>();
annotationMap.put(BIND_VIEW,bindViewAnnotations);
}
bindViewAnnotations.add(element);
}
}
//将OnClick注解节点分类存储
for (Element element : onClickElement) {
//得到方法节点
ExecutableElement executableElement = (ExecutableElement) element;
String activityName = executableElement.getEnclosingElement().getSimpleName().toString();
TypeElement typeElement = (TypeElement) executableElement.getEnclosingElement();
String packageName = processingEnv.getElementUtils().getPackageOf(typeElement).toString();
String canonicalName = packageName+"."+activityName;
Map<String, List<Element>> annotationMap = map.get(canonicalName);
if(annotationMap == null){
annotationMap = new HashMap<>();
map.put(canonicalName,annotationMap);
List<Element> onClickAnnotations = new ArrayList<>();
annotationMap.put(ON_CLICK,onClickAnnotations);
onClickAnnotations.add(element);
}else {
List<Element> onClickAnnotations = annotationMap.get(ON_CLICK);
if(onClickAnnotations == null){
onClickAnnotations = new ArrayList<>();
annotationMap.put(ON_CLICK,onClickAnnotations);
}
onClickAnnotations.add(element);
}
}
//将OnLongClick注解节点分类存储
for (Element element : onLongClickElement) {
//得到方法节点
ExecutableElement executableElement = (ExecutableElement) element;
String activityName = executableElement.getEnclosingElement().getSimpleName().toString();
TypeElement typeElement = (TypeElement) executableElement.getEnclosingElement();
String packageName = processingEnv.getElementUtils().getPackageOf(typeElement).toString();
String canonicalName = packageName+"."+activityName;
Map<String, List<Element>> annotationMap = map.get(canonicalName);
if(annotationMap == null){
annotationMap = new HashMap<>();
map.put(canonicalName,annotationMap);
List<Element> onLongClickAnnotations = new ArrayList<>();
annotationMap.put(ON_LONG_CLICK,onLongClickAnnotations);
onLongClickAnnotations.add(element);
}else {
List<Element> onLongClickAnnotations = annotationMap.get(ON_LONG_CLICK);
if(onLongClickAnnotations == null){
onLongClickAnnotations = new ArrayList<>();
annotationMap.put(ON_LONG_CLICK,onLongClickAnnotations);
}
onLongClickAnnotations.add(element);
}
}
//分类完成，开始写模板代码了
if(map.size() == 0){
return false;
}
Writer writer = null;
Iterator<String> canonicalNames = map.keySet().iterator();
while (canonicalNames.hasNext()){
//全类名
String canonicalName = canonicalNames.next();
print(canonicalName);
//包名
String packageName = canonicalName.substring(0,canonicalName.lastIndexOf("."));
print(packageName);
String activityName = canonicalName.substring(canonicalName.lastIndexOf(".")+1);
print(activityName);
try {
//package com.calm.baseknowledge02;
//import com.calm.annotations.IBind;
//public class MainActivity_ViewBinding implements IBind<MainActivity> {
// @Override
// public void bind(MainActivity target) {
// target.tvInfo = target.findViewById(R.id.tvInfo);
// target.btnChange = target.findViewById(R.id.btnChange);
// }
//}
//创建.java文件，名称类似com.calm.baseknowledge02.MainActivity_ViewBinding
JavaFileObject sourceFile = filer.createSourceFile(canonicalName+END_WITH);
writer = sourceFile.openWriter();
writer.write("package "+packageName+";\n");
writer.write("import com.calm.annotations.IBind;\n");
writer.write("import android.view.View;\n");
writer.write("public class "+activityName+END_WITH+" implements IBind<"+canonicalName+"> {\n");
writer.write("@Override\n");
writer.write("public void bind("+canonicalName+" target){\n");
//注解map
Map<String,List<Element>> annotationMap = map.get(canonicalName);
if(annotationMap != null){
//处理BindView注解
List<Element> bindViews = annotationMap.get(BIND_VIEW);
if(bindViews != null && bindViews.size() > 0){
for (Element bindView : bindViews) {
int id = bindView.getAnnotation(BindView.class).value();
writer.write("target."+bindView.getSimpleName()+" = ("+bindView.asType()+")target.findViewById("+id+");\n");
}
}
//处理OnClick注解
List<Element> onClicks = annotationMap.get(ON_CLICK);
if(onClicks != null && onClicks.size() > 0){
for (Element onClick : onClicks) {
int[] ids = onClick.getAnnotation(OnClick.class).value();
for (int id : ids) {
// findViewById(R.id.btnChange).setOnClickListener(new View.OnClickListener() {
// @Override
// public void onClick(View view) {
//
// }
// });
writer.write("target.findViewById("+id+").setOnClickListener(new View.OnClickListener() {\n");
writer.write("@Override\n");
writer.write("public void onClick(View view) {\n");
writer.write("target."+onClick.getSimpleName().toString()+"(view);\n");
writer.write("}\n");
writer.write("});\n");
}
}
}
//处理OnLongClick注解
List<Element> onLongClicks = annotationMap.get(ON_LONG_CLICK);
if(onLongClicks != null && onLongClicks.size() > 0){
for (Element onLongClick : onLongClicks) {
int[] ids = onLongClick.getAnnotation(OnLongClick.class).value();
for (int id : ids) {
// findViewById(R.id.btnChange).setOnLongClickListener(new View.OnLongClickListener() {
// @Override
// public boolean onLongClick(View view) {
//
// return false;
// }
// });
writer.write("target.findViewById("+id+").setOnLongClickListener(new View.OnLongClickListener() {\n");
writer.write("@Override\n");
writer.write("public boolean onLongClick(View view) {\n");
writer.write("target."+onLongClick.getSimpleName().toString()+"(view);\n");
writer.write("return true;\n");
writer.write("}\n");
writer.write("});\n");
}
}
}
}
writer.write("}\n");
writer.write("}\n");
} catch (IOException e) {
e.printStackTrace();
}finally {
if(writer != null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
return false;
}
private void print(String msg){
messager.printMessage(Diagnostic.Kind.NOTE,msg);
}
}
关键的地方都有注释，就不一一解释了。这个类都不需要我们主动调用，在编译的时候由javac帮我们进行调用。然后编译下代码，我们就会生成一个我们最开始的那样一个类。 为了能使用这些类，我们还要写一个注入的类
public class CButterknife{
public static void bind(Object o) {
String name = o.getClass().getName()+"_ViewBinding";
try {
Class<?> clzz = Class.forName(name);
IBind iBind = (IBind) clzz.newInstance();
iBind.bind(o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
这个类也很简单，由于我们生成的类是有命名套路的。比如类为MainActivity，那么生成的类则为MainActivity_ViewBinding，那么我们要进行注入就很简单了，通过反射实例化该类，调用bind方法即可，就这么简单。然后在Activity中使用就更简单，只需要一句代码即可。
public class MainActivity extends AppCompatActivity {
@BindView(R.id.tvInfo)
TextView tvInfo;
@BindView(R.id.btnChange)
Button btnChange;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
CButterknife.bind(this);
}
@OnClick(R.id.btnChange)
public void onClick(View view){
if(view.getId() == R.id.btnChange){
tvInfo.setText("我是点击按钮后变化的数据");
}
}
@OnLongClick(R.id.btnChange)
public void onLongClick(View view){
if(view.getId() == R.id.btnChange){
tvInfo.setText("我是长按按钮后变化的数据");
}
}
}
这里需要注意的是CButterknife.bind(this)这句代码一定要在setContentView之后调用。
image
以上是Android开发技术中APT实现ButterKnife的一些原理解析和实战演练，更多Android技术分享尽在《Android核心技术手册》里面几十个技术板块划分，上千个小技术点带你进阶进入高工领域。
文末
编译时技术 最重要的作用就是在编译时可以 生成模板代码 ;由于生成代码操作是在编译时进行的 , 不会对运行时的性能产生影响 。
程序的周期 :
- 源码期 : 开发时 , 刚编写完 " .java " 代码 , 还未编译之前 , 就处于源码期 ;
- 编译期 : 程序由 java 源码编译成 class 字节码文件 ;
- 运行期 : 将字节码文件加载到 Java 虚拟机中运行 ;
编译时技术 APT 作用于 编译期 , 在这个过程中使用该技术 , 生成代码 ;编译时技术 2 2 2 大核心要素 : 在编译时 , 执行生成代码的逻辑 , 涉及到两个重要概念 。
① 编译时注解
② 注解处理器
网友评论