Java学习之反射机制

前段时间在做项目的时候，由于是用的纯Servlet基础框架进行开发的，没有用到那些集成的框架，后来在后台处理表单中的数据的时候，感觉有很多东西都是重复的，比较繁琐，例如获取到前台页面表单中的值之后，要在后台实例化一个对象并且调用定义的setter方法来给对象赋值，由于表单中的数据比较多，然后这个调用setter方法的代码就显得有些重复臃肿，后来网上查资料才了解到可以通过java中的反射机制简化这一操作，并且也知道了很多框架里面也都用到了反射。。。

一、什么是反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

简单的来说，反射机制指的是程序在运行时能够获取到自身的一些信息，在java中，只要给定类的名字，那么就可以通过反射机制来获取类的所有相关信息。

二、应用场合

其实在之前的时候，就已经接触过了反射机制，Java中使用JDBC操作数据库的时候，只是那个时候还不知道专业术语叫“反射机制”，例如：加载数据库的驱动类的代码。Class.forName(“com.mysql.jdbc.Driver”) ; 通过了解之后才知道原来这就是反射机制，并且也知道了很多集成的开发框架都有用到反射机制，像hibernate、struts等集成框架基本上都是通过反射机制去实现的。

三，示例

package com.wx.utils.tool;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import com.wx.pojo.repair.RepairProduct;

