反射相关知识总结

Class对象

Java程序中许多对象在运行时都会有两种类型：编译时类型和运行时类型。

每个类被加载之后，系统就会为该类生成一个对应的Class对象，通过Class对象可以访问到Java虚拟机中的这个类。

Java程序中获得Class对象有如下三种方式：

(1)使用Class类的forName()静态方法。该方法需要传入字符串参数，该字符串参数的值是某个类的全限定类名(必须添加完整的包名)。

(2)调用某个类的Class属性来获取该类对应的Class对象。比如：Person.class将返回Person类对应的Class对象。

(3)调用某个对象的getClass()方法，该方法是java.lang.Object类中的一个方法，所以所有Java对象都可以调用该方法，该方法返回该对象所属类对应的Class对象。

第一种和第二种方式都是直接根据类来获取该类的Class对象，但相比之下，第二种方式有如下两种优势:

(1)代码更安全，程序在编译阶段就可以知道需要访问的Class对象是否存在。

(2)程序性能更高，因为这种方式无须调用方法，所以性能更好。

所以大部分时候建议使用第二种来获取Class对象。当我们获取到Class对象后，程序就可以调用Class对象的方法来获取该类的真实信息。

从Class对象中获取信息

Class对应的类包含四个构造函数：

(1)Connstructor<T> getConstructor(Class<?>... parameter types)：返回此Class对象所表示的类的指定的public构造函数。

(2)Connstructor<T>[] getConstructors()：返回此Class对象所表示的类的所有public构造函数。

(3)Connstructor<T>
getDeclaredConstructor(Class<?>... parameter types)：返回此Class对象所表示的类的指定构造函数，与构造的访问级别无关。

(4)Connstructor<T>[]
getDeclaredConstructosr()：返回此Class对象所表示的类所有构造函数，与构造的访问级别无关。

访问Class对应的类所包含的方法：

(1)Metnod getMethod(String name,Class<?>...
parameter types)：返回此Class对象所表示的类的指定public方法。

(2)Method[] getMethods()：返回此Class对象所表示的类的所有public方法。

(3)Method getDeclaredMethod(String name,Class<?>...
parameter types)：返回此Class对象所表示的类的指定方法，与方法的访问级别无关。

(4)Method[] getDeclaredMethods()：返回此Class对象所表示的类的全部方法，与方法的访问级别无关。

访问Class对应的类所包含的属性(Field)：

(1)Field getField(String name)：返回该Class对象所表示的类的指定的public属性。

(2)Field[]
getFields()：返回该Class对象所表示的类的所有public属性。

(3)Field
getDeclaredField(String name)：返回该Class对象所表示的类的指定属性，与属性的访问级别无关。

(4)Field[]
getDeclaredFields()：返回该Class对象所表示的类的全部属性，与属性的访问级别无关。

访问Class对象的类上所包含的注解：

(1)<A extends Annotation> A getAnnotation(Class<A> annotationClass)：试图获取该Class对象所表示类上指定类型的注解；如果该类型的注解不存在则返回null。

(2)Annotation[] getAnnotations()：返回此元素上存在的所有注解。

(3)Annotation[] getDeclaredAnnotations()：返回直接存在与此元素上的所有注解。

访问Class对象对应类包含的内部类

(1)Class<?>[] getDeclaredClasses():返回该Class对象所对应类里包含的全部内部类。

(2)Class<?> getDeclaringClass()：返回该Class对象所对应类所在的外部类。

(3)Class<?>[] getInterfaces()：返回该Class对象对应类所实现的全部接口。

(4)int getModifiers()：返回此类或接口的所有修饰符。必须使用Modifier工具类，才能获得真实的修饰符。

(5)Package getPackaget()：获取此类的包。

(6)String getName()：以字符串形式返回此Class对象所表示的类的名称。

(7)String getSimpleName()：以字符串形式返回此Class对象所表示的类的简称。

(8)Class<? super T> getSuperclass()：返回该Class所表示的类的超类(父类，基类)对应的Class对象。

Class对象用于判断该类是否为接口，枚举，注解类：

(1)boolean isAnnotation()：返回此Class对象是否表示一个注解类型。

(2)boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)：判断此Class对象上是否使用了Annotation注解修饰。

(3)boolean isAnonymousClass()：返回此Class对象是否是一个匿名类。

(4)boolean isArray()：返回此Class对象是否表示一个数组类。

(5)boolean isEnum()：返回此Class对象是否表示一个枚举类。

(6)boolean isInterface()：返回此Class对象是否表示一个接口。

(7)boolean isInstance(Object obj)：判断obj是否是此Class对象的实例，该方法可以完全代替instanceof操作符。

