什么是反射

反射是一种计算机处理方式。有程序可以访问、检测和修改它本身状态或行为的这种能力。能提供封装程序集、类型的对象。
对于Java这种OOP语言来讲,运行状态中，我们可以根据“类的部分信息”来还原“类的全部信息”,这就是Java中的反射。

Java虚拟机的体系结构

Java虚拟机屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。通俗地说Java虚拟机就是处理Java程序（确切地说是Java字节码）的虚拟机。
作为虚拟机，JVM的结构和常见的操作系统一致，有着自己的堆、栈、方法区、PC计数器和指令系统。它的结构如下图所示:
这里我们暂时不去谈类加载子系统与执行引擎，只谈一下Java运行时的数据区，它由五个部分组成:

image.png

(1)程序计数器(线程私有)
程序计数器是当前线程所执行的字节码的行号指示器，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，
分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。
因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的线程计数器，各条线程之间的计数器互不影响，独立存储。
(2)虚拟机栈(线程私有)
在Java(或者其他JVM的语言)每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。
每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
Java虚拟机栈存放局部变量表，如编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，根据不同的虚拟机实现，它可能是一个指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或者与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。
这也导致在Java中匿名内部类来自外部闭包环境的自由变量必须是final的(Java编译器是capture-by-value模式)，不过在Kotlin中则没有此限制，它通过自动包装实现了capture-by-reference(所以它没有基本类型)。
(3)本地方法栈(线程私有)
与虚拟机栈的作用相似，其区别为虚拟机栈执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机所使用的Native方法。
(4)堆(线程共享)
是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域唯一的目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。
Java堆是垃圾收集器管理的主要区域，因此很多时候也被称为“GC堆”（Garbage Collected Heap）。由于现在收集器基本都是采用的分代收集算法，所以Java堆中还可以细分为：新生代和老年代。
(5)方法区(线程共享)
方法区用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
具体来讲，对于我们在Java程序中使用的每一个类，它都会在方法区生成一个对应的class文件,这个文件记录的信息有:
(如果你想了解更多的信息，可以参考http://blog.csdn.net/luanlouis/article/details/39892027)，这里只简单的说明一下。
1.类信息
2.字段信息
3.方法信息
4.常量池
5.类变量(静态static字段,或者companion object)
6.classLoader的引用
7.class对象的引用
8.方法表
正由于在JVM的方法区中实时记录了这些信息，我们才可以在运行时获取类的全部信息，其关键在于获取其对应的Class对象。

获取Class对象

在Java中，获取Class对象有以下几种方法:
1: Class.forName("类名字符串") （注意：类名字符串必须是全称，包名+类名）
2: 类名.class
3: 实例对象.getClass()

    public void getClassTest()
    {
       try{
           Class baseInfo = Class.forName("com.suiseiseki.www.BaseInfo");
           Class object = Object.class;
           Class date = (new Date()).getClass();
           Class testclass = this.getClass();
       }
       catch (Exception e)
       {
           e.printStackTrace();
       }
    }

还原类的信息

获取类的构造器

Java提供以下Api用于获取类的构造方法:

// 获取“参数是parameterTypes”的public的构造函数
public Constructor    getConstructor(Class[] parameterTypes)
// 获取全部的public的构造函数
public Constructor[]    getConstructors()
// 获取“参数是parameterTypes”的，并且是类自身声明的构造函数，包含public、protected和private方法。
public Constructor    getDeclaredConstructor(Class[] parameterTypes)
// 获取类自身声明的全部的构造函数，包含public、protected和private方法。
public Constructor[]    getDeclaredConstructors()
// 如果这个类是“其它类的构造函数中的内部类”，调用getEnclosingConstructor()就是这个类所在的构造函数；若不存在，返回null。
public Constructor    getEnclosingConstructor()

例如:

public class Test1 {

    public void testConstructor()
    {
       try{
           Class c = Country.class;
           //获取public的无参数构造器
           Constructor origin = c.getDeclaredConstructor();
           //获取private的构造器（注意int.class不是Integer.class)
           Constructor cst2 = c.getDeclaredConstructor(new Class[]{int.class,int.class});
           //构造器是private的，所以这里要设置为可访问
           cst2.setAccessible(true);

           Country c1 = (Country)origin.newInstance();
           Country c2 = (Country)cst2.newInstance(30,100);
           System.out.println(c1);
           System.out.println(c2);
       }
       catch (Exception e) {}
    }
}
class Country{
    public int pop;
    public int money;
    public Country(){
        pop = 0;
        money = 0;
    }
    private Country(int pop,int money)
    {
        this.pop = pop;
        this.money = money;
    }
    @Override
    public String toString()
    {
        return "pop "+pop+" money: "+money;
    }

    public void doublePop()
    {
        this.pop = this.pop * 2;
    }

    private int multiMoney(int n)
    {
        this.money = this.money*n;
        return this.money;
    }

}

在获取到构造器后，可以调用构造器的newInstance创建对象。例子中可以看到，反射是可以访问类的private域的，而且还可以修改它，使用被隐藏的构造器。

获取类的方法

在Java中，方法是作为Method对象包装的，获取类的方法对象的Api如下:

// 获取“名称是name，参数是parameterTypes”的public的函数(包括从基类继承的、从接口实现的所有public函数)
public Method    getMethod(String name, Class[] parameterTypes)
// 获取全部的public的函数(包括从基类继承的、从接口实现的所有public函数)
public Method[]    getMethods()
// 获取“名称是name，参数是parameterTypes”，并且是类自身声明的函数，包含public、protected和private方法。
public Method    getDeclaredMethod(String name, Class[] parameterTypes)
// 获取全部的类自身声明的函数，包含public、protected和private方法。
public Method[]    getDeclaredMethods()
// 如果这个类是“其它类中某个方法的内部类”，调用getEnclosingMethod()就是这个类所在的方法；若不存在，返回null。
public Method    getEnclosingMethod()

例如，以下方法获取方法并调用:

    public void testMethod()
    {
        try{
            Class c = Country.class;
            Country country3 = new Country();
            country3.money = 100;
            country3.pop = 3;
            //获取public方法(无参数，无返回值)
            Method mDoublePop = c.getMethod("doublePop",new Class[]{});
            //调用invoke执行方法，需要传入一个该类的对象
            mDoublePop.invoke(country3);
            System.out.println(country3);
            //获取public方法(有参数，有返回值)
            Method mMultimoney = c.getMethod("multiMoney", new Class[]{int.class});
            mMultimoney.setAccessible(true);
            mMultimoney.invoke(country3,42);
            System.out.println(country3);
        }
        catch (Exception e) {}
    }

对应方法:

    public void doublePop()
    {
        this.pop = this.pop * 2;
    }

    private int multiMoney(int n)
    {
        this.money = this.money*n;
        return this.money;
    }

获取类的成员变量

在Java中，成员变量称为Field对象,获取类成员变量的Api如下:

// 获取“名称是name”的public的成员变量(包括从基类继承的、从接口实现的所有public成员变量)
public Field    getField(String name)
// 获取全部的public成员变量(包括从基类继承的、从接口实现的所有public成员变量)
public Field[]    getFields()
// 获取“名称是name”，并且是类自身声明的成员变量，包含public、protected和private成员变量。
public Field    getDeclaredField(String name)
// 获取全部的类自身声明的成员变量，包含public、protected和private成员变量。
public Field[]    getDeclaredFields()

例如:

    public void fieldTest()
    {
        try{
            Class c = Country.class;
            Country country4 = new Country();
            country4.money = 100;
            country4.pop = 3;

            Field fPop = c.getField("pop");
            fPop.set(42,country4);
            System.out.println(country4);
        }
        catch (Exception e) {}
    }

注意权限的问题，如果没有权限，需要setAccessible(true)，否则会抛出异常

类的其它信息

1.注解

// 获取类的"annotationClass"类型的注解 (包括从基类继承的、从接口实现的所有public成员变量)
public Annotation<A>    getAnnotation(Class annotationClass)
// 获取类的全部注解 (包括从基类继承的、从接口实现的所有public成员变量)
public Annotation[]    getAnnotations()
// 获取类自身声明的全部注解 (包含public、protected和private成员变量)
public Annotation[]    getDeclaredAnnotations()

现在，我们可以编写一些程序来自动处理程序中的注解了，例如根据注解来决定是否处理一个类:

    public void handleMyAnnotation(List<Class> list)
    {
        for(Class clazz : list)
        {
            if(clazz.getAnnotation(MyAnnotation.class))
            {
                println("This class is under Annotation");
            }
        }
    }

很多著名的开源库(Dagger2,GSON,Retrofit,AspectJ)等都是通过反射+注解完成的，这些库在方便了编写程序的同时也会带来一些性能开销（尽管它们自身已经尽力地做了优化),
反射在把装载期做的事情搬到了运行期，因此编译器没法对反射相关的代码做优化。

