Java的RTTI和反射机制代码分析

rtti，即run-time type identification，运行时类型识别。运行时类型识别是java中非常有用的机制，在java运行时，rtti维护类的相关信息。rtti能在运行时就能够自动识别每个编译时已知的类型。

很多时候需要进行向上转型，比如base类派生出derived类，但是现有的方法只需要将base对象作为参数，实际传入的则是其派生类的引用。那么rtti就在此时起到了作用，比如通过rtti能识别出derive类是base的派生类，这样就能够向上转型为derived。类似的，在用接口作为参数时，向上转型更为常用，rtti此时能够判断是否可以进行向上转型。

而这些类型信息是通过class对象（java.lang.class）的特殊对象完成的，它包含跟类相关的信息。每当编写并编译一个类时就会产生一个.class文件，保存着class对象，运行这个程序的java虚拟机（jvm）将使用被称为类加载器（class loader）的子系统。而类加载器并非在程序运行之前就加载所有的class对象，如果尚未加载，默认的类加载器就会根据类名查找.class文件（例如，某个附加类加载器可能会在数据库中查找字节码），在这个类的字节码被加载时接受验证，以确保没有被破坏并且不包含不良java代码。这也是java中的类型安全机制之一。一旦某个类的class对象被载入内存，就可以创建该类的所有对象。

package typeinfo;
class base {
  static { system.out.println("加载base类"); }
}
class derived extends base { 
  static { system.out.println("加载derived类");}
}
public class test {
  static void printerinfo(class c) {
    system.out.println("类名: " + c.getname() +
      "是否接口? [" + c.isinterface() + "]");
  }
  public static void main(string[] args) {
    class c = null;
    try {
      c = class.forname("typeinfo.derived");
    } catch (classnotfoundexception e) {
      system.out.println("找不到base类");
      system.exit(1);
    }
    printerinfo(c);
    class up = c.getsuperclass(); // 取得c对象的基类
    object obj = null;
    try {
      obj = up.newinstance();
    } catch (instantiationexception e) {
      system.out.println("不能实例化");
      system.exit(1);
    } catch (illegalaccessexception e) {
      system.out.println("不能访问");
      system.exit(1);
    }
    printerinfo(obj.getclass());
  } /* 输出:
  加载base类
  加载derived类
  类名: typeinfo.derived是否接口? [false]
  类名: typeinfo.base是否接口? [false]
  */
}

上述代码中，forname方法是静态方法，参数是类名，用来查找是否存在该类，如果找到则返回一个class引用，否则会抛出classnotfoundexception异常。

如果类不是在默认文件夹下，而是在某个包下，前面的包名需要带上，比如这里的typeinfo.derived。

可以通过getsuperclass方法来返回基类对应的class对象。使用newinstance方法可以按默认构造创建一个实例对象，在不能实例化和不能访问时分别抛出。会抛出instantiationexception和illegalaccessexception异常。

java还提供了一种方法来生成对class对象的引用，即类字面常量。对上述程序来说，up等价于base.class。

对于基本数据类型的包装类来说，char.class等价于character.type，int.class等价于integer.type。其余的ab.class等价于ab.type。（比如void.class等价于void.typ）。另外，java se5开始int.class和integer.class也是一回事。

泛化的class引用，见下面代码

    class intclass = int.class;
    class<integer> genericintclass = int.class;
    genericintclass = integer.class; // 等价
    intclass = double.class; // ok
    // genericintclass = double.class; // illegal!

class<integer>对象的引用指定了integer对象，所以不能将引用指向double.class。为了放松限制可以使用通配符?，即class<?>，效果跟class是一样的，但是代码更为优雅，使用class<?>表示你并非是碰巧或疏忽才使用一个非具体的类引用。同时，可以限制继承的类，示例如下

class base {}
class derived extends base {}
class base2 {}
public class test {
  public static void main(string[] args) {
    class<? extends base> cc = derived.class; // ok
    // cc = base2.class; // illegal
  } 
}

向class引用添加泛型语法的原因仅仅是为了提供编译期类型检查，以便在编译时就能发现类型错误。

总结下来，我们已知的rtti形式包括：

1、传统的类型转换，由rtti保证类型转换的正确性，如果执行一个错误的类型转换，就会抛出classcastexception异常；

2、代表对象的类型的class对象，通过查询class对象（即调用class类的方法）可以获取运行时所需的信息。

在c++中经典的类型转换并不使用rtti，这点具体见c++的rtti部分。（说句题外话，以前学c++时看到rtti这章只是随便扫了眼，现在才记起来dynamic_cast什么的都是为了类型安全而特地添加的，c++在安全方面可以提供选择性，就像java的stringbuilder和stringbuffer，安全和效率不可兼得？而java在类型安全上则更为强制，就像表达式x = 1不能被隐式转型为boolean类型）。

而java中rtti还有第3种形式，就是关键字instanceof，返回一个布尔值，告诉对象是不是某个特定类型的示例，见下列代码。

class base {}
class derived extends base {}
public class test {
  public static void main(string[] args) {
    derived derived = new derived();
    system.out.println(derived instanceof base); // 输出true
  } 
}

利用 instanceof 可以判断某些类型，比如基类shape派生出各种类（circle、rectangle等），现在某方法要为所有circle上色，而输入参数时一堆shape对象，此时就可以用instandof判断该shape对象是不是circle对象。

rtti可以识别程序空间的所有类，但是有时候需要从磁盘文件或网络文件中读取一串字节码，并且被告知这些字节代表一个类，就需要用到反射机制。

