Retrofit解析3之反射

整体Retrofit内容如下：

1、Retrofit解析1之前哨站——理解RESTful
2、Retrofit解析2之使用简介
3、Retrofit解析3之反射
4、Retrofit解析4之注解
5、Retrofit解析5之代理设计模式
6、Retrofit解析6之面向接口编程
7、Retrofit解析7之相关类解析
8、Retrofit解析8之核心解析——ServiceMethod及注解1
9、Retrofit解析8之核心解析——ServiceMethod及注解2
10、Retrofit解析9之流程解析
11、Retrofit解析10之感谢

本篇文章的主要内容如下：

1、什么是反射和反射机制
2、什么是Java反射
3、Java反射可以做什么
4、反射机制的优缺点
5、Java类加载原理
6、核心类及API
7、Method的invoke原理解析
8、泛型与反射

一、什么是反射与反射机制

(一)、什么是反射

反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。在计算机科学领域，反射是一类应用，它们能够自描述和自控制。这类应用通过某种机制来实现对自己行为的描述和检测，并根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

(二)、反射机制

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法功能称为反射机制

二、什么是Java反射

Java 反射是Java语言的一个很重要的特征，它使得Java具备了"动态化"。

在Java中的反射机制，被称为Reflection。它允许运行中的Java程序对自身进行检测，并能直接操作程序的内部属性或方法。Reflection机制允许程序在正在执行的过程中，利用Reflection APIs取得任何已知名称的类的内部信息。包括如下：package、 type parameters、 superclass、 implemented interfaces、 inner classes、 outer classes、 fields、 constructors、 methods、 modifiers等，并可以在执行过程中，动态生成Instances、变更fields内容或唤起methods。

通俗的讲就是

.class反编译-->.java，这样就可以通过反射机制访问Java对象的属性，方法，构造方法等。

三、Java反射可以做什么?

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

运行时判断任意一个对象所属的类
在运行时构造任意个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用人一个对象的方法
生成动态代理

四、反射机制的优缺点：

为什么要用反射机制，直接创建对象不就可以了吗？这就涉及到了动态与静态的概念。

静态编译：在编译时确定类型，绑定对象，即通过。
动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了Java的灵活性，体现了多态的应用，有以降低类之间的耦合性。

优缺点

1、优点:
可以实现动态创建对象和编译，体现出很大的灵活性，特别是J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把它设计的很完美，当这个程序编译，发布了，当发现需要更新某些功能时，我们不可能要用户把之前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时都才动态的创建和编译，就可以显示该功能。
2、缺点：
对性能有影响，使用反射基本上是一种解释操作，我可以告诉JVM，我希望做什么并且它满足我们的需求，这类操作总是慢于直接执行相同的操作。

五、Java类加载原理

为了后里面讲解Java反射原理方便，在这里先讲解Java类加载原理

(一)、概述

Class文件由类装载器加载后，在JVM中将形成一份描述Class结构的元数据对象，通过该元数据可以获知Class的结构信息：如构造函数，属性和方法等，Java允许用户借这个Class相关原信息对象间接调用Class对象的功能。

虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。

JVM把class文件加载到内存，并对数据进行校验，解析和初始化，最形成JVM可以直接使用的JAVA类型的过程。

加载-->链接(-->验证-->准备-->解析)-->初始化-->使用-->卸载

1、加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。

class字节码-->类加载类--->内存(Class对象，方法区中运行时数据)--->外部可以通过Class对象，操作类

2、链接

将Java类的二进制代码合并到JVM的运行状态之中的过程

验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
准备：正式为类变量(static变量)分配内存并设置变量初始值的阶段，这些内存都将在方法区中进行分配
解析：虚拟机常量池内的符合引用替换为直接引用的过程。
常用吃：虚拟常用池内的符合引用替换为直接引用的过程。

3、初始化

初始化阶段是执行类构造器Class的()方法的过程。类构造器()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句(static)块中的语句合并产生的。
当初始化一个类的时候，如果发现其弗雷还没有进行初始化、则需要先执行父类的初始化。
虚拟机会保证一个的类()方法在多线程中呗正确的加锁和同步。
当访问一个Java类的静态域时，只有真正声明这个域才会被初始化。

初始化.png

4、使用

5、卸载