/**
* 类的反射机制
* 通过java中的反射机制，动态的给对象属性赋值，并且获取对象属性值
* @remark
* @author feizi
* @time 2015-2-5下午4:07:03
*/
public class ClassRefUtil {

public static void main(String[] args) {
//构建map集合，存放值
Map<String, String> fieldValueMap = new HashMap<String, String>();
fieldValueMap.put("id", "10010");
fieldValueMap.put("cust_tax_code", "440232323232323");
fieldValueMap.put("cust_name", "飞子科技");
fieldValueMap.put("contact", "飞子");
fieldValueMap.put("tel", "15623232323");
fieldValueMap.put("addr", "飞子广场");
fieldValueMap.put("product", "飞机");
fieldValueMap.put("notes", "飞不起来");
fieldValueMap.put("create_time", "2015-02-06 12:23:55");

//类的全路径（带包名）
String className = "com.wx.pojo.repair.RepairProduct";
Object obj = null;

try {
//根据类的路径（类名）来创建Class对象
Class<?> c = Class.forName(className);

//创建类的实例
obj = c.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}

//通过反射赋值
setFieldValue(obj, fieldValueMap);

//通过反射取值
int i = 0;
Map<String, String> getFieldValueMap = getFieldValueMap(obj);

/**
* 1、这个对所有的对象都是通用的
*/
System.out.println("\n\n=========输出调用get方法后取到的值==========");
for (Entry<String, String> entry : getFieldValueMap.entrySet()) {
System.out.println("[字段 "+(++i)+"] ["+entry.getKey()+"]   ---   [" + entry.getValue()+"]");
}

/**
* 2、通过反射方式动态调用set方法赋值，通过原生get方式取值
* 也可以通过下面这种方式，直接调用类中定义的get方法进行取值
* 只是需要先把obj对象通过强制类型转换强转成我们需要操作的对象类型
*/
/*RepairProduct product = (RepairProduct) obj;
System.out.println("id:"+product.getId());
System.out.println("cust_tax_code:"+product.getCust_tax_code());
System.out.println("cust_name:"+product.getCust_name());
System.out.println("contact:"+product.getContact());
System.out.println("tel:"+product.getTel());
System.out.println("addr:"+product.getAddr());
System.out.println("product:"+product.getProduct());
System.out.println("notes:"+product.getNotes());
System.out.println("create_time:"+product.getCreate_time());
System.out.println("order:"+product.getOrder());*/
}

/**
* 通过反射调用get方法取值，并且以属性名称，和属性值以键值对的形式放于Map集合中
* @param Object obj
* @return
*/
public static Map<String, String> getFieldValueMap(Object obj){
try {
//通过getClass方法获得obj类的类类型（即Class类型）
Class<?> c = obj.getClass();

//定义一个Map集合，存放get方法获取的值
Map<String, String> getFieldValueMap = new HashMap<String, String>();

//获取obj对象中自身定义的所有方法,包括public,private,protected
//(也可以用c.getMethods()，只不过这个是获取obj中所有共有的方法,包括从父类继承的或从接口实现的所有public方法)
Method[] methods = c.getDeclaredMethods();

//获取obj对象中自身定义的所有属性变量
Field[] fields = c.getDeclaredFields();

if(null != fields && fields.length > 0){
//遍历fields数组
for (Field field : fields) {
//获取属性的定义名称
String fieldName = field.getName();

//获取属性的定义类型
String fieldType = field.getType().getSimpleName();

//拼接属性的get方法
String fieldGetMethodName = defineGetOrSetMethod(fieldName,"get");

//判断该属性是否定义了get方法
if (!checkGetOrSetMethod(methods, fieldGetMethodName)) {
continue;
}

//获取类中定义的get方法
Method fieldGetMethod = c.getMethod(fieldGetMethodName, new Class[]{});

//调用get方法获取值
Object fieldVal = fieldGetMethod.invoke(obj, new Object[]{});

String result = null;

if("Date".equals(fieldType)){
result = date2String((Date)fieldVal);
}else{
if(null != fieldVal){
result = String.valueOf(fieldVal);
}
}
getFieldValueMap.put(fieldName, result);
}
}

return getFieldValueMap;
} catch (Exception e) {
e.printStackTrace();
}

return null;
}

/**
* 传递Map集合，通过反射调用set方法给属性动态赋值，
* @param Object obj
* @param fieldValueMap
*/
public static void setFieldValue(Object obj,Map<String, String> fieldValueMap){
try {
//通过getClass方法获得obj类的类类型（即Class类型）
Class<?> c = obj.getClass();

//获取对象中自身定义的所有方法
Method[] methods = c.getDeclaredMethods();

//获取对象中自身定义的所有属性
Field[] fields = c.getDeclaredFields();

//遍历fields属性数组
if(null != fields && fields.length > 0){
for (Field field : fields) {

//获取属性的定义名称
String fieldName = field.getName();

//拼接属性的set方法(自定义的set方法)
String fieldSetMethodName = defineGetOrSetMethod(fieldName,"set");

//判断该属性是否定义了set方法
if (!checkGetOrSetMethod(methods, fieldSetMethodName)) {
continue;
}

//获取类中定义的set方法
Method fieldSetMethod = c.getMethod(fieldSetMethodName, field.getType());

//取出map集合中需要操作的属性值
String fieldValue = fieldValueMap.get(fieldName);

if(!isBlank(fieldValue)){
//获取属性的定义类型
String fieldType = field.getType().getSimpleName();

//根据参数类型判断，调用不同的set方法
if("String".equals(fieldType)){
fieldSetMethod.invoke(obj, fieldValue);
}else if("Date".equals(fieldType)){
fieldSetMethod.invoke(obj, string2Date(fieldValue));
}else if(("Integer".equals(fieldType)) || ("int".equals(fieldType))){
fieldSetMethod.invoke(obj, Integer.parseInt(fieldValue));
}else if("Long".equalsIgnoreCase(fieldType)){
fieldSetMethod.invoke(obj, Long.parseLong(fieldValue));
}else if("Double".equalsIgnoreCase(fieldType)){
fieldSetMethod.invoke(obj, Double.parseDouble(fieldValue));
}else if("Boolean".equalsIgnoreCase(fieldType)){
fieldSetMethod.invoke(obj, Boolean.parseBoolean(fieldValue));
}else{
//没有合适的类型匹配
System.out.println("not suitable type" + fieldType);
}

/**
* 当然也可以通过下列这种方式来判断参数的类型，不过还是觉得上面那种方式判断简洁一些，下面要多写一些代码
*/

/*Class[] paramTypes = fieldSetMethod.getParameterTypes();
System.out.println("方法的参数类型-paramTypes："+Arrays.toString(paramTypes));

if(paramTypes[0] == String.class){
fieldSetMethod.invoke(obj, fieldValue);
}else if(paramTypes[0] == Date.class){
fieldSetMethod.invoke(obj, string2Date(fieldValue));
}else if((paramTypes[0] == Integer.class) || (paramTypes[0] == int.class)){
fieldSetMethod.invoke(obj, Integer.parseInt(fieldValue));
}else if((paramTypes[0] == Long.class) || (paramTypes[0] == long.class)){
fieldSetMethod.invoke(obj, Long.parseLong(fieldValue));
}else if((paramTypes[0] == Double.class) || (paramTypes[0] == double.class)){
fieldSetMethod.invoke(obj, Double.parseDouble(fieldValue));
}else if((paramTypes[0] == Boolean.class) || (paramTypes[0] == boolean.class)){
fieldSetMethod.invoke(obj, Boolean.parseBoolean(fieldValue));
}else{
//没有合适的类型匹配
System.out.println("not suitable type" + fieldType);
}*/

}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 拼接属性的  get 方法 或   set 方法
* 因为我们自身在定义getter方法的时候，都是将属性名的第一个字母转成大写了
* @return
*/
public static String defineGetOrSetMethod(String fieldName,String methodType){
if(isBlank(fieldName)){
return null;
}

//这里也可以直接用“get 或   set”+属性名称，（属性名称的首字母也可以不用转换成大写，上面判断的时候用equalsIgnoreCase忽略大小写就可以了）
return methodType + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
}

/**
* String字符串转Date日期格式
* @param dateStr
* @return
*/
public static Date string2Date(String dateStr){
if(isBlank(dateStr)){
return null;
}

try {
String fmtStr = null;
if(dateStr.indexOf(":") > 0){
fmtStr = "yyyy-MM-dd HH:mm:ss";
}else{
fmtStr = "yyyy-MM-dd";
}

DateFormat df = new SimpleDateFormat(fmtStr);

return df.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}

/**
* 日期转字符串
* @param date
* @return
*/
public static String date2String(Date date){
if(null == date){
return null;
}

try {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df.format(date);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* 判断某个属性是否定义了gettter和setter方法
* @param methods
* @param fieldMethodName
* @return
*/
public static boolean checkGetOrSetMethod(Method[] methods,String fieldMethodName){
boolean flag = false;

if (null != methods && methods.length > 0) {
for (Method method : methods) {
if(fieldMethodName.equals(method.getName())){
flag = true;
}
}
}
return flag;
}

/**
* 判空
* @param str
* @return
*/
public static boolean isBlank(String str){
if(null == str || str.trim().length() == 0){
return true;
}
return false;
}
}

运行main方法后的效果：



四、在程序中进行调用，这里是在Servlet中进行调用的，获取表单的值，并且给对象赋值。

/**
* 保存用户报修的产品信息
* @param request
* @param response
* @throws IOException
* @throws ServletException
*/
public void saveRepairInfo(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException{
log.info("======================进入到saveRepairInfo");

//获取参数map集合
Map<String, String> fieldValueMap = makeParamMap(request);

//需要操作的类的全路径（带包名）
String className = "com.wx.pojo.repair.RepairProduct";
Object obj = null;

try {
//通过类名（类的全路径）创建Class对象
Class<?> c = Class.forName(className);

//通过Class对象获取类的实例
obj = c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}

//创建时间
fieldValueMap.put("create_time", df.format(new Date()));

//通过类的反射机制调用set方法动态给对象赋值
ClassRefUtil.setFieldValue(obj, fieldValueMap);

//通过强制类型转换将obj对象强转成RepairProduct类型的对象
RepairProduct product = (RepairProduct) obj;

//调用保存方法保存保修的信息
boolean flag = productService.saveRepairInfo(product);

log.info("=============保存成功标志flag:"+flag);

if(flag){
//设备报修信息保存之后，主动向客户推送一条报修成功的消息
SendTemplateMsgService.sendRepairSuccessMsg(product);

//设置页面跳转后显示的内容
request.setAttribute("title", "报修成功！");
request.setAttribute("msg", "您的设备信息已经报修成功，请您耐心等待，稍后我们将会在第一时间处理您的问题！您可以在我的服务记录中查看相关记录，感谢合作！！！");

//使用ServletContext来进行页面重定向
ServletContext sc = getServletContext();
//保存成功之后，将跳转到成功界面
sc.getRequestDispatcher("/mobile/feedBack.jsp").forward(request, response);
}
}

五，通过request.getParameterNames()方法将页面form表单中的数据获取出来并且封装成一个map键值对集合返回给调用者。这里给抽象出来形成一个单独的方法，也可以便于程序中其他的地方要用到。

/**
* 将request.getParameterNames()方法取出的枚举参数列表转换成Map集合
* @param params
* @return
*/
public Map<String, String> makeParamMap(HttpServletRequest request){
Map<String, String> paramMap = new HashMap<String, String>();

//读取所有可用的表单参数,该方法可以取得所有变量的名称，该方法返回一个Emumeration(枚举),键值对
Enumeration paramNames = request.getParameterNames();

if(null != paramNames){
//遍历枚举
while(paramNames.hasMoreElements()){
String paramName = (String) paramNames.nextElement();
String paramValue = request.getParameter(paramName);

paramMap.put(paramName, paramValue);
}
}

return paramMap;
}

额，由于也是刚接触，所以理解的也比较浅，上面的这些只是我自己的一些理解，也不知道这样对不对，当然，反射机制属于Java中的高级应用范畴了，也是一种相当相当好的机制，我个人觉得如果理解了反射机制，也会帮助我们更好的去理解那些集成的框架，这些框架学习起来也会相对的更加的容易一些。嗯。。。慢慢进步吧！！！