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

一、apt是什么?有什么用，带着疑惑来学习

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

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

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

创新互联长期为上1000+客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为新华企业提供专业的成都做网站、成都网站制作、成都外贸网站建设，新华网站改版等技术服务。拥有十年丰富建站经验和众多成功案例,为您定制开发。

1、创建几个Library来声明

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

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

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

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

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

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

定义了运行时注解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. 
  
  
  
  
  2.     implementation 'com.google.auto.service:auto-service:1.0-rc2' 
    3. 
  
  
  
  
  3.     implementation project(':aptlib-anno')
    4. 
  
  
  
  
  4. }
    5.

创建BindViewProcessor

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

4、写工具类BindViewTools

在aptlib项目中写绑定类

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

5、主项目app中引入

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

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

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

总结

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

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

当前题目：注解APT应用详解(手把手教你写ButterKnife工具)
分享链接：http://www.36103.cn/qtweb/news29/7679.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

python知识

同城分类信息

成都ssl证书申请　　 　网络营销推广　　 　响应式网站建设公司　　 　中建建业环保　　 　成都网站制作　　 　网站设计制作　　 　成都seo优化　　 　全网营销　　 　香港云主机　　 　香港空间腾讯云　　 　网站服务器租用　　 　成都微商城开发　　 　微信公众号二次开发　　 　联通机柜租用　　 　成都高电机柜租用　　 　微信小程序公众号开发　　 　四川网站建设　　 　四川服务器托管　　 　四川成都网站建设　　 　网站制作