使用和卸载没有什么好讲解的，就不说了。

最后附上别人的思维导图

类加载.png

(二) 其它：

1、这里说下和的区别

在编译生成class文件时，会自动产生两个方法，一个是类的初始化方法，另一个是实例化的初始化方法

:在JVM第一次加载class文件时调用，包括静态变量初始化语句和静态块的执行
: 在实例创建出来的时候调用，包括调用new操作符；滴啊用Class或者java.lang.reflect.Constructor对象的newInstance()方法；调用任何现有对象的clone()方法；通过java.io.ObjectInputStream类的getObject()方法反序列化。

2、主动引用和被动引用

主动引用:一定会发生类的初始化

new一个类的对象
调用类的静态成员(除了final常量)和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当虚拟机启动，java helloworld，则一定会初始化helloworld类，说白了就是先启动main方法所在的类。
当初始化一个类，如果其父类没有被初始化，则会先初始化他的父类。

被动引用:不会发生类的初始化

当访问一个静态域时，

当访问一个静态域时，只有真正声明这个域的类才会被初始化
通过子类引用父类的静态变量，不会导致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发此类的初始化(常量在编译阶段就存入调用类的常量池中了)

六、核心类及API

核心类，位于java.lang.reflect包中

Class类：代表一个类
Field类：代表一个类
Method类：代表类的方法
Constructor类：代表类的构造方式
Array类：提供了动态创建数组，以及访问数组的元素的静态方法

(一)Class

1、Class是什么？

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标记，这项信息记录了每个对象所属的类。虚拟机通常使用运行时类型信息选择正确方法去执行，用来保存这些类型的类是Class类。

Class类封装一个对象和接口运行时的状态，当加载类时，Class类型的对象自动创建。Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的，因此不能显示地声明一个Class对对象。

虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类(型)都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象加载。

基本的Java类型(boolean、byte、char、shor、int、long、float、double)和关键字void也都对应一个Class对象。每个数据属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都
共享该Class对象。一般某个类Class对象被载入内存，它就用来创建这个类的所有对象。

2、Class类的常用方法

在java.lang.Object类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。Class类是Reflection API中的核心类。它有如下方法：

方法名	作用
getName()	获得类的完整名称
getFields()	获得类的public类型的属性
getDeclaredFields()	获得类的所有属性
getMethod()	获得类的public类型方法
getDeclaredFiedMethods()	获得类的所有方法
getMethod(String name,Class[] parameterTypes)	获得类的特定方法，name参数制定方法的名字，parameterTypes 参数制定方法参数类型
getConstructors()	获得类的public类型的构造方法
getConstructor(Class[] parameterTypes)	获得类的特定构造方式，parameterTypes 参数指定构造方法的参数类型
newInstance()	通过类的不带参数的构造方法创建这个类的一个对象

PS:

大家在使用Class实例化其他类的对象的时候，一定要自己定义午餐的构造函数
所有类的对象其实都得Class的实例

3、获取Class对象的三种方式

通过Object类的getClass()方法
例如 Class c1=new String("hello world").getClass();
通过Class类的静态方法——forName()来实现：
Class c2 = Class.forName("MyObject");
如果T是一个已定义的类型的话，在java中，它的.class文件名：T.class就代表了与其匹配的Class对象。例如：
Class c3 = Manager.class;
Class c4 = int.class;
Class c5 = Double[].class;

(二)、Constructor

Constructor 提供关于类的单个构造方法的信息以及对它的访问权限，用来封装反射得到的构造器。

1、获取构造方法
Class 类提供四个public方法，用于获取某个类的构造方法

方法名	作用
Constructor getConstructor(Class[] params)	根据构造函数的参数，返回一个具体的具有public属性的构造函数
Constructor[] getConstructor()	返回所有具有public属性的构造函数数组
Constructor getDeclaredConstructor(Class[] params)	根据构造函数的参数，返回一个具体的构造函数(不分public和非public 属性)
Constructor getDeclaredConstrutors()	返回该类中所有的构造函数数组(不分public 和非public属性)

由于Java语言是一种面向对象的语言，具有多态的性质，那么我们可以通过构造方法的参数列表的不同，来调用不同的构造方法去创建类的实例。同样，获取不同的构造方法的信息，也需要提供与之对应的参数类型信息；因此，就产生了以上四种不同的获取构造方法的方式。