2.接口和基类

// 获取实现的全部接口
public Type[]    getGenericInterfaces()
// 获取基类
public Type    getGenericSuperclass()

注意反射获取的基类是直接的基类（也就是说只能获取上一级),要获取继承链，需要进一步深度遍历

3.描述性信息

// 获取“类名”
public String    getSimpleName()
// 获取“完整类名”
public String    getName()
// 类是不是“枚举类”
public boolean    isEnum()
// obj是不是类的对象
public boolean    isInstance(Object obj)
// 类是不是“接口”
public boolean    isInterface()
// 类是不是“本地类”。本地类,就是定义在方法内部的类。
public boolean    isLocalClass()
// 类是不是“成员类”。成员类,是内部类的一种，但是它不是“内部类”或“匿名类”。
public boolean    isMemberClass()
// 类是不是“基本类型”。 基本类型，包括void和boolean、byte、char、short、int、long、float 和 double这几种类型。
public boolean    isPrimitive()

在Kotlin中使用Java中的反射

作为基于JVM的语言，Kotlin当然也支持Java语言中原有的反射机制(而且代码量往往更少)，通过类的javaClass实现。
例如，一个常见的通过反射来获取R文件中控件的ID描述的程序:

    val viewId : String by lazy {
            val c = R.id()
            val fields = c.javaClass.declaredFields
            val r = fields.find { it.getInt(c) == view.id }?.name?:"Not found"
            r
    }

