Android基础系列篇（一）：注解的那些事儿~

持续创作，加快成长！这是我参加「日新方案 10 月更文挑战」的第8天，点击检查活动详情

前言

本系列文章首要是汇总了一下大佬们的技能文章，归于Android基础部分，作为一名合格的安卓开发工程师，咱们肯定要熟练掌握java和android，本期就来说说这些~

[非商业用途,如有侵权,请告知我,我会删去]

DD一下： 开发文档跟之前依旧相同，需求的跟作者直接要。

注解

Annotation 中文译过来便是注解、标释的意思，在 Java 中注解是一个很重要的常识点，但常常仍是有点让新手不简略了解。

我个人以为，比较糟糕的技能文档首要特征之一便是：用专业名词来介绍专业名词。 比方：

Java 注解用于为 Java 代码供给元数据。作为元数据，注解不直接影响你的代码履行，但也有一些类型的注解实际上能够用于这一目的。Java 注解是从 Java5 开端增加到 Java 的。 这是大多数网站上关于 Java 注解，解说的确正确，可是说实在话，我第一次学习的时分，脑筋一片空白。这什么跟什么啊？听了像没有听相同。由于概念太过于笼统，所以初学者实在是比较吃力才干够了解，然后跟着自己开发进程中不断地强化操练，才会慢慢对它构成正确的知道。

我在写这篇文章的时分，我就在考虑。怎样让自己或许让读者能够比较直观地知道注解这个概念？是要去官方文档上翻译说明吗？我立刻否定了这个答案。

后来，我想到了相同东西————墨水，墨水能够蒸发、能够有不同的色彩，用来解说注解正好。

不过，我持续发散思维后，想到了相同东西能够更好地代替墨水，那便是印章。印章能够沾上不同的墨水或许印泥，能够定制印章的文字或许图画，假如乐意它也能够被戳到你任何想戳的物体外表。

可是，我再持续发散思维后，又想到相同东西能够更好地代替印章，那便是标签。标签是一张便当纸，标签上的内容能够自在界说。常见的如货架上的商品价格标签、图书馆中的书本编码标签、实验室中化学材料的称号类别标签等等。

而且，往笼统地说，标签并纷歧定是一张纸，它能够是对人和事物的特点点评。也便是说，标签具备关于笼统事物的解说。

所以，依据如此，我完结了自我的常识认知晋级，我决定用标签来解说注解。

1.注解的界说

注解通过 @interface 要害字进行界说。

public @interface TestAnnotation {
}

它的办法跟接口很类似，不过前面多了一个 @ 符号。上面的代码就创立了一个姓名为 TestAnnotaion 的注解。

你能够简略了解为创立了一张姓名为 TestAnnotation 的标签。

1.1注解的特点

注解的特点也叫做成员变量。注解只要成员变量，没有办法。注解的成员变量在注解的界说中以“无形参的办法”办法来声明，其办法名界说了该成员变量的姓名，其回来值界说了该成员变量的类型。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
  int id();
  String msg();
}

上面代码界说了 TestAnnotation 这个注解中具有 id 和 msg 两个特点。在运用的时分，咱们应该给它们进行赋值。

赋值的办法是在注解的括号内以 value=”” 办法，多个特点之前用 ，离隔。

@TestAnnotation(id=3,msg="hello annotation")
public class Test {
}

需求留意的是，在注解中界说特点时它的类型有必要是 8 种根本数据类型外加 类、接口、注解及它们的数组。

注解中特点能够有默许值，默许值需求用 default 要害值指定。比方：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
  public int id() default -1;
  public String msg() default "Hi";
}

TestAnnotation 中 id 特点默许值为 -1，msg 特点默许值为 Hi。 它能够这样运用。

@TestAnnotation()
public class Test {}

由于有默许值，所以无需求再在 @TestAnnotation 后边的括号里边进行赋值了，这一步能够省掉。

其他，还有一种状况。假如一个注解内仅仅只要一个姓名为 value 的特点时，运用这个注解时能够直接接特点值填写到括号内。

public @interface Check {
  String value();
}

上面代码中，Check 这个注解只要 value 这个特点。所以能够这样运用。

@Check("hi")
int a;

这和下面的效果是相同的

@Check(value="hi")
int a;

最终，还需求留意的一种状况是一个注解没有任何特点。比方

public @interface Perform {}

那么在运用这个注解的时分，括号都能够省掉。

@Perform
public void testMethod(){}

2.自界说注解

2.1注解好像标签

之前某新闻客户端的谈论有盖楼的习惯，所以 “乔布斯从头界说了手机、罗永浩从头界说了傻X” 就常常极为工整地出现在了谈论楼层中，而且广大网友在相当长的一段时刻内关于这种行为乐此不疲。这其实便是等同于贴标签的行为。 在某些网友眼中，罗永浩就成了傻X的代名词。

广大网友给罗永浩贴了一个名为“傻x”的标签，他们并不真实了解罗永浩，不知道他当教师、砸冰箱、办博客的壮举，可是由于“傻x”这样的标签存在，这有助于他们直接快速地对罗永浩这个人做出点评，然后依据此，罗永浩就能够成为茶余酒后的谈资，这便是标签的力量。

而在网络的另一边，老罗靠他的人格魅力天然收获一大批忠实的拥泵，他们关于老罗贴的又是另一种标签。

老罗仍是老罗，可是由于人们关于它贴上的标签不同，所以构成关于他的观点大相径庭，不喜欢他的人整天在网络上谈论打击嘲讽，而崇拜欣赏他的人则会乐意赚钱购买锤子手机的发布会门票。

我无意于点评这两种行为，我再引个比方。

《奇葩说》是近年网络上十分火热的争辩节目，其间辩手陈铭被其他一个辩手马薇薇进犯说是————“站在世界中心呼喊爱”，然后贴上了一个大大的标签————“鸡汤男”，自此今后，观众再看到陈铭的时分，首要映入脑海中便是“鸡汤男”三个大字，其实自身而言陈铭十分优秀，为人师表、作风正派、谈吐举动得当，可是在网络中，由于文娱至上的环境所构成的，人们更乐意以文娱的心态来认知全部，所以“鸡汤男”就如陈铭自己所说成了一个撕不了的标签。

咱们能够笼统归纳一下，标签是对事物行为的某些角度的点评与解说。

到这儿，总算能够引出本文的主角注解了。

初学者能够这样了解注解：想像代码具有生命，注解便是关于代码中某些鲜活个体的贴上去的一张标签。简化来讲，注解好像一张标签。

在未开端学习任何注解详细语法而言，你能够把注解看成一张标签。这有助于你快速地了解它的大致效果。假如初学者在学习进程有大脑放空的时分，请不要紧张，对自己说：

注解，标签。注解，标签。

2.2注解语法

由于平常开发罕见，信任有不少的人员会以为注解的地位不高。其实同 classs 和 interface 相同，注解也归于一种类型。它是在 Java SE 5.0 版别中开端引进的概念。

2.3元注解

元注解是什么意思呢？

元注解是能够注解到注解上的注解，或许说元注解是一种根本注解，可是它能够运用到其它的注解上面。

假如难于了解的话，你能够这样了解。元注解也是一张标签，可是它是一张特殊的标签，它的效果和目的便是给其他一般的标签进行解说说明的。

元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种。

@Retention

Retention 的英文意为保存期的意思。当 @Retention 运用到一个注解上的时分，它解说说明晰这个注解的的存活时刻。

它的取值如下：

