Java类型信息详解

2.3 Java类型信息详解

运行时类型信息（RTTI）使得我们可以在程序运行时发现和使用类型信息，其工作原理是Class对象中包含了与类有关的信息。

2.3.1 Class对象

每一个类有一个Class对象，编译期生成，保存在同名的.class文件中。这些Class对象包含了这个类型的父类、接口、构造函数、方法、属性等详细信息，这些class文件在程序运行时会被ClassLoader加载到JVM中，在JVM中就表现为一个Class对象，JVM使用该Class对象创建该类的所有常规对象。

需要注意的是，Class对象和其他对象一样，我们可以获取并操作它的引用，反射就是基于这一点进行的。

instanceof和isInstance

首先这两者是一个语义：引用的实际类型（而非静态类型）是否和指定类型相匹配。两者的区别在于：

• 前者是Java的操作符，而该语法要求instanceof运算符的右操作数是一个引用类型名，即编译期常量
• 后者是Java标准库里的一个方法，其被调用对象等价于instanceof运算符的右操作数的意义，但可以是运行时的java.lang.Class对象，而不要求是编译时常量，比instanceOf运算符更灵活。

我们可以使用Class.isInstance()方法可以写出这样的代码：

public static boolean areTypesCompatible(Object expected, Object obj) {
    return Objects.requireNonNull(expected)
                  .getClass()
                  .isInstance(obj);
}

来检查obj所引用的对象的实际类型是否为expected所引用的对象的实际类型的子类。显然我们不能用instanceof来实现这个功能：

return obj instanceof expected.getClass(); // doesn't compile

这里简要说明一下其原理：首先，每个类T都有一个T.class对象，其是Class类对象，而这个T.class对象中含有类T的信息：类型名、成员、父类、接口、加载器等。具体判断一般是如下步骤（假设要检查的对象引用是obj，目标的类型对象是T）：

1. obj如果为null，则返回false；否则设S为obj的类型对象，剩下的问题就是检查S是否为T的子类型。
2. 如果S == T，则返回true。
3. 接下来分为3种情况，S是数组类型、接口类型或者类类型。之所以要分情况是因为instanceof要做的是“子类型检查”，而Java语言的类型系统里数组类型、接口类型与普通类类型三者的子类型规定都不一样，必须分开来讨论。其中需要注意的是：对接口类型的instanceof就直接遍历S里记录的它所实现的接口，看有没有跟T一致的；而对类类型的instanceof则是遍历S的super链（继承链）一直到Object，看有没有跟T一致的，遍历类的super链意味着这个算法的性能会受类的继承深度的影响。

2.3.2 Java类的加载、链接和初始化

有关类的加载、连接和初始化，在之后的JVM详解中将会详细介绍，这里就不再详述。

创建自己的类加载器

在Java应用开发过程中，可能会需要创建应用自己的类加载器。典型的场景包括实现特定的Java字节码查找方式，对字节代码进行加密/解密以及实现同名Java类的隔离等。创建自己的类加载器并不是一件复杂的事情，只需要继承自java.lang.ClassLoader类并覆写对应的方法即可。ClassLoader中提供的方法有不少，下面介绍几个创建类加载器时需要考虑的:

1. defineClass()：这个方法用来完成从Java字节码的字节数组到java.lang.Class的转换。这个方法是不能被覆写的，一般是native实现。
2. findLoadedClass()：这个方法用来根据名称查找已经加载过的Java类，一个类加载器不会重复加载同一个类。
3. findClass()：这个方法用来根据名称查找并加载Java类，当我们在实现自己的类加载器时应该覆写该方法来实现自己的类加载逻辑。
4. loadClass()：这个方法用来根据名称加载Java类。
5. resolveClass()：这个方法用来链接一个Java类。

类加载器的代理模式默认使用的是父类优先的策略，这个策略的实现是封装在loadClass中的，如果希望修改此策略，就要覆写loadClass方法。下面的代码给出了自定义的类加载器的常见实现模式:

public class MyClassLoader extends ClassLoader {
    protected Class findClass(String name) throws ClassNotFoundException {
        byte[] b = null; //查找或生成Java类的字节代码
        return defineClass(name, b, 0, b.length);
    }
}

2.3.3 反射（运行时的类信息）

通过反射可以获取程序在运行时刻的内部结构，而知道了一个Java类的内部结构之后，就可以与它进行交互，包括创建新的对象和调用对象中的方法等。

基本用法

反射的第一个主要作用是获取程序在运行时刻的内部结构，这对于程序的检查工具和调试器来说，是非常实用的功能，可以很简单地遍历出来一个Java类的内部结构，包括其中的构造方法、声明的域和定义的方法等。

反射的另外一个作用是在运行时刻对一个Java对象进行操作。这些操作包括动态创建一个Java类的对象，获取某个域的值以及调用某个方法。在Java源代码中编写的对类和对象的操作，都可以在运行时刻通过反射来实现。

只要有了其Class类的对象，就可以通过其中的方法来获取到该类中的构造方法、域和方法。对应的方法分别是getConstructor、getField和getMethod。这三个方法还有相应的getDeclaredXXX版本，区别在于getDeclaredXXX版本的方法只会获取该类自身所声明的元素，而不会考虑继承下来的。Constructor、Field和Method这三个类分别表示类中的构造方法、域和方法。这些类中的方法可以获取到所对应结构的元数据。考虑下面一个简单的例子：

