Java注解和反射与动态代理

##Java 注解和反射与动态代理

元注解

在定义注解时，注解类也能够使用其他的注解声明。对注解类型进行注解的注解类，我们称之为 metaannotation（元注解）。一般的，我们在定义自定义注解时，需要指定的元注解有两个：
在定义注解时，注解类也能够使用其他的注解声明。对注解类型进行注解的注解类，我们称之为 >metaannotation（元注解）。一般的，我们在定义自定义注解时，需要指定的元注解有两个：

@Target
注解标记另一个注解，以限制可以应用注解的 Java 元素类型。目标注解指定以下元素类型之一作为其值：

ElementType.ANNOTATION_TYPE 可以应用于注解类型。

ElementType.CONSTRUCTOR 可以应用于构造函数。

ElementType.FIELD 可以应用于字段或属性。

ElementType.LOCAL_VARIABLE 可以应用于局部变量。

ElementType.METHOD 可以应用于方法级注解。

ElementType.PACKAGE 可以应用于包声明。

ElementType.PARAMETER 可以应用于方法的参数。

ElementType.TYPE 可以应用于类的任何元素。

@Retention
注解指定标记注解的存储方式：

RetentionPolicy.SOURCE - 标记的注解仅保留在源级别中，并被编译器忽略。

RetentionPolicy.CLASS - 标记的注解在编译时由编译器保留，但 Java 虚拟机(JVM)会忽略。

RetentionPolicy.RUNTIME - 标记的注解由 JVM 保留，因此运行时环境可以使用它。
@Retention 三个值中 SOURCE < CLASS < RUNTIME，即CLASS包含了SOURCE，RUNTIME包含SOURCE、
CLASS。下文会介绍他们不同的应用场景。

举个栗子：

// @Target(ElementType.TYPE)//只能在类上标记该注解
@Target({ElementType.FIELD, ElementType.METHOD})//只能在属性和方法上标记
@Retention(RetentionPolicy.SOURCE) //注解保留在源码这中
public @interface ViewInject {
    //限制输入的是资源id
    @IdRes int value();
}

注解类型元素

在上文元注解中，允许在使用注解时传递参数。我们也能让自定义注解的主体包含 annotation type element (注解类型元素) 声明，它们看起来很像方法，可以定义可选的默认值。

@Target({ElementType.TYPE,ElementType.FIELD})
 @Retention(RetentionPolicy.SOURCE) public 
 @interface Alex {
  String value(); //无默认值 
  int age() default 1; //有默认值 
  }

注意：在使用注解时，如果定义的注解中的类型元素无默认值，则必须进行传值。

注解应用场景

按照@Retention 元注解定义的注解存储方式，注解可以被在三种场景下使用：

RetentionPolicy.SOURCE

RetentionPolicy.SOURCE 作用于源码级别的注解，可提供给IDE语法检查、APT等场景使用，在类中使用 SOURCE 级别的注解，其编译之后的class中会被丢弃。

IDE语法检查

如：我们定义方法 test ，此方法接收参数 teacher 需要在：ALEX、BOB;中选择一个。如果使用枚举能够实现
为:

public enum Teacher{ 
   ALEX,BOB 
}
public void test(Teacher teacher) { 

}

而现在为了进行内存优化，我们现在不再使用枚举，则方法定义为：

public static final int ALEX = 1; 
public static final int BOB = 2; 
public void test(int teacher) {

}

然而此时，调用 test 方法由于采用基本数据类型int，将无法进行类型限定。此时使用@IntDef增加自定义注解：

public static final int ALEX = 1; 
public static final int BOB = 2; 
@IntDef(value = {MAN, WOMEN}) //限定为ALEX，BOB
@Target(ElementType.PARAMETER) //作用于参数的注解 
@Retention(RetentionPolicy.SOURCE) //源码级别注解 
public @interface Teacher {

}

public void test(@Teacher int teacher) {

}

此时，我们再去调用 test 方法，如果传递的参数不是 LANCE 或者 ALVIN 则会显示 Inspection 警告(编译不会报
错)。

APT注解处理器

