当前位置：首页 >探索 >注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出

注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出

2024-06-29 08:28:35 [百科] 来源：避面尹邢网

注解APT应用详解(手把手教你写ButterKnife工具)

作者： Android开发编程 移动开发 Android APT(Annotation Processing Tool)即注解处理器，注解是应用详一种处理注解的工具，确切的解手教写具说它是javac的一个工具，它用来在编译时扫描和处理注解。把手注解处理器以Java代码(或者编译过的注解字节码)作为输入，生成.java文件作为输出。应用详

 [[410458]]

本文转载自微信公众号「Android开发编程」，解手教写具作者Android开发编程。把手转载本文请联系Android开发编程公众号。注解

一、应用详APT是解手教写具什么?有什么用，带着疑惑来学习

  • APT(Annotation Processing Tool)即注解处理器，把手是注解一种处理注解的工具，确切的应用详说它是javac的一个工具，它用来在编译时扫描和处理注解。解手教写具注解处理器以Java代码(或者编译过的字节码)作为输入，生成.java文件作为输出;
  • 简单来说就是在编译期，通过注解生成.java文件;
  • 使用APT的优点就是方便、简单，可以少些很多重复的代码;用过ButterKnife、Dagger、EventBus等注解框架的同学就能感受到，利用这些框架可以少些很多代码，只要写一些注解就可以了，他们不过是通过注解，帮助生成了一些高效代码;

二、APT应用-仿照ButterKnife写个注解

注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出

通过APT实现一个功能，通过对View变量的注解，实现View的绑定

注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出

1、创建几个Library来声明

注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出

  1. Android Library：aptlibs 正常的写Android的lib   
  2. Java or Kotlin Library：aptlib-anno （专门放我们编写的注解） 
  3. Java or Kotlin Library ：aptlib-processor （编写动态生成文件的逻辑） 
  4. aptlibs 
  5. plugins {  
  6.     id 'com.android.library' 
  7.     id 'kotlin-android' 
  8. } 
  9. aptlib-anno  
  10. plugins {  
  11.     id 'java-library' 
  12. } 
  13. aptlib-processor 
  14. 是plugins {  
  15.     id 'java-library' 
  16. } 

这个要记清楚，很多博主估计自己都没有写过apt，分不清楚AndroidLib和javaLib

apt 本来java 提供的，另外 Android库中不允许继承AbstractProcessor

2 、定义注解-自定义注解

记住要在 aptlib-anno 库下面创建

  1. @Retention(RetentionPolicy.CLASS) 
  2. @Target(ElementType.FIELD) 
  3. public @interface BindView {  
  4.     int value(); 
  5. } 

定义了运行时注解BindView，其中value()用于获取对应View的id;

  • @Retention(RetentionPolicy.CLASS)：表示编译时注解
  • @Target(ElementType.FIELD)：表示注解范围为类成员(构造方法、方法、成员变量)
  • @Retention：定义被保留的时间长短
  • RetentionPoicy.SOURCE、RetentionPoicy.CLASS、RetentionPoicy.RUNTIME
  • @Target：定义所修饰的对象范围
  • TYPE、FIELD、METHOD、PARAMETER、CONSTRUCTOR、LOCAL_VARIABLE等

3、定义注解处理器-动态生成关联文件

aptlib-processor 库

首先在本lib下添加依赖

  1. dependencies {  
  2.     implementation 'com.google.auto.service:auto-service:1.0-rc2'  
  3.     implementation project(':aptlib-anno') 
  4. } 

