JAVA的反射机制

关键字：

Class： 类类，它是一个类，直接继承自Object类，不要与JAVA的内部关键字class相混淆。

Method： 同样是一个类，用于记录某个类或接口的成员方法的信息，并且可以调用（invoke）该方法。

Field： 同样是一个类，用于记录某个类的实例的成员变量的信息。

reflection: JAVA使用该单词来描述这种机制，reflection有影子，倒影的意思，个人认为如果翻译成“镜像”，能更直观的反射出reflection机制到底是一种什么样的机制。

反射机制概述：

所谓反射，或倒影，就是“从镜子里看某一事物，虽然我没有看到实物，但是通过镜子，我看到了与实物极其相似的效果”。一旦有了这种机制，回到JAVA中来说，你给我任何 一个类，虽然我不能直接看到该类的细节，但是我可以在运行期间从其“镜像”中看到我想看到的任何一个细节。

例子：

/**
 * JAVA的反射机制，即在运行时而非编译期知晓某个指定类的内部结构
 * 使用反射机制时，最重要的一个类就是“类类”，即Class类，它同样继承自Object
 * 在JAVA程序启动后，针对每个对象，JVM都会自动为其生成一个关联的Class的实例
 * 
 * EG：有一个类叫Customer，运行期间，该类生成一个对象叫cstm，那么JVM会为cstm生成
 * 一个Class的实例，比如叫cstm_class，以追踪cstm的信息
 *  
 * 本例程是学习【风中叶-张龙】老师的视频之后自由编写，用于加深对JAVA反射机制的理解。
 *  
 * */

package com.owen.reflection;

import java.util.List;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;


/**
 * ClassInfomation类，一个例子，其内演示如何动态知晓某个指定类的相关结构
 * */
public class ClassInformation {
	
	/**
	 * 记录用户动态指定的类全名
	 * */
	private String m_classFullName;
	/**
	 * 与用户指定类相关联的Class类
	 * */
	private Class<?> m_classType;

	/**
	 * 下面是两个构造方法，一个是不带参数的默认构造方法，另一个是带参数的构造方法
	 * 
	 * 获取某个类的classType有四种方法：
	 * 1，当知道目标类的全名时，可使用Class的forName方法
	 * 2，当知道目标类的类名时，可使用.class的方式
	 * 3，当知道目标类的一个实例时，可使用实例调用getClass方法
	 * 4，针对8个内部数据类型，可使用TYPE，比如Integer.TYPE,它跟Integer.class是相同的效果
	 * 
	 * */
	public ClassInformation() {}

	public ClassInformation(String classFullName) {
		if ("".equals(classFullName)) {
			m_classFullName = null;
			m_classType = null;
			return;
		}
		try {
			/**
			 * 知道类的全名，故可采用forName的方法去获取其classType
			 * */
			m_classType = Class.forName(classFullName);
			m_classFullName = classFullName;
		} catch (Exception e) {
			System.out.println("Exception of Class.forName()" + e);
		}
	}

	public String getM_classFullName() {
		return m_classFullName;
	}

	public void setM_classFullName(String m_classFullName) {
		this.m_classFullName = m_classFullName;
	}

	public Class<?> getM_classType() {
		return m_classType;
	}

	public void setM_classType(Class<?> m_classType) {
		this.m_classType = m_classType;
	}

	/**
	 * 以下是Class类中常用的方法，获取全部成员变量，获取公开成员变量，获取全部方法（不包括构造方法），获取全部公开的方法（不包括构造）
	 * */
	public List<String> getPublicFields() {
		List<String> list = new ArrayList<String>();
		for (Field field : m_classType.getFields()) {
			list.add(field.toString());
		}
		return list;
	}

	public List<String> getAllFields() {
		List<String> list = new ArrayList<String>();
		for (Field field : m_classType.getDeclaredFields()) {
			list.add(field.toString());
		}
		return list;
	}

	public List<String> getPublicMethods() {
		List<String> list = new ArrayList<String>();
		for (Method method : m_classType.getMethods()) {
			list.add(method.toString());
		}
		return list;
	}

	public List<String> getAllMethods() {
		List<String> list = new ArrayList<String>();
		for (Method method : m_classType.getDeclaredMethods()) {
			list.add(method.toString());
		}
		return list;
	}

	
	/**
	 * 这里是动态生成一个对象的副本，所谓动态，即编译期不清楚该对象的内部结构，而是在运行期使用Class采用反射机制去动态获取
	 * 
	 * 基本流程：
	 * 1，当前目标是一个类的对象，故使用obj.getClass()去获取与其相关的Class对象
	 * 2，调用目标对象的默认构造方法，即通过Class的不带参数的newInstance方法来完成，这里需要注意，目标对象所属的类必须要存在默认构造方法
	 *    （所谓存在即，或者存在JAVA默认提供的无参构造方法，或者当存在带参数的构造方法时，需要显式写出默认无参的构造方法）
	 * 3，通过Class获取目标对象的所有成员变量
	 * 4，针对目标对象的每个成员变量，通过其变量理分析出与其相关的get set方法
	 * 5，针对获取的每一个get方法，通过使用Method的invoke方法去执行之，以获取当前成员变量的当前值
	 * 6，针对每一个set方法，通过使用Method的invoke方法去执行之，参数是第5步中通过对get的调用取得的值
	 * 
	 * 当所有成员变量的值均被设定之后，目标类的一个新实例就完成了对当前实例的复制
	 * */
	public Object copyObject(Object obj) throws Exception {
		Class<?> classType = obj.getClass();

		Object cpyObj = classType.newInstance();

		Field[] fields = classType.getDeclaredFields();
		for (Field field : fields) {
			String fieldName = field.getName();
			String firstLetter = fieldName.substring(0, 1).toUpperCase();
			String strGetMethod = "get" + firstLetter + fieldName.substring(1);
			String strSetMethod = "set" + firstLetter + fieldName.substring(1);

			Method getMethod = classType.getMethod(strGetMethod, new Class[] {});
			Method setMethod = classType.getMethod(strSetMethod,new Class[] { field.getType() });

			Object value = getMethod.invoke(obj, new Object[] {});

			setMethod.invoke(cpyObj, new Object[] { value });
		}
		return cpyObj;
	}

	public String getGetMethodName(Field field) {
		String fieldName = field.getName();
		return "get" + fieldName.substring(0, 1).toUpperCase()
				+ fieldName.substring(1);
	}

	public String getSetMethodName(Field field) {
		String fieldName = field.getName();
		return "set" + fieldName.substring(0, 1).toUpperCase()
				+ fieldName.substring(1);
	}

	public Method getGetMethod(Class<?> classType, Field field)
			throws NoSuchMethodException, SecurityException {
		if (null == classType) {
			return null;
		}
		String getMethodName = getGetMethodName(field);
		return classType.getMethod(getMethodName, new Class[] {});
	}

	public Method getSetMethod(Class<?> classType, Field field)
			throws NoSuchMethodException, SecurityException {
		if (null == classType) {
			return null;
		}
		String setMethodName = getSetMethodName(field);
		return classType.getMethod(setMethodName,
				new Class[] { field.getType() });
	}

}

最后：感谢张龙老师（风中叶）的细心讲解视频