浅谈 RTTI

技术

Forest in West Virginia

什么是 RTTI？

RTTI 即 Runtime Type Information，顾名思义，也就是在运行时，识别对象和类的信息。RTTI 有两种，一种是“传统的” RTTI，它假定我们在编译时就已经知道了所有的类型；另一种是“反射”机制，它允许我们在运行时发现和使用类的信息。

最简单的一个例子，比如：

1
2
3
4
List<Shape> shapeList = Arrays.asList(new Circle(), new Square(), new Triangle());
for(Shape shape : shapeList) {
    shape.draw();
}

当从 shapeList 中取出元素时（其实元素是用数组保存的，而数组会把所有元素都当作 Object 来持有），会自动将元素转型回对应的对象。

也就是说在保存对象和取出对象后，会发生以下这两个过程：

1
2
(Object) shape // 向上转型
(Shape) object // 向下转型

这其实就是就是 RTTI 最基本的使用形式。在 Java 中，所有的类型转换都是在运行时进行类型正确性检查的。

Class 对象：类的信息

Class 对象包含了与类有关的信息，事实上 Java 中是用 Class 对象来创建这个类中的所有的对象的。每当编译完成，就会生成一个 Class 对象，被保存在 .class 文件中。JVM 使用 ClassLoader 来加载对象，所有的类都是在对其第一次使用（静态成员被引用，静态常量除外）或者用 new 关键字创建对象后，动态加载到 JVM 中的。所谓的动态加载也就是在被使用到时才去加载。

1
Class.forName("package.name.CanonicalName");

这个方法是获取 Class 对象引用的一种方法，调用 Class.forName() 之后该类会被初始化。Class 对象中还有一个 newInstance() 的方法，可以用来创建对象新实例。除此之外，Class 对象中还有很多实用的方法，用来获取类的信息，比如获取类的接口、方法、成员变量等等。

类字面常量

我们还可以使用 .class 的形式来引用 Class 对象。

1
Class intClass = int.class;

泛化的 Class 引用

从 Java SE 5 开始，我们可以利用泛型对 Class 对象进行类型限定。

1
2
Class<Integer> intClass = int.class; // legal
intClass = double.class; // illegal

instanceof

RTTI 除了可以确保类型转换的正确性和通过 Class 对象获取运行时的类型信息外，还有第三种形式，那就是 instanceof，我们可以用这个关键字来确定某个对象是不是某个类的实例，比如：

1
2
3
4
5
6
7
8
Animal[] animals = {new Dog(), new Fish()};
for (Animal animal : animals) {
    // 向下转型前，先使用 instanceof 来判断类型
    if (animal instanceof Fish) {
        Fish fish = (Fish) animal;
        fish.swim();
    }
}

反射：无所不能

RTTI 会在编译期打开和检查 .class 文件并利用这些信息做一些有用的事，而反射会在运行时打开和检查 .class 文件，这是 RTTI 和反射之间的真正区别。Java 中通过 Class 类和 java.lang.reflect 类库对反射的概念进行了支持。一起来看下这段代码：

1
2
3
4
5
6
7
8
public static void main(String[] args) throws Exception {
    // 在编译期，Class.forName() 的结果是不可知的，只能通过反射去获取运行时的信息
	Class<?> klass = Class.forName(args[0]);
    Method[] methods = klass.getMethods();
    for (Method method : methods) {
        System.out.println(method);
    }
}

以上 main() 方法中，通过读取命令行参数实例化 Class 对象，然后打印该对象中的方法。此时的 klass 对象完全是未知的，但是我们可以通过反射去获取其中的信息，创建对象或者调用方法。

反射是无孔不入的，无论是私有方法还是私有内部类的方法，哪怕是匿名类的方法，也无法逃脱反射的调用。对于私有域来说也一样，只有 final 域，才不会被修改。反射可以说是给我们的程序留了一道后门，但是总的来说，从反射给我们带来的优劣对比上看，利大于弊。

动态代理

代理是最常见的设计模式之一，它可以让我们的代码更加灵活，比如在进行操作之前做一些额外的工作。下面是一个简单代理的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
interface Interface {
    void doSomething();

    void doSomethingElse(String args);
}

class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("doSomething");
    }

    @Override
    public void doSomethingElse(String args) {
        System.out.println("doSomethingElse " + args);
    }
}

class SimpleProxy implements Interface {

    Interface mInterface;

    public SimpleProxy(Interface anInterface) {
        mInterface = anInterface;
    }

    @Override
    public void doSomething() {
        System.out.println("SimpleProxy doSomething");
        mInterface.doSomething();
    }

    @Override
    public void doSomethingElse(String args) {
        System.out.println("SimpleProxy doSomethingElse");
        mInterface.doSomethingElse(args);
    }
}

简单来说，代理就是将实际对象的方法调用分离开来，从而允许我们对一些操作进行修改，或者添加额外的操作。而动态代理比代理的思想更进一步，它允许我们动态地创建代理并动态地处理对所代理方法的调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class SimpleDynamicProxy {

    public static void consumer(Interface interf) {
        interf.doSomething();
        interf.doSomethingElse("args");
    }

    public static void main(String[] args) {
        System.out.println("---------- no proxy ----------");
        RealObject real = new RealObject();
        consumer(real);

        System.out.println("---------- simple proxy ----------");
        consumer(new SimpleProxy(real));

        System.out.println("---------- dynamic proxy ----------");
        
        // 创建代理对象：设置 ClassLoader、接口 Class 对象、InvocationHandler
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[]{Interface.class}, // 数组里的 Class 对象必须是接口且不能重复
                new DynamicProxyHandler(real));
        consumer(proxy);
    }

    /**
     * 代理对象必须实现自己的 InvocationHandler，所有的调用都会被重定向到这个调用处理器上
     */
    static class DynamicProxyHandler implements InvocationHandler {
        /**
         * 被代理的对象，调用的请求会转发到这个“实际”对象上
         */
        private Object proxied;

        public DynamicProxyHandler(Object proxied) {
            this.proxied = proxied;
        }

        /**
         * 该方法接收三个参数，代理对象的实例、调用的方法的实例以及方法的参数。
         * 我们一般在这里确定调用该方法时所采取的措施。
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Proxy: " + proxy.getClass()
                    + ", method: " + method + ", args: " + args);

            // 如果方法参数不为空则输出参数
            if (args != null) {
                for (int i = 0; i < args.length; i++) {
                    System.out.println("args[" + i + "] = " + args[i]);
                }
            }

            // 转发请求给被代理对象
            return method.invoke(proxied, args);
        }
    }
}

使用动态代理其实很简单，首先要定义一个自己的 InvocationHandler，然后再通过 Proxy.newProxyInstance 创建一个代理对象。

使用动态代理的优势

动态代理的优点主要有两个：

  1. 更强的灵活性。我们不用在设计实现的时候就指定某一个代理类来代理某一个被代理对象，而是可以把这种指定延迟到程序运行时由 JVM 来实现。
  2. 动态代理更为统一与简洁。

第一点从上面的例子就能看出，我们必须事先就确定 SimpleProxy 作为 Interface 的代理，并且编写每种方法对应的代码，而动态代理允许我们利用反射机制生成任意类型的动态代理类。第二点也很明显，当使用动态代理的时候，我们只需要在一个地方进行修改，写的代码也变少了。

参考资料：