Java RTTI and Reflection

Reference:

Java编程思想

java 反射（Reflect）

Java系列笔记(2) - Java RTTI和反射机制

Java Reflection in Action, 有空再补

----------------------------------------------------------------------------------------------

对于面向对象, 以多态的方式编写程序是首选的方式, 即使用基类reference, 而不是具体的类对象来编写程序

在这种情况下, 你根本就不需要知道基类reference具体指向的是那个类对象, 因为编译器会自动调用相应的逻辑, 大大的简化了编程的复杂度

比如下面的例子, 对于draw, 只需要写Shape.draw(), 此时Shape可以指向circle, square, triangle, 任一个对象

所以对于绝大部分情况下, 其实是不需要知道RTTI (Run-time Type Identification)的, 所以当你用到RTTI, 首先确认你真的需要吗, 设计没有问题吗, 不应该使用多态吗?

当然对于一些特殊和复杂的情况下, 获取RTTI是有较大帮助的,

比如上面的例子, 你只想把circle画成红色来高亮强调, 或则在调用旋转操作的时候想要跳过circle(因为旋转对circle没有意义), 这个时候就需要RTTI

对于Java的RTTI, 无论什么形式, 没有什么神秘的, 毫无例外的都是通过class对象来获得信息.

传统的RTTI和新的Reflection的唯一差别, 就是在何时去check class对象文件 
传统的RTTI是在编译时候去check, 这个其实可以满足绝大部分需求

但是对于某些需求, 
从磁盘, 或网络连接中读取一个对象, 在编译的时候还没有读, 所以你无法在编译的时候check 
在RMI(远程方法调用)中, 需要知道你调用的类的各种信息 
这些情况下, class对象文件必须到运行时才能获取(从磁盘或网络上), 这是传统的RTTI无法支持的 
这时就需要使用Reflection接口

 

Class对象

可以看到class对象是RTTI的核心, 下面就具体来看看这个对象

在Java中, 每个class都有一个相应的Class对象(每个类编译完成后, 存放在生成的.class文件中), 用于表示这个类的类型信息. 
Class对象用于创建类的所有普通的instance, 并且RTTI也是通过Class对象实现, 哪怕是最简单的cast

当类第一次被使用时, class对象会被类加载器加载到JVM中,

确切的说, 当第一次引用该类的static member时, class对象会被加载. 构造函数是隐含的static member, 所以用new创建对象的时候也会被当作引用static member 

This happens when the program makes the first reference to a static member of that class. 
It turns out that the constructor is also a static method of a class, even though the static keyword is not used for a constructor. Therefore, creating a new object of that class using the new operator also counts as a reference to a static member of the class.

类加载器, 会先check该class对象是否已经被加载, 如果没有加载, 首先找到对应的.class文件, 然后check这个class文件是否被破坏或含有不良代码, 一旦class对象被载入, 就可以用来创建普通对象

 

Class对象的生成方式

1. 使用Class的静态成员forName

Class.forName("类名字符串") (注意: 类名字符串必须是全称, 包名+类名), 如果找不到该类会抛ClassNotFoundException异常

2. Class literals, 更加安全和高效的方法, 类名.class

Class literals work with regular classes as well as interfaces, arrays, and primitive types.

可用于接口, 数组和基本类型

需要注意的是, 使用Class literals来创建class对象时, 会有惰性, 对象初始化会被延迟到真正使用, 即引用静态成员时发生

对于基本类型, 还可以使用包装器类的Type

 

3.实例对象.getClass()

