java反射要点

1.定义：java中的一组API，主要是面向底层运行时动态获取类的内部信息的一种方式。


2.应用：
  1》反射的起点（Class），获取类对象（类的字节码对象）有以下三种方式，
     Class c1=类名.class;
     Class c2=new 类名().getClass();
     Class c3=Class.forName(类全名);
     注意：内存中每个类的字节码对象只有一份。

  2》通过类对象获取类中属性对象
       Class c=new 类名().getClass(); 
       Field[] fs=c.getFields();//获取所有public修饰的属性对象（包括父类的）
       Field[] fs2=c.getDeclaredFields();//获取类中所有属性对象（不包括父类的）
       Field f=c.getField(String fieldName);//获取类中某个public属性对象（包括父类的）
       Field f=c.getDeclaredField(String fieldName);//获取类中某个属性对象（不包括父类的）
       
  3》通过属性对象给属性赋值
      Class c=类名.class;
      Field f=c.getField(String fieldName);
      f.set(属性所在类的对象，具体值);//前提是属性可访问
      另外，java中根据属性类型提供了一系列对应的set方法，如setInt(),setLong()
      如果属性是私有的，需要先执行f.setAccessible(true)     

  4》通过类对象获取类中的方法对象
       类中的每个方法都是Method类的实例。
       Class c=类名.class;
       Method[] m=c.getMethods();//获取类中的所有public方法(包含父类)
       Method[] m=c.getDeclaredMethods();//获取类中的所有方法(不包含父类)
       Method m=c.getMethod(String methodName,Class<?>... paraTypes);//获取类中的某一个public方法（包含父类）
       Method m=c.getDeclaredMethod(String methodName,Class<?>... paraTypes);//获取类中的某一个方法（不包含父类）

  5》通过方法对象执行类中的某个方法
       Class c=类名.class;
       Method m=c.getDeclaredMethod(String methodName,Class<?>... paraTypes);
       m.invoke(new 类名(),Object... args);//实例方法
       m.invoke(null,Object... args);//静态方法
       如果方法是私有的，需要先执行m.setAccessible(true) 

  6》通过类对象获取类中的构造方法对象
      Class<?> c=类名.class;
      Constructor<?>[] con=c.getConstructors();//获取所有public的构造方法
      Constructor<?>[] con=c.getDeclaredConstructors();//获取所有的构造方法
      Constructor<?> con=c.getConstructor(Class<?>... paramTypes);//获取某个public构造方法
      Constructor<?> con2=c.getDeclaredConstructor(Class<?>... paramTypes);//获取某个构造方法

  7》通过构造方法对象构建对象
       Class<?> c=类名.class;
       Constructor<?> con=c.getConstructor(Class<?>... paramTypes);
       con.newInstance();
       Constructor<?> con2=c.getDeclaredConstructor(Class<?>... paramTypes);
       con2.newInstance(Object... args);


3.总结
   反射（Reflection）就是一组API，它提供了一种自省机制，能够发现自身的属性和方法，通常应用于框架开发和工具开发，反射的执行效率不高。



举例（网上找的）：
    /*
 * 通过Java反射机制，动态给对象属性赋值，并获取属性值
 */
public class ClassRefUtil {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<String, String> valMap = new HashMap<String, String>();  
        valMap.put("userName", "michael");  
        valMap.put("age", "27");  
        valMap.put("height", "173.5");  
        valMap.put("date", "2010-10-24");  
        valMap.put("times", "1287932898276");  
        valMap.put("flag", "false");  
   
        ChildInfo rl = new ChildInfo(); 
        System.out.println("通过反射赋值.");  
        PublicUtil.setFieldValue(rl, valMap);  
   
