Introspector

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. }