@TryLoveCatch 2023-03-07T08:18:59.000000Z 字数 12350 阅读 1096

Java知识体系之注解

Java知识体系

注解

注解是一种元数据（描述数据的数据），注解本质是一个继承了Annotation 的特殊接口。
描述作用，不会直接生效，需要在编译前/运行时获取注解信息

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
public interface Override extends Annotation{
}

元注解

元注解是修饰其他注解的注解。

@Documented：让注解信息出现在 document 中
@Retention ：定义该注解的生命周期，支持以下三种参数
- RetentionPolicy.SOURCE : 注解会保留在源码中，在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
- RetentionPolicy.CLASS : 注解会保留在class文件中，但运行时不能取得
- RetentionPolicy.RUNTIME : 注解会保留在class文件中，而且运行时可以取得，因此可以使用反射机制读取该注解的信息。
@Target ：表示该注解用于什么地方，支持以下几种参数
- ElementType.TYPE : 作用于任何类、接口、枚举
- ElementType.FIELD : 作用于一个域或者属性
- ElementType.METHOD : 作用于一个方法
- ElementType.PARAMTER : 作用于参数
- ElementType.CONSTRUCTOR : 作用于构造函数
- ElementType.LOCAL_VARIABLE : 作用于本地变量
- ElementType. ANNOTATION_TYPE : 作用于注解
- ElementType.PACKAGE : 作用于包
@Inherited ：当前注解是否可以继承。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。注意：@Inherited对接口继承或实现都不起作用，只针对类继承

自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ContentView {
    //属性叫 value ，在使用时可以直接传参数即可，不必显式的指明键值对，是一种快捷方法
    int value();
}

我们可以使用 default xxx 为注解的某个属性指定默认值，这样即使不指定某个属性，编译器也不会报错。这通常可以节约很多时间，比如这样：

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface Author {
    String name() default "shixinzhang";
    String date();
}

自定义注解规则

Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
参数成员只能用public或默认(default)这两个访问权修饰
参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,因为你除此之外没有别的获取注解对象的方法
注解也可以没有定义成员, 不过这样注解就没啥用了

注解的作用

编译前提示信息：注解可以被编译器用来发现错误，或者清除不必要的警告；
编译时生成代码：一些处理器可以在编译时根据注解信息生成代码，比如 Java 代码，xml 代码等；
运行时处理：我们可以在运行时根据注解，通过反射获取具体信息，然后做一些操作。

注解的用法

自定义注解：规定处理对象类型，保存阶段，以及包含的值
使用注解修饰我们想要的处理的类、方法或者属性
读取注解，使用注解处理器处理

注解处理器

注解处理器分为两种：

运行时处理器
编译时处理器

运行时处理器

Java 进阶巩固：什么是注解以及运行时注解的使用

运行时注解需要使用注解 + 反射，非常简单。

我们先自定义一个 ContentView 注解，表示当前布局对应的 layout 文件：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ContentView {
    //属性叫 value ，在使用时可以直接传参数即可，不必显式的指明键值对，是一种快捷方法
    int value() ;
}

然后用它修饰一个 Activity：

@ContentView(R.layout.activity_annotation)
public class AnnotationTestActivity extends BaseActivity {
        @Override
    protected void onCreate(@Nullable final Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);  //调用父类的 onCreate
    }
}

在 BaseActivity 中反射获取当前类使用的注解，拿到注解的值，就可以直接设置布局了：

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    annotationProcess();
}
//读取注解，进行处理
private void annotationProcess() {
    Class c = this.getClass();
    //遍历所有子类
    for (; c != Context.class; c = c.getSuperclass()) {
        //找到使用 ContentView 注解的类
        ContentView annotation = (ContentView) c.getAnnotation(ContentView.class);
        if (annotation != null) {
            try {   //有可能出错的地方都要 try-catch
                //获取 注解中的属性值，为 Activity 设置布局
                this.setContentView(annotation.value());
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
            return;
        }
    }
}

这样就简单实现了运行时根据注解动态设置布局的功能。

运行时注解需要使用大量 Java 反射而引起较为严重的性能问题。
在使用运行时注解时需要小心，在调用方法时注意对异常的捕获，避免调用失败。

编译时处理器

使用编译时注解简单实现类似 ButterKnife 的效果
处理编译时注解需要使用 APT。
APT 即 Annotation Processing Tool，注解处理工具，它可以在编译时检测源代码文件，找到符合条件的注解修饰的内容，然后进行相应的处理。
我们在使用 ButterKnife，gradle 依赖中的 apt 就是指定在编译时调用它们的注解处理器：

compile "com.jakewharton:butterknife:$rootProject.butterknifeVersion"
apt "com.jakewharton:butterknife-compiler:$rootProject.butterknifeVersion"

编译时注解的使用一般分为三步：

创建注解
编译时使用注解处理器生成代码
运行时调用生成的代码

这里，我们写一个类似 ButterKnife 使用注解实现 findViewById 的 demo。
大概思路就是这样子：

先写一个注解，这个注解修饰一个成员变量，同时指定这个变量对应的 id
然后写个注解处理器，读取当前类的所有被注解修饰的成员对象和 id，生成对应的 findViewById 代码
最后写个运行时绑定的类，初始化当前类的成员

注解处理器所在的 module 必须是 Java Library，因为要用到特有的 javax；
注解处理器需要依赖注解 module，所以注解所在的 module 也要是 Java Library；
运行时绑定的类要操作 Activity 或者 View，所以需要为 Android Library。

创建注解

New 一个 Module，选择为 Java library，我们起名为 ioc-annotation

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BindView {
    int value();
}

编译时注解的 Retention 为 RetentionPolicy.CLASS，即只在编译时保留。
修饰目标为 ElementType.FIELD，即成员变量。

创建运行时绑定的类

我们需要在 Activity 中调用一个绑定的方法，它的作用调用生成类方法，来完成findviewbyid的过程。类似 ButterKnife：

@Override
protected void onCreate(@Nullable final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_annotation);
    ViewBinder.bind(this);
}