        System.out.println("通过反射取值:");  
        int i = 0;
        Map<String, String> fieldValMap = PublicUtil.getFieldValueMap(rl); 
        for (Entry<String, String> entry : fieldValMap.entrySet()) {  
            i++;
            System.out.println("[字段 "+i+"] ["+entry.getKey()+"]   ---   [" + entry.getValue()+"]");  
        }  
    }
     
     
    /** 
     * 取Bean的属性和值对应关系的MAP 
     * @param bean 
     * @return Map 
     */ 
    public static Map<String, String> getFieldValueMap(Object bean) {  
        Class<?> cls = bean.getClass();  
        Map<String, String> valueMap = new HashMap<String, String>();  
        // 取出bean里的所有方法  
        Method[] methods = cls.getDeclaredMethods();  
        Field[] fields = cls.getDeclaredFields();  
   
        for (Field field : fields) {  
            try {  
                String fieldType = field.getType().getSimpleName();  
                String fieldGetName = parGetName(field.getName());  
                if (!checkGetMet(methods, fieldGetName)) {  
                    continue;  
                }  
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});  
                Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});  
                String result = null;  
                if ("Date".equals(fieldType)) {  
                    result = fmtDate((Date) fieldVal);  
                } else {  
                    if (null != fieldVal) {  
                        result = String.valueOf(fieldVal);  
                    }  
                }  
                valueMap.put(field.getName(), result);  
            } catch (Exception e) {  
                continue;  
            }  
        }  
        return valueMap;  
   
    }  
   
    /** 
     * set属性的值到Bean 
     * @param bean 
     * @param valMap 
     */ 
    public static void setFieldValue(Object bean, Map<String, String> valMap) {  
        Class<?> cls = bean.getClass();  
        // 取出bean里的所有方法  
        Method[] methods = cls.getDeclaredMethods();  
        Field[] fields = cls.getDeclaredFields();  
   
        for (Field field : fields) {  
            try {  
                String fieldSetName = parSetName(field.getName());  
                if (!checkSetMet(methods, fieldSetName)) {  
                    continue;  
                }  
                Method fieldSetMet = cls.getMethod(fieldSetName, field.getType());  
                String value = valMap.get(field.getName());  
                if (null != value && !"".equals(value)) {  
                    String fieldType = field.getType().getSimpleName();  
                    if ("String".equals(fieldType)) {  
                        fieldSetMet.invoke(bean, value);  
                    } else if ("Date".equals(fieldType)) {  
                        Date temp = parseDate(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Integer".equals(fieldType) || "int".equals(fieldType)) {  
                        Integer intval = Integer.parseInt(value);  
                        fieldSetMet.invoke(bean, intval);  
                    } else if ("Long".equalsIgnoreCase(fieldType)) {  
                        Long temp = Long.parseLong(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Double".equalsIgnoreCase(fieldType)) {  
                        Double temp = Double.parseDouble(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {  
                        Boolean temp = Boolean.parseBoolean(value);  
                        fieldSetMet.invoke(bean, temp);  
                    } else {  
                        System.out.println("not supper type" + fieldType);  
                    }  
                }  
            } catch (Exception e) {  
                continue;  
            }  
        }  
   
    }  
   
    /** 
     * 格式化string为Date 
     * @param datestr 
     * @return date 
     */ 
    private static Date parseDate(String datestr) {  
        if (null == datestr || "".equals(datestr)) {  
            return null;  
        }  
        try {  
            String fmtstr = null;  
            if (datestr.indexOf(':') > 0) {  
                fmtstr = "yyyy-MM-dd HH:mm:ss";  
            } else {  
                fmtstr = "yyyy-MM-dd";  
            }  
            SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);  
            return sdf.parse(datestr);  
        } catch (Exception e) {  
            return null;  
        }  
    }  
    /** 
     * 日期转化为String 
     * @param date 
     * @return date string 
     */ 
    private static String fmtDate(Date date) {  
        if (null == date) {  
            return null;  
        }  
        try {  
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);  
            return sdf.format(date);  
        } catch (Exception e) {  
            return null;  
        }  
    }  
   
    /** 
     * 判断是否存在某属性的 set方法 
     * @param methods 
     * @param fieldSetMet 
     * @return boolean 
     */ 
    private static boolean checkSetMet(Method[] methods, String fieldSetMet) {  
        for (Method met : methods) {  
            if (fieldSetMet.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
    /** 
     * 判断是否存在某属性的 get方法 
     * @param methods 
     * @param fieldGetMet 
     * @return boolean 
     */ 
    private static boolean checkGetMet(Method[] methods, String fieldGetMet) {  
        for (Method met : methods) {  
            if (fieldGetMet.equals(met.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
   
    /** 
     * 拼接某属性的 get方法 
     * @param fieldName 
     * @return String 
     */ 
    private static String parGetName(String fieldName) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return "get" + fieldName.substring(0, 1).toUpperCase()  
                + fieldName.substring(1);  
    }  
    /** 
     * 拼接在某属性的 set方法 
     * @param fieldName 
     * @return String 
     */ 
    private static String parSetName(String fieldName) {  
        if (null == fieldName || "".equals(fieldName)) {  
            return null;  
        }  
        return "set" + fieldName.substring(0, 1).toUpperCase()  
                + fieldName.substring(1);  
    } 
 
}