• RetentionPolicy.SOURCE 注解只在源码阶段保存，在编译器进行编译时它将被丢掉忽视。
• RetentionPolicy.CLASS 注解只被保存到编译进行的时分，它并不会被加载到 JVM 中。
• RetentionPolicy.RUNTIME 注解能够保存到程序运转的时分，它会被加载进入到 JVM 中，所以在程序运转时能够获取到它们。

咱们能够这样的办法来加深了解，@Retention 去给一张标签解说的时分，它指定了这张标签粘贴的时刻。@Retention 相当于给一张标签上面盖了一张时刻戳，时刻戳指明晰标签粘贴的时刻周期。

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}

上面的代码中，咱们指定 TestAnnotation 能够在程序运转周期被获取到，因而它的生命周期十分的长。

@Documented

望文生义，这个元注解肯定是和文档有关。它的效果是能够将注解中的元素包括到 Javadoc 中去。

@Target

Target 是方针的意思，@Target 指定了注解运用的当地。

你能够这样了解，当一个注解被 @Target 注解时，这个注解就被限制了运用的场景。

类比到标签，本来标签是你想粘贴到哪个当地就到哪个当地，可是由于 @Target 的存在，它粘贴的当地就十分详细了，比方只能粘贴到办法上、类上、办法参数上等等。@Target 有下面的取值

• ElementType.ANNOTATION_TYPE 能够给一个注解进行注解
• ElementType.CONSTRUCTOR 能够给构造办法进行注解
• ElementType.FIELD 能够给特点进行注解
• ElementType.LOCAL_VARIABLE 能够给局部变量进行注解
• ElementType.METHOD 能够给办法进行注解
• ElementType.PACKAGE 能够给一个包进行注解
• ElementType.PARAMETER 能够给一个办法内的参数进行注解
• ElementType.TYPE 能够给一个类型进行注解，比方类、接口、枚举

@Inherited

Inherited 是承继的意思，可是它并不是说注解自身能够承继，而是说假如一个超类被 @Inherited 注解过的注解进行注解的话，那么假如它的子类没有被任何注解运用的话，那么这个子类就承继了超类的注解。 说的比较笼统。代码来解说。

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}
@Test
public class A {}
public class B extends A {}

注解 Test 被 @Inherited 润饰，之后类 A 被 Test 注解，类 B 承继 A,类 B 也具有 Test 这个注解。

能够这样了解：

老子十分有钱，所以人们给他贴了一张标签叫做富豪。

老子的儿子长大后，只要没有和老子隔绝父子关系，尽管别人没有给他贴标签，可是他天然也是富豪。

老子的孙子长大了，天然也是富豪。

这便是人们口中戏称的富一代，富二代，富三代。尽管叫法不同，好像好多个标签，但其实作业的实质也便是他们有一张一起的标签，也便是老子身上的那张富豪的标签。

@Repeatable

Repeatable 天然是可重复的意思。@Repeatable 是 Java 1.8 才加进来的，所以算是一个新的特性。

什么样的注解会多次运用呢？一般是注解的值能够一起取多个。

举个比方，一个人他既是程序员又是产品司理,一起他仍是个画家。

@interface Persons {
  Person[] value();
}
@Repeatable(Persons.class)
@interface Person{
  String role default "";
}
@Person(role="artist")
@Person(role="coder")
@Person(role="PM")
public class SuperMan{
}

留意上面的代码，@Repeatable 注解了 Person。而 @Repeatable 后边括号中的类相当于一个容器注解。

什么是容器注解呢？便是用来存放其它注解的当地。它自身也是一个注解。

咱们再看看代码中的相关容器注解。

@interface Persons {
  Person[] value();
}

按照规定，它里边有必要要有一个 value 的特点，特点类型是一个被 @Repeatable 注解过的注解数组，留意它是数组。

假如不好了解的话，能够这样了解。Persons 是一张总的标签，上面贴满了 Person 这种同类型但内容不相同的标签。把 Persons 给一个 SuperMan 贴上，相当于一起给他贴了程序员、产品司理、画家的标签。

咱们或许关于 @Person(role=”PM”) 括号里边的内容感兴趣，它其实便是给 Person 这个注解的 role 特点赋值为 PM ，咱们不明白正常，立刻就讲到注解的特点这一块。

2.4Java 预置的注解

Java 言语自身现已供给了几个现成的注解。

@Deprecated

这个元素是用来符号过期的元素，想必咱们在日常开发中常常碰到。编译器在编译阶段遇到这个注解时会发出提示正告，告知开发者正在调用一个过期的元素比方过期的办法、过期的类、过期的成员变量。

public class Hero {
  @Deprecated
  public void say(){
    System.out.println("Noting has to say!");
   }
  public void speak(){
    System.out.println("I have a dream!");
   }
}

界说了一个 Hero 类，它有两个办法 say() 和 speak() ，其间 say() 被 @Deprecated 注解。然后咱们在 IDE 中别离调用它们。

能够看到，say() 办法上面被一条直线划了一条，这其实便是编译器识别后的提示效果。

@Override

这个咱们应该很了解了，提示子类要复写父类中被 @Override 润饰的办法

@SuppressWarnings

阻挠正告的意思。之前说过调用被 @Deprecated 注解的办法后，编译器会正告提示，而有时分开发者会忽略这种正告，他们能够在调用的当地通过 @SuppressWarnings 到达目的。

@SuppressWarnings("deprecation")
public void test1(){
  Hero hero = new Hero();
  hero.say();
  hero.speak();
}

@SafeVarargs

参数安全类型注解。它的目的是提示开发者不要用参数做一些不安全的操作,它的存在会阻挠编译器产生 unchecked 这样的正告。它是在 Java 1.7 的版别中加入的。

@SafeVarargs // Not actually safe!
  static void m(List<String>... stringLists) {
  Object[] array = stringLists;
  List<Integer> tmpList = Arrays.asList(42);
  array[0] = tmpList; // Semantically invalid, but compiles without warnings
  String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
}

上面的代码中，编译阶段不会报错，可是运转时会抛出 ClassCastException 这个反常，所以它尽管告知开发者要妥善处理，可是开发者自己仍是搞砸了。

Java 官方文档说，未来的版别会授权编译器对这种不安全的操作产生过错正告。

@FunctionalInterface

函数式接口注解，这个是 Java 1.8 版别引进的新特性。函数式编程很火，所以 Java 8 也及时增加了这个特性。

函数式接口 (Functional Interface) 便是一个具有一个办法的一般接口。 比方

@FunctionalInterface
public interface Runnable {
  /**
   * When an object implementing interface <code>Runnable</code> is used
   * to create a thread, starting the thread causes the object's
   * <code>run</code> method to be called in that separately executing
   * thread.
   * <p>
   * The general contract of the method <code>run</code> is that it may
   * take any action whatsoever.
   *
   * @see   java.lang.Thread#run()
   */
  public abstract void run();
}

咱们进行线程开发中常用的 Runnable 便是一个典型的函数式接口，上面源码能够看到它就被 @FunctionalInterface 注解。

或许有人会疑问，函数式接口符号有什么用，这个原因是函数式接口能够很简略转换为 Lambda 表达式。这是其他的主题了，有兴趣的同学请自己查找相关常识点学习。

3.注解的运用

3.1注解的运用

上面创立了一个注解，那么注解的的运用办法是什么呢。

@TestAnnotation
public class Test {
}

创立一个类 Test,然后在类界说的当地加上 @TestAnnotation 就能够用 TestAnnotation 注解这个类了。

你能够简略了解为将 TestAnnotation 这张标签贴到 Test 这个类上面。

3.2注解的提取

前面的部分讲了注解的根本语法，现在是时分检测咱们所学的内容了。