New 一个 Module，选择为 Android library，我们起名为 ioc，创建 ViewBinder

**
 * Description:
 * <br> 从生成类中为当前 Activity/View 中的 View findViewById
 */
public class ViewBinder {
    private static final String SUFFIX = "$$ViewInjector";
    //Activity 中调用的方法
    public static void bind(Activity activity) {
        bind(activity, activity);
    }
    /**
     * 1.寻找对应的代理类
     * 2.调用接口提供的绑定方法
     *
     * @param host
     * @param root
     */
    @SuppressWarnings("unchecked")
    private static void bind(final Object host, final Object root) {
        if (host == null || root == null) {
            return;
        }
        Class<?> aClass = host.getClass();
        String proxyClassFullName = aClass.getName() + SUFFIX;    //拼接生成类的名称
        try {
            Class<?> proxyClass = Class.forName(proxyClassFullName);
            ViewInjector viewInjector = (ViewInjector) proxyClass.newInstance();
            if (viewInjector != null) {
                viewInjector.inject(host, root);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

MyActivity$$ViewInjector，这个就是我们约定好的生产的类名。

ViewInjector，是一个接口，主要用来反射调用。

public interface ViewInjector<T> {
    void inject(T t, Object source);
}

创建注解处理器

注解处理器的作用是读取注解、生成代码，按照我们约定好的类名来生成类，并且包含findViewById的代码。
具体的参考链接，这里就不赘述了。

使用

public class AnnotationTestActivity extends BaseActivity {
    @BindView(R.id.tv_content)
    public TextView mTextView;
    @BindView(R.id.tv_bottom_content)
    public TextView mBottomTextView;
    @Override
    protected void onCreate(@Nullable final Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_annotation);
        ViewBinder.bind(this);
    }
    //...
}

点击 Build -> Rebuild Project，然后在 app -> build -> generated -> source -> apt -> flavor名字 -> 使用注解的包名下，看到生成类。

原理

Java注解（Annotation）原理详解

例子

自定义一个运行时注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface HelloAnnotation {
    String say() default "Hi";
}

然后在Main函数中解析注解

@HelloAnnotation(say = "Do it!")
public class TestMain {
    public static void main(String[] args) {
        HelloAnnotation annotation = TestMain.class.getAnnotation(HelloAnnotation.class);//获取TestMain类上的注解对象
        System.out.println(annotation.say());//调用注解对象的say方法，并打印到控制台
    }
}

运行程序，输出结果如下：

Do it!

注解本质

我们来看一下HelloAnnotation的字节码

$ javap -verbose HelloAnnotation 
Warning: Binary file HelloAnnotation contains com.kevin.java.annotation.runtimeAnnotation.HelloAnnotation
Classfile /home/kevin/Workspace/IdeaProjects/JavaLearn/out/production/JavaLearn/com/kevin/java/annotation/runtimeAnnotation/HelloAnnotation.class
  Last modified Aug 6, 2016; size 496 bytes
  MD5 checksum a6c87f863669f6ab9050ffa310160ea5
  Compiled from "HelloAnnotation.java"
public interface com.kevin.java.annotation.runtimeAnnotation.HelloAnnotation extends java.lang.annotation.Annotation
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION
Constant pool:
   #1 = Class              #18            // com/kevin/java/annotation/runtimeAnnotation/HelloAnnotation
   #2 = Class              #19            // java/lang/Object
   #3 = Class              #20            // java/lang/annotation/Annotation
   #4 = Utf8               say
   #5 = Utf8               ()Ljava/lang/String;
   #6 = Utf8               AnnotationDefault
   #7 = Utf8               Hi
   #8 = Utf8               SourceFile
   #9 = Utf8               HelloAnnotation.java
  #10 = Utf8               RuntimeVisibleAnnotations
  #11 = Utf8               Ljava/lang/annotation/Target;
  #12 = Utf8               value
  #13 = Utf8               Ljava/lang/annotation/ElementType;
  #14 = Utf8               TYPE
  #15 = Utf8               Ljava/lang/annotation/Retention;
  #16 = Utf8               Ljava/lang/annotation/RetentionPolicy;
  #17 = Utf8               RUNTIME
  #18 = Utf8               com/kevin/java/annotation/runtimeAnnotation/HelloAnnotation
  #19 = Utf8               java/lang/Object
  #20 = Utf8               java/lang/annotation/Annotation
{
  public abstract java.lang.String say();
    descriptor: ()Ljava/lang/String;
    flags: ACC_PUBLIC, ACC_ABSTRACT
    AnnotationDefault:
      default_value: s#7}
SourceFile: "HelloAnnotation.java"
RuntimeVisibleAnnotations:
  0: #11(#12=[e#13.#14])
  1: #15(#12=e#16.#17)

看第7行，很明显，HelloAnnotation就是继承了Annotation的接口。
再看第10行，flag字段中，我们可以看到，有个ACC_ANNOTATION标记，说明是一个注解，所以

注解本质是一个继承了Annotation的特殊接口。

看一下Annotation接口声明

package java.lang.annotation;
public interface Annotation {
    boolean equals(Object var1);
    int hashCode();
    String toString();
    Class<? extends Annotation> annotationType();
}

代理

我们运行TestMain，并打断点，看一下HelloAnnotation具体是什么类的对象：

可以看到HelloAnnotation注解的实例是jvm生成的动态代理类的对象。
我们来看一下这个生成的代理类：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.sun.proxy;
import com.kevin.java.annotation.runtimeAnnotation.HelloAnnotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy1 extends Proxy implements HelloAnnotation {
    private static Method m1;
    private static Method m2;
    private static Method m4;
    private static Method m3;
    private static Method m0;
    public $Proxy1(InvocationHandler var1) throws  {
        super(var1);
    }
    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final Class annotationType() throws  {
        try {
            return (Class)super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final String say() throws  {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.kevin.java.annotation.runtimeAnnotation.HelloAnnotation").getMethod("annotationType", new Class[0]);
            m3 = Class.forName("com.kevin.java.annotation.runtimeAnnotation.HelloAnnotation").getMethod("say", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从第14行我们可以看到，我们自定义的注解HelloAnnotation是一个接口，而$Proxy1这个Java生成的动态代理类就是它的实现类。

现在我们知道了HelloAnnotation注解（接口）是一个继承了Annotation接口的特殊接口。

而我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象$Proxy1，该类就是HelloAnnotation注解（接口）的具体实现类。

AnnotationInvocationHandler

既然是Proxy，那么就应该有一个InvocationHandler来处理代理，通过断点，我们可以知道这个对应的就是AnnotationInvocationHandler：

class AnnotationInvocationHandler implements InvocationHandler, Serializable {
    private final Class<? extends Annotation> type;
    private final Map<String, Object> memberValues;
    private transient volatile Method[] memberMethods = null;
    ....
    AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
      this.type = type;
      this.memberValues = memberValues;
  }
  public Object invoke(Object proxy, Method method, Object[] args) {
      String member = method.getName();
      Class<?>[] paramTypes = method.getParameterTypes();
      // Handle Object and Annotation methods
      if (member.equals("equals") && paramTypes.length == 1 &&
          paramTypes[0] == Object.class)
          return equalsImpl(args[0]);
      assert paramTypes.length == 0;
      if (member.equals("toString"))
          return toStringImpl();
      if (member.equals("hashCode"))
          return hashCodeImpl();
      if (member.equals("annotationType"))
          return type;
      // Handle annotation member accessors
      Object result = memberValues.get(member);
      if (result == null)
          throw new IncompleteAnnotationException(type, member);
      if (result instanceof ExceptionProxy)
          throw ((ExceptionProxy) result).generateException();
      if (result.getClass().isArray() && Array.getLength(result) != 0)
          result = cloneArray(result);
      return result;
  }
  ...
  ...
}

我们一眼就可以看到一个有意思的名字: memberValues，这是一个Map，而断点中可以看到这是一个 LinkedHashMap，key为注解的属性名称，value即为注解的属性值。

注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。

而我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象$Proxy1。

通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler的invoke方法。

该方法会从memberValues这个Map中索引出对应的值。

而memberValues的来源是Java常量池。

简单来说，注解就是接口+Map，然后通过动态代理将他们组合起来。

APT

apt不再神秘
 Android APT 实例讲解
 Android开源系列-组件化框架Arouter-(三)APT技术详解
 KotlinPoet简介

apt怎么参与到javac的编译过程的？
apt与javac约定在META-INF/services/javax.annotation.processing.Processor文件中注册apt插件。

这个逻辑，让我感觉APT是基于SPI实现的

apt不能修改已有代码的执行流程，如果要实现类似“日志打点”等在原代码的基础上插入一些功能，一般需要通过aspectj来实现。这类功能是在编译后期(javac之后)修改字节码文件来实现。

生成java文件，可以使用Square出品的javapoet

implementation "com.squareup:javapoet:1.11.1"

生成kotlin文件，可以使用Square出品的KotlinPoet

compile 'com.squareup:kotlinpoet:1.12.0'

参考

Java 进阶巩固：什么是注解以及运行时注解的使用
 使用编译时注解简单实现类似 ButterKnife 的效果
 Android 如何编写基于编译时注解的项目