java反射和内省

java中一个强大的功能，莫过于反射了。通常我们看看的Struct2、Struct1、Spring、Hibernate等等集合无一不使用了反射机制。那么什么是反射呢，到底有什么用呢？

一、反射机制概念

   简单的讲，反射就是通过把指定的类中各种元素成分都映射成相关的反射包中的相应类，使得我们可以动态的调用类的相应成员，比如构造方法、成员方法、成员变量等。它被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。 

Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。 

换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

二、反射的功能：

2.1在运行时判断任意一个对象所属的类  如 aclass.getClass() == bclass.getClass()

2.2在运行时构造任意一个类的对象    如Class.forName(className).netInstance()，className是运行时才得出来的类名

2.3在运行时判段任意一个类所具有的成员变量和方法  

2.4在运行时调用任一个对象的方法 

2.5在运行时创建新类对象 

三、反射API中重点的几个类

Class：Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该Class 对象

      没有构造方法，具体如何获取Class对象的实例，下面的示例代码中将会总结。

      常用的方法用：

         T cast(Object obj) 、static Class<?> forName(String className) 、 ClassLoader getClassLoader() 、 Constructor<T> getConstructor(Class<?>... parameterTypes) 、
         Constructor<?>[] getConstructors() 、  Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)、 Constructor<?>[] getDeclaredConstructors() 、
         Field getDeclaredField(String name)、 Field[] getDeclaredFields() 、Method getDeclaredMethod(String name, Class<?>... parameterTypes)
         Method[] getDeclaredMethods() 、Field getField(String name) 、 Field[] getFields() 、 Method getMethod(String name, Class<?>... parameterTypes)
         Method[] getMethods() 、int getModifiers() 、String getName() 、InputStream getResourceAsStream(String name)、 boolean isArray() 、T newInstance()

Constructor：Constructor 提供关于类的单个构造方法的信息以及对它的访问权限

     没用构造方法，一般都是通过Class对象中的相应类来获得Constructor对象的。

      常用的方法：

        Class<T> getDeclaringClass() 、Class<?>[] getExceptionTypes() 、Type[] getGenericExceptionTypes()、Type[] getGenericParameterTypes() 、
         int getModifiers() 、String getName() 、Class<?>[] getParameterTypes() 、boolean isVarArgs() 、 T newInstance(Object... initargs)

Method：Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

        没有构造方法，也是通常Class对象中相应的方法来获取Method对象。

        常用的方法：

          Class<?> getDeclaringClass() 、int getModifiers() 、String getName() 、Class<?>[] getParameterTypes() 
           Class<?> getReturnType() 、Object invoke(Object obj, Object... args)

Field：Field提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

         没有构造方法，也是通常Class对象中相应的方法来获取Method对象。

        常用的方法：

         Object get(Object obj) 、 int getModifiers() 、String getName() 、Class<?> getType() 、 void set(Object obj, Object value)。另外还支持相应的int getInt(Object obj)

         与void setInt(Object obj, int value)等相应的直接对基本数据类型进行操作。

Modifier：Modifier 类提供了static 方法和常量，对类和成员访问修饰符进行解码。

          这是没有构造方法的，都是通过相应的Class、Constructor、Method、Field类对象得到的，且常用的方法static boolean isPublic(int mod) 、static boolean isPrivate(int mod) 等，用个方法是static String toString(int mod)蛮好用的，此方法是返回描述指定修饰符中的访问修饰符标志的字符串。

四、反射举例代码：

在使用Java的反射功能时，基本首先都要获取类的Class对象，再通过Class对象获取其他的对象

[java]  view plain copy