通过Class对象，如果我们需要确定一个方法，应该由方法名和形参列表来确定。比如：clazz.getMethod("method1",String.class);这样来确定一个叫method1（String str）的方法。确定构造函数则只需要参数列表就OK了，因为同一个类的所有构造函数的名字都是相同的。

使用反射生成并操作对象

创建对象

反射创建对象有两种方式:

(1)使用Class对象的newInstance()方法来创建该Class对象对应类的实例，这种方式要求该Class对象的对应类有默认的构造函数，而执行newInstance()方法时，实际上是利用默认的构造函数来创建类的实例。

(2)先使用Class对象获取指定的Constructor对象，在调用Constructor对象的newInstance()方法来创建该Class对象对应的实例。通过这种方式可以选择使用某个类的指定构造函数来创建实例。

经典实例：

public class ObjectPoolFactory {

// 定义一个对象池。
private Map<String, Object> objectPool = new HashMap<String, Object>();

// 创建对象 的方法
private Object createObject(String clazzName)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
// 根据字符串来获取对应的Class对象
Class<?> clazz = Class.forName(clazzName);
// 使用Class对象的默认构造函数创建实例
return clazz.newInstance();
}

// 初始化对象池，根据配置文件来创建对象。
public void initPool(String fileName) throws InstantiationException,
IllegalAccessException, ClassNotFoundException {
FileInputStream fis = null;
try {
fis = new FileInputStream(fileName);
Properties props = new Properties();
props.load(fis);
for (String name : props.stringPropertyNames()) {
objectPool.put(name, createObject(props.getProperty(name)));
}
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

public Object getObject(String name) {
return objectPool.get(name);
}

public static void main(String[] args) {
ObjectPoolFactory pf = new ObjectPoolFactory();
try {
pf.initPool("D:\\test.txt");
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(pf.getObject("a"));
}

// 在D盘创建一个test.txt的文件，文件内容为：
// a=java.util.Date
// b=javax.swing.JFrame

//打印的结果是:Sun Mar 17 10:50:10 CST 2013
}

如果我们不想使用默认的构造函数来创建对象，而想利用指定的构造函数来创建对象。

我们可以采用下面的步骤。

(1)获取该类的Class对象。

(2)利用Class对象的getConstructor()方法来获取指定的构造函数。

(3)调用Constructor的newInstance方法来创建Java对象。

经典实例

public class CreateJFrame {

public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("javax.swing.JFrame");
Constructor ctor = clazz.getConstructor(String.class);
Object obj = ctor.newInstance("测试窗口");
System.out.println(obj);
}
}

实际上在开发过程中，只有当程序需要动态创建某个类的对象时才会考虑使用反射，反射创建对象性能稍低，通常在开发通用性比较广的框架，基础平台时可能会使用大量的反射。

调用方法

当获得某个类对应的Class对象后，就可以通过该Class对象的getMethods()方法或者getMethod()方法来获取全部方法或指定方法。获取方法后，程序可以调用Method里的invoke方法。来执行对应的方法：

Object invoke(Object obj,Object ...args)：该方法中的obj是执行该方法的主调，args是执行该方法时传入该方法的实参。

当通过Menthod的invoke方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限。如果程序确实需要调用某个对象的private方法，可以先调用Method对象的如下方法：

setAccessible(boolean flag)：将Method对象的accessible标志设置为指示的布尔值，如果设为true则指示该Method在使用时应该取消Java语言访问权限检查。如果设为false则指示该Method在使用时应该实施Java语言访问权限检查（实际上setAccessible方法并不属于Method，而是属于它的父类，因此Method，Constructor，Field都可以调用该方法，从而实现通过反射访问private修饰的属性）。

访问属性值

通过Class对象的getFields()或getField()方法可以获取该类所包含的全部属性或指定的属性。

Field提供如下两组方法访问属性：

(1)getXxx(Object obj)：获取obj对象该Field的属性值。此处的Xxx对应的是8个基本数据类型，如果该属性的类型是引用类型则直接使用get(Object obj)。

(2)setXxx(Object obj,Xxx val)：将obj对象的该Field设置成val值。此处的Xxx对应的是8个基本数据类型，如果该属性的类型是引用类型则直接使用set(Object obj,Value v)。

操作数组

java.lang.reflect包下还提供了一个Array类，程序可以通过使用Array类动态的创建数组，操作数组元素等。

Array提供了如下几个类方法：

(1)static Object newInstance(Class<?> componentType,int...lenght)：创建一个具有指定的元素类型、指定维度(长度)的新数组。

(2)static xxx getXxx(Object array,int index)：返回该array数组中第index个元素。其中xxx是个各种基本数据类型，如果数组元素是引用类型，则该方法变为get(Object obj,int index)。

(3)static void setXxx(Object array,int index,xxx val)：将array数组中第index个元素的值设为val。其中xxx是个各种基本数据类型，如果数组元素是引用类型，则该方法变为set(Object obj,int index,Ojbect val)。

经典实例：

public class ArrayTest {

public static void main(String[] args) {

try {
// 创建一个元素类型为String ，长度为10的数组。
Object arr = Array.newInstance(String.class, 10);
// 为arr数组设置值
Array.set(arr, 5, "Java语言");
Array.set(arr, 6, "Android技术");
Object one = Array.get(arr, 5);
Object two = Array.get(arr, 6);
System.out.println("one=" + one + "    ,two=" + two);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}

使用反射生成JDK动态代理

java.lang.reflect包提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成JDK动态代理类或动态代理对象。

使用Proxy和InvocationHandler创建动态代理

Proxy提供用于创建动态代理类和代理对象的静态方法，它也是所有动态代理类的父类。如果我们在程序中为一个或多个接口动态地生成实现类，就可以使用Proxy来创建动态代理类；如果需要为一个或多个接口动态创建实例，可以使用Proxy来创建动态代理实例。

Proxy提供了如下两个方法来创建动态代理类和动态代理实例：

(1)static Class<?> getProxyClass(ClassLoader loader,Class<?>...interfaces)：创建一个动态代理类所对应的Class对象，该代理类将实现interfaces所指定的多个接口。

(2)static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)：直接创建一个动态代理对象，该代理对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。

实际上即使采用第一种方式获取了一个动态代理类之后，当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

经典实例:

public class ProxyTest {

public static void main(String[] args) throws Exception {
// 创建一个InvocationHandler对象
InvocationHandler handler = new MyInvocationHandler();
// 使用指定的InvocationHandler对象来生成一个动态代理对象。
Person p = (Person) Proxy.newProxyInstance(Person.class
.getClassLoader(), new Class[] { Person.class }, handler);
// 调用动态代理对象的方法。
p.walk();
p.sayHello("Java");
}
}

interface Person {
void walk();

void sayHello(String name);
}

class MyInvocationHandler implements InvocationHandler {

/**
* proxy：代表动态代理对象 method:代表正在执行的方法 args:代表执行代理对象方法时传入的参数
*
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("正在执行的方法：" + method);
if (args != null) {
System.out.println("下面执行该方法时参数为");
for (Object obj : args) {
System.out.println(obj);
}
} else {
System.out.println("调用该方法无须参数");
}
return null;
}

}

使用反射类获取泛型信息

通过指定类对应的Class对象，程序可以获取该类里包含的所有Field，不管该Field使用private修饰还是public修饰。获得了Filed对象后，就可以很容易第获取该field的数据类型。比如:Class<?> a=field.getType(); 但这种方式只对普通类型的Field有效。如果该Filed的类型是有泛型限制的类型，如果Map<String,Integer>类型，则不能准确得到该Field的泛型参数。

获得指定Field的泛型类型步骤如下：

(1)创建Type对象：Type type=field.getGenericType();

(2)将Type对象强制转换为ParameterizedType对象:ParameterizedType ptype=(ParameterizedType)type;

(3)调用ParameterizedType对象的getRawType()方法，返回被泛型现在的类型。ParameterizedType的getActualTypeArguments()方法，返回泛型参数类型。

经典实例:

public class GenericTest {

private Map<String, Integer> score;

public static void main(String[] args) throws Exception {
Class<GenericTest> clazz = GenericTest.class;
Field field = clazz.getDeclaredField("score");
// 直接使用getType方法获取Field类型【只对普通的属性有效】
Class<?> a = field.getType();
System.out.println("score的类型是：" + a);
// 获得Field实例field的泛型类型
Type type = field.getGenericType();
// 如果type类型是ParameterizedType对象
if (type instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) type;
// 获取原来类型
Type rType = pType.getRawType();
System.out.println("原始类型是:" + rType);
// 获取泛型类型的泛型参数
Type[] tArgs = pType.getActualTypeArguments();
System.out.println("泛型类型是:");
for (int i = 0; i < tArgs.length; i++) {
System.out.println("第" + i + "个泛型类型是:" + tArgs[i]);
}
} else {
System.out.println("获取泛型类型错误！");
}
}
}

打印结果:

score的类型是：interface java.util.Map

原始类型是:interface java.util.Map

泛型类型是:

第0个泛型类型是:class java.lang.String

第1个泛型类型是:class java.lang.Integer

Type也是java.lang.reflect包下的一个接口，该接口代表所有类型的公共高级接口，Class是Type接口的实现类，Type包括原始类型，参数化类型，数组类型，类型变量和基本类型等。