使用懒加载避免了无用的性能开销。
需要注意的是直接调用R.id::class获取的是KClass对象，它代表Kotlin中反射的入口，要获取Java的Class对象，需要其.java属性，例如:

        {
            val c = R.id::class
            val fields = c.java.fields
            val r = fields.find { it.getInt(c) == view.id }?.name?:"Not found"
            r
        }

以上两种方式代表了通过对象和类名访问Java原有反射API的方式。

Kotlin中的KClass反射

Kotlin是函数式编程语言，它有一些独有的特性，例如，在Kotlin中的Property往往对应了Java中的Field以及对应的getter/setter,
而函数本身也具有类型，也可以作为变量保存。
要使用Kotlin的反射Api,需要获取对应的KClass对象，可以通过以下方式:
1.类名::class

val clazz = Country::class

2.对象.javaclass.kotlin

val clazz = country4.javaClass.kotlin

KClass是一个泛型接口，它的定义如下：

public interface KClass<T : Any> : KDeclarationContainer, KAnnotatedElement, KClassifier {
    //返回类的名字
    public val simpleName: String?

    //返回类的全包名
    public val qualifiedName: String?

     //返回这个类可访问的所有函数和属性，包括继承自基类的，但是不包括构造器
    override val members: Collection<KCallable<*>>

    //返回这个类的所有构造器
    public val constructors: Collection<KFunction<T>>

     //返回这个类中定义的其他类，包括内部类(inner class声明的)和嵌套类(class声明的)
    public val nestedClasses: Collection<KClass<*>>

     //如果这个类声明为object，则返回其实例，否则返回null
    public val objectInstance: T?

    // 判断一个对象是否为此类的实例
    // 和 对象 is 类名 作用一样，如:  country3 is Country
    @SinceKotlin("1.1")
    public fun isInstance(value: Any?): Boolean

     // 返回这个类的泛型列表
    @SinceKotlin("1.1")
    public val typeParameters: List<KTypeParameter>

     //以列表的方式依次显示其直接基类
    @SinceKotlin("1.1")
    public val supertypes: List<KType>

     // 返回这个类的可见性
    @SinceKotlin("1.1")
    public val visibility: KVisibility?

    // 这个类是否为final类（PS:在Kotlin中，类默认是final的，除非这个类声明为open或者abstract)
    @SinceKotlin("1.1")
    public val isFinal: Boolean

    // 这个类是否是open的(abstract类也是open的），表示这个类可以被继承
    @SinceKotlin("1.1")
    public val isOpen: Boolean

    //是否为抽象类
    @SinceKotlin("1.1")
    public val isAbstract: Boolean

    //判断是否为密封类
    /* 密封类:用sealed修饰，其子类只能在其内部定义 */
    @SinceKotlin("1.1")
    public val isSealed: Boolean

     // 判断类是否为data类
    @SinceKotlin("1.1")
    public val isData: Boolean