public class ClassTest {    public static void main(String [] args)throws Exception{        String str1="abc";        Class cls1=str1.getClass();        Class cls2=String.class;        Class cls3=Class.forName("java.lang.String");        System.out.println(cls1==cls2);  //True        System.out.println(cls1==cls3);  //True    }}

 

RTTI的形式

总结一下传统的RTTI的形式, 如下3种

1. 向上转型或向下转型(upcasting and downcasting)

向上转型(子类cast到父类)是绝对安全的, 所以不需要check, 可以通过赋值操作完成 
但是向下转型(父类cast到子类)却是有风险的, 编译器需要check向下转型是否合理, 这就需要使用RTTI来check实际类型

2. Class对象

传统的RTTI和反射都依赖于Class对象, 什么时候是传统RTTI, 什么时候是反射?

Class<?> c = Class.forName(args[0]); //这种情况就是反射, 只有在运行时产能得到args[0]Method[] methods = c.getMethods(); Constructor[] ctors = c.getConstructors(); 

3. instanceof或isInstance()

从下面看出两种的不同用法,

//x是否是Dog类的instancex instanceof Dog  // obj instanceof classname Dog.class.isInstance(x) //动态的instanceof, classobj.isInstance(obj)

 

Reflection, 反射

反射, 即在Java运行时环境中动态获取类的信息, 以及动态调用对象的方法的功能, 让Java跨入半动态语言的行列, 毕竟Java不允许动态的更改.

Java 反射机制主要提供了以下功能:

- 在运行时判断任意一个对象所属的类

- 在运行时构造任意一个类的对象

- 在运行时判断任意一个类所具有的成员变量和方法

- 在运行时调用任意一个对象的方法

- 生成动态代理

 

在JDK中, 主要由以下类来实现Java 反射机制, 这些类都位于java.lang.reflect包中:

- Java.lang.Class类: 代表一个类

- Field类: 代表类的成员变量(成员变量也称为类的属性)

- Method类: 代表类的方法

- Constructor类: 代表类的构造方法

- Array类: 提供了动态创建数组 以及访问数组元素的静态方法

使用的例子, 参考java 反射（Reflect）

 

动态代理

普通的代理, 静态代理, 很简单, 问题就是必须手工的写代理 
那么如果真实的对象中有100个方法, 那么在代理类中就需要写100个代理接口, 是不是很麻烦

动态代理, 就是可以自动生成代理类, 其实代理类是很简单的, 实现代理类的关键就是知道真正的对象中有哪些接口, Reflection出场... 
Reflection包中封装实现了动态代理, 可以直接使用

下面给出两种创建动态代理的方法 
一种, 先生成代理类, 再创建代理对象 
另一种, 直接生成代理对象

/**** 方式一****///创建InvocationHandler对象InvocationHandler handler = new MyInvocationHandler(...);//创建动态代理类Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });//创建动态代理类的实例Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).newInstance(new Object[] { handler });/**** 方式二****///创建InvocationHandler对象InvocationHandler handler = new MyInvocationHandler(...);//直接创建动态代理类的实例Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[] { Foo.class }, handler);

===========================================================================================================================

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：
Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，
Constructor[] getConstructors() -- 获得类的所有公共构造函数
Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)
获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：
Field getField(String name) -- 获得命名的公共字段
Field[] getFields() -- 获得类的所有公共字段
Field getDeclaredField(String name) -- 获得类声明的命名的字段
Field[] getDeclaredFields() -- 获得类声明的所有字段
用于获得方法信息函数：
Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() -- 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
Method[] getDeclaredMethods() -- 获得类声明的所有方法
 
 
Java允许我们从多种管道为一个class生成对应的Class object。下图是一份整理。
Class object 诞生管道示例
运用getClass()
注：每个class 都有此函数
String str = "abc";
Class c1 = str.getClass();
运用
Class.getSuperclass()2
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用static method
Class.forName()
（最常被使用）
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");
Class c4 = Class.forName ("I");
Class c5 = Class.forName ("[I");
运用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的TYPE 语法
 
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;
图2：Java 允许多种管道生成Class object。
 
 
 
 
 
Java classes 各成份所对应的Reflection APIs
Java class成份，分别对应于下图的Reflection API，其中出现的Package、Method、Constructor、Field等等classes，都定义于java.lang.reflect。
Java class 内部模块（参见图3）Java class 内部模块说明相应之Reflection API，多半为Class methods。返回值类型(return type)(1) packageclass隶属哪个packagegetPackage()Package(2) importclass导入哪些classes
无直接对应之API。
解决办法见图5-2。
 (3) modifier
class（或methods, fields）的属性
 
int getModifiers()
Modifier.toString(int)
Modifier.isInterface(int)
int
String
bool
(4) class name or interface nameclass/interface名称getName()String(5) type parameters参数化类型的名称getTypeParameters()TypeVariable <Class>[](6) base classbase class（只可能一个）getSuperClass()Class(7) implemented interfaces实现有哪些interfacesgetInterfaces()
Class[]
 
(8) inner classes内部classesgetDeclaredClasses()Class[](8') outer class如果我们观察的class 本身是inner classes，那么相对它就会有个outer class。getDeclaringClass()Class(9) constructors构造函数getDeclaredConstructors()不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。Constructor[](10) methods操作函数getDeclaredMethods()不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。Method[](11) fields字段（成员变量）getDeclaredFields()不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。Field[]