我通过用标签来比作注解，前面的内容是讲怎样写注解，然后贴到哪个当地去，而现在咱们要做的作业便是审阅这些标签内容。 形象的比方便是你把这些注解标签在合适的时分撕下来，然后审阅上面的内容信息。

要想正确审阅注解，离不开一个手法，那便是反射。

3.3注解与反射

注解通过反射获取。首要能够通过 Class 方针的 isAnnotationPresent() 办法判别它是否运用了某个注解

public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}

然后通过 getAnnotation() 办法来获取 Annotation 方针。

 public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}

或许是 getAnnotations() 办法。

public Annotation[] getAnnotations() {}

前一种办法回来指定类型的注解，后一种办法回来注解到这个元素上的一切注解。

假如获取到的 Annotation 假如不为 null，则就能够调用它们的特点办法了。比方

@TestAnnotation()
public class Test {
  public static void main(String[] args) {
    boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
    if ( hasAnnotation ) {
      TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
      System.out.println("id:"+testAnnotation.id());
      System.out.println("msg:"+testAnnotation.msg());
     }
   }
}

程序的运转成果是：

id:-1
msg:

这个正是 TestAnnotation 中 id 和 msg 的默许值。

上面的比方中，仅仅审阅出了注解在类上的注解，其实特点、办法上的注解照样是能够的。同样仍是要假手于反射。

@TestAnnotation(msg="hello")
public class Test {
  @Check(value="hi")
  int a;
  @Perform
  public void testMethod(){}
  @SuppressWarnings("deprecation")
  public void test1(){
    Hero hero = new Hero();
    hero.say();
    hero.speak();
   }
  public static void main(String[] args) {
    boolean hasAnnotation = Test.class.isAnnotationPresent(TestAnnotation.class);
    if ( hasAnnotation ) {
      TestAnnotation testAnnotation = Test.class.getAnnotation(TestAnnotation.class);
      //获取类的注解
      System.out.println("id:"+testAnnotation.id());
      System.out.println("msg:"+testAnnotation.msg());
     }
    try {
      Field a = Test.class.getDeclaredField("a");
      a.setAccessible(true);
      //获取一个成员变量上的注解
      Check check = a.getAnnotation(Check.class);
      if ( check != null ) {
        System.out.println("check value:"+check.value());
       }
      Method testMethod = Test.class.getDeclaredMethod("testMethod");
      if ( testMethod != null ) {
        // 获取办法中的注解
        Annotation[] ans = testMethod.getAnnotations();
        for( int i = 0;i < ans.length;i++) {
          System.out.println("method testMethod annotation:"+ans[i].annotationType().getSimpleName());
         }
       }
     } catch (NoSuchFieldException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      System.out.println(e.getMessage());
     } catch (SecurityException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      System.out.println(e.getMessage());
     } catch (NoSuchMethodException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      System.out.println(e.getMessage());
     }
   }
}

它们的成果如下：

id:-1
msg:hello
check value:hi
method testMethod annotation:Perform

需求留意的是，假如一个注解要在运转时被成功提取，那么 @Retention(RetentionPolicy.RUNTIME) 是有必要的。

3.4注解的运用场景

我信任博文讲到这儿咱们都很了解了注解，可是有不少同学肯定会问，注解到底有什么用呢？

对啊注解到底有什么用？

咱们无妨将目光放到 Java 官方文档上来。

文章开端的时分，我用标签来类比注解。但标签比方仅仅我的手法，而不是目的。为的是让咱们在初度学习注解时能够不被那些笼统的新概念搞懵。已然现在，咱们现已对注解有所了解，咱们无妨再仔细阅读官方最严谨的文档。

注解是一系列元数据，它供给数据用来解说程序代码，可是注解并非是所解说的代码自身的一部分。注解关于代码的运转效果没有直接影响。 注解有许多用处，首要如下：

• 供给信息给编译器： 编译器能够运用注解来勘探过错和正告信息
• 编译阶段时的处理： 软件东西能够用来运用注解信息来生成代码、Html文档或许做其它相应处理。
• 运转时的处理： 某些注解能够在程序运转的时分接受代码的提取 值得留意的是，注解不是代码自身的一部分。

假如难于了解，能够这样看。罗永浩仍是罗永浩，不会由于某些人关于他“傻x”的点评而改动，标签仅仅某些人关于其他事物的点评，可是标签不会改动事物自身，标签仅仅特定人群的手法。所以，注解同样无法改动代码自身，注解仅仅某些东西的的东西。

仍是回到官方文档的解说上，注解首要针对的是编译器和其它东西软件(SoftWare tool)。

当开发者运用了Annotation 润饰了类、办法、Field 等成员之后，这些 Annotation 不会自己收效，有必要由开发者供给相应的代码来提取并处理 Annotation 信息。这些处理提取和处理 Annotation 的代码统称为 APT（Annotation Processing Tool)。

现在，咱们能够给自己答案了，注解有什么用？给谁用？给 编译器或许 APT 用的。

假如，你仍是没有搞清楚的话，我亲自写一个好了。

3.5亲手自界说注解完结项目

我要写一个测验结构，测验程序员的代码有无明显的反常。

—— 程序员 A : 我写了一个类，它的姓名叫做 NoBug，由于它一切的办法都没有过错。 —— 我：自信是好事，不过为了避免意外，让我测验一下怎样？ —— 程序员 A: 怎样测验？ —— 我：把你写的代码的办法都加上 @Jiecha 这个注解就好了。 —— 程序员 A: 好的。

package ceshi;
import ceshi.Jiecha;
public class NoBug {
  @Jiecha
  public void suanShu(){
    System.out.println("1234567890");
   }
  @Jiecha
  public void jiafa(){
    System.out.println("1+1="+1+1);
   }
  @Jiecha
  public void jiefa(){
    System.out.println("1-1="+(1-1));
   }
  @Jiecha
  public void chengfa(){
    System.out.println("3 x 5="+ 3*5);
   }
  @Jiecha
  public void chufa(){
    System.out.println("6 / 0="+ 6 / 0);
   }
  public void ziwojieshao(){
    System.out.println("我写的程序没有 bug!");
   }
}

上面的代码，有些办法上面运用了 @Jiecha 注解。

这个注解是我写的测验软件结构中界说的注解。

package ceshi;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface Jiecha {
}

然后，我再编写一个测验类 TestTool 就能够测验 NoBug 相应的办法了。

package ceshi;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestTool {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    NoBug testobj = new NoBug();
    Class clazz = testobj.getClass();
    Method[] method = clazz.getDeclaredMethods();
    //用来记载测验产生的 log 信息
    StringBuilder log = new StringBuilder();
    // 记载反常的次数
    int errornum = 0;
    for ( Method m: method ) {
      // 只要被 @Jiecha 标注过的办法才进行测验
      if ( m.isAnnotationPresent( Jiecha.class )) {
        try {
          m.setAccessible(true);
          m.invoke(testobj, null);
         } catch (Exception e) {
          // TODO Auto-generated catch block
          //e.printStackTrace();
          errornum++;
          log.append(m.getName());
          log.append(" ");
          log.append("has error:");
          log.append("\n\r  caused by ");
          //记载测验进程中，产生的反常的称号
          log.append(e.getCause().getClass().getSimpleName());
          log.append("\n\r");
          //记载测验进程中，产生的反常的详细信息
          log.append(e.getCause().getMessage());
          log.append("\n\r");
         } 
       }
     }
    log.append(clazz.getSimpleName());
    log.append(" has  ");
    log.append(errornum);
    log.append(" error.");
    // 生成测验报告
    System.out.println(log.toString());
   }
}

测验的成果是：

1234567890
1+1=11
1-1=0
3 x 5=15
chufa has error:
 caused by ArithmeticException