(三)、Field 成员变量信息

想一想成员变量中都包含什么：

成员变量类型+成员变量名

类的成员变量也是一个对象，它是java.lang.reflect.Field的一个对象，所以我们通过java.lang.reflect.Field里面封装的方法来获取这些信息。

如果想单独获取某个成员变量，通过Class类的以下方法实现：

方法名	作用
Field getDeclaredField(String name)	获得该类自身声明的所有变量，不包括其父类的变量
Field getField(String name)	获得该类自所有的public成员变量，包括其父类变量

举例如下：
参数是成员变量的名字。
例如一个类A有如下成员变量：

private int n;

如果A有一个对象a，那么就可以这样得到其成员变量：

Class c = a.getClass();
Field field = c.getDeclaredField("n");

由于Method 在Retrofit比较重要，我们就单独讲解以下

(四) Method类及invoke

Method 提供关于类或接口上单独某个方法(以及如何反问该方法)的信息，一个完整方法包含的属性有：方法上使用的注解、方法的修饰符、方法上定义的泛型参数、方法的返回值、方法名称、方法抛出的异常。

1、获取Method

有4种获取Method的方式：

方法名	作用
Method getMethod(String name, Class[] params)	根据方法名和参数，返回一个具体的具有public属性的方法
Method[] getMethods()	返回所有具有public属性的方法数组
Method getDeclaredMethod(String name, Class[] params)	根据方法名和参数，返回一个具体的方法（不分public和非public属性）
Method[] getDeclaredMethods()	返回该类中的所有的方法数组（不分public和非public属性）

PS:在获取类的方法时，有一个地方值得大家注意，就是getMethods()方法和getDeclaredMethods()方法。
在

getMethods():用于获取类的所有的public修饰域的成员方法，包括从父类继承的public方法和实现接口的public方法
getDeclaredMethods()：用于获取当前类中定义的所有的成员方法和实现接口的方法，不包括从父类继承的方法。

2、Method的API

那来看下Method的API，因为Retrofit里面大量用到了Method的api

方法名	作用
T getAnnotation(Class annotationClass)	如果存在该元素的指定类型的注释，则返回这些注解，否则返回 null
Annotation[] etDeclaredAnnotations()	返回直接存在于此元素上的所有注解
Class getDeclaringClass()	返回表示声明由此 Method 对象表示的方法的类或接口的 Class 对象
Object getDefaultValue()	返回由此 Method 实例表示的注解成员的默认值。
Class[] getExceptionTypes()	返回 Class 对象的数组，这些对象描述了声明将此 Method 对象表示的底层方法抛出的异常类型。
Type[] getGenericExceptionTypes()	返回 Type 对象数组，这些对象描述了声明由此 Method 对象抛出的异常。
Type[] getGenericParameterTypes()	按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的。
Type getGenericReturnType()	返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象
int getModifiers()	以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。
String getName()	以 String 形式返回此 Method 对象表示的方法名称。
Annotation[][] getParameterAnnotations()	返回表示按照声明顺序对此 Method 对象所表示方法的形参进行注释的那个数组的数组。
Class[] getParameterTypes()	按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。
Class getReturnType()	返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型。
TypeVariable[] getTypeParameters()	返回 TypeVariable 对象的数组，这些对象描述了由 GenericDeclaration 对象表示的一般声明按声明顺序来声明的类型变量
Object invoke(Object obj, Object... args)	对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。