1. package com.enhance;  
2. import java.lang.reflect.Constructor;  
3. import java.lang.reflect.Field;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Modifier;  
6. import java.util.ArrayList;  
7. import java.util.Arrays;  
8. import java.util.List;  
9.    
10. public class ReflectDemo {  
11.       
12.     private int pos ;  
13.     public String name;  
14.       
15.     private int size ;  
16.     private final static double PI = 3.1415926;  
17.       
18.     private ArrayList<String> alist = new ArrayList<String>();  
19.       
20.     /** 
21.      * 静态方法，反射调用invork时，第一个参数为null即无作用对象，由于也没有参数。 
22.      * 所以最终的反射在调用时，肯定是invork(null)即可。 
23.      * @return 
24.      */  
25.     public static double getPI(){  
26.         return PI;  
27.     }  
28.    
29.     /** 
30.      * @param args 
31.      * @throws Exception  
32.      */  
33.     public static void main(String[] args) throws Exception {  
34.         getClassTest();  
35.         applyReflectChangeObjValDemo();  
36.         reflectInvorkArrayDeom();  
37.         //获取一个类的方法签名、构造函数签名、成员变量等。  
38.         printClass("java.lang.String");  
39.         arraysAsListTest();  
40.           
41.     }  
42.       
43.     public static void getClassTest() throws Exception{  
44.           
45.         /* 
46.         三种方式来获得Class对象，三种方式得出来的对象都是一个都是此类的字节码对象 
47.         1> 对象.getClass() 
48.         2> 类名.class     不会加载类，即不会静态初始化等 
49.         3> Class.forName(完全限定类名)   会加载类，会静态初始化 
50.          */  
51.           
52.         String str1 = "abc";  
53.         Class c1 = str1.getClass();  
54.         Class c2 = String.class;  
55.         Class c3 = Class.forName("java.lang.String");  
56.           
57.         System.out.println("c1==c2::"+(c1==c2));  // true  
58.         System.out.println("c2==c3::"+(c2==c3));  // true  
59.           
60.         //Class对象中用isPrimitive()方法可判断是否基本类型字节码  
61.         System.out.println("c1.isPrimitive()=="+c1.isPrimitive()); //false  
62.           
63.         Class c4 = int.class;  
64.         System.out.println("c1.isPrimitive()=="+c4.isPrimitive()); // true  
65.         System.out.println("c3==c4::"+(c3==c4));  // false    
66.         //包装类，可使用类名.TYPE得到基本类型的Class对象  
67.         Class c5 = Integer.TYPE;  
68.         System.out.println("c4==c5::"+(c4==c5));  // true  
69.           
70.           
71.         //反射得到实例对象的，有两个方法一种是先得到反射中的构造器，通过构造器的newInstance来搞定  
72.         //另一种是直接通过class的newInstance，但这个方法是要求类必须有个无参的构造方法  
73.         Class strCl = Class.forName("java.lang.String");  
74.         Constructor strCon = strCl.getConstructor(StringBuilder.class);  
75.         String str = (String)strCon.newInstance(new StringBuilder("sdf"));  
76.         String strr = (String)strCl.newInstance();  
77.           
78.     }  
79.       
80.     private static void arraysAsListTest() {  
81.         int[] a1 = new int[]{4,5,6};  
82.         List l1 = Arrays.asList(a1);  //因为a1不是object[]数组，不会用jdk1.4中的asList(Object[] objs)来调用  
83.                                       //而是用jdk1.5中的asList(T... args)所以int[]当成了一个Object来传入，此  
84.                                       //此List中只有一个元素，是int[]型的 Object。  
85.         System.out.println(l1+"-----------"+l1.size()); //size为1,只有一个元素  打印的是：[[I@10b30a7]-----------1  
86.         for(int i=0;i<l1.size();i++){  
87.               
88.             System.out.print(l1.get(i)+" ,"); //[I@c17164 只有此元素  
89.         }  
90.     }  
91.    
92.     /* 
93.      * 总结：反射在调用带数组参数的方法时，一定要注意invork方法调用的情况，因为传入invork方法是一个数组的话，编译器会采用JDK1.4折方法特性将数组拆包， 
94.      * 数组中每个元素将作为一个参数传入到相应方法中。这样肯定会与之前的getMethod中的数组.class有冲突，会报 
95.      * java.lang.IllegalArgumentException: wrong number of arguments 参数数量不对了。 
96.      * 为了解决此问题，有两种方法，一种是不让JDK1.4插手，那么就可将数组前面强转成Object，这样编译器会使用JDK1.5的，不会将数组拆包。 
97.      * 如：m1.invoke(rd, (Object)new String[]{"abc","bcd"}); 
98.      * 另一种方法是，还是让JDK1.4编，那么外面再用一个数组包起，这个数组。这样JDK1.4遇到这个数组的数组，拆包后还是一样数组正好与getMethod中是一致的。 
99.      * 如m1.invoke(rd, new Object[]{new String[]{"abc","bcd"}}); 
100.      *  
101.      * */  
102.     private static void reflectInvorkArrayDeom() {  
103.         ReflectDemo rd = new ReflectDemo();  
104.           
105.         Method m1 = null ;  
106.         try{  
107.             Class lc = rd.getClass();  
108.             int[] intArr = new int[]{3,5};  
109.             m1 = lc.getMethod("printIntArray", int[].class);  
110.             m1.invoke(rd, intArr);  
111.               
112.             String[] strArr = new String[]{"abc","bcd"};  
113.             m1 = lc.getMethod("printStringArray", String[].class);  
114.             //m1.invoke(rd, strArr); //这样调用是有问题的，因为在invork方法发现第二个参数是String[]数组  
115.                                 //此时invork会用1.4的Object[]，在1.4中第二个参数会先被拆包，拆成多个参数传与相应的方法中  
116.                                 //但此时已经与getMethod中声明的String[].class有冲突了，所以会报IllegalArgumentException异常  
117.                                 //java.lang.IllegalArgumentException: wrong number of arguments 参数数量不对  
118.             //解决这个问题有两个方法，一是用jdk1.5提供的可变参数，那么为让编译器知道去调用1.5的，那么就要将数组变成一个对象。  
119.             m1.invoke(rd, (Object)strArr);  
120.             //另一个解决方法是，1.4的是不要个数组吗，给个数组它new Object[]，这个数组里呢，再传入个String[]数组，这样编译器在使用1.4的时  
121.             //先将数组拆包后，取去其中元素，正好是一个数组与上面的String[].class是吻合的。即可以调用了。  
122.             m1.invoke(rd, new Object[]{strArr});  
123.               
124.               
125.             Integer[] integerArr = new Integer[]{12,56};  
126.             m1 = lc.getMethod("printIntegerArray", Integer[].class);  
127.             //m1.invoke(rd, integerArr);  同时这样调用也是有问题的  
128.             m1.invoke(rd, (Object)integerArr);  
129.         }catch(Exception e){  
130.             e.printStackTrace();  
131.         }  
132.           
133.     }  
134.    
135.     /** 
136.      * printClass用于打印，运行时才知道来的类，具体哪些构造方法，哪些方法以及哪些变量 
137.      * @param className 
138.      */  
139.     private static void printClass(String className) {  
140.         ArrayList<String> al = new ArrayList<String>();   
141.         Class clazz = null ;  
142.         try {  
143.             clazz = Class.forName(className);  
144.         } catch (ClassNotFoundException e) {  
145.             throw new RuntimeException("类名有问题，请重新输入");  
146.               
147.         }  
148.         String modifierName = Modifier.toString(clazz.getModifiers());  
149.         StringBuilder sb = new StringBuilder();  
150.         if(modifierName != null && modifierName.length()>0){  
151.             sb.append(modifierName);  
152.         }  
153.           
154.         sb.append(" "+clazz.getName()+"{");  
155.         sb.append(System.getProperty("line.separator"));  
156.         printConstructors(clazz,sb);  
157.         printMethods(clazz,sb);  
158.         printFields(clazz,sb);  
159.           
160.         sb.append(System.getProperty("line.separator"));  
161.         sb.append("}");  
162.         System.out.println(sb.toString());  
163.     }  
164.    
165.     /** 
166.      * 打印运行时类的，变量。 
167.      * @param clazz 运行时类的字节码 
168.      * @param sb 打印的内容先用StringBuilder缓存下 
169.      */  
170.     private static void printFields(Class clazz, StringBuilder sb) {  
171.         sb.append(System.getProperty("line.separator"));  
172.         sb.append("\t");  
173.         Field[] fields = clazz.getFields();  
174.         for(Field field:fields){  
175.             sb.append(Modifier.toString(field.getModifiers()));  
176.             sb.append(field.getName());  
177.             sb.append(System.getProperty("line.separator"));  
178.             sb.append("\t");  
179.         }  
180.     }  
181.    
182.     /** 
183.      * 打印运行时类的方法。 
184.      * @param clazz 运行时类的字节码 
185.      * @param sb 打印的内容先用StringBuilder缓存下 
186.      */  
187.     private static void printMethods(Class clazz, StringBuilder sb) {  
188.         sb.append(System.getProperty("line.separator"));  
189.         sb.append("\t");  
190.         Method[] methods = clazz.getMethods();  
191.         for(Method method:methods){  
192.             Class[] paraClasses = method.getParameterTypes();  
193.             sb.append(Modifier.toString(method.getModifiers()));  
194.             sb.append(" "+method.getName()+"(");  
195.             for(Class paraClass: paraClasses){  
196.                 sb.append(paraClass.getName()+",");  
197.             }  
198.             if(null != paraClasses && 0 != paraClasses.length){  
199.                 sb.deleteCharAt(sb.length()-1);  
200.             }  
201.             sb.append(")");  
202.             sb.append(System.getProperty("line.separator"));  
203.             sb.append("\t");  
204.         }  
205.     }  
206.    
207.     /** 
208.      * 打印运行时类的构造方法。 
209.      * @param clazz 运行时类的字节码 
210.      * @param sb 打印的内容先用StringBuilder缓存下 
211.      */  
212.     private static void printConstructors(Class clazz,StringBuilder sb) {  
213.         sb.append("\t");  
214.         Constructor[] cons = clazz.getConstructors();  
215.         for(Constructor con : cons){  
216.             String conModifier = Modifier.toString(con.getModifiers());  
217.             sb.append(conModifier);  
218.             sb.append(" "+con.getName()+"(");  
219.             Class[] types = con.getParameterTypes();  
220.             for(Class type:types){  
221.                 sb.append(type.getName()+",");  
222.             }  
223.             if(null!=types && 0 !=types.length){  
224.                 sb.deleteCharAt(sb.length()-1); //删除最后一个逗号,字符  
225.             }  
226.             sb.append(")");  
227.             sb.append(System.getProperty("line.separator"));  
228.             sb.append("\t");  
229.         }  
230.     }  
231.    
232.    
233.     /** 
234.      * 测试反射运行时得到的方法及变量，如何调用，如何设置值。 
235.      */  
236.     private static void applyReflectChangeObjValDemo() {  
237.         ReflectDemo rd = new ReflectDemo();  
238.       
239.         Method m1 = null ;  
240.         try{  
241.             Class lc = rd.getClass();  
242.             m1 = lc.getMethod("setName", String.class);  //setName方法，有参数参数是String的。  
243.             Boolean b = (Boolean)m1.invoke(rd, "four");  
244.             System.out.println("---------------:"+rd.getName());  
245.             rd.setSize(21);  
246.             m1 = lc.getMethod("getSize");  
247.             Integer size = (Integer)m1.invoke(rd); //getSize方法返回int，没有参数。  
248.             System.out.println("Size大小：："+size);  
249.               
250.             m1 = lc.getMethod("getPI");  
251.             Double d = (Double)m1.invoke(null); //静态方法，无参数且返回为double，静态方法第一个参数肯定是null，第二参数若无参数则空起来即可。  
252.             System.out.println("PI的值为：："+d.doubleValue());  
253.               
254.             Field f = lc.getDeclaredField("pos");  //私有的成员变量，反射想拿到的话，必须用getDeclaredField  
255.             f.setAccessible(true);   //私有的成员变量，反射想访问的话，必须setAccessible为true  
256.             int value = 88;  
257.             f.set(rd, value);  
258.             System.out.println("------pos为---"+rd.getPos());  
259.             f.set(rd, size);  
260.             System.out.println("-----恢复pos后为---"+rd.getPos());  
261.               
262.             rd.setName("sdfasdf");  
263.             f = lc.getField("name");  
264.             System.out.println("------------name的值为-------::"+f.get(rd));  
265.             f.set(rd, "zhangsan");  
266.             System.out.println("------------name的值为-------::"+f.get(rd));  
267.               
268.         }catch(Exception e){  
269.             e.printStackTrace();  
270.             System.out.println("异常了------------------------------------------");  
271.         }  
272.           
273.     }  
274.    
275.     /** 
276.      * 理解，反射作用于数组时内容是采用什么机制的。需要注意JDK1.4与JDK1.5 反射数组的不同。 
277.      * @param args 
278.      */  
279.     public static void printIntArray(int[] args){  
280.         System.out.println("------printIntArray invorked---------");  
281.         for(int arg:args){  
282.             System.out.println(arg);  
283.         }  
284.           
285.     }  
286.       
287.     public static void printStringArray(String[] args){  
288.         System.out.println("------printStringArray invorked---------");  
289.         for(String arg:args){  
290.             System.out.println(arg);  
291.         }  
292.           
293.     }  
294.       
295.     public static void printIntegerArray(Integer... args){  
296.         System.out.println("------printIntegerArray invorked---------");  
297.         for(Integer arg:args){  
298.             System.out.println(arg);  
299.         }  
300.     }  
301.       
302.     public int getPos() {  
303.         return pos;  
304.     }  
305.    
306.     public void setPos(int pos) {  
307.         this.pos = pos;  
308.     }  
309.    
310.     public String getName() {  
311.         return name;  
312.     }  
313.    
314.     public void setName(String name) {  
315.         this.name = name;  
316.     }  
317.    
318.     public int getSize() {  
319.         return size;  
320.     }  
321.    
322.     public void setSize(int size) {  
323.         this.size = size;  
324.     }  
325.    
326.     public ArrayList<String> getAlist() {  
327.         return alist;  
328.     }  
329.    
330.     public void setAlist(ArrayList<String> alist) {  
331.         this.alist = alist;  
332.     }  
333.    
334. }  