/ by zero
NoBug has 1 error.

提示 NoBug 类中的 chufa() 这个办法有反常，这个反常称号叫做 ArithmeticException，原因是运算进程中进行了除 0 的操作。

所以，NoBug 这个类有 Bug。

这样，通过注解我完结了我自己的目的，那便是对别人的代码进行测验。

所以，再问我注解什么时分用？我只能告知你，这取决于你想运用它干什么用。

3.6注解运用实例

注解运用的当地太多了，如： JUnit 这个是一个测验结构，典型运用办法如下：

public class ExampleUnitTest {
  @Test
  public void addition_isCorrect() throws Exception {
    assertEquals(4, 2 + 2);
   }
}

@Test 符号了要进行测验的办法 addition_isCorrect().

还有例如ssm结构等运用了许多的注解。

注解部分总结

• 假如注解难于了解，你就把它类同于标签，标签为了解说事物，注解为了解说代码。
• 注解的根本语法，创立好像接口，可是多了个 @ 符号。
• 注解的元注解。
• 注解的特点。
• 注解首要给编译器及东西类型的软件用的。
• 注解的提取需求借助于 Java 的反射技能，反射比较慢，所以注解运用时也需求谨慎计较时刻本钱。

4.APT完结原理

4.1 SPI机制

SPI是jdk内置的服务发现机制， 全称叫Service Provider Interface.

SPI的作业原理， 便是ClassPath途径下的META-INF/services文件夹中， 以接口的全限制名来命名文件名， 文件里边写该接口的完结。 然后再资源加载的办法，读取文件的内容(接口完结的全限制名)， 然后再去加载类。

SPI能够很灵活的让接口和完结别离， 让api供给者只供给接口， 第三方来完结。

这一机制为许多结构的扩展供给了或许，比方在 Dubbo、JDBC、SpringBoot 中都运用到了SPI机制。尽管他们之间的完结办法不同，但原理都差不多。今天咱们就来看看，SPI到底是何方神圣，在许多开源结构中又扮演了什么人物。

4.1.1 JDK中的SPI

咱们先从JDK开端，通过一个很简略的比方来看下它是怎样用的。

4.1.1.1、小栗子

首要，咱们需求界说一个接口，SpiService

package com.dxz.jdk.spi;
​
public interface SpiService {
   void println();
}

然后，界说一个完结类，没其他意思，只做打印。

package com.dxz.jdk.spi;
​
public class SpiServiceImpl implements SpiService {
   @Override
   public void println() {
     System.out.println("------SPI DEMO-------");
   }
}

最终呢，要在resources途径下装备增加一个文件。文件姓名是接口的全限制类名，内容是完结类的全限制类名，多个完结类用换行符分隔。

文件内容便是完结类的全限制类名：

4.1.1.2、测验

然后咱们就能够通过 ServiceLoader.load 办法拿到完结类的实例，并调用它的办法。

public static void main(String[] args){
   ServiceLoader<SpiService> load = ServiceLoader.load(SpiService.class);
   Iterator<SpiService> iterator = load.iterator();
   while (iterator.hasNext()){
     SpiService service = iterator.next();
     service.println();
   }
}

4.1.1.3、源码剖析

首要，咱们先来了解下 ServiceLoader，看看它的类结构。

public final class ServiceLoader<S> implements Iterable<S>{
   //装备文件的途径
   private static final String PREFIX = "META-INF/services/";
   //加载的服务类或接口
   private final Class<S> service;
   //已加载的服务类调集
   private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
   //类加载器
   private final ClassLoader loader;
   //内部类，真实加载服务类
   private LazyIterator lookupIterator;
}

当咱们调用 load 办法时，并没有真实的去加载和查找服务类。而是调用了 ServiceLoader 的构造办法，在这儿最重要的是实例化了内部类 LazyIterator ，它才是接下来的主角。

private ServiceLoader(Class<S> svc, ClassLoader cl) {
   //要加载的接口
   service = Objects.requireNonNull(svc, "Service interface cannot be null");
   //类加载器
   loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
   //访问控制器
   acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
   //先清空
   providers.clear();
   //实例化内部类 
   LazyIterator lookupIterator = new LazyIterator(service, loader);
}

查找完结类和创立完结类的进程，都在 LazyIterator 完结。当咱们调用 iterator.hasNext和iterator.next 办法的时分，实际上调用的都是 LazyIterator 的相应办法。

public Iterator<S> iterator() {
​
   return new Iterator<S>() {
  
     public boolean hasNext() {
       return lookupIterator.hasNext();
     }
     public S next() {
       return lookupIterator.next();
     }
     .......
   };
}

所以，咱们要点重视 lookupIterator.hasNext() 办法，它最终会调用到 hasNextServicez ，在这儿回来完结类称号。

private class LazyIterator implements Iterator<S>{
   Class<S> service;
   ClassLoader loader;
   Enumeration<URL> configs = null;
   Iterator<String> pending = null;
   String nextName = null;  
   private boolean hasNextService() {
     //第2次调用的时分，现已解析完结了，直接回来
     if (nextName != null) {
       return true;
     }
     if (configs == null) {
       //META-INF/services/ 加上接口的全限制类名，便是文件服务类的文件
       //META-INF/services/com.viewscenes.netsupervisor.spi.SPIService
       String fullName = PREFIX + service.getName();
       //将文件途径转成URL方针
       configs = loader.getResources(fullName);
     }
     while ((pending == null) || !pending.hasNext()) {
       //解析URL文件方针，读取内容，最终回来
       pending = parse(service, configs.nextElement());
     }
     //拿到第一个完结类的类名
     nextName = pending.next();
     return true;
   }
}

然后当咱们调用 next() 办法的时分，调用到 lookupIterator.nextService 。它通过反射的办法，创立完结类的实例并回来。

private S nextService() {
   //全限制类名
   String cn = nextName;
   nextName = null;
   //创立类的Class方针
   Class<?> c = Class.forName(cn, false, loader);
   //通过newInstance实例化
   S p = service.cast(c.newInstance());
   //放入调集，回来实例
   providers.put(cn, p);
   return p; 
}

到这停止，现已获取到了类的实例。

4.1.2 JDBC中的运用

咱们开头说，SPI机制为许多结构的扩展供给了或许，其实JDBC就运用到了这一机制。

在以前，需求先设置数据库驱动的衔接，再通过 DriverManager.getConnection 获取一个 Connection 。

String url = "jdbc:mysql:///consult?serverTimezone=UTC";
String user = "root";
String password = "root";
​
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, user, password);

而现在，设置数据库驱动衔接，这一过程就不再需求，那么它是怎样分辨是哪种数据库的呢？答案就在SPI。

4.1.2.1 加载

下图mysql Driver的实例。 com.mysql.cj.jdbc.Driver便是Driver的完结。

mysql驱动为例

mysql Driver完结类

Driver接口上的一段注释。

DriverManager将尝试加载尽或许多的驱动程序。

咱们把目光回到 DriverManager 类，它在静态代码块里边做了一件比较重要的事。很明显，它现现已过SPI机制， 把数据库驱动衔接初始化了。

public class DriverManager {
   static {
     loadInitialDrivers();
     println("JDBC DriverManager initialized");
   }
}

接下来咱们去DriverManger上看看是怎样加载Driver接口的完结类的。