补充一个知识点：
在反射机制中，Field的getModifiers()方法返回int类型值表示该字段的修饰符，其中该修饰符是java.lang.reflect.Modifier的静态属性。对应如下：
Modifier.java

 /**
     * The {@code int} value representing the {@code public}
     * modifier.
     */
    public static final int PUBLIC           = 0x00000001;

    /**
     * The {@code int} value representing the {@code private}
     * modifier.
     */
    public static final int PRIVATE          = 0x00000002;

    /**
     * The {@code int} value representing the {@code protected}
     * modifier.
     */
    public static final int PROTECTED        = 0x00000004;

    /**
     * The {@code int} value representing the {@code static}
     * modifier.
     */
    public static final int STATIC           = 0x00000008;

    /**
     * The {@code int} value representing the {@code final}
     * modifier.
     */
    public static final int FINAL            = 0x00000010;

    /**
     * The {@code int} value representing the {@code synchronized}
     * modifier.
     */
    public static final int SYNCHRONIZED     = 0x00000020;

    /**
     * The {@code int} value representing the {@code volatile}
     * modifier.
     */
    public static final int VOLATILE         = 0x00000040;

    /**
     * The {@code int} value representing the {@code transient}
     * modifier.
     */
    public static final int TRANSIENT        = 0x00000080;

    /**
     * The {@code int} value representing the {@code native}
     * modifier.
     */
    public static final int NATIVE           = 0x00000100;

    /**
     * The {@code int} value representing the {@code interface}
     * modifier.
     */
    public static final int INTERFACE        = 0x00000200;

    /**
     * The {@code int} value representing the {@code abstract}
     * modifier.
     */
    public static final int ABSTRACT         = 0x00000400;

    /**
     * The {@code int} value representing the {@code strictfp}
     * modifier.
     */
    public static final int STRICT           = 0x00000800;

简单一点就是：

PUBLIC: 1
PRIVATE: 2
PROTECTED: 4
STATIC: 8
FINAL: 16
SYNCHRONIZED: 32
VOLATILE: 64
TRANSIENT: 128
NATIVE: 256
INTERFACE: 512
ABSTRACT: 1024
STRICT: 2048

3、Method的invoke方法

注意事项1

通过Method对象调用invoke()方法

//获取一个方法名为doHello，参数类型为String的方法
Method method = MyObject.class.getMethod("doHello", String.class);
Object returnValue = method.invoke(null, "value1");

如果是一个静态方法调用的话，可以穿用null代替制定对象作为invoke()方法的参数，在上面的方法中，如果doHello不是静态方法的话，你就要传入有效的MyObject对象，而不是null。

注意事项2

当通过Method的invoke()方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限，如果程序确实需要调用某个对象的private方法，则可以先调用Method对象的如下方法。

setAccessible(boolean flag)

将Method对象的accessible设置为制定的布尔值。值为true，指示Method在使用时应该取消Java语言访问权限检查；值为false，则指示该Method在使用时实施Java语言的访问权限检查。

七、Method的invoke原理解析

先上代码

Class actionClass=Class.forName(“MyClass”);
Object action=actionClass.newInstance();
Method method = actionClass.getMethod(“myMethod”,null);
method.invoke(action,null);

上面就是最常见的反射使用的例子，前两行实现了类的装载、链接和初始化（newInstance方法实际上也是使用反射调用了方法），后两行实现了从class对象中获取到method对象然后执行反射调用。下面简单分析一下后两行的原理。

Class Method{
     public Object invoke(Object obj,Object[] param){
        MyClass myClass=(MyClass)obj;
        return myClass.myMethod();
     }
}

method.invoke(action,null);的原理其实就是动态的生成类似于上面的字节码，加载到JVM中运行。

1、获取Method对象

首先来看下Method对象是如何生成的。

Method生成.png

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里面维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称为根对象。每次getMethod获取到的Method对象都持有对跟对象的引用，因此一些重量级别的Method的成员变量(主要是MethodAccessor)，我们不希望每次创建Method都要重新初始化，于是所有代表同一个方法的Method对象都共享根对象的MethodAccessor，每一次创建都会调用对象的copy方法复制一份：

    Method copy() {
        if(this.root != null) {
            throw new IllegalArgumentException("Can not copy a non-root Method");
        } else {
            Method var1 = new Method(this.clazz, this.name, this.parameterTypes, this.returnType, this.exceptionTypes, this.modifiers, this.slot, this.signature, this.annotations, this.parameterAnnotations, this.annotationDefault);
            var1.root = this;
            var1.methodAccessor = this.methodAccessor;
            return var1;
        }
    }

2、调用invoke()方法

获取到Method对象之后，调用invoke方法的流程如下：

调用invoke.png

上代码

    @CallerSensitive
    public Object invoke(Object var1, Object... var2) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        if(!this.override && !Reflection.quickCheckMemberAccess(this.clazz, this.modifiers)) {
            Class var3 = Reflection.getCallerClass();
            this.checkAccess(var3, this.clazz, var1, this.modifiers);
        }

        MethodAccessor var4 = this.methodAccessor;
        if(var4 == null) {
            var4 = this.acquireMethodAccessor();
        }

        return var4.invoke(var1, var2);
    }

