面试题：Java注解的理解和应用场景

Java注解（Annotation）又称之为标注是JDK1.5引入的一种注释机制。是元数据的一种形式，提供有关于程序但是不属于程序本身的数据。本篇我们来聊聊关于注解以及使用场景项目中源码地址Github。

Java注解的定义

• Java注解（Annotation）又称之为标注是JDK1.5引入的一种注释机制。是元数据的一种形式，提供有关于程序但是不属于程序本身的数据。注解本身是没有任何意义的，如果结合反射，插桩等技术才有意义。

• 元注解：在定义注解时，注解类也能够使用其他的注解声明。对注解类型进行注解的注解类，我们称之为 meta-annotation（元注解）。元注解有四种，最常用的就是@Retention和@Target，所有注解的父类都是java.lang.annotation Annotation：

  注解	意义
  Retention	注解的保留位置
  Target	注解的作用目标
  Document	说明该注解将被包含在javadoc中
  Inherited	说明子类可以继承父类中的该注解

• @Retention：用来表示注解的保留位置

  注解的保留位置	释义
  Retention(RetentionPolicy.SOURCE)	注解仅存在于源码中，编译后在class字节码文件中不包含
  Retention(RetentionPolicy.CLASS)	默认值，注解会在class字节码文件中存在，但运行时无法获得
  Retention(RetentionPolicy.RUNTIME)	注解会在class字节码文件中存在，在运行时可以通过反射获取到

• @Target：注解的作用目标

  解的作用目标	释义
  Target(ElementType.TYPE)	类、接口，注解，枚举
  Target(ElementType.FIELD)	字段，枚举的常量
  Target(ElementType.METHOD)	方法
  Target(ElementType.PARAMETER)	方法参数
  Target(ElementType.CONSTRUCTOR)	构造体
  Target(ElementType.LOCAL_VARIABLE)	局部变量
  Target(ElementType.ANNOTATION_TYPE)	注解
  Target(ElementType.PACKAGE)	包
  Target(ElementType.TYPE_PARAMETER)	类型参数声明注解，JDK1.8新加的
  Target(ElementType.TYPE_USE)	使用类型注解，JDK1.8新加的

• 从上面的分析看，Retention注解的三种类型，作用的时间长短如下，SOURCE < CLASS < RUNTIME，即CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。

注解的使用场景

• javac在编译java文件之前会先调取注解处理程序对注解的处理，然后才会编译java文件 。因为注解的保留级别不同，所以对注解的使用自然存在不同场景。下面分别对三种使用场景举例说明。

  级别	技术	说明
  SOURCE源码级别	APT	在编译期能够获取注解与注解声明的类，包括类中的成员信息，一般用于生成额外的辅助类。
  CLASS字节码	字节码插桩	在编译生成class之后，根据注解作为判断，通过修改class的数据来实现字节码级别的插桩操作
  RUNTIME运行时	反射	在程序运行期间，通过反射技术动态获取注解与属性元素值，来完成逻辑操作。

SOURCE源码级别使用场景：

• SOURCE级别第一个使用场景是在Android开发中，IDEA语法检查，下面看一段代码：

  public class TestRetention {
     public static void main(String[] args) {
         get(TYPE_NAME);
         get(TYPE_AGE);
         get(3);//IDEA提示错误
     }
  
     private static void get(@Type int type) {
         if (type == TYPE_NAME) {
             System.out.println("type=1");
         } else {
             System.out.println("type=2");
         }
     }
  
  
     static final int TYPE_NAME = 1;
     static final int TYPE_AGE = 2;
  
     @IntDef({TYPE_NAME, TYPE_AGE})
     @Retention(RetentionPolicy.SOURCE)
     @interface Type {
     }
  }
  

  • 我们声明了一个注解TYPE，并且指明了只能传入两个值，分别是TYPE_NAME,TYPE_NAME，这样做有两个好处。
    • 1 在使用get方法的时候，就只能传入这两个值，如果传入其它的值的话，IDE会友好的提示错误。并且减少程序中输入错误值带来的安全隐患。
    • 2 还有一个好处是在get方法体内部，我们就可以不用考虑其它值的影响，就可以大大减少if else的编写，不然还得考虑其它值的影响, 还得使用else if。这样就能大大简化代码的编写。
    • 需要注意的是：如果对于IDE的错误提示不顾的话，程序还是能正常运行的，所以运行前一定要检查IDE的错误提示，解决掉。
• SOURCE级别注解的第二个使用场景是- APT注解器处理 Annotation Process Tool，这个使用场景会在以后的文章中介绍。

CLASS字节码级别使用场景：字节码插桩技术