public class DriverManager {
​
   /**
   * Load the initial JDBC drivers by checking the System property
   * jdbc.properties and then use the {@code ServiceLoader} mechanism
   */
   static {
     loadInitialDrivers();
     println("JDBC DriverManager initialized");
   }
​
   private static void loadInitialDrivers() {
     AccessController.doPrivileged(new PrivilegedAction<Void>() {
       public Void run() {
         ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
         Iterator<Driver> driversIterator = loadedDrivers.iterator();
         try{
           while(driversIterator.hasNext()) {
             driversIterator.next();
           }
         } catch(Throwable t) {
        
         }
         return null;
       }
     });
}

在DriverManger类初始化的时分， 调用loadInitialDrivers办法。

详细进程还得看 loadInitialDrivers ，它在里边查找的是Driver接口的服务类，所以它的文件途径便是：

META-INF/services/java.sql.Driver

在loadInitialDrivers办法中，

private static void loadInitialDrivers() {
   AccessController.doPrivileged(new PrivilegedAction<Void>() {
     public Void run() {
       //很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
       //所以它要找的便是META-INF/services/java.sql.Driver文件
       ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
       Iterator<Driver> driversIterator = loadedDrivers.iterator();
       try{
         //查到之后创立方针
         while(driversIterator.hasNext()) {
           driversIterator.next();//当调用next办法时，就会创立这个类的实例。它就完结了一件事，向 DriverManager 注册自身的实例。
         }
       } catch(Throwable t) {
         // Do nothing
       }
       return null;
     }
   });
}

这段代码是完结SPI的要害， 真是这个ServiceLoader类去完结SPI的。 那么下面就剖析剖析ServiceLoader的代码， 看看是怎样完结SPI的。

package java.util;
​
public final class ServiceLoader<S> implements Iterable<S> {
  public static <S> ServiceLoader<S> load(Class<S> service) {
     ClassLoader cl = Thread.currentThread().getContextClassLoader();
     return ServiceLoader.load(service, cl);
   }
​
  //其间service便是要加载完结类对应的接口， loader便是用该加载器去加载对应的完结类
  public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader){
     return new ServiceLoader<>(service, loader);
   }
}

先调用ServiceLoader类的静态办法load， 然后依据当时线程的上下文类加载器，创立一个ServiceLoader实例。

private static final String PREFIX = "META-INF/services/";
​
public void reload() {
     providers.clear();
     lookupIterator = new LazyIterator(service, loader);
   }
private ServiceLoader(Class<S> svc, ClassLoader cl) {
     service = Objects.requireNonNull(svc, "Service interface cannot be null");
     loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
     acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
     reload();
   }

创立ServiceLoader实例的时分，接着创立一个Iterator完结类。 接下来这个Iterator剖析的要点。根本一切的加载类的完结逻辑都在里边。

其间ServiceLoader类中一个常量的界说是要害的。 前面说过，咱们service的完结类在放在哪， 便是这儿写死的常量途径。

//这儿先介绍Iterator的变量，先大概有个形象。
private class LazyIterator
     implements Iterator<S>
   {
     //service， loader前面介绍过了。
     Class<S> service;
     ClassLoader loader;
     Enumeration<URL> configs = null;
     Iterator<String> pending = null;
     String nextName = null;
​
    public boolean hasNext() {
     //省掉权限相关代码
     return hasNextService(); 
     }
​
    private boolean hasNextService() {
       //一开端nextName肯定为空
       if (nextName != null) {
         return true;
       }
       //一开端configs也肯定为空
       if (configs == null) {
         try {
           //PREFIX = META-INF/services/
           //以mysql为例，便是 META-INF/services/java.sql.Driver
           String fullName = PREFIX + service.getName();
           if (loader == null) configs = ClassLoader.getSystemResources(fullName);
           //loader去加载这个classpath下文件。
           //这儿很有或许回来的是多个文件的资源，
           //例如一个项目下既有mysql驱动， 也有sql server驱动等
           //所以回来的是一个枚举类型。
           else configs = loader.getResources(fullName);
         } catch (IOException x) {
           fail(service, "Error locating configuration files", x);
         }
       }
       while ((pending == null) || !pending.hasNext()) {
         if (!configs.hasMoreElements()) {
           return false;
         }
         //然后依据加载出来的资源，解析一个文件中的内容。放到Iterator完结类中
         pending = parse(service, configs.nextElement());
       }
       //这儿next回来的便是文件一行的内容，一般一行对应一个接口的完结类。
       //一个接口放多行，就能够有多个接口完结类中。
       nextName = pending.next();
       return true;
     }
}

configs变量，就对应service文件。 是个枚举， 便是说能够界说多个service文件。

pending 变量： 就对应configs中， service文件解析出来的一行有效内容，即一个完结类的全限制类称号。

parse办法便是简略，不是要点。这儿就略过了。便是读取service文件中读取，一行便是一个nextName，然后遇到“#“就跳过“#”后边的内容。所以service文件能够用“#”作为注释。 直到遇到空行，解析结束。

LazyIterator类中的hasNext办法就剖析完了。 运用classLoader.getResources办法加载service文件。我看了下getResources办法，并一定是加载classpath下的资源，得依据classLoader来解决。不过绝大多数状况下，都是classpath的资源。这儿为了好了解，就了解成classpath下的资源。

接着剖析LazyIterator#next办法。

public S next() {
    //删去权限相关代码
    return nextService();
 }
private S nextService() {
       if (!hasNextService())
         throw new NoSuchElementException();
       //这个nextName前面剖析过了
       String cn = nextName;
       nextName = null;
       Class<?> c = null;
       try {
         //加载类，且不初始化
         c = Class.forName(cn, false, loader);
       } catch (ClassNotFoundException x) {
         fail(service,
           "Provider " + cn + " not found");
       }
       if (!service.isAssignableFrom(c)) {
         fail(service,
           "Provider " + cn  + " not a subtype");
       }
       try {
         //类型判别
         S p = service.cast(c.newInstance());
        //最终放到ServiceLoader实例变量Map中，缓存起来，下次直接运用
         providers.put(cn, p);
         return p;
       } catch (Throwable x) {
         fail(service,
           "Provider " + cn + " could not be instantiated",
           x);
       }
       throw new Error();      // This cannot happen
     }

next办法就比较简略了，依据前面解析出来的nextName（接口完结类的全限制称号），用Class.forName创立对应的Class方针。

4.1.2.2 创立Connection

DriverManager.getConnection() 办法便是创立衔接的当地，它通过循环已注册的数据库驱动程序，调用其connect办法，获取衔接并回来。

private static Connection getConnection(String url, Properties info, Class<?> caller) throws SQLException {  
   //registeredDrivers中就包括com.mysql.cj.jdbc.Driver实例
   for(DriverInfo aDriver : registeredDrivers) {
     if(isDriverAllowed(aDriver.driver, callerCL)) {
       try {
         //调用connect办法创立衔接
         Connection con = aDriver.driver.connect(url, info);
         if (con != null) {
           return (con);
         }
       }catch (SQLException ex) {
         if (reason == null) {
           reason = ex;
         }
       }
     } else {
       println("skipping: " + aDriver.getClass().getName());
     }
   }
}

4.1.2.3 扩展

已然咱们知道JDBC是这样创立数据库衔接的，咱们能不能再扩展一下呢？假如咱们自己也创立一个 java.sql.Driver 文件，自界说完结类MySQLDriver，那么，在获取衔接的前后就能够动态修改一些信息。

仍是先在项目resources下创立文件，文件内容为自界说驱动类 com.jcc.java.spi.domyself.MySQLDriver

咱们的 MySQLDriver 完结类，承继自MySQL中的 NonRegisteringDriver ，还要完结 java.sql.Driver 接口。这样，在调用connect办法的时分，就会调用到此类，但实际创立的进程还靠MySQL完结。

