java 自省 使用

1. import javax.swing.*;  
2. import java.awt.*;  
3. import java.awt.event.*;  
4. import java.beans.*;  
5. import java.io.*;  
6. import java.lang.reflect.Method;  
7. public class myBeanIntrospector  
8. {  
9.  public myBeanIntrospector()  
10.  {  
11.   try  
12.   {  
13.    //实例化一个Bean  
14.    Student beanObj = new Student();  
15.    //依据Bean产生一个相关的BeanInfo类  
16.    BeanInfo bInfoObject =   
17.    Introspector.getBeanInfo(beanObj.getClass(),beanObj.getClass().getSuperclass());  
18.    //定义一个用于显示的字符串  
19.    String output = "";  
20.   
21.    //开始自省  
22.    
23.    /* 
24.    * BeanInfo.getMethodDescriptors() 
25.    * 用于获取该Bean中的所有允许公开的成员方法，以MethodDescriptor数组的形式返回 
26.    * 
27.    * MethodDescriptor类 
28.    * 用于记载一个成员方法的所有信息 
29.    * MethodDescriptor.getName() 
30.    * 获得该方法的方法名字 
31.    * MethodDescriptor.getMethod() 
32.    * 获得该方法的方法对象（Method类） 
33.    * 
34.    * Method类 
35.    * 记载一个具体的的方法的所有信息 
36.    * Method.getParameterTypes() 
37.    * 获得该方法所用到的所有参数，以Class数组的形式返回 
38.    * 
39.    * Class..getName() 
40.    * 获得该类型的名字 
41.    */  
42.    output = "内省成员方法：\n";  
43.    MethodDescriptor[] mDescArray = bInfoObject.getMethodDescriptors();  
44.    for (int i=0;i<mDescArray.length ;i++ )  
45.    {  
46.     //获得一个成员方法描述器所代表的方法的名字  
47.     String methodName = mDescArray[i].getName();  
48.       
49.     String methodParams = new String();  
50.     //获得该方法对象  
51.     Method methodObj = mDescArray[i].getMethod();  
52.     //通过方法对象获得该方法的所有参数，以Class数组的形式返回  
53.     Class[] parameters = methodObj.getParameterTypes();  
54.     if (parameters.length>0)  
55.     {  
56.      //获得参数的类型的名字  
57.      methodParams = parameters[0].getName();  
58.      for (int j=1;j<parameters.length ;j++ )  
59.      {  
60.       methodParams = methodParams + "," + parameters[j].getName();  
61.      }  
62.     }  
63.     output += methodName + "(" + methodParams + ")\n";  
64.    }  
65.    System.out.println(output);  
66.    
67.    /* 
68.    * BeanInfo.getPropertyDescriptors() 
69.    * 用于获取该Bean中的所有允许公开的成员属性，以PropertyDescriptor数组的形式返回 
70.    * 
71.    * PropertyDescriptor类 
72.    * 用于描述一个成员属性 
73.    * 
74.    * PropertyDescriptor.getName() 
75.    * 获得该属性的名字 
76.    * 
77.    * PropertyDescriptor.getPropertyType() 
78.    * 获得该属性的数据类型，以Class的形式给出 
79.    * 
80.    */  
81.    output = "内省成员属性：\n";  
82.    PropertyDescriptor[] mPropertyArray = bInfoObject.getPropertyDescriptors();  
83.    for (int i=0;i<mPropertyArray.length ;i++ )  
84.    {  
85.     String propertyName = mPropertyArray[i].getName();  
86.     Class propertyType = mPropertyArray[i].getPropertyType();  
87.     output += propertyName + " ( " + propertyType.getName() + " )\n";  
88.    }  
89.    System.out.println(output);  
90.    
91.   
92.    /* 
93.    * BeanInfo.getEventSetDescriptors() 
94.    * 用于获取该Bean中的所有允许公开的成员事件，以EventSetDescriptor数组的形式返回 
95.    * 
96.    * EventSetDescriptor类 
97.    * 用于描述一个成员事件 
98.    * 
99.    * EventSetDescriptor.getName() 
100.    * 获得该事件的名字 
101.    * 
102.    * EventSetDescriptor.getListenerType() 
103.    * 获得该事件所依赖的事件监听器，以Class的形式给出 
104.    * 
105.    */  
106.    output = "内省绑定事件：\n";  
107.    EventSetDescriptor[] mEventArray = bInfoObject.getEventSetDescriptors();  
108.    for (int i=0;i<mEventArray.length ;i++ )  
109.    {  
110.     String EventName = mEventArray[i].getName();  
111.     Class listenerType = mEventArray[i].getListenerType();  
112.     output += EventName + "(" + listenerType.getName() + ")\n";  
113.    }  
114.    System.out.println(output);  
115.    System.out.println("write by esonghui :)");  
116.    
117.   }  
118.   catch (Exception e)  
119.   {  
120.    System.out.println("异常：" + e);  
121.   }  
122.  }  
123.  public static void main(String[] args)   
124.  {  
125.   new myBeanIntrospector();  
126.  }  
127. }