创建BindViewProcessor

  1. @AutoService(Processor.class) 
  2. public class BindViewProcessor extends AbstractProcessor {  
  3.     private Messager mMessager; 
  4.     private Elements mElementUtils; 
  5.     private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>(); 
  6.     @Override 
  7.     public synchronized void init(ProcessingEnvironment processingEnv) {  
  8.         super.init(processingEnv); 
  9.         mMessager = processingEnv.getMessager(); 
  10.         mElementUtils = processingEnv.getElementUtils(); 
  11.     } 
  12.     @Override 
  13.     public Set<String> getSupportedAnnotationTypes() {  
  14.         HashSet<String> supportTypes = new LinkedHashSet<>(); 
  15.         supportTypes.add(BindView.class.getCanonicalName()); 
  16.         return supportTypes; 
  17.     } 
  18.     @Override 
  19.     public SourceVersion getSupportedSourceVersion() {  
  20.         return SourceVersion.latestSupported(); 
  21.     } 
  22.     @Override 
  23.     public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnv) {  
  24.            mMessager.printMessage(Diagnostic.Kind.NOTE, "processing..."); 
  25.         mProxyMap.clear(); 
  26.         //得到所有的注解 
  27.         Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class); 
  28.         for (Element element : elements) {  
  29.             VariableElement variableElement = (VariableElement) element; 
  30.             TypeElement classElement = (TypeElement) variableElement.getEnclosingElement(); 
  31.             String fullClassName = classElement.getQualifiedName().toString(); 
  32.             ClassCreatorProxy proxy = mProxyMap.get(fullClassName); 
  33.             if (proxy == null) {  
  34.                 proxy = new ClassCreatorProxy(mElementUtils, classElement); 
  35.                 mProxyMap.put(fullClassName, proxy); 
  36.             } 
  37.             BindView bindAnnotation = variableElement.getAnnotation(BindView.class); 
  38.             int id = bindAnnotation.value(); 
  39.             proxy.putElement(id, variableElement); 
  40.         } 
  41.         //通过遍历mProxyMap，创建java文件 
  42.         for (String key : mProxyMap.keySet()) {  
  43.             ClassCreatorProxy proxyInfo = mProxyMap.get(key); 
  44.             try {  
  45.                 mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName()); 
  46.                 JavaFileObject jfo = processingEnv.getFiler().createSourceFile(proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement()); 
  47.                 Writer writer = jfo.openWriter(); 
  48.                 writer.write(proxyInfo.generateJavaCode()); 
  49.                 writer.flush(); 
  50.                 writer.close(); 
  51.             } catch (IOException e) {  
  52.                 mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error"); 
  53.             } 
  54.         } 
  55.         mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ..."); 
  56.         return true; 
  57.     } 
  58. } 
  1. public class ClassCreatorProxy {  
  2.     private String mBindingClassName; 
  3.     private String mPackageName; 
  4.     private TypeElement mTypeElement; 
  5.     private Map<Integer, VariableElement> mVariableElementMap = new HashMap<>(); 
  6.     public ClassCreatorProxy(Elements elementUtils, TypeElement classElement) {  
  7.         this.mTypeElement = classElement; 
  8.         PackageElement packageElement = elementUtils.getPackageOf(mTypeElement); 
  9.         String packageName = packageElement.getQualifiedName().toString(); 
  10.         String className = mTypeElement.getSimpleName().toString(); 
  11.         this.mPackageName = packageName; 
  12.         this.mBindingClassName = className + "_ViewBinding"; 
  13.     } 
  14.     public void putElement(int id, VariableElement element) {  
  15.         mVariableElementMap.put(id, element); 
  16.     } 
  17.     /** 
  18.      * 创建Java代码 
  19.      * @return 
  20.      */ 
  21.     public String generateJavaCode() {  
  22.         StringBuilder builder = new StringBuilder(); 
  23.         builder.append("package ").append(mPackageName).append(";\n\n"); 
  24.         builder.append("import com.example.gavin.apt_library.*;\n"); 
  25.         builder.append('\n'); 
  26.         builder.append("public class ").append(mBindingClassName); 
  27.         builder.append(" { \n"); 
  28.         generateMethods(builder); 
  29.         builder.append('\n'); 
  30.         builder.append("}\n"); 
  31.         return builder.toString(); 
  32.     } 
  33.     /** 
  34.      * 加入Method 
  35.      * @param builder 
  36.      */ 
  37.     private void generateMethods(StringBuilder builder) {  
  38.         builder.append("public void bind(" + mTypeElement.getQualifiedName() + " host ) { \n"); 
  39.         for (int id : mVariableElementMap.keySet()) {  
  40.             VariableElement element = mVariableElementMap.get(id); 
  41.             String name = element.getSimpleName().toString(); 
  42.             String type = element.asType().toString(); 
  43.             builder.append("host." + name).append(" = "); 
  44.             builder.append("(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));\n"); 
  45.         } 
  46.         builder.append("  }\n"); 
  47.     } 
  48.     public String getProxyClassFullName() 
  49.     {  
  50.         return mPackageName + "." + mBindingClassName; 
  51.     } 
  52.     public TypeElement getTypeElement() 
  53.     {  
  54.         return mTypeElement; 
  55.     } 
  56. } 
  • init：初始化。可以得到ProcessingEnviroment，ProcessingEnviroment提供很多有用的工具类Elements, Types 和 Filer
  • getSupportedAnnotationTypes：指定这个注解处理器是注册给哪个注解的，这里说明是注解BindView
  • getSupportedSourceVersion：指定使用的Java版本，通常这里返回SourceVersion.latestSupported()
  • process：可以在这里写扫描、评估和处理注解的代码，生成Java文件
  • auto-service 库：自动生成代码需要借助的库

4、写工具类BindViewTools

在aptlib项目中写绑定类

  1. public class BindViewTools {  
  2.     public static void bind(Activity activity) {  
  3.         Class clazz = activity.getClass(); 
  4.         try {  
  5.             Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding"); 
  6.             Method method = bindViewClass.getMethod("bind", activity.getClass()); 
  7.             method.invoke(bindViewClass.newInstance(), activity); 
  8.         } catch (Exception e) {  
  9.             e.printStackTrace(); 
  10.         } 
  11.     } 
  12. } 

5、主项目app中引入

  1. implementation project(path: ':aptlib') 
  2.  annotationProcessor project(path: ':aptlib-process') 

在MainActivity中，在View的前面加上BindView注解，把id传入即可

  1. public class MainActivity extends AppCompatActivity {  
  2.     @BindView(R.id.tv) 
  3.     TextView mTextView; 
  4.     @BindView(R.id.btn) 
  5.     Button mButton; 
  6.     @Override 
  7.     protected void onCreate(Bundle savedInstanceState) {  
  8.         super.onCreate(savedInstanceState); 
  9.         setContentView(R.layout.activity_main); 
  10.         BindViewTools.bind(this); 
  11.         mTextView.setText("bind TextView success"); 
  12.         mButton.setText("bind Button success"); 
  13.     } 
  14. } 

总结

1、APT技术其实就是自定义注解和注解处理器，在编译期间生成Java文件，类似于IOC控制反转，可以方便的进行解耦;

2、如果你也可以实现很多不同的项目，比如路由框架等等，后续也会写一些apt的项目

 

责任编辑：武晓燕 来源： Android开发编程 ButterKnife工具APT

(责任编辑：探索)

    相关内容
    推荐文章
    热点阅读
      随机内容

      友情链接

      接受PR>=1、BR>=1，流量相当，内容相关类链接。

      Copyright ©2024 Powered by 注解APT应用详解(手把手教你写ButterKnife工具) 生成.java文件作为输出,避面尹邢网   sitemap