比如在ide中创建图形化程序时会使用到一些控件，只需要从本地的控件对应class文件中读取即可，然后再主动修改这些控件的属性。（题外话：大概.net组件就是这样的？学c#时总听到反射，但总没感觉用过，前几天做.net项目的同学也跟我说他从来都没用过委托和事件……）

class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含field、method和constructor类（每个类都实现了member接口），这些类型的对象都是jvm在运行时创建的，用以表示未知类里对应成员。

这样就可以用constructor创建未知对象，用get()和set()方法读取和修改与field对象关联的字段，用invoke方法调用与method对象关联的字段，等等。

// 使用反射展示类的所有方法, 即使方法是在基类中定义的
package typeinfo;
// print类的print方法等价于system.out.println，方便减少代码量
import static xyz.util.print.*;
import java.lang.reflect.constructor;
import java.lang.reflect.method;
import java.util.regex.pattern;
// {args: typeinfo.showmethods}
public class showmethods {
  private static string usage = 
    "usage:\n" +
    "showmethods qualified.class.name\n" +
    "to show all methods in class or:\n" +
    "showmethods qualified.class.name word\n" +
    "to search for methods involving 'word'";
  // 去掉类名前面的包名
  private static pattern p = pattern.compile("\\w+\\.");
  public static void main(string[] args) {
    if (args.length < 1) {
      print(usage);
      system.exit(0);
    }
    int lines = 0;
    try {
      class<?> c = class.forname(args[0]);
      // 反射获得对象c所属类的方法
      method[] methods = c.getmethods();
      // 反射获得对象c所属类的构造
      constructor[] ctors = c.getconstructors();
      if (args.length == 1) {
        for (method method : methods)
          print(p.matcher(method.tostring()).replaceall(""));
        for (constructor ctor : ctors)
          print(p.matcher(ctor.tostring()).replaceall(""));
      }
    } catch (classnotfoundexception e) {
      print("no such class: " + e);
    }
  } /*
  public static void main(string[])
  public final void wait() throws interruptedexception
  public final void wait(long,int) throws interruptedexception
  public final native void wait(long) throws interruptedexception
  public boolean equals(object)
  public string tostring()
  public native int hashcode()
  public final native class getclass()
  public final native void notify()
  public final native void notifyall()
  public showmethods()
  */
}

简单来说，反射机制就是识别未知类型的对象。反射常用于动态代理中。举例如下：

import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
class dynamicproxyhandler implements invocationhandler {
  private object proxied; // 代理对象
  public dynamicproxyhandler(object proxied) {
    // todo auto-generated constructor stub
    this.proxied = proxied;
  }
  @override
  public object invoke(object proxy, method method, object[] args) throws throwable {
    // todo auto-generated method stub
    system.out.println("代理类: " + proxy.getclass() + "\n"
        + "代理方法: " + method + "\n"
        + "参数: " + args);
    if (args != null)
      for (object arg : args)
        system.out.println(" " + arg);
    return method.invoke(proxied, args);
  }
}
interface interface { void dosomething(); }

class realobject implements interface {
  
  @override
  public void dosomething() {
    // todo auto-generated method stub
    system.out.println("dosomething");
  }
}
public class dynamicproxydemo {
  public static void consumer(interface iface) {
    iface.dosomething();
  }
  public static void main(string[] args) {
    realobject realobject = new realobject();
    // 使用动态代理
    interface proxy = (interface)proxy.newproxyinstance(
        interface.class.getclassloader(),
        new class[] { interface.class }, 
        new dynamicproxyhandler(realobject));
    consumer(proxy);
  } /* 输出：
  代理类: class $proxy0
  代理方法: public abstract void interface.dosomething()
  参数: null
  dosomething
  */
}

代理是基本的设计模式之一，即用代理类为被代理类提供额外的或不同的操作。而动态代理则需要一个类加载器，就像java实现rtti时需要类加载器加载类的信息，这样就可以知道类的相关信息。

关键方法是：

object java.lang.reflect.proxy.newproxyinstance(classloader loader, class<?>[] interfaces, invocationhandler h) throws illegalargumentexception

传入三个参数：代理接口的加载器（通过class对象的getclassloader方法获取），代理的方法接口，代理对象

前两个参数很好理解，就是要代理的方法所属的接口对应的class对象（主语）的加载器和class对象本身,主要是参数3，要设计一个实现invocationhandler接口的类，作为代理对象，一般命名以handler结尾，handler翻译为处理者，很形象，就是代替原对象进行处理的处理者（即代理），在程序设计中经常被翻译成“句柄”。

这个类通过传入代理对象来构造，比如这里传入的是object对象。然后必须覆盖invoke方法。

通过最后输出和invoke方法的具体实现可以发现，return method.invoke(proxied, args);是相当于原对象调用该方法（类似c++的回调函数？）

由于有类加载器，所以代理对象可以知道原对象的具体类名、方法、参数，本示例在调用方法前就输出了这些。

实际应用中可能会针对类名而有所选择。比如接口中有好多个类，你可以选择性的对特定的类、方法、参数进行处理

比如 if(proxied instanceof realobject) {} 或者 if(method.getname.equals("dosomething")) {}

ps：我这个示例没有参数所以没有距离

参考：《java编程思想》第四版，更多细节见书上第14章

总结

以上就是本文关于java的rtti和反射机制代码分析的全部内容，希望对大家有所帮助。