登山则情满于山，观海则意溢于海。这篇文章主要讲述使用APT实现Android中View的注入相关的知识，希望能为你提供帮助。
个人博客使用APT实现android中View的注入 前言
http://www.milovetingting.cn
APT是Annotation Processing Tool的简写，通过在java编译时期，处理注解，生成代码。APT在ButterKnife、Dagger2等框架中都有应用。下面通过使用APT，实现一个类似ButterKnife的简单的View注入的框架。(参考Jett老师的课程)ButterKnife的实现原理既然准备实现类似ButterKnife的框架，那么我们就需要了解ButterKnife的实现原理。
ButterKnife的使用是从
ButterKnife.bind()开始的:@NonNull @UiThread
public static Unbinder bind(@NonNull Activity target) {
View sourceView = target.getWindow().getDecorView();
return bind(target, sourceView);
}可以看到，
bind方法中又调用了内部的bind方法@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);
}
}在这个bind方法中，主要通过
findBindingConstructorForClass方法获取到构造函数，然后返回具体的实例。@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());
//没有Class，则递归调用，从父类中查找
bindingCtor = findBindingConstructorForClass(cls.getSuperclass());
} catch (NoSuchMethodException e) {
throw new RuntimeException("
Unable to find binding constructor for "
+ clsName, e);
}
//放入到缓存中
BINDINGS.put(cls, bindingCtor);
return bindingCtor;
}
}在
findBindingConstructorForClass方法中，首先查询缓存中是否有需要的构造函数，如果没有，那么会通过反射查找,最终返回了ButterKnife生成的辅助类XXX_ViewBinding的构造函数。Build工程后，在生成的XXX_ViewBinding的Java文件的构造方法中，可以看到ButterKnife帮我们自己调用了
findViewById
文章图片
//MainActivity_ViewBinding类中的方法
@UiThread
public MainActivity_ViewBinding(MainActivity target, View source) {
this.target = target;
target.tv = Utils.findRequiredViewAsType(source, R.id.tv, "
field '
tv'
"
, TextView.class);
}//Utils类中方法
public static <
T>
T findRequiredViewAsType(View source, @IdRes int id, String who,
Class<
T>
cls) {
View view = findRequiredView(source, id, who);
return castView(view, id, who, cls);
}//Utils类中方法
public static View findRequiredView(View source, @IdRes int id, String who) {
View view = source.findViewById(id);
if (view != null) {
return view;
}
String name = getResourceEntryName(source, id);
throw new IllegalStateException("
Required view '
"
+ name
+ "
'
with ID "
+ id
+ "
for "
+ who
+ "
was not found. If this view is optional add '
@Nullable'
(fields) or '
@Optional'
"
+ "
(methods) annotation."
);
}可以得出结论，ButterKnife就是利用
APT解析注解，在编译时生成了辅助类，用来帮助我们去调用findViewById方法，从而减少手动使用findViewById实现自已的View注入框架【使用APT实现Android中View的注入】了解了原理后，就可以自己来实现简单的View注入框架了。
新建annotation模块
新建
Java Library类型的Module,名称为annotation，用来定义注解
文章图片
新建annotation_compiler模块
然后，同样的方法新建名为annotation_compiler的模块，用来
处理注解新建Binder模块
我们还需要新建一个名为Binder的模块，用来
供用户直接调用添加依赖
新建这三个Modeule后，需要为相应的Module
添加依赖。app模块需要依赖上面的三个模块，annotation_compiler需要依赖annotation。
文章图片
文章图片
编写annotation模块代码
在annotation模块下新建
BindView注解@Target(ElementType.FIELD)
@Retention(RetentionPolicy.SOURCE)
public @interface BindView {
int value();
}编写annotation_compiler模块代码
要使用APT，需要添加相关依赖，在
annotation_compiler模块下的build.gradle文件中编辑dependencies {
//注册APT功能
annotationProcessor '
com.google.auto.service:auto-service:1.0-rc4'
compileOnly '
com.google.auto.service:auto-service:1.0-rc4'
}同步后就可以使用APT了。
在annotation_compiler模块下新建
AnnotationsCompiler类,继承自AbstractProcessor@AutoService(Processor.class)
public class AnnotationsCompiler extends AbstractProcessor {
//...
}需要
重写三个方法/**
* 支持的Java版本
*
* @return
*/
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}/**
* 支持的注解
*
* @return
*/
@Override
public Set<
String>
getSupportedAnnotationTypes() {
Set<
String>
types = new HashSet<
>
();
types.add(BindView.class.getCanonicalName());
return types;
}@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
filer = processingEnvironment.getFiler();
}重写
process方法，主要的逻辑都在这里实现@Override
public boolean process(Set<
? extends TypeElement>
set, RoundEnvironment roundEnvironment) {
Set<
? extends Element>
elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
//类：TypeElement
//方法：ExecutableElement
//属性：VariableElementMap<
String, List<
VariableElement>
>
map = new HashMap<
>
();
for (Element element : elements) {
VariableElement variableElement = (VariableElement) element;
String activityName = variableElement.getEnclosingElement().getSimpleName().toString();
List<
VariableElement>
variableElements = map.get(activityName);
if (variableElements == null) {
variableElements = new ArrayList<
>
();
map.put(activityName, variableElements);
}
variableElements.add(variableElement);
}if (map.size() >
0) {
Writer writer = null;
Iterator<
String>
iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String activityName = iterator.next();
List<
VariableElement>
variableElements = map.get(activityName);
//获取包名
TypeElement typeElement =
(TypeElement) variableElements.get(0).getEnclosingElement();
String packageName =
processingEnv.getElementUtils().getPackageOf(typeElement).toString();
try {
JavaFileObject sourceFile =
filer.createSourceFile(packageName + "
."
+ activityName +
"
_ViewBinding"
);
writer = sourceFile.openWriter();
writer.write("
package "
+ packageName + "
;
"
);
writer.write("
import "
+ PACKAGE_NAME_BINDER + "
.IBinder;
"
);
writer.write("
public class "
+activityName+"
_ViewBinding implements IBinder<
"
+packageName+"
."
+activityName+"
>
{
"
);
writer.write("
@Override
"
);
writer.write("
public void bind("
+packageName+"
."
+activityName+"
target){
"
);
for(VariableElement variableElement:variableElements)
{
//获取名字
String variableName = variableElement.getSimpleName().toString();
//获取ID
int id = variableElement.getAnnotation(BindView.class).value();
//得到类型
TypeMirror typeMirror = variableElement.asType();
writer.write("
target."
+variableName+"
=("
+typeMirror+"
)target.findViewById("
+id+"
);
"
);
}
writer.write("
}
}"
);
} catch (Exception e) {
e.printStackTrace();
}
finally {
if(writer!=null)
{
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}return false;
}编写Binder模块代码
在Binder模块下新建
IBinder类public interface IBinder<
T>
{/**
* 绑定activity
*
* @param t
*/
void bind(T t);
}新建ViewBinder类，这个类是直接供用户调用的
public class ViewBinder {
public static void bind(Object activity) {
String name = activity.getClass().getName() + "
_ViewBinding"
;
try {
Class<
?>
clazz = Class.forName(name);
IBinder binder = (IBinder) clazz.newInstance();
binder.bind(activity);
} catch (Exception e) {
e.printStackTrace();
}
}
}在app模块调用
编写好上面的模块后，执行Build-Rebuild Project后，可以看到生成的java类文件
文章图片
在app模块的MainActivity中使用
@BindView(R.id.tv)
TextView tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//调用自己定义的ViewBinder
ViewBinder.bind(this);
tv.setText("
Hi,ViewBinder!"
);
}运行应用后，可以看到已经更改了TextView的显示，从而证明我们自己定义的ViewBinder是可以正常运行的。
结束使用APT实现Android中View的注入，具体步骤就是上面描述的。当然，这个只是一个简单的示例，如果要开发出完善的框架，还有很多需要注意和优化的，这里只是记录开发的一般流程，以便后面需要时查找资料。
源码源码地址：https://github.com/milovetingting/Samples/tree/master/ViewBinder
推荐阅读
- Android中网络框架的简单封装
- Android 杂项
- Springboot集成mybatis通用Mapper与分页插件PageHelper(推荐)
- CMDB3完善采集端代码(ssh方案的多线程采集), 异常处理, 服务端目录结构的设计(django的app), API数据分析比对入库
- ApplicationDocker 安装 MySQL
- Android Studio 连接mumu模拟器
- 2020Android春招面试经历（已拿今日头条28Koffer）
- 无法加载文件 C:Users***AppDataRoamingpmcnpm.ps1，因为在此系统上禁止运行脚本
- 简单聊聊AndroidIPC机制