public class MySQLDriver extends NonRegisteringDriver implements Driver{
   static {
     try {
       DriverManager.registerDriver(new MySQLDriver());
     } catch (SQLException e) {
       e.printStackTrace();
     }
   }
   public MySQLDriver() throws SQLException {}
​
   @Override
   public Connection connect(String url, Properties info) throws SQLException {
     System.out.println("准备创立数据库衔接.url:"+url);
     System.out.println("JDBC装备信息："+info);
     //重置装备
     info.setProperty("user", "root");
     Connection connection =  super.connect(url, info);
     System.out.println("数据库衔接创立完结!"+connection.toString());
     return connection;
   }
}

这样的话，当咱们获取数据库衔接的时分，就会调用到这儿。

--------------------输出成果---------------------
准备创立数据库衔接.url:jdbc:mysql:///consult?serverTimezone=UTC
JDBC装备信息：{user=root, password=root}
数据库衔接创立完结!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f

4.1.3 SpringBoot中的运用

Spring Boot供给了一种快速的办法来创立可用于生产环境的依据Spring的运用程序。它依据Spring结构，更倾向于约定而不是装备，而且旨在使您尽快发动并运转。

即便没有任何装备文件，SpringBoot的Web运用都能正常运转。这种神奇的作业，SpringBoot正是依靠自动装备来完结。

提到这，咱们有必要重视一个东西： SpringFactoriesLoader，自动装备便是依靠它来加载的。

4.1.3.1 装备文件

SpringFactoriesLoader 来负责加载装备。咱们打开这个类，看到它加载文件的途径是： META-INF/spring.factories

笔者在项目中查找这个文件，发现有4个Jar包都包括它：

• List itemspring-boot-2.1.9.RELEASE.jar
• spring-beans-5.1.10.RELEASE.jar
• spring-boot-autoconfigure-2.1.9.RELEASE.jar
• mybatis-spring-boot-autoconfigure-2.1.0.jar

那么它们里边都是些啥内容呢？其实便是一个个接口和类的映射。在这儿笔者就不贴了，有兴趣的小伙伴自己去看看。

比方在SpringBoot发动的时分，要加载一切的 ApplicationContextInitializer ，那么就能够这样做：

SpringFactoriesLoader.loadFactoryNames(ApplicationContextInitializer.class, classLoader)

4.1.3.2 加载文件

loadSpringFactories 就负责读取一切的 spring.factories 文件内容。

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
​
   MultiValueMap<String, String> result = cache.get(classLoader);
   if (result != null) {
     return result;
   }
   try {
     //获取一切spring.factories文件的途径
     Enumeration<URL> urls = lassLoader.getResources("META-INF/spring.factories");
     result = new LinkedMultiValueMap<>();
     while (urls.hasMoreElements()) {
       URL url = urls.nextElement();
       //加载文件并解析文件内容
       UrlResource resource = new UrlResource(url);
       Properties properties = PropertiesLoaderUtils.loadProperties(resource);
       for (Map.Entry<?, ?> entry : properties.entrySet()) {
         String factoryClassName = ((String) entry.getKey()).trim();
         for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
           result.add(factoryClassName, factoryName.trim());
         }
       }
     }
     cache.put(classLoader, result);
     return result;
   }
   catch (IOException ex) {
     throw new IllegalArgumentException("Unable to load factories from location [" +
       FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
}

能够看到，它并没有选用JDK中的SPI机制来加载这些类，不过原理差不多。都是通过一个装备文件，加载并解析文件内容，然后通过反射创立实例。

4.1.3.3 参加其间

假如你希望参加到 SpringBoot 初始化的进程中，现在咱们又多了一种办法。

咱们也创立一个 spring.factories 文件，自界说一个初始化器。

org.springframework.context.ApplicationContextInitializer=com.youyouxunyin.config.context.MyContextInitializer

然后界说一个MyContextInitializer类

public class MyContextInitializer implements ApplicationContextInitializer {
   @Override
   public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
     System.out.println(configurableApplicationContext);
   }
}

4.1.4 Dubbo中的运用

咱们了解的Dubbo也不例外，它也是通过 SPI 机制加载一切的组件。同样的，Dubbo 并未运用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满意需求。在 Dubbo 中，SPI 是一个十分重要的模块。依据 SPI，咱们能够很简略的对 Dubbo 进行拓宽。

它的运用办法同样是在 META-INF/services 创立文件并写入相关类名。

4.1.5 sentinel中的运用

通过SPI机制将META-INFO/servcie下装备好的默许职责链构造这加载出来，然后调用其builder()办法进行构建调用链。

public final class SlotChainProvider {
​
   private static volatile SlotChainBuilder slotChainBuilder = null;
​
   /**
   * The load and pick process is not thread-safe, but it's okay since the method should be only invoked
   * via {@code lookProcessChain} in {@link com.alibaba.csp.sentinel.CtSph} under lock.
   *
   * @return new created slot chain
   */
   public static ProcessorSlotChain newSlotChain() {
     if (slotChainBuilder != null) {
       return slotChainBuilder.build();
     }
​
     // Resolve the slot chain builder SPI.
     slotChainBuilder = SpiLoader.of(SlotChainBuilder.class).loadFirstInstanceOrDefault();
​
     if (slotChainBuilder == null) {
       // Should not go through here.
       RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
       slotChainBuilder = new DefaultSlotChainBuilder();
     } else {
       RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: {}",
         slotChainBuilder.getClass().getCanonicalName());
     }
     return slotChainBuilder.build();
   }
​
   private SlotChainProvider() {}
}

SpiLoader.of()

   public static <T> SpiLoader<T> of(Class<T> service) {
     AssertUtil.notNull(service, "SPI class cannot be null");
     AssertUtil.isTrue(service.isInterface() || Modifier.isAbstract(service.getModifiers()),
         "SPI class[" + service.getName() + "] must be interface or abstract class");
​
     String className = service.getName();
     SpiLoader<T> spiLoader = SPI_LOADER_MAP.get(className);
     if (spiLoader == null) {
       synchronized (SpiLoader.class) {
         spiLoader = SPI_LOADER_MAP.get(className);
         if (spiLoader == null) {
           SPI_LOADER_MAP.putIfAbsent(className, new SpiLoader<>(service));
           spiLoader = SPI_LOADER_MAP.get(className);
         }
       }
     }
​
     return spiLoader;
   }

@Spi(isDefault = true)
public class DefaultSlotChainBuilder implements SlotChainBuilder {
​
   @Override
   public ProcessorSlotChain build() {
     ProcessorSlotChain chain = new DefaultProcessorSlotChain();
​
     List<ProcessorSlot> sortedSlotList = SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted();
     for (ProcessorSlot slot : sortedSlotList) {
       if (!(slot instanceof AbstractLinkedProcessorSlot)) {
         RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");
         continue;
       }
​
       chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
     }
​
     return chain;
   }
}

职责链同样是由spi机制加载出来的，上面的加载只会在第一次运用的时分加载，然后缓存到内从后，今后直接取即可。

至此，SPI机制的完结原理就剖析完了。 尽管SPI咱们日常开发顶用的很少，可是至少了解了解仍是有必要的。 例如： 一些结构完结中一般都会用到SPI机制。

vert.x内部也是许多运用SPI

4.2 APT注解处理器

4.2.1 基础常识

注解的保存时刻分为三种：

• SOURCE——只在源代码中保存，编译器将代码编译成字节码文件后就会丢掉
• CLASS——保存到字节码文件中，但Java虚拟机将class文件加载到内存是纷歧定在内存中保存
• RUNTIME——一直保存到运转时

一般咱们运用后两种，由于SOURCE首要起到符号方便了解的效果，无法对代码逻辑供给有效的信息。

