反射相关知识总结

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包括原始类型，参数化类型，数组类型，类型变量和基本类型等。