• 字节码插桩技术其实可以理解为在字节码层面编码的技术。我们知道.java文件需要先编译.class，然后才能被加载在虚拟机中运行，字节码插桩就是在.class文件中插入代码，执行我们需要的逻辑。一般应用在性能分析，代码埋点等。
• 比如下面这个需求是为了能够检测所有打某一个注解标记方法的执行耗时时间，如果在每一个方法前后都添加代码，很明显这个是不太好的方法。这个时候就可以使用字节码插桩技术。
  • 1先声明一个测试类，假如我们需要对其中打了注解Deprecated的方法前后加上代码来检测耗时操作，我们通过字节码插桩的方式实现。

  public class ByteInsert {
  
      @Deprecated
      public void needInsertMethod() {
          //sleep 3 seconds to monitor do some work
          try {
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      public void normalMethod() {
  
      }
  }
  

  • 2 引入依赖库

  testImplementation "org.ow2.asm:asm:7.1"
  testImplementation "org.ow2.asm:asm-commons:7.1"
  

  • 3 在test目录下创建一个ASMUnitTest类，用来测试结果，编码如下,：

  @Test
  public void test() {
      try {
          FileInputStream fis = new FileInputStream("xxx\\ByteInsert.class");
          ClassReader classReader = new ClassReader(fis);
  
          ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
  
          //开始插桩
          classReader.accept(new MyClassVisitor(Opcodes.ASM7, classWriter), ClassReader.EXPAND_FRAMES);
          byte[] bytes = classWriter.toByteArray();
          FileOutputStream fos = new FileOutputStream("xxx\\NewByteInsert.class");
          fos.write(bytes);
          fis.close();
          fos.close();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
  

  • 4 上面MyClassVisitor是自定义的继承ClassVisitor的类，我们重写了visitMethod方法：

  static class MyClassVisitor extends ClassVisitor {
  
      public MyClassVisitor(int api) {
          super(api);
      }
  
      public MyClassVisitor(int api, ClassVisitor classVisitor) {
          super(api, classVisitor);
      }
  
      /**
       * 每找到一个方法，这个API就执行一次(包括构造方法)
       */
      @Override
      public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
          MethodVisitor methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions);
          System.out.println("visitMethod name:" + name + "-descriptor:" + descriptor + "--signature:" + signature);
          return new MyMethodVisitor(api, methodVisitor, access, name, descriptor);
      }
  }
  

  • 5 visitMethod中有一个类MyMethodVisitor方法是继承自AdviceAdapter的类，实现了其中的onMethodEnter和onMethodExit，在对应的地方插入需要的字节码，运行上面的test()方法后最终的结果如图所示，为了便于区分结果，把插桩后的结果输出到了一个新的字节码NewByteInsert.class文件中，可以看到ByteInsert.class中的needInsertMethod只有Thread.sleep(3000)这一行代码，而在NewByteInsert.class中的needInsertMethod已经前后插入了新的代码，可以对运行时间进行统计。对没有注解的方法normalMethod我们都没有进行插桩，实现了需求。
    

RUNTIME运行时使用场景：反射

• 注解保留至运行期，意味着我们能够在运行期间结合反射技术获取注解中的所有信息。反射的应用场景非常丰富，我们知道使用ButterKnife可以不用我们手动的去findViewById，我们来实现这个同样的功能。

反射实现findViewById操作

• 1 首先声明一个注解类，用来对成员变量进行注解。

  @Retention(value = RetentionPolicy.RUNTIME)
  @Target(ElementType.FIELD)
  public @interface InjectView {
      @IdRes int value();
  }
  

• 2 写一个工具类，用来实现findViewById的操作，这样在代码中直接对成员变量进行注解就可以使用成员变量了。

  class InjectUtils {
      // inject view
      static void injectView(Activity activity) {
          Field[] fields = activity.getClass().getDeclaredFields();
          for (Field f : fields) {
              if (f.isAnnotationPresent(InjectView.class)) {
                  InjectView annotation = f.getAnnotation(InjectView.class);
                  int viewId = annotation.value();
                  f.setAccessible(true);
                  View view = activity.findViewById(viewId);
                  try {
                      f.set(activity, view);
                  } catch (IllegalAccessException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  }
  

• 3 在Activity中就可以直接使用了。

  public class AActivity extends AppCompatActivity {
  	//TODO please use command "adb shell am start -n com.oman.forward/.study.annotation.AActivity" to launch this activity
  
      @InjectView(R.id.title)
      private Button mTitle;
  
      @InjectView(R.id.title2)
  	// @BindView(R.id.title2)
      public Button mTitle2;
  
      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_a);
          InjectUtils.injectView(this);
  		// ButterKnife.bind(this);
          mTitle.setText("self bind successfully");
          mTitle2.setText("Buffer Knife Bind successfully");
  	}
  }
  

  限于篇幅，有些案例没有写在文章中，可以去项目中查看源码，具体源码可以去项目中源码地址Github查看。