需要注意：反射在调用带数组参数的方法时，一定要注意invork方法调用的情况，因为传入invork方法是一个数组的话，编译器会采用JDK1.4折方法特性将数组拆包，数组中每个元素将作为一个参数传入到相应方法中。这样肯定会与之前的getMethod中的数组.class有冲突，会报java.lang.IllegalArgumentException: wrong number of arguments 参数数量不对了。

为了解决此问题，有两种方法，
一种是不让JDK1.4插手，那么就可将数组前面强转成Object，这样编译器会使用JDK1.5的，不会将数组拆包。如：m1.invoke(rd, (Object)new String[]{"abc","bcd"});
另一种方法是，还是让JDK1.4编，那么外面再用一个数组包起，这个数组。这样JDK1.4遇到这个数组的数组，拆包后还是一样数组正好与getMethod中是一致的。如m1.invoke(rd, new Object[]{new String[]{"abc","bcd"}});

五、内省

内省对应的英文单词为IntroSpector，它主要用于对JavaBean进行操作，JavaBean是一种特殊的Java类，其中的某些方法符合某种命名规则，如果一个Java类中的一些方法符合某种命名规则，则可以把它当作JavaBean来使用。通常的JavaBean是满足有setter与getter方法，且方法名去掉set前缀后，若第二个字母是小写，则属性名为第一个字母小写后的方法名后缀如setXxx 则 属性名为xxx。而若第二个字母也是小写，则属性名是去掉前缀后所有的后缀，如setCPU，则CPU为属性名。这点在后期学习的el表代式都有应用。

