Java的RTTI和反射机制代码分析
RTTI，即Run-TimeTypeIdentification，运行时类型识别。运行时类型识别是Java中非常有用的机制，在Java运行时，RTTI维护类的相关信息。RTTI能在运行时就能够自动识别每个编译时已知的类型。
很多时候需要进行向上转型，比如Base类派生出Derived类，但是现有的方法只需要将Base对象作为参数，实际传入的则是其派生类的引用。那么RTTI就在此时起到了作用，比如通过RTTI能识别出Derive类是Base的派生类，这样就能够向上转型为Derived。类似的，在用接口作为参数时，向上转型更为常用，RTTI此时能够判断是否可以进行向上转型。
而这些类型信息是通过Class对象（java.lang.Class）的特殊对象完成的，它包含跟类相关的信息。每当编写并编译一个类时就会产生一个.class文件，保存着Class对象，运行这个程序的Java虚拟机（JVM）将使用被称为类加载器（ClassLoader）的子系统。而类加载器并非在程序运行之前就加载所有的Class对象，如果尚未加载，默认的类加载器就会根据类名查找.class文件（例如，某个附加类加载器可能会在数据库中查找字节码），在这个类的字节码被加载时接受验证，以确保没有被破坏并且不包含不良Java代码。这也是Java中的类型安全机制之一。一旦某个类的Class对象被载入内存，就可以创建该类的所有对象。
packagetypeinfo;
classBase{
static{System.out.println("加载Base类");}
}
classDerivedextendsBase{
static{System.out.println("加载Derived类");}
}
publicclassTest{
staticvoidprinterInfo(Classc){
System.out.println("类名:"+c.getName()+
"是否接口?["+c.isInterface()+"]");
}
publicstaticvoidmain(String[]args){
Classc=null;
try{
c=Class.forName("typeinfo.Derived");
}catch(ClassNotFoundExceptione){
System.out.println("找不到Base类");
System.exit(1);
}
printerInfo(c);
Classup=c.getSuperclass();//取得c对象的基类
Objectobj=null;
try{
obj=up.newInstance();
}catch(InstantiationExceptione){
System.out.println("不能实例化");
System.exit(1);
}catch(IllegalAccessExceptione){
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）。另外，JavaSE5开始int.class和Integer.class也是一回事。
泛化的Class引用，见下面代码
ClassintClass=int.class; ClassgenericIntClass=int.class; genericIntClass=Integer.class;//等价 intClass=double.class;//ok //genericIntClass=double.class;//Illegal!
Class
classBase{}
classDerivedextendsBase{}
classBase2{}
publicclassTest{
publicstaticvoidmain(String[]args){
Classcc=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，返回一个布尔值，告诉对象是不是某个特定类型的示例，见下列代码。
classBase{}
classDerivedextendsBase{}
publicclassTest{
publicstaticvoidmain(String[]args){
Derivedderived=newDerived();
System.out.println(derivedinstanceofBase);//输出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对象关联的字段，等等。
//使用反射展示类的所有方法,即使方法是在基类中定义的
packagetypeinfo;
//Print类的print方法等价于System.Out.Println，方便减少代码量
importstaticxyz.util.Print.*;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.Method;
importjava.util.regex.Pattern;
//{Args:typeinfo.ShowMethods}
publicclassShowMethods{
privatestaticStringusage=
"usage:\n"+
"ShowMethodsqualified.class.name\n"+
"Toshowallmethodsinclassor:\n"+
"ShowMethodsqualified.class.nameword\n"+
"Tosearchformethodsinvolving'word'";
//去掉类名前面的包名
privatestaticPatternp=Pattern.compile("\\w+\\.");
publicstaticvoidmain(String[]args){
if(args.length<1){
print(usage);
System.exit(0);
}
intlines=0;
try{
Classc=Class.forName(args[0]);
//反射获得对象c所属类的方法
Method[]methods=c.getMethods();
//反射获得对象c所属类的构造
Constructor[]ctors=c.getConstructors();
if(args.length==1){
for(Methodmethod:methods)
print(p.matcher(method.toString()).replaceAll(""));
for(Constructorctor:ctors)
print(p.matcher(ctor.toString()).replaceAll(""));
}
}catch(ClassNotFoundExceptione){
print("Nosuchclass:"+e);
}
}/*
publicstaticvoidmain(String[])
publicfinalvoidwait()throwsInterruptedException
publicfinalvoidwait(long,int)throwsInterruptedException
publicfinalnativevoidwait(long)throwsInterruptedException
publicbooleanequals(Object)
publicStringtoString()
publicnativeinthashCode()
publicfinalnativeClassgetClass()
publicfinalnativevoidnotify()
publicfinalnativevoidnotifyAll()
publicShowMethods()
*/
}
简单来说，反射机制就是识别未知类型的对象。反射常用于动态代理中。举例如下：
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
classDynamicProxyHandlerimplementsInvocationHandler{
privateObjectproxied;//代理对象
publicDynamicProxyHandler(Objectproxied){
//TODOAuto-generatedconstructorstub
this.proxied=proxied;
}
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
//TODOAuto-generatedmethodstub
System.out.println("代理类:"+proxy.getClass()+"\n"
+"代理方法:"+method+"\n"
+"参数:"+args);
if(args!=null)
for(Objectarg:args)
System.out.println(""+arg);
returnmethod.invoke(proxied,args);
}
}
interfaceInterface{voiddoSomething();}
classRealObjectimplementsInterface{
@Override
publicvoiddoSomething(){
//TODOAuto-generatedmethodstub
System.out.println("doSomething");
}
}
publicclassDynamicProxyDemo{
publicstaticvoidconsumer(Interfaceiface){
iface.doSomething();
}
publicstaticvoidmain(String[]args){
RealObjectrealObject=newRealObject();
//使用动态代理
Interfaceproxy=(Interface)Proxy.newProxyInstance(
Interface.class.getClassLoader(),
newClass[]{Interface.class},
newDynamicProxyHandler(realObject));
consumer(proxy);
}/*输出：
代理类:class$Proxy0
代理方法:publicabstractvoidInterface.doSomething()
参数:null
doSomething
*/
}
代理是基本的设计模式之一，即用代理类为被代理类提供额外的或不同的操作。而动态代理则需要一个类加载器，就像Java实现RTTI时需要类加载器加载类的信息，这样就可以知道类的相关信息。
关键方法是：
Objectjava.lang.reflect.Proxy.newProxyInstance(ClassLoaderloader,Class[]interfaces,InvocationHandlerh)throwsIllegalArgumentException
传入三个参数：代理接口的加载器（通过Class对象的getClassLoader方法获取），代理的方法接口，代理对象
前两个参数很好理解，就是要代理的方法所属的接口对应的Class对象（主语）的加载器和Class对象本身,主要是参数3，要设计一个实现InvocationHandler接口的类，作为代理对象，一般命名以Handler结尾，Handler翻译为处理者，很形象，就是代替原对象进行处理的处理者（即代理），在程序设计中经常被翻译成“句柄”。
这个类通过传入代理对象来构造，比如这里传入的是Object对象。然后必须覆盖invoke方法。
通过最后输出和invoke方法的具体实现可以发现，returnmethod.invoke(proxied,args);是相当于原对象调用该方法（类似C++的回调函数？）
由于有类加载器，所以代理对象可以知道原对象的具体类名、方法、参数，本示例在调用方法前就输出了这些。
实际应用中可能会针对类名而有所选择。比如接口中有好多个类，你可以选择性的对特定的类、方法、参数进行处理
比如if(proxiedinstanceofRealObject){}或者if(method.getName.equals("doSomething")){}
PS：我这个示例没有参数所以没有距离
参考：《Java编程思想》第四版，更多细节见书上第14章
总结
以上就是本文关于Java的RTTI和反射机制代码分析的全部内容，希望对大家有所帮助。