     // 判断类是否为内部类（嵌套类为nest,不算)
    @SinceKotlin("1.1")
    public val isInner: Boolean

    //判断这个类是否为companion object
    @SinceKotlin("1.1")
    public val isCompanion: Boolean

}

除此之外，KClass还有一些很有用的扩展函数/属性，例如:

//返回其所有的基类
val KClass<*>.allSuperclasses: Collection<KClass<*>>
//返回其companionObject
val KClass<*>.companionObject: KClass<*>?
//返回其声明的所有函数
val KClass<*>.declaredFunctions: Collection<KFunction<*>>
//返回其扩展函数和属性
val KClass<*>.declaredMemberExtensionFunctions: Collection<KFunction<*>>
val <T : Any> KClass<T>.declaredMemberExtensionProperties: Collection<KProperty2<T, *, *>>
//返回其自身声明的函数和属性
val KClass<*>.declaredMemberFunctions: Collection<KFunction<*>>
val <T : Any> KClass<T>.declaredMemberProperties: Collection<KProperty1<T, *>>

其实还有很多，这里就不一一列举了，它们其实都可以通过基本Api然后进行filter获得
需要注意的是，在函数作为一等公民以后，函数和属性具有了共同的接口KCallable，允许你调用其call方法来使用函数或者访问属性的getter：

class DVT {
    fun test()
    {
        val su = Person("su",24)
        val clazz = su.javaClass.kotlin
        val list = clazz.members
        for(calls in list)
        {
            when(calls.name)
            {
                "name" -> print("name is"+calls.call(su))
                "age" -> print("age is"+calls.call(su))
                "selfDescribe" -> calls.call()
            }
        }
    }
}
data class Person(val name : String,var age : Int)
{
    fun selfDescribe() : String
    {
        return "My name is $name,I am $age years old"
    }
}

需要注意，call这个方法的参数类型是vararg Any?，如果你用错误的类型实参(数量不一致或者类型不一致)去调用是会报错的,
为了避免这种情况，你可以用更具体的方式去调用这个函数。

class DVT {
    fun test()
    {
        val su = Person("su",24)
        val clazz = su.javaClass.kotlin
        val function1 = Person::selfDescribe
        val function2 = Person::grow
        function1.invoke(su)
        function2.invoke(su,1)
    }
}
data class Person(val name : String,var age : Int)
{
    fun selfDescribe() : String
    {
        return "My name is $name,I am $age years old"
    }
    fun grow(a : Int) : Int
    {
        age+=a
        return age
    }
}

function1的类型是KFunction0<String>,function2的类型是KFunction1<Int,Int>,像KFunctionN这样的接口代表了不同数量参数的参数，
它们都继承了KFunction并添加了一个invoke成员，它拥有数量刚好的参数，包含参数和返回参数
这种类型称为编译器生成的类型，你不能找到它们的声明，你可以使用任意数量参数的函数接口（而不是先声明一万个不同参数数量的接口)
对于call函数，它是对于所有类型通用的手段，但是不保证安全性。
你也可以反射调用属性的getter和setter：

        val ageP = Person::age
        //通过setter-call调用（不安全)
        ageP.setter.call(24)
        //通过set()调用(安全)
        ageP.set(su,24)
        //通过getter-call调用(不安全)
        ageP.getter.call()
        //通过get调用(安全）
        ageP.get(su)

所有属性都是KProperty1的实例，它是一个泛型类KProperty1<R,T>,其中R为接收者类型(文中的Person类),T为属性类型(文中为Int),
这样就保证了你对正确类型的接收者调用其方法。
其子类KMutableProperty代表var属性

兼容问题

虽然Kotlin号称完全兼容Java，但是从注解和反射的概念来看，似乎它并不代表一切Java的工具库都可以应用到Kotlin中。
例如通过对代码注解自动生成模板代码的库（APT）,生成的代码均为 Java 代码而非 kt代码。对于一些作用于java文件到class文件转换过程中的库(AspectJ)，实际上是很无力的,它不能作用于kt文件,大部分基于这个过程的AOP框架都不能正常工作。唯一能正确作用的是.class到.dex转换中的库(热修复,基于Javaassist)。因此，如果要引入前两种第三方库，需要确认它们是否支持Kotlin语言。
对于代码注解自动生成模板代码的库(Dagger,ButterKnife,DBFlow这些常见的APT库)，可以尝试Kotlin Annotation processing tool，简称kapt，但是并不保证能完全正常工作