JAVA的内省机制(introspector)与反射机制(reflection)

原创 2012年03月22日 22:07:04

相对而言,反射比内省更容易理解一点。用一句比较白的话来概括,反射就是让你可以通过名称来得到对象 ( 类,属性,方法 ) 的技术,这种技术比内省机制使用范围更广泛。例如我们可以通过类名来生成一个类的实例;知道了方法名,就可以调用这个方法;知道了属性名就可以访问这个属性的值。 内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性,这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法,通过这些 API 可以使你不需要了解这个规则(但你最好还是要搞清楚),这些 API 存放于包 java.beans 中。
一般的做法是通过类 Introspector 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器( PropertyDescriptor ),通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。下面我们来看一个例子,这个例子把某个对象的所有属性名称和值都打印出来:

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

JAVA的内省机制(introspector)与反射机制(reflection)

 相对而言,反射比内省更容易理解一点。用一句比较白的话来概括,反射就是让你可以通过名称来得到对象 ( 类,属性,方法 ) 的技术,这种技术比内省机制使用范围更广泛。例如我们可以通过类名来生成一个类的实...
  • zgmzyr
  • zgmzyr
  • 2010年07月21日 17:19
  • 4416

java 反射(Reflection)和内省(Introspector)

总论: java中所有对象(object)不是引用类型(reference)就是基本类型(primitive)。不管什么类型对象,java虚拟机都会为之实例化一个 java.lang.Class的不可...
  • sam_linux
  • sam_linux
  • 2013年10月21日 21:45
  • 1860

JAVA Introspector内省用法

package cn.itcat.introspector; import java.beans.BeanInfo; import java.beans.Introspector; import ja...
  • dlj949611520
  • dlj949611520
  • 2016年04月15日 20:24
  • 594

Java内省机制IntroSpector

内省(IntroSpector)是Java语言对JavaBean 类属性、事件的一种处理方法。 例如类A中有属性name, 那我们可以通过getName,setName 来得到其值或者设置新的值。 通...
  • conquer0715
  • conquer0715
  • 2015年01月17日 15:39
  • 3982

Java:内省(Introspector)深入理解

内省(Introspector) 是Java 语言对 JavaBean 类属性、事件的一种缺省处理方法。   JavaBean是一种特殊的类,主要用于传递数据信息,这种类中的方法主要用于访问私有...
  • zmx729618
  • zmx729618
  • 2016年05月05日 09:30
  • 2679

JAVA内省(Introspector)

'ɪntrəspektɜ 什么是Java内省:内省是Java语言对Bean类属性、事件的一种缺省处理方法。 Java内省的作用:一般在开发框架时,当需要操作一个JavaBean时,如果一直用反射来操作...
  • x605940745
  • x605940745
  • 2014年03月01日 23:29
  • 3430

Java进阶之reflection(反射机制)——反射概念与基础

这里写链接内容  反射机制是Java动态性之一,而说到动态性首先得了解动态语言。那么何为动态语言?一、动态语言动态语言,是指程序在运行时可以改变其结构:新的函数可以引进,已有的函数可以被删除等结构上的...
  • xu__cg
  • xu__cg
  • 2016年10月20日 22:00
  • 2615

JAVA的内省机制(introspector)与反射机制(reflection)

相对而言,反射比内省更容易理解一点。用一句比较白的话来概括,反射就是让你可以通过名称来得到对象 ( 类,属性,方法 ) 的技术,这种技术比内省机制使用范围更广泛。例如我们可以通过类名来生成一个类的实例...
  • zoumin123456
  • zoumin123456
  • 2015年11月08日 18:18
  • 203

《JavaBean》-----Java的内省机制

在之前做过的项目中,都涉及到了前后台的交互,当我们将前台页面上获得的参数传递到后台的时候,我们可以利用很多方法,譬如用Ajax的表单提交,或者直接用JQuery封装的Ajax传递。当我们传递到后台的时...
  • u013067402
  • u013067402
  • 2016年08月05日 20:26
  • 1363

Java内省机制小总结

Java内省机制小总结 Java中的反射机制是通过名称得到类的方法和对象的成份,对于一切Java类都是适用的,但是有时候使用起来比较麻烦。而JavaBean是一种特殊的Java类,遵守JavaBean...
  • changqianger
  • changqianger
  • 2015年04月28日 20:32
  • 852
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA的内省机制(introspector)与反射机制(reflection)
举报原因:
原因补充:

(最多只允许输入30个字)