代码解释

首先，检查AccessibleObject的overrider属性是否为true。因为AccessibleObject是Method、Field、Constructor的父类，override属性默认为false，可调用setAccessible方法改变，如果设置为true，则表示可以忽略访问权限的限制，直接调用。
其次，如果不是true，则要进行访问权限监测，用Reflection的quickCheckMemberAccess方法检查是不是public，如果不再用Reflection.getCallerClass()方法获得到调用这个方法的Class，然后做是否有权限访问的校验，校验之后缓存一次，以便下次如果还是这个类调用就不用去做校验，直接用上次的结果。(很奇怪用这种方式缓存，因为这种方式如果下次换个类来调用的话，就不会用缓存了，而再验证一遍，把这次的结果作为缓存，但上一次的缓存结果就冲掉了，这是一个很简单的缓存机制，只适用一个类的重复调用。)
再次，调用MethodAccessor的invoke()方法。每个Method对象包含一个root对象，root对象里持有
一个MethodAccessor对象。我么获得的Method独享相当于一个root对象的镜像，所有这类Method共享root李的MethodAccessor对象，(这个对象有ReflectionFactory方法生成，ReflectionFactory对象在Method类中是static final的native方法实例化。)
最后，我们深入一下NativeMethodAccessorImpl的invoke()方法，NativeMethodAccessorImpl的invoke方法里面调用了native方法的invoke执行。可以都看到，调用Method.invoke之后，就会去调用MethodAccessor.invoke().MethodAccessor就是上面提到的所有同名method共享的对象，有ReflectionFactory创建。创建机制采用了一种名为inflation的方式，如果该方法的累计调用次数<=15，会创建出NativeMethodAccessorImpl，它的实现就是直接调用native方法实现反射；如果该方法的累计调用次数>15，会有Java代码创建处于字节码组装而成的MethodAccessorImpl。

PS：是否采用inflation和15这个数字都可以在JVM参数中调整。

总结一下：

一个方法可以生成多个Method对象，但只有一个root对象，主要用持有一个MethodAccessor对象，这个对象也可以认为一个方法只有一个，相当于是static的，因为Method的invoke是交给MethodAccessor执行的，

八、泛型与反射

(一)、什么是泛型

泛型(Generic type 或者 generics) 是对Java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把来类型参数看做是使用参数化类型时制定的类型的一个占位符，就像方法的形式参数是运行时传递值的占位符一样。

可以在集合框架( Collection frameword ) 中看到泛型的动机。例如，Mapl类允许您向一个Map 添加任意类的对象，即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String) 的对象。因为Map.get()被定义为返回Object，所以一般必须将Map.get()的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();
m.put("key", "hello");
String s = (String) m.get("key");

要让程序通过编译，必须将get()的结果强制类型转换为String，并且希望结果真的是一个String。但是有可能某人已经在映射中保存了不是String的东西，这样的话，上面的代码将会抛出ClassCastException。

理想情况下，你可能会得出这样一个观点，即m是一个Map，它将String键映射到String值。这可以让您消除代码中强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这样就是泛型所做的工作。

(二)、泛型的好处

Java语言中引入泛型是一个比较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，已经成为泛型化，这带来很多好处:

类型安全：泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程序上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中(或者如果幸运的话，还存在注释中)。
Java程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如"String 列表"或者"String 到 String 的映射"。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当做ClassCastException 展示出来。将类型检查从运行时挪到编译时有助于你更容易找到错误。并提高程序的可靠性。
消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转化。这使得代码更加可读，并且减少了出错的机会

(三)、命名类型参数

推荐的命名约定是使用大写的单个字幕作为类型参数。这与C++约定有所不同，并反映了大多数泛型类将具有少量类型参数的假设。对常见的泛型模式，推荐的名称是：

K————键，比如映射的键
V————值，比如List和Set的内容，或者Map中的值。
E————异常类
T————泛型

(四)泛型擦除

1、类型擦除

正确理解泛型概念的首要前提是理解类型擦除(type erasure)。Java中泛型基本上都是编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就叫做类型擦除。

比如在代码中定义List