传智播客Spring2.5视频教程_编码剖析Spring依赖注入的原理 4

出处http://kdisk-sina-com.javaeye.com/blog/230995

2008-08-21

反射 (Reflection) 和内省 (Introspector)

关键字: reflection, introspector
很多朋友在深入的接触 JAVA 语言后就会发现这样两个词：反射 (Reflection) 和内省 (Introspector) ，经常搞不清楚这到底是怎么回事，在什么场合下应用以及如何使用？今天把这二者放在一起介绍，因为它们二者是相辅相成的。

反射

相对而言，反射比内省更容易理解一点。用一句比较白的话来概括，反射就是让你可以通过名称来得到对象 ( 类，属性，方法 ) 的技术。例如我们可以通过类名来生成一个类的实例；知道了方法名，就可以调用这个方法；知道了属性名就可以访问这个属性的值。

还是写两个例子让大家更直观的了解反射的使用方法：

Java代码



引用

//通过类名来构造一个类的实例

Class cls_str = Class.forName( "java.lang.String" );

// 上面这句很眼熟，因为使用过 JDBC 访问数据库的人都用过 J

Object str = cls_str.newInstance();

// 相当于 String str = new String();

//通过方法名来调用一个方法

String methodName = "length" ;

Method m = cls_str.getMethod(methodName, null );

System.out.println( "length is " + m.invoke(str, null ));

// 相当于 System.out.println(str.length());

引用
//通过类名来构造一个类的实例
Class cls_str = Class.forName( "java.lang.String" );
// 上面这句很眼熟，因为使用过 JDBC 访问数据库的人都用过 J
Object str = cls_str.newInstance();
// 相当于 String str = new String();
//通过方法名来调用一个方法
String methodName = "length" ;
Method m = cls_str.getMethod(methodName, null );
System.out.println( "length is " + m.invoke(str, null ));
// 相当于 System.out.println(str.length());

上面的两个例子是比较常用方法。看到上面的例子就有人要发问了：为什么要这么麻烦呢？本来一条语句就完成的事情干吗要整这么复杂？没错，在上面的例子中确实没有必要这么麻烦。不过你想像这样一个应用程序，它支持动态的功能扩展，也就是说程序不重新启动但是可以自动加载新的功能，这个功能使用一个具体类来表示。首先我们必须为这些功能定义一个接口类，然后我们要求所有扩展的功能类必须实现我指定的接口，这个规定了应用程序和可扩展功能之间的接口规则，但是怎么动态加载呢？我们必须让应用程序知道要扩展的功能类的类名，比如是 test.Func1 ，当我们把这个类名 ( 字符串 ) 告诉应用程序后，它就可以使用我们第一个例子的方法来加载并启用新的功能。这就是类的反射，请问你有别的选择吗？

关于方法的反射建议大家看我的另外一篇文章《 利用 Turbine 的事件映射来扩展 Struts 的功能 》，地址是： http://www.javayou.com/article/CSDN/extend_struts.html 。这篇文章详细介绍了如果通过反射来扩展 Struts 框架的功能。

内省

内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中。

一般的做法是通过类 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方法。下面我们来看一个例子，这个例子把某个对象的所有属性名称和值都打印出来：

Java代码



引用

/*

* Created on 2004-6-29

*/

package demo;

import java.beans.BeanInfo;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

/**

* 内省演示例子

* @author liudong

*/

public class IntrospectorDemo {

String name;

public static void main(String[] args) throws Exception{

IntrospectorDemo demo = new IntrospectorDemo();

demo.setName( "Winter Lau" );

// 如果不想把父类的属性也列出来的话，

// 那 getBeanInfo 的第二个参数填写父类的信息

BeanInfo bi = Introspector.getBeanInfo(demo.getClass(), Object. class );

PropertyDescriptor[] props = bi.getPropertyDescriptors();

for ( int i=0;i<props.length;i++){

System.out.println(props[i].getName()+ "=" +

props[i].getReadMethod().invoke(demo, null ));

}

}

public String getName() {

return name;

}

public void setName(String name) {

this .name = name;

}

}

引用
/*
* Created on 2004-6-29
*/

package demo;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

/**
* 内省演示例子
* @author liudong
*/

public class IntrospectorDemo {
String name;
public static void main(String[] args) throws Exception{
IntrospectorDemo demo = new IntrospectorDemo();
demo.setName( "Winter Lau" );

// 如果不想把父类的属性也列出来的话，
// 那 getBeanInfo 的第二个参数填写父类的信息
BeanInfo bi = Introspector.getBeanInfo(demo.getClass(), Object. class );
PropertyDescriptor[] props = bi.getPropertyDescriptors();
for ( int i=0;i<props.length;i++){
System.out.println(props[i].getName()+ "=" +
props[i].getReadMethod().invoke(demo, null ));
}

}

public String getName() {
return name;
}

public void setName(String name) {
this .name = name;
}
}

Web 开发框架 Struts 中的 FormBean 就是通过内省机制来将表单中的数据映射到类的属性上，因此要求 FormBean 的每个属性要有 getter/setter 方法。但也并不总是这样，什么意思呢？就是说对一个 Bean 类来讲，我可以没有属性，但是只要有 getter/setter 方法中的其中一个，那么 Java 的内省机制就会认为存在一个属性，比如类中有方法 setMobile ，那么就认为存在一个 mobile 的属性，这样可以方便我们把 Bean 类通过一个接口来定义而不用去关心具体实现，不用去关心 Bean 中数据的存储。比如我们可以把所有的 getter/setter 方法放到接口里定义，但是真正数据的存取则是在具体类中去实现，这样可提高系统的扩展性。

总结
将 Java 的反射以及内省应用到程序设计中去可以大大的提供程序的智能化和可扩展性。有很多项目都是采取这两种技术来实现其核心功能，例如我们前面提到的 Struts ，还有用于处理 XML 文件的 Digester 项目，其实应该说几乎所有的项目都或多或少的采用这两种技术。在实际应用过程中二者要相互结合方能发挥真正的智能化以及高度可扩展性。
！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
·································································································································································

2008-08-21

类Introspector的使用

关键字: introspector

Java代码



import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

import java.beans.*;

import java.io.*;

import java.lang.reflect.Method;

public class myBeanIntrospector

{

public myBeanIntrospector()

{

try

{

//实例化一个Bean

Student beanObj = new Student();

//依据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();

}

}