时刻	解析	功能影响
RUNTIME	运转时	反射	有
CLASS	编译期	APT+JavaPoet	无

如上图，对比两种解析办法：

• 运转时注解比较简略易懂，能够运用反射技能在程序运转时获取指定的注解信息，由于用到反射，所以功能会收到一定影响。
• 编译期注解能够运用APT(Annotation Processing Tool)技能，在编译期扫描和解析注解，并结合JavaPoet技能生成新的java文件，是一种更高雅的解析注解的办法，不会对程序功能产生太大影响。

下面以BindView为例，介绍两种办法的不同运用办法。

4.2.2 运转时注解

运转时注解首要通过反射进行解析，代码运转进程中，通过反射咱们能够知道哪些特点、办法运用了该注解，而且能够获取注解中的参数，做一些咱们想做的作业。

首要，新建一个注解

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface BindViewTo {
   int value() default -1; //需求绑定的view id
}

然后，新建一个注解解析东西类AnnotationTools，和一般的反射用法并无不同：

public class AnnotationTools {
​
   public static void bindAllAnnotationView(Activity activity) {
     //取得成员变量
     Field[] fields = activity.getClass().getDeclaredFields();
​
     for (Field field : fields) {
       try {
         if (field.getAnnotations() != null) {
           //判别BindViewTo注解是否存在
           if (field.isAnnotationPresent(BindViewTo.class)) {
             //获取访问权限
             field.setAccessible(true);
             BindViewTo getViewTo = field.getAnnotation(BindViewTo.class);
             //获取View id
             int id = getViewTo.value();
             //通过id获取View，并赋值该成员变量
             field.set(activity, activity.findViewById(id));
           }
         }
       } catch (Exception e) {
       }
     }
   }
}

在Activity中调用

public class MainActivity extends AppCompatActivity {
​
   @BindViewTo(R.id.text)
   private TextView mText;
​
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
​
     //调用注解绑定，当时Activity中一切运用@BindViewTo注解的控件将自动绑定
     AnnotationTools.bindAllAnnotationView(this);
​
     //测验绑定是否成功
     mText.setTextColor(Color.RED);
   }
​
}

测验成果毫无意外，字体变成了赤色，说明绑定成功。

4.2.3 编译期注解（APT+JavaPoet）

编译期注解解析需求用到APT(Annotation Processing Tool)技能，APT是javac中供给的一种编译时扫描和处理注解的东西，它会对源代码文件进行检查，并找出其间的注解，然后依据用户自界说的注解处理办法进行额外的处理。APT东西不只能解析注解，还能结合JavaPoet技能依据注解生成新的的Java源文件，最终将生成的新文件与原来的Java文件一起编译。

APT完结流程如下：

0. 创立一个java lib作为注解解析库——如apt_processor
1. 在创立一个java lib作为注解声明库——如apt_annotation
2. 搭建两个lib和主项目的依靠关系
3. 完结AbstractProcessor
4. 编译和调用

整个流程是固定的，咱们的首要作业是承继AbstractProcessor，而且完结其间四个办法。下面一步一步详细介绍：

4.2.3.１创立解析库apt_processor

apply plugin: 'java-library'
​
dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   compile 'com.squareup:javapoet:1.9.0' // square开源的 Java 代码生成结构
   compile 'com.google.auto.service:auto-service:1.0-rc2' //Google开源的用于注册自界说注解处理器的东西
   implementation project(':apt_annotation') //依靠自界说注解声明库
}
sourceCompatibility = "7"
targetCompatibility = "7"

4.2.3.２ 创立注解库apt_annotation

声明一个注解BindViewTo，留意@Retention不再是RUNTIME，而是CLASS。

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.CLASS)
public @interface BindViewTo {
   int value() default -1;
}

4.2.3.３ 搭建主项目依靠关系

dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation project(':apt_annotation')  //依靠自界说注解声明库
   annotationProcessor project(':apt_processor')  //依靠自界说注解解析库（仅编译期）
}

这儿需求解说一下，由于注解解析库只在程序编译期有用，没必要打包进APK。所以依靠解析库运用的要害字是annotationProcessor，这是google为gradle插件增加的特性，表明只在编译期依靠，不会打包进最终APK。这也是为什么前面要把注解声明和注解解析拆分成两个库的原因。由于注解声明是一定要编译到最终APK的，而注解解析不需求。

4.2.3.４ 完结AbstractProcessor

这是最杂乱的一步，也是完结咱们希望作业的要点。首要，咱们在apt_processor中创立一个承继自AbstractProcessor的子类，重载其间四个办法：

• init()——此处初始化一个东西类
• getSupportedSourceVersion()——声明支撑的Java版别，一般为最新版别
• getSupportedAnnotationTypes()——声明支撑的注解列表
• process()——编译器回调办法，apt中心完结办法

详细代码如下：

//@SupportedSourceVersion(SourceVersion.RELEASE_7)
//@SupportedAnnotationTypes("com.xibeixue.apt_annotation.BindViewTo")
@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {
​
   private Elements mElementUtils;
   private HashMap<String, BinderClassCreator> mCreatorMap = new HashMap<>();
​
   /**
   * init办法一般用于初始化一些用到的东西类，首要有
   * processingEnvironment.getElementUtils(); 处理Element的东西类，用于获取程序的元素，例如包、类、办法。
   * processingEnvironment.getTypeUtils(); 处理TypeMirror的东西类，用于取类信息
   * processingEnvironment.getFiler(); 文件东西
   * processingEnvironment.getMessager(); 过错处理东西
   */
   @Override
   public synchronized void init(ProcessingEnvironment processingEnvironment) {
     super.init(processingEnvironment);
     mElementUtils = processingEnv.getElementUtils();
   }
​
   /**
   * 获取Java版别，一般用最新版别
   * 也能够运用注解办法：@SupportedSourceVersion(SourceVersion.RELEASE_7)
   */
   @Override
   public SourceVersion getSupportedSourceVersion() {
     return SourceVersion.latestSupported();
   }
​
   /**
   * 获取方针注解列表
   * 也能够运用注解办法：@SupportedAnnotationTypes("com.xibeixue.apt_annotation.BindViewTo")
   */
   @Override
   public Set<String> getSupportedAnnotationTypes() {
     HashSet<String> supportTypes = new LinkedHashSet<>();
     supportTypes.add(BindViewTo.class.getCanonicalName());
     return supportTypes;
   }
​
   /**
   * 编译期回调办法,apt中心完结办法
   * 包括一切运用方针注解的元素(Element)
   */
   @Override
   public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
     //扫描整个工程, 找出一切运用BindViewTo注解的元素
     Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindViewTo.class);
     //遍历元素, 为每一个类元素创立一个Creator
     for (Element element : elements) {
       //BindViewTo限制了只能特点运用, 这儿强转为变量元素VariableElement
       VariableElement variableElement = (VariableElement) element;
       //获取封装特点元素的类元素TypeElement
       TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
       //获取简略类名
       String fullClassName = classElement.getQualifiedName().toString();
       BinderClassCreator creator = mCreatorMap.get(fullClassName);
       //假如不存在, 则创立一个对应的Creator
       if (creator == null) {
         creator = new BinderClassCreator(mElementUtils.getPackageOf(classElement), classElement);
         mCreatorMap.put(fullClassName, creator);
​
       }
       //将需求绑定的变量和对应的view id存储到对应的Creator中
       BindViewTo bindAnnotation = variableElement.getAnnotation(BindViewTo.class);
       int id = bindAnnotation.value();
       creator.putElement(id, variableElement);
     }