操作JavaBean另一个方法的工具包是BeanUtils，它需要loggin包的支持。

BeanUtils 官方下载地址：http://commons.apache.org/beanutils/

Logging 官方下载地址：http://commons.apache.org/logging/

具体示例代码：

[java]  view plain copy

1. package com.enhance;  
2.    
3. import java.beans.BeanInfo;  
4. import java.beans.IntrospectionException;  
5. import java.beans.Introspector;  
6. import java.beans.PropertyDescriptor;  
7. import java.lang.reflect.InvocationTargetException;  
8. import java.lang.reflect.Method;  
9. import java.util.ArrayList;  
10. import java.util.Arrays;  
11. import java.util.HashMap;  
12. import java.util.Map;  
13.    
14. import org.apache.commons.beanutils.BeanUtils;  
15. import org.apache.commons.beanutils.PropertyUtils;  
16.    
17. /** 
18.  * 内省对应的英文单词为IntroSpector，它主要用于对JavaBean进行操作，JavaBean是一种特殊的Java类， 
19.  * 其中的某些方法符合某种命名规则，如果一个Java类中的一些方法符合某种命名规则，则可以把它当作JavaBean来使用。 
20.  * 通常的JavaBean是满足有setter与getter方法，且方法名去掉set前缀后，若第二个字母是小写，则属性名为第一个字母小写后的方法名后缀 
21.  * 如setXxx 则 属性名为xxx。而若第二个字母也是小写，则属性名是去掉前缀后所有的后缀，如setCPU，则CPU为属性名。这点在后期学习的el表代式都有应用。 
22.  *  
23.  * */  
24. public class IntroSpectorDemo {  
25.       
26.     public static void main(String[] args){  
27.           
28.         ReflectDemo rfd = new ReflectDemo();  
29.         rfd.setName("zhangsan");  
30.         rfd.setPos(0);  
31.         rfd.setSize(3);  
32.         ArrayList<String> al = new ArrayList<String>();  
33.         al.add("abc");  
34.         al.add("bcd");  
35.         rfd.setAlist(al);  
36.           
37.         propertyDescriptorDemo(rfd);  
38.         //beanInfo无法一次的得到某一个属性的PropertyDescriptor。  
39.         //BeanInfo需要通过Introspector来获取  
40.         beanInfoDemo(rfd);  
41.         beanUtilsDemo(rfd);  
42.     }  
43.    
44.     private static void beanUtilsDemo(ReflectDemo rfd) {  
45.         String name = null;  
46.         PropertyDescriptor pd = null ;  
47.         try{  
48.             //通过BeanUtils的getProperty方法，获得属性的值  
49.             name = BeanUtils.getProperty(rfd, "name");  
50.             System.out.println(name);  
51.             //通过BeanUtils的setProperty方法，获得属性的值  
52.             BeanUtils.setProperty(rfd, "name", "wangwu");  
53.             System.out.println(rfd.getName());  
54.             //通过BeanUtils反射，若属性是List集合则只能得到集合中的第一个元素  
55.             name = BeanUtils.getProperty(rfd, "alist");  
56.             System.out.println(name);  
57.               
58.             //但Collection等集合中的元素可以通过getArrayPropertys来获取元素中每个值  
59.             String[] names = BeanUtils.getArrayProperty(rfd, "alist");  
60.             System.out.println("------alist-------::"+Arrays.toString(names));  
61.               
62.             //用PropertyDescriptor来拿属性的值  
63.             pd = new PropertyDescriptor("alist",rfd.getClass());  
64.             Class propClazz = pd.getPropertyType();  
65.             System.out.println("属性的类型为::"+propClazz.getName());  
66.               
67.             Method readMethod = pd.getReadMethod();  
68.             Object obj = readMethod.invoke(rfd);  
69.             System.out.println(obj.getClass().isArray());  //false，不是数组  
70.             ArrayList<String> alist = (ArrayList<String>)obj;  
71.             System.out.println(alist);  
72.               
73.             System.out.println("----------------隔开，下面测试用Map的方式来玩转BeanUtils---------------");  
74.             Map<String,Integer> map = new HashMap<String,Integer>();  
75.             map.put("size", 88);  
76.             map.put("age", 28);  
77.               
78.             //BeanUtils可以直接操作Map对象，来获取其中的键值对呢   
79.             String sizeStr = BeanUtils.getProperty(map, "size");  
80.             String ageStr = BeanUtils.getProperty(map, "age");  
81.             System.out.println("[size="+sizeStr+",age="+ageStr+"]");  
82.             //还有个相似的类就是PropertyUtils，它与BeanUtils的区别是，getProperty返回的是属性的实际类型，  
83.             //setProperty时，也就将实现类型值传下其中，而不像BeanUtils都是字符串，返回的是字符串，set设置时也是字符串。  
84.             Integer age = (Integer)PropertyUtils.getProperty(map, "age");  
85.             System.out.println(age);  
86.               
87.         }catch(Exception e){  
88.             e.printStackTrace();  
89.         }  
90.     }  
91.    
92.     private static void beanInfoDemo(ReflectDemo rfd) {  
93.         BeanInfo bi = null;  
94.         String propName = "name";  
95.         try {  
96.             bi = Introspector.getBeanInfo(rfd.getClass());  
97.             PropertyDescriptor[] pds = bi.getPropertyDescriptors();  
98.             for(PropertyDescriptor pd:pds){  
99.                 if(propName.equals(pd.getName())){  
100.                     System.out.println("beaninfo得到PropertyDescriptors数组后，再迭代PropertyDescriptor，得到name的值：："+pd.getReadMethod().invoke(rfd));                   
101.                 }  
102.             }  
103.               
104.         } catch (Exception e) {  
105.             e.printStackTrace();  
106.         }  
107.           
108.           
109.     }  
110.    
111.     private static void propertyDescriptorDemo(ReflectDemo rfd) {  
112.           
113.         //牛逼的PropertyDescriptor类，可以对符合JavaBean属性的方法进行操作呢，直接得到getReadMethod与getWriteMethod  
114.         PropertyDescriptor pd = null ;  
115.           
116.         try {  
117.             pd = new PropertyDescriptor("name",rfd.getClass());  
118.             Class propClazz = pd.getPropertyType();  
119.             System.out.println("属性的类型为::"+propClazz.getName());  
120.               
121.             Method readMethod = pd.getReadMethod();  
122.             Method writeMethod = pd.getWriteMethod();  
123.               
124.             //调用读方法，读取目前name中的值  
125.             System.out.println("调用读方法，读name的值为：："+readMethod.invoke(rfd));  
126.               
127.             //调用写方法，设置name中的值  
128.             writeMethod.invoke(rfd, "lisi");  
129.             System.out.println("调用写方法，将name的值改变后为：："+rfd.getName());  
130.               
131.         } catch (IntrospectionException e) {  
132.             e.printStackTrace();  
133.         }catch (IllegalArgumentException e) {  
134.             e.printStackTrace();  
135.         } catch (IllegalAccessException e) {  
136.             e.printStackTrace();  
137.         } catch (InvocationTargetException e) {  
138.             e.printStackTrace();  
139.         }  
140.     }  
141.    
142. }  

转自:http://blog.csdn.net/luqin1988/article/details/8019374