public class MyClass {
    public int count;
    public MyClass(int start) {
        count = start;
    }
    public void increase(int step) {
        count = count + step;
    }
}
...
public void testRefelct() {
    try {
        Class clazz = Class.forName("com.app.MyClass");
        //获取构造方法
        Constructor constructor = clazz.getConstructor(int.class);
        //创建对象
        MyClass myClassReflect = constructor.newInstance(10);
        //获取方法
        Method method = MyClass.class.getMethod("increase", int.class);
        //调用方法
        method.invoke(myClassReflect, 5);
        //获取域
        Field field = MyClass.class.getField("count");
        //获取域的值
        System.out.println("Reflect -> " + field.getInt(myClassReflect));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

需要注意的是，数组对象比较特殊，Array类提供了一系列的静态方法用来创建数组和对数组中的元素进行访问和操作。

Object array = Array.newInstance(String.class, 10); //等价于 new String[10]
Array.set(array, 0, "Hello"); //等价于array[0] = "Hello"
Array.set(array, 1, "World"); //等价于array[1] = "World"
System.out.println(Array.get(array, 0)); //等价于array[0]

使用反射可以绕过Java默认的访问控制检查，比如可以直接获取到对象的私有域的值或是调用私有方法。只需要在获取到Constructor、Field和Method类的对象之后，调用setAccessible方法并设为true即可。有了这种机制，就可以很方便的在运行时刻获取到程序的内部状态。

需要注意的是：通过反射创建出来的对象，一般要继续使用反射去做字段访问或者方法调用；或者是如果这个反射创建出来的对象实现了已知接口的话，可以cast成已知接口的引用然后来用。

处理泛型

Java引入了泛型后，反射也做了相应的修改，以提供对泛型的支持。由于类型擦除机制的存在，泛型类中的类型参数等信息，在运行时刻是不存在的，JVM看到的都是原始类型。对此，Java5对Java类文件的格式做了修订，添加了Signature属性，用来包含不在JVM类型系统中的类型信息。在运行时刻，JVM会读取Signature属性的内容并提供给反射API来使用。比如在代码中声明了一个域是List类型的，虽然在运行时刻其类型会变成原始类型List，但是仍然可以通过反射来获取到所用的实际的类型参数

Field field = Pair.class.getDeclaredField("myList"); //myList的类型是List
Type type = field.getGenericType();
if (type instanceof ParameterizedType) {
    ParameterizedType paramType = (ParameterizedType) type;
    Type[] actualTypes = paramType.getActualTypeArguments();
    for (Type aType : actualTypes) {
        if (aType instanceof Class) {
            Class clz = (Class) aType;
            System.out.println(clz.getName()); //输出java.lang.String
        }
    }
}

动态代理

在代理模式里，代理对象和被代理对象一般实现相同的接口，调用者与代理对象进行交互，代理的存在对于调用者来说是透明的。代理对象则可以封装一些内部的处理逻辑，如访问控制、远程通信、日志、缓存等。比如一个对象访问代理就可以在普通的访问机制之上添加缓存的支持。传统的代理模式的实现，需要在源代码中添加一些附加的类。这些类一般是手写或是通过工具来自动生成。Java5引入了动态代理机制，允许开发人员在运行时刻动态的创建出代理类及其对象。在运行时刻，可以动态创建出一个实现了多个接口的代理类。

每个代理类的对象都会关联一个表示内部处理逻辑的InvocationHandler接口的实现。当使用者调用了代理对象所代理的接口中的方法的时候，这个调用的信息会被传递给InvocationHandler的invoke方法。在invoke方法的参数中可以获取到代理对象、方法对应的Method对象和调用的实际参数。invoke方法的返回值被返回给使用者。这种做法实际上相当于对方法调用进行了拦截。

下面的代码用来代理一个实现了List接口的对象，所实现的功能也非常简单，那就是禁止使用List接口中的add方法。如果在getList中传入一个实现List接口的对象，那么返回的实际就是一个代理对象，尝试在该对象上调用add方法就会抛出来异常。

public List getList(final List list) {
    return (List) Proxy.newProxyInstance(DummyProxy.class.getClassLoader(), new Class[]{List.class}, new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if ("add".equals(method.getName())) {
                throw new UnsupportedOperationException();
            } else {
                return method.invoke(list, args);
            }
        }
    });
}

这里的实际流程是，当代理对象的add方法被调用的时候，InvocationHandler中的invoke方法会被调用。参数method就包含了调用的基本信息，如果调用的是add方法，就会抛出异常；如果调用的是其它方法的话，则执行原来的逻辑。

使用案例

反射的存在，为Java语言添加了一定程度上的动态性，可以实现某些动态语言中的功能。反射实际上定义了一种相对于编译时刻而言更加松散的契约。如果被调用的Java对象中并不包含某个方法,而在调用者代码中进行引用的话，在编译时刻就会出现错误。而反射则可以把这样的检查推迟到运行时刻来完成，这一点在框架开发中尤其重要。通过把Java中的字节代码增强、类加载器和反射结合起来，可以处理一些对灵活性要求很高的场景。比如在有些情况下，可能会需要从远端加载一个Java类来执行，客户端Java程序可以通过网络从服务器端下载Java类来执行，从而可以实现自动更新的机制。一般的做法是下载了类字节代码（或者源码）之后，通过自定义类加载器加载出Class类的对象，再通过反射就可以创建出实例了。