​
     //每一个类将生成一个新的java文件，其间包括绑定代码
     for (String key : mCreatorMap.keySet()) {
       BinderClassCreator binderClassCreator = mCreatorMap.get(key);
       //通过javapoet构建生成Java类文件
       JavaFile javaFile = JavaFile.builder(binderClassCreator.getPackageName(),
           binderClassCreator.generateJavaCode()).build();
       try {
         javaFile.writeTo(processingEnv.getFiler());
       } catch (IOException e) {
         e.printStackTrace();
       }
​
     }
     return false;
   }
}

其间，BinderClassCreator是代码生成相关办法，详细代码如下：

public class BinderClassCreator {
​
   public static final String ParamName = "rootView";
​
   private TypeElement mTypeElement;
   private String mPackageName;
   private String mBinderClassName;
   private Map<Integer, VariableElement> mVariableElements = new HashMap<>();
​
   /**
   * @param packageElement 包元素
   * @param classElement  类元素
   */
   public BinderClassCreator(PackageElement packageElement, TypeElement classElement) {
     this.mTypeElement = classElement;
     mPackageName = packageElement.getQualifiedName().toString();
     mBinderClassName = classElement.getSimpleName().toString() + "_ViewBinding";
   }
​
   public void putElement(int id, VariableElement variableElement) {
     mVariableElements.put(id, variableElement);
   }
​
   public TypeSpec generateJavaCode() {
     return TypeSpec.classBuilder(mBinderClassName)
         //public 润饰类
         .addModifiers(Modifier.PUBLIC)
         //增加类的办法
         .addMethod(generateMethod())
         //构建Java类
         .build();
​
   }
​
   private MethodSpec generateMethod() {
     //获取全类名
     ClassName className = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
     //构建办法--办法名
     return MethodSpec.methodBuilder("bindView")
         //public办法
         .addModifiers(Modifier.PUBLIC)
         //回来void
         .returns(void.class)
         //办法传参（参数全类名，参数名）
         .addParameter(className, ParamName)
         //办法代码
         .addCode(generateMethodCode())
         .build();
   }
​
   private String generateMethodCode() {
     StringBuilder code = new StringBuilder();
     for (int id : mVariableElements.keySet()) {
       VariableElement variableElement = mVariableElements.get(id);
       //变量称号
       String name = variableElement.getSimpleName().toString();
       //变量类型
       String type = variableElement.asType().toString();
       //rootView.name = (type)view.findViewById(id), 留意原类中变量声明不能为private，不然这儿是获取不到的
       String findViewCode = ParamName + "." + name + "=(" + type + ")" + ParamName + ".findViewById(" + id + ");\n";
       code.append(findViewCode);
​
     }
     return code.toString();
   }
​
   public String getPackageName() {
     return mPackageName;
   }
}

4.2.3.５ 编译和调用

在MainActivity中调用，这儿需求强调的是待绑定变量不能声明为private，原因在上面代码注释中现已解说了。

public class MainActivity extends AppCompatActivity {
​
   @BindViewTo(R.id.text)
   public TextView mText;
​
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);//这儿的MainActivity需求先编译生成后才干调用
     new MainActivity_ViewBinding().bindView(this);
     //测验绑定是否成功
     mText.setTextColor(Color.RED);
   }
}

此时，build或rebuild工程（需求先注掉MainActivity的调用），会看到在generatedJava文件夹下生成了新的Java文件。

上面的调用办法需求先编译一次才干运用，当有多个Activity时比较繁琐，而且无法做到统一。

咱们也能够选择另一种更简洁的办法，即反射调用。新建东西类如下：

public class MyButterKnife {
​
     public static void bind(Activity activity) {
       Class clazz = activity.getClass();
       try {
         Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
         Method method = bindViewClass.getMethod("bindView", activity.getClass());
         method.invoke(bindViewClass.newInstance(), activity);
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
​
}

调用办法改为：

   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
​
     //通过反射调用
     MyButterKnife.bind(this);
​
     //测验绑定是否成功
     mText.setTextColor(Color.RED);
   }

此办法尽管也会略微影响功能，但仍然比直接运用运转时注解高效得多。

4.2.4 APT注解处理器总结

提到底，APT是一个编译器东西，是一个十分好的从源码到编译期的过渡解析东西。尽管结合JavaPoet技能被各大结构运用，可是仍然存在固有的缺陷，比方变量不能私有，仍然要选用反射调用等，一般开发者可斟酌运用。

个人以为APT有如下优点：

0. 装备办法，替换文件装备办法，改为代码内装备，进步程序内聚性
1. 代码精简，一劳永逸，省去繁琐杂乱的格式化代码，适合团队内推广

以上优点一起也是缺点，由于许多代码都在后台生成，会对新同学构成了解困难，影响其对整体架构的了解，增加学习本钱。

近期研究热修正和APT，发现从咱们写完结代码，到代码真实履行，期间还真是有大把的“空子”能够钻啊，借图mark一下。

4.3 javac源码剖析

4.3.1 javac概述

咱们都知道 *.java 文件要首要被编译成 *.class 文件才干被 JVM 知道，这部分的作业首要由 Javac 来完结，类似于 Javac 这样的咱们称之为前端编译器；

可是 *.class 文件也不是机器言语，怎样才干让机器识别呢？就需求 JVM 将 *.class 文件编译成机器码，这部分作业由JIT 编译器完结；

除了这两种编译器，还有一种直接把 *.java 文件编译本钱地机器码的编译器，咱们称之AOT 编译器。

4.3.2 javac 的编译进程

首要，咱们先导一份 javac 的源码（依据 openjdk8）出来，下载地址：hg.openjdk.java.net/jdk8/jdk8/l…，然后将 JDK_SRC_HOME/langtools/src/share/classes/com/sun 目录下的源文件全部复制到工程的源码目录中，生成的 目录如下：

咱们履行 com.sun.tools.javac.Main 的 main 办法，就和咱们在指令窗口中运用 javac 指令相同：

从 Sun Javac 的代码来看，编译进程大致能够分为三个过程：

• 解析和填充符号表进程
• 刺进式注解处理器的注解处理进程
• 剖析和字节码生成进程

这三个过程所做的作业内容大致如下：

这三个过程之间的关系和交互次序如下图所示，能够看到假如注解处理器在处理注解期间对语法树进行了修改，编译器将回到解析和填充符号表的进程进行从头处理，直到注解处理器没有再对语法树进行修改停止。

Javac 编译的入口是 com.sun.tools.javac.main.JavaCompiler 类，上述三个过程的代码都集中在这个类的 compile() 和 compile2() 中：

4.3.3 javac编译器编译程序的过程

词法剖析
  首要是读取源代码，找出这些字节中哪些是咱们界说的语法要害词，如Java中的if、else、for等要害词
  语法剖析的成果:从源代码中找出一些标准化的token流
   注:token是一种认证机制
​
语法剖析
  检查要害词组合在一起是不是Java言语标准，如if后边是不是紧跟着一个布尔表达式。
  语法剖析的成果：构成一个契合Java言语标准的笼统语法树
​
语义剖析
  把一些难懂的、杂乱的语法转化为愈加简略的语法
  语义剖析的成果：完结杂乱语法到简略语法的简化,如将foreach句子转化成for循环成果，还有注解等。最终构成一个注解过后的笼统语法树，这颗语法树更接近方针言语的语法规则
​
生成字节码
  通过字节码生成器生成字节码，依据通过注解的笼统语法树生成字节码，也便是将一个数据结构转化成另一个数据结构
  代码生成器的成果：生成契合Java虚拟机标准的字节码
​
注：笼统语法树
  在计算机科学中，笼统语法树是源代码语法结构的一种笼统表明。它以树状的办法体现编程言语的语法结构，树上的每个节点都表明源代码中的一种结构