java——-檢討機制（代碼例子）-

相對而言，反射比內省更容易理解一點。用一句比較白的話來歸納，反射就是讓你能夠經過名稱來獲得對象 ( 類，屬性，方法 ) 的技術，這種技術比內省機制使用範圍更普遍。例如咱們能夠經過類名來生成一個類的實例；知道了方法名，就能夠調用這個方法；知道了屬性名就能夠訪問這個屬性的值。 內省是 Java 語言對 Bean 類屬性、事件的一種缺省處理方法。例如類 A 中有屬性 name, 那咱們能夠經過 getName,setName 來獲得其值或者設置新的值。經過 getName/setName 來訪問 name 屬性，這就是默認的規則。 Java 中提供了一套 API 用來訪問某個屬性的 getter/setter 方法，經過這些 API 能夠使你不須要了解這個規則（但你最好仍是要搞清楚），這些 API 存放於包 java.beans 中。 
通常的作法是經過類 Introspector 來獲取某個對象的 BeanInfo 信息，而後經過 BeanInfo 來獲取屬性的描述器（ PropertyDescriptor ），經過這個屬性描述器就能夠獲取某個屬性對應的 getter/setter 方法，而後咱們就能夠經過反射機制來調用這些方法。下面咱們來看一個例子，這個例子把某個對象的全部屬性名稱和值都打印出來：

package MyTest;     
public class bean {     
        private String id = null ;     
        private String name = null ;     
    
        public String getId() {     
                return id;     
        }     
        public void setId(String id) {     
                this.id = id;     
        }     
    
        public String getName() {     
                return name;     
        }     
        public void setName(String name) {     
                this.name = name;     
        }     
}     
    
package MyTest;     
import java.beans.BeanInfo;     
import java.beans.EventSetDescriptor;     
import java.beans.Introspector;     
import java.beans.MethodDescriptor;     
import java.beans.PropertyDescriptor;     
import java.lang.reflect.Method;     
public class myBeanIntrospector {     
public myBeanIntrospector()        
  {        
   try       
   {        
    //實例化一個Bean        
    bean beanObj = new bean();        
    //依據Bean產生一個相關的BeanInfo類        
    BeanInfo bInfoObject =         
    Introspector.getBeanInfo(beanObj.getClass(),beanObj.getClass().getSuperclass());        
    //定義一個用於顯示的字符串        
    String output = "";        
        
    //開始自省        
          
    /*     
    * BeanInfo.getMethodDescriptors()     
    * 用於獲取該Bean中的全部容許公開的成員方法，以MethodDescriptor數組的形式返回     
    *     
    * MethodDescriptor類     
    * 用於記載一個成員方法的全部信息     
    * MethodDescriptor.getName()     
    * 得到該方法的方法名字     
    * MethodDescriptor.getMethod()     
    * 得到該方法的方法對象（Method類）     
    *     
    * Method類     
    * 記載一個具體的的方法的全部信息     
    * Method.getParameterTypes()     
    * 得到該方法所用到的全部參數，以Class數組的形式返回     
    *     
    * Class..getName()     
    * 得到該類型的名字     
    */       
    output = "內省成員方法：/n";        
    MethodDescriptor[] mDescArray = bInfoObject.getMethodDescriptors();        
    for (int i=0;i<mDescArray.length ;i++ )        
    {        
     //得到一個成員方法描述器所表明的方法的名字        
     String methodName = mDescArray[i].getName();        
             
     String methodParams = new String();        
     //得到該方法對象        
     Method methodObj = mDescArray[i].getMethod();        
     //經過方法對象得到該方法的全部參數，以Class數組的形式返回        
     Class[] parameters = methodObj.getParameterTypes();        
     if (parameters.length>0)        
     {        
      //得到參數的類型的名字        
      methodParams = parameters[0].getName();        
      for (int j=1;j<parameters.length ;j++ )        
      {        
       methodParams = methodParams + "," + parameters[j].getName();        
      }        
     }        
     output += methodName + "(" + methodParams + ")/n";        
    }        
    System.out.println(output);        
          
    /*     
    * BeanInfo.getPropertyDescriptors()     
    * 用於獲取該Bean中的全部容許公開的成員屬性，以PropertyDescriptor數組的形式返回     
    *     
    * PropertyDescriptor類     
    * 用於描述一個成員屬性     
    *     
    * PropertyDescriptor.getName()     
    * 得到該屬性的名字     
    *     
    * PropertyDescriptor.getPropertyType()     
    * 得到該屬性的數據類型，以Class的形式給出     
    *     
    */       
    output = "內省成員屬性：/n";        
    PropertyDescriptor[] mPropertyArray = bInfoObject.getPropertyDescriptors();        
    for (int i=0;i<mPropertyArray.length ;i++ )        
    {        
     String propertyName = mPropertyArray[i].getName();        
     Class propertyType = mPropertyArray[i].getPropertyType();        
     output += propertyName + " ( " + propertyType.getName() + " )/n";        
    }        
    System.out.println(output);        
          
        
    /*     
    * BeanInfo.getEventSetDescriptors()     
    * 用於獲取該Bean中的全部容許公開的成員事件，以EventSetDescriptor數組的形式返回     
    *     
    * EventSetDescriptor類     
    * 用於描述一個成員事件     
    *     
    * EventSetDescriptor.getName()     
    * 得到該事件的名字     
    *     
    * EventSetDescriptor.getListenerType()     
    * 得到該事件所依賴的事件監聽器，以Class的形式給出     
    *     
    */       
    output = "內省綁定事件：/n";        
    EventSetDescriptor[] mEventArray = bInfoObject.getEventSetDescriptors();        
    for (int i=0;i<mEventArray.length ;i++ )        
    {        
     String EventName = mEventArray[i].getName();        
     Class listenerType = mEventArray[i].getListenerType();        
     output += EventName + "(" + listenerType.getName() + ")/n";        
    }        
    System.out.println(output);        
    System.out.println("write by esonghui :");        
          
   }        
   catch (Exception e)        
   {        
    System.out.println("異常：" + e);        
   }        
  }        
  public static void main(String[] args)         
  {        
   new myBeanIntrospector();        
  }        
}