APT(Annotation Processing Tool 的简称),可以在代码编译期解析注解,并且生成新的 Java 文件,减少手动的代码输入。现在有很多主流库都用上了 APT,比如 Dagger2,ButterKnife,EventBus3 等,我们要紧跟潮流,与时俱进呐! (ง •̀_•́)ง
下面通过一个简单的 VIEw 注入项目 VIEwFinder 来介绍 APT 相关内容,简单实现了类似于ButterKnife 中的两种注解 @BindVIEw 和 @OnClick 。
项目地址:https://github.com/brucezz/VIEwFinder
大概项目结构如下:
vIEwFinder-annotation - 注解相关模块 vIEwFinder-compiler - 注解处理器模块 vIEwfinder - API 相关模块 sample - 示例 Demo 模块实现目标
在通常的 AndroID 项目中,会写大量的界面,那么就会经常重复地写一些代码,比如:
TextVIEw text = (TextVIEw) findVIEwByID(R.ID.tv);text.setonClickListener(new VIEw.OnClickListener() { @OverrIDe public voID onClick(VIEw vIEw) { // on click }});
天天写这么冗长又无脑的代码,还能不能愉快地玩耍啦。所以,我打算通过 VIEwFinder 这个项目替代这重复的工作,只需要简单地标注上注解即可。通过控件 ID 进行注解,并且@OnClick 可以对多个控件注解同一个方法。就像下面这样子咯:
@BindVIEw(R.ID.tv) TextVIEw mTextVIEw;@OnClick({R.ID.tv,R.ID.btn})public voID onSomethingClick() { // on click}
定义注解
创建 module vIEwFinder-annotation ,类型为 Java library,定义项目所需要的注解。
在 VIEwFinder 中需要两个注解 @BindVIEw 和 @OnClick 。实现如下:
@Retention(RetentionPolicy.CLASS)@Target(ElementType.FIELD)public @interface BindVIEw { int value();}
@Retention(RetentionPolicy.CLASS)@Target(ElementType.METHOD)public @interface OnClick { int[] value();}
@BindVIEw 需要对成员变量进行注解,并且接收一个 int 类型的参数; @OnClick 需要对方法进行注解,接收一组 int 类型参数,相当于给一组 VIEw 指定点击响应事件。
编写 API
创建 module vIEwfinder,类型为 AndroID library。在这个 module 中去定义 API,也就是去确定让别人如何来使用我们这个项目。
首先需要一个 API 主入口,提供静态方法直接调用,就比如这样:
VIEwFinder.inject(this);
同时,需要为不同的目标(比如 Activity、Fragment 和 VIEw 等)提供重载的注入方法,最终都调用 inject() 方法。其中有三个参数:
host 表示注解 VIEw 变量所在的类,也就是注解类 source 表示查找 VIEw 的地方,Activity & VIEw 自身就可以查找,Fragment 需要在自己的 itemVIEw 中查找 provIDer 是一个接口,定义了不同对象(比如 Activity、VIEw 等)如何去查找目标 VIEw,项目中分别为 Activity、VIEw 实现了 ProvIDer 接口。public class VIEwFinder { private static final ActivityProvIDer PROVIDER_ACTIVITY = new ActivityProvIDer(); private static final VIEwProvIDer PROVIDER_VIEW = new VIEwProvIDer(); public static voID inject(Activity activity) { inject(activity,activity,PROVIDER_ACTIVITY); } public static voID inject(VIEw vIEw) { // for vIEw inject(vIEw,vIEw); } public static voID inject(Object host,VIEw vIEw) { // for fragment inject(host,vIEw,PROVIDER_VIEW); } public static voID inject(Object host,Object source,ProvIDer provIDer) { // how to implement ? }}
那么 inject() 方法中都写一些什么呢?
首先我们需要一个接口 Finder,然后为每一个注解类都生成一个对应的内部类并且实现这个接口,然后实现具体的注入逻辑。在 inject() 方法中首先找到调用者对应的 Finder 实现类,然后调用其内部的具体逻辑来达到注入的目的。
接口 Finder 设计如下 :
public interface Finder<T> { voID inject(T host,ProvIDer provIDer);}
举个例子,为 MainActivity 生成 MainActivity$$Finder,对其注解的 VIEw 进行初始化和设置点击事件,这就跟我们平常所写的重复代码基本相同。
public class MainActivity$$Finder implements Finder<MainActivity> { @OverrIDe public voID inject(final MainActivity host,ProvIDer provIDer) { host.mTextVIEw = (TextVIEw) (provIDer.findVIEw(source,2131427414)); host.mbutton = (button) (provIDer.findVIEw(source,2131427413)); host.mEditText = (EditText) (provIDer.findVIEw(source,2131427412)); VIEw.OnClickListener Listener; Listener = new VIEw.OnClickListener() { @OverrIDe public voID onClick(VIEw vIEw) { host.onbuttonClick(); } }; provIDer.findVIEw(source,2131427413).setonClickListener(Listener); Listener = new VIEw.OnClickListener() { @OverrIDe public voID onClick(VIEw vIEw) { host.onTextClick(); } }; provIDer.findVIEw(source,2131427414).setonClickListener(Listener); }}
好了,所有注解类都有了一个名为 xx$$Finder 的内部类。我们首先通过注解类的类名,得到其对应内部类的 Class 对象,然后实例化拿到具体对象,调用注入方法。
public class VIEwFinder { // same as above private static final Map<String,Finder> FINDER_MAP = new HashMap<>(); public static voID inject(Object host,ProvIDer provIDer) { String classname = host.getClass().getname(); try { Finder finder = FINDER_MAP.get(classname); if (finder == null) { Class<?> finderClass = Class.forname(classname + "$$Finder"); finder = (Finder) finderClass.newInstance(); FINDER_MAP.put(classname,finder); } finder.inject(host,source,provIDer); } catch (Exception e) { throw new RuntimeException("Unable to inject for " + classname,e); } }}
另外代码中使用到了一点反射,所以为了提高效率,避免每次注入的时候都去找 Finder 对象,这里用一个 Map 将第一次找到的对象缓存起来,后面用的时候直接从 Map 里面取。
到此,API 模块的设计基本搞定了,接下来就是去通过注解处理器为每一个注解类生成 Finder内部类。
创建注解处理器
创建 module vIEwFinder-compiler,类型为 Java library,实现一个注解处理器。
这个模块需要添加一些依赖:
compile project(':vIEwfinder-annotation')compile 'com.squareup:javapoet:1.7.0'compile 'com.Google.auto.service:auto-service:1.0-rc2'因为要用到前面定义的注解,当然要依赖 vIEwFinder-annotation。 javapoet 是方块公司出的又一个好用到爆炸的裤子,提供了各种 API 让你用各种姿势去生成 Java 代码文件,避免了徒手拼接字符串的尴尬。 auto-service 是 Google 家的裤子,主要用于注解 Processor,对其生成 meta-inf 配置信息。
下面就来创建我们的处理器 VIEwFinderProcessor。
@autoService(Processor.class)public class VIEwFinderProcesser extends AbstractProcessor { /** * 使用 Google 的 auto-service 库可以自动生成 meta-inf/services/javax.annotation.processing.Processor 文件 */ private filer mfiler; //文件相关的辅助类 private Elements mElementUtils; //元素相关的辅助类 private Messager mMessager; //日志相关的辅助类 @OverrIDe public synchronized voID init(ProcessingEnvironment processingEnv) { super.init(processingEnv); mfiler = processingEnv.getfiler(); mElementUtils = processingEnv.getElementUtils(); mMessager = processingEnv.getMessager(); } /** * @return 指定哪些注解应该被注解处理器注册 */ @OverrIDe public Set<String> getSupportedAnnotationTypes() { Set<String> types = new linkedHashSet<>(); types.add(BindVIEw.class.getCanonicalname()); types.add(OnClick.class.getCanonicalname()); return types; } /** * @return 指定使用的 Java 版本。通常返回 SourceVersion.latestSupported()。 */ @OverrIDe public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported(); } @OverrIDe public boolean process(Set<? extends TypeElement> annotations,RoundEnvironment roundEnv) { // to process annotations return false; }}
用 @autoService 来注解这个处理器,可以自动生成配置信息。
在 init() 可以初始化拿到一些实用的工具类。
在 getSupportedAnnotationTypes() 方法中返回所要处理的注解的集合。
在 getSupportedSourceVersion() 方法中返回 Java 版本。
这几个方法写法基本上都是固定的,重头戏在 process() 方法。
这里插播一下 Element 元素相关概念,后面会用到不少。
Element 元素,源代码中的每一部分都是一个特定的元素类型,分别代表了包、类、方法等等,具体看 Demo。
package com.example;public class Foo { // TypeElement private int a; // VariableElement private Foo other; // VariableElement public Foo() {} // ExecuteableElement public voID setA( // ExecuteableElement int newA // TypeElement ) { }}
这些 Element 元素,相当于 XML 中的 DOM 树,可以通过一个元素去访问它的父元素或者子元素。
element.getEnclosingElement();// 获取父元素
element.getEnclosedElements();// 获取子元素
注解处理器的整个处理过程跟普通的 Java 程序没什么区别,我们可以使用面向对象的思想和设计模式,将相关逻辑封装到 model 中,使得流程更清晰简洁。分别将注解的成员变量、点击方法和整个注解类封装成不同的 model。
public class BindVIEwFIEld { private VariableElement mFIEldElement; 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())); } mFIEldElement = (VariableElement) element; BindVIEw bindVIEw = mFIEldElement.getAnnotation(BindVIEw.class); mResID = bindVIEw.value(); } // some getter methods}
主要就是在初始化时校验了一下元素类型,然后获取注解的值,在提供几个 get 方法。OnClickMethod 封装类似。
public class AnnotatedClass { public TypeElement mClassElement; public List<BindVIEwFIEld> mFIElds; public List<OnClickMethod> mMethods; public Elements mElementUtils; // omit some easy methods public Javafile generateFinder() { // method inject(final T host,ProvIDer provIDer) MethodSpec.Builder injectMethodBuilder = MethodSpec.methodBuilder("inject") .addModifIErs(ModifIEr.PUBliC) .addAnnotation(OverrIDe.class) .addParameter(Typename.get(mClassElement.asType()),"host",ModifIEr.FINAL) .addParameter(Typename.OBJECT,"source") .addParameter(TypeUtil.PROVIDER,"provIDer"); for (BindVIEwFIEld fIEld : mFIElds) { // find vIEws injectMethodBuilder.addStatement("host.$N = ($T)(provIDer.findVIEw(source,$L))",fIEld.getFIEldname(),Classname.get(fIEld.getFIEldType()),fIEld.getResID()); } if (mMethods.size() > 0) { injectMethodBuilder.addStatement("$T Listener",TypeUtil.ANDROID_ON_CliCK_ListENER); } for (OnClickMethod method : mMethods) { // declare OnClickListener anonymous class 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(); injectMethodBuilder.addStatement("Listener = $L ",Listener); for (int ID : method.IDs) { // set Listeners injectMethodBuilder.addStatement("provIDer.findVIEw(source,$L).setonClickListener(Listener)",ID); } } // generate whole class typespec finderClass = typespec.classBuilder(mClassElement.getSimplename() + "$$Finder") .addModifIErs(ModifIEr.PUBliC) .addSuperinterface(ParameterizedTypename.get(TypeUtil.FINDER,Typename.get(mClassElement.asType()))) .addMethod(injectMethodBuilder.build()) .build(); String packagename = mElementUtils.getPackageOf(mClassElement).getQualifIEdname().toString(); // generate file return Javafile.builder(packagename,finderClass).build(); }}
AnnotatedClass 表示一个注解类,里面放了两个列表,分别装着注解的成员变量和方法。在generateFinder() 方法中,按照上一节设计的模板,利用 JavaPoet 的 API 生成代码。这部分没啥特别的姿势,照着 JavaPoet 文档 来就好了,文档写得很细致。
有很多地方需要用到对象的类型,普通类型可以用
Classname get(String packagename,String simplename,String... simplenames)
传入包名、类名、内部类名,就可以拿到想要的类型了(可以参考 项目中TypeUtil 类)。
用到泛型的话,可以用
ParameterizedTypename get(Classname rawType,Typename... typeArguments)
传入具体类和泛型类型就好了。
这些 model 都确定好了之后,process() 方法就很清爽啦。使用 RoundEnvironment 参数来查询被特定注解标注的元素,然后解析成具体的 model,最后生成代码输出到文件中。
@autoService(Processor.class)public class VIEwFinderProcesser extends AbstractProcessor { private Map<String,AnnotatedClass> mAnnotatedClassMap = new HashMap<>(); @OverrIDe public boolean process(Set<? extends TypeElement> annotations,RoundEnvironment roundEnv) { // process() will be called several times mAnnotatedClassMap.clear(); try { processBindVIEw(roundEnv); processOnClick(roundEnv); } catch (IllegalArgumentException e) { error(e.getMessage()); return true; // stop process } for (AnnotatedClass annotatedClass : mAnnotatedClassMap.values()) { try { info("Generating file for %s",annotatedClass.getFullClassname()); annotatedClass.generateFinder().writeto(mfiler); } catch (IOException e) { error("Generate file Failed,reason: %s",e.getMessage()); return true; } } return true; } private voID processBindVIEw(RoundEnvironment roundEnv) throws IllegalArgumentException { for (Element element : roundEnv.getElementsAnnotateDWith(BindVIEw.class)) { AnnotatedClass annotatedClass = getAnnotatedClass(element); BindVIEwFIEld fIEld = new BindVIEwFIEld(element); annotatedClass.addFIEld(fIEld); } } private voID processOnClick(RoundEnvironment roundEnv) { // same as processBindVIEw() } private AnnotatedClass getAnnotatedClass(Element element) { TypeElement classElement = (TypeElement) element.getEnclosingElement(); String fullClassname = classElement.getQualifIEdname().toString(); AnnotatedClass annotatedClass = mAnnotatedClassMap.get(fullClassname); if (annotatedClass == null) { annotatedClass = new AnnotatedClass(classElement,mElementUtils); mAnnotatedClassMap.put(fullClassname,annotatedClass); } return annotatedClass; }}
首先解析注解元素,并放到对应的注解类对象中,最后调用方法生成文件。model 的代码中还会加入一些校验代码,来判断注解元素是否合理,数据是否正常,然后抛出异常,处理器接收到之后可以打印出错误提示,然后直接返回 true 来结束处理。
至此,注解处理器也基本完成了,具体细节参考项目代码。
实际项目使用
创建 module sample,普通的 AndroID module,来演示 VIEwFinder 的使用。
在整个项目下的 build.gradle 中添加
classpath 'com.neenbedankt.gradle.plugins:androID-apt:1.8'
然后在 sample module 下的 build.gradle 中添加
apply plugin: 'com.neenbedankt.androID-apt'
同时添加依赖:
compile project(':vIEwfinder-annotation')compile project(':vIEwfinder')apt project(':vIEwfinder-compiler')
然后随便创建个布局,随便添加几个控件,就能体验注解啦。
public class MainActivity extends AppCompatActivity { @BindVIEw(R.ID.tv) TextVIEw mTextVIEw; @BindVIEw(R.ID.btn) button mbutton; @BindVIEw(R.ID.et) EditText mEditText; @OnClick(R.ID.btn) public voID onbuttonClick() { Toast.makeText(this,"onbuttonClick",Toast.LENGTH_SHORT).show(); } @OnClick(R.ID.tv) public voID onTextClick() { Toast.makeText(this,"onTextClick",Toast.LENGTH_SHORT).show(); } @OverrIDe protected voID onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentVIEw(R.layout.activity_main); VIEwFinder.inject(this); }}
这个时候 build 一下项目,就能看到生成的 MainActivity$$Finder 类了,再运行项目就跑起来了。每次改变注解之后,build 一下项目就好啦。
all done ~
这个项目也就是个玩具级的 APT 项目,借此来学习如何编写 APT 项目。感觉 APT 项目更多地是考虑如何去设计架构,类之间如何调用,需要生成什么样的代码,提供怎样的 API 去调用。最后才是利用注解处理器去解析注解,然后用 JavaPoet 去生成具体的代码。
思路比实现更重要,设计比代码更巧妙。
参考
Annotation-Processing-Tool详解 (大力推荐) AndroID 如何编写基于编译时注解的项目 JavaPoet 文档 ButterKnife (代码结构设计很棒)通过此文,希望能帮助大家开发AndroID应用程序,谢谢大家对本站的支持!
总结以上是内存溢出为你收集整理的Android 利用 APT 技术在编译期生成代码全部内容,希望文章能够帮你解决Android 利用 APT 技术在编译期生成代码所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错,欢迎将内存溢出网站推荐给程序员好友。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)