APT全称为：”Anotation Processor Tools”，意为注解处理器。顾名思义，其用于处理注解。编写好的Java源文
件，需要经过 javac 的编译，翻译为虚拟机能够加载解析的字节码Class文件。注解处理器是 javac 自带的一个工
具，用来在编译时期扫描处理注解信息。你可以为某些注解注册自己的注解处理器。注册的注解处理器由 javac
调起，并将注解信息传递给注解处理器进行处理。

注解处理器是对注解应用最为广泛的场景。在Glide、EventBus3、Butterknifer、Tinker、ARouter等等常用
框架中都有注解处理器的身影。但是你可能会发现，这些框架中对注解的定义并不是 SOURCE 级别，更多的
是 CLASS 级别，别忘了：CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。

RetentionPolicy.CLASS

定义为 CLASS 的注解，会保留在class文件中，但是会被虚拟机忽略(即无法在运行期反射获取注解)。此时完全符合
此种注解的应用场景为字节码操作。如：AspectJ、热修复Roubust中应用此场景。

RetentionPolicy.RUNTIME

注解保留至运行期，意味着我们能够在运行期间结合反射技术获取注解中的所有信息。

反射

反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。

Java反射机制主要提供了以下功能：

在运行时构造任意一个类的对象
在运行时获取或者修改任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法（属性）

Class

反射始于Class，Class是一个类，封装了当前对象所对应的类的信息.

获取Class对象的三种方式

通过类名获取类名.class

通过对象获取对象名.getClass()

通过全类名获取 Class.forName(全类名) classLoader.loadClass(全类名)

判断是否为某个类的实例

一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的
isInstance() 方法来判断是否为某个类的实例，它是一个 native 方法：

1	public native boolean isInstance(Object obj);

判断是否为某个类的类型

1	public boolean isAssignableFrom(Class<?> cls)

创建实例

通过反射来生成对象主要有两种方式。

使用Class对象的newInstance()方法来创建Class对象对应类的实例。

1 2	Class<?> c = String.class; Object str = c.newInstance();

先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。
/获取String所对应的Class对象

Class<?> c = String.class; 
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class); 
//根据构造器创建实例
Object obj = constructor.newInstance("23333"); 
System.out.println(obj);

获取构造器信息

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的public构造函数(包括父类）
 
Constructor[] getConstructors() -- 获得类的所有公共构造函数 Constructor 

getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(包括私有) 

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的
一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:

1	public T newInstance(Object ... initargs)

获取类的成员变量（字段）信息

获得字段信息的方法

Field getField(String name) -- 获得命名的公共字段 

Field[] getFields() -- 获得类的所有公共字段 

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

调用方法

当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。 invoke 方法的原型为:

1	public Object invoke(Object obj, Object... args)

利用反射创建数组

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference 其中的Array类为
java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象，它的原型是:

1	public static Object newInstance(Class<?> componentType, int length);

动态代理原理

静态代理

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

目的：

通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性；

通过代理对象对访问进行控制；

代理模式一般会有三个角色：

抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。
代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。一般来说，被代理对象和代理对象是一对一的关系，当然一个代理对象对应多个被代理对象也是可以的。
静态代理，一对一则会出现时静态代理对象量多、代码量大，从而导致代码复杂，可维护性差的问题，一对多则代理对象会出现扩展能力差的问题。

动态代理

在运行时再创建代理类和其实例，因此显然效率更低。要完成这个场景，需要在运行期动态创建一个Class。JDK提供了 Proxy 来完成这件事情。基本使用如下：

//抽象角色 
interface Api {
 void test(String a); 
}
//真实角色
class ApiImpl{ 
 @Override public void test(String a) {
 
    System.out.println("真实实现：" + a);
   
   } 
}
//创建真实角色实例
ApiImpl api = new ApiImpl();
//JDK动态代理: 
Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Api.class}, 
 //JDK实现只能代理接口 
new InvocationHandler() { 
      @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{ 
        //执行真实对象方法
        return method.invoke(api, args); 
        } 
    });

实际上， Proxy.newProxyInstance 会创建一个Class，与静态代理不同，这个Class不是由具体的.java源文件编译
而来，即没有真正的文件，只是在内存中按照Class格式生成了一个Class。

基于java反射和注解简单实现butterknife