风太少 2005-08-15 13:23 发表评论

我在几个月前曾经发表过一个帖子，就是和大家一起学习struts源代码。成为一名合格的程序员，阅读大量的优秀程序是必不可少的。只看书是不会让你水平有很大提高的，要多看多写。
本来是打算等下面几篇文章写好后一起发布的，这样大家可能才能看得明白些，但是根据我现在的状况，估计还要一、两个月。所以，为了防止在struts源代码发生过大变化后我的文章就没有太大价值了，所以就提前发表了，霍霍~~~
我的email为：mariah_fan@hotmail.com，有什么不对的地方请大家指正：）
struts作为J2EE的MVC框架已经取得了很大的成功，下面将分几篇文章说明struts源程序的结构。
第一篇 struts的初始化

struts 的核心类是org.apache.struts.action.ActionServlet，这个类将会在struts第一次使用时，
作为servlet初始化并存入tomcat容器。很显然的，初始化将会调用init方法初始化相应的数据。

一、initInternal()方法：
通过调用MessageResources.getMessageResources(internalName)方法生成一个
MessageResources类，getMessageResources是通过调用MessageResourcesFactory.
createResources(config)来实现的。至于MessageResourcesFactory是一个abstract类，任何
继承自它的类都要实现createResources方法，生成MessageResources对象。整个程序生成
MessageResourcesFactory使用了如下技巧：
MessageResourcesFactory.factoryClass = factoryClass;
MessageResourcesFactory.clazz = null;
首先会通过factoryClass来定义一个类全名，然后通过ClassLoader.loadClass
(factoryClass)方法来生成这个类，并赋给clazz，然后通过newInstance来生成一个对象。
在本程序中，生成MessageResources对象实际就是对如下属性进行了初始化：
this.factory = factory;("org.apache.struts.util.PropertyMessageResourcesFactory")
this.config = config;("org.apache.struts.action.ActionResources")
this.returnNull = returnNull;(true/false)

对于MessageResources类的作用是根据不同的Locate来格式化相应的string。或者把你需要改变
的string存放到数组中，然后通过getMessage(Locale locale, String key, Object args[])
方法来格式化。然后把格式好的string存放到HashMap里，这样就可以为以后重用。这里的key是
使用的locale.toString() + "." + key

在PropertyMessageResources中的loadLocale方法用来读取resource的初始化信息。首先它会
通过一个HashMap检测这个localKey相关的message是否已经被初始化了，如果被初始化过就跳
出，检测的方法是locales.get(localeKey) != null。
然后会读取如下一个文件：
org/apache/struts/action/ActionResources_(localKey).properties，然后进行如下操作：
Properties props = new Properties();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
is = classLoader.getResourceAsStream(name);
props.load(is);
Iterator names = props.keySet().iterator();
while (names.hasNext()) {
String key = (String) names.next();
if (log.isTraceEnabled()) {
log.trace(" Saving message key '" + messageKey(localeKey, key));
}
messages.put(messageKey(localeKey, key), props.getProperty(key));
}

PropertyMessageResources 就是通过上面的loadLocale方法查找与Locale locale, String key
相对对应的Message.查找的次序如下locale.toString()，然后是
localeKey = localeKey.substring(0, underscore)，然后是defaultLocale，然后是key。

最后，resource类的结构如下：
PropertyMessageResources extends MessageResources
PropertyMessageResourcesFactory extends MessageResourcesFactory

二、initOther()方法：
从servlet中获取config和debug两个参数，然后初始化ConvertUtils对象。由于
ConvertUtils.deregister()的初始化，所有的Converter都是有初始值的，所以这里Struts自己
把这些初始值设置为null，即转换出错的时候返回null，而不是初始值。使用ConvertUtils类的
原因是由于从form传输过来的都是String类型的值，所以我们要把它们转换成相应的类型。

提到几个技巧：
*public boolean isIndexed() {
if (type == null) {
return (false);
//技巧一：判断是否是一个Array类的方法
} else if (type.isArray()) {
return (true);
//技巧二：判断type是否是List的一个父类或者父接口，或者与List为同一个类
//要注意如果List是另一个primitive的TYPE类，那么type必须也是这个类才会
//返回true，否则都是false。注意long.TYPE与Long.class是不同的
} else if (List.class.isAssignableFrom(type)) {
return (true);
} else {
return (false);
}
}

*//componentType为Array类所存储的元素的类别
Class componentType = indexedProperty.getClass().getComponentType();
//生成一个新的Array
Object newArray = Array.newInstance(componentType, (index + 1));
System.arraycopy(indexedProperty, 0, newArray, 0, length);
indexedProperty = newArray;
set(name, indexedProperty);
int newLength = Array.getLength(indexedProperty);
for (int i = length; i < newLength; i++) {
Array.set(indexedProperty, i, createProperty(name+"["+i+"]", componentType));
}

三、initServlet()方法：
这个方法主要是通过digester类解析web.xml，对String servletMapping属性进行初始化。对于
digester说明如下：这是一个基于DOM的SAX实现的类，它是事件触发的，根据xml文件的结构，
每次读到一个节点元素就会触发一个事件。

InputStream input = getServletContext().getResourceAsStream("/WEB-INF/web.xml");
这是一个比较少见的方法。首先通过this.servletName = getServletConfig().
getServletName()获取servlet的名称，然后根据
if (servletName.equals(this.servletName)) {
this.servletMapping = urlPattern;
}
来判断当前读到的servlet名称是否是我们运行的servlet的名称，如果是，就把url-pattern作为
我们的servletMapping。

四、getServletContext().setAttribute(Globals.ACTION_SERVLET_KEY, this)
把自己存储到servletContext中，属性名为Globals.ACTION_SERVLET_KEY。

五、ModuleConfig moduleConfig = initModuleConfig("", config)
这个方法使用由initOther()方法获取的config值为要解析的xml路径，用来初始化ModuleConfig。
它首先采用与生成MessageResourcesFactory同样的方法产生一个MessageResourcesFactory对象：
MessageResourcesFactory为一个抽象类，每一个继承它的类都要实现
createModuleConfig(String prefix)方法。本程序使用的缺省的MessageResourcesFactory类为
org.apache.struts.config.impl.DefaultModuleConfigFactory，它
的createModuleConfig(String prefix)方法会生成一个ModuleConfigImpl类。

ModuleConfigImpl类相当于一个JavaBean，用来存放一个web模块运行时所需要的配置信息。当
然，一个web模块可以拥有多个ModuleConfig，但是缺省的是prefix长度为0的ModuleConifg。它
的每个属性几乎都是由HashMap组成的，它通过一个configured布尔值来描述当前的ModuleConfig
是否已经被初始化完毕，在每存放一个属性的时候都会监测这个值。如果初始化完毕而还要改变
里面的属性值，则会报出IllegalStateException("Configuration is frozen")异常，现在对它
的属性简单说明如下：
* protected HashMap actionConfigs：
这个HashMap用来存储ActionConfig对象。
* protected HashMap dataSources
这个HashMap用来存储DataSourceConfig对象。
* protected HashMap exceptions
这个HashMap用来存储ExceptionConfig对象。
* protected HashMap formBeans
这个HashMap用来存储FormBeanConfig对象。
* protected HashMap forwards
这个HashMap用来存储ForwardConfig对象。
* protected HashMap messageResources
这个HashMap用来存储MessageResourcesConfig对象。
* protected ArrayList plugIns
这个HashMap用来存储PlugInConfig对象。
* protected ControllerConfig controllerConfig
ControllerConfig类
* protected boolean configured
标志这个ModuleConfig是(true)否(false)配置完成。
* protected String prefix
用来标志和区分ModuleConfig类，同时在使用上面的config类初始化相应的资源以后，也是通
过这个prefix来区分所属的不同的web模块。
* protected String actionMappingClass = "org.apache.struts.action.ActionMapping"
ActionMapping类名，缺省为org.apache.struts.action.ActionMapping。

初始化ModuleConfig的方法如下：
首先是使用getServletConfig().getInitParameter("mapping")来获取设定的ActionMapping类
名，然后通过initConfigDigester()方法来生成一个digester。最后用","分隔config，对每一
块调用parseModuleConfigFile(prefix, paths, config, digester, path)方法解析。注意，这
个方法实际上只有两个参数是有意义的：path为我们要解析的xml文件，config用来初始化完成
后保存到servletContext中。

如果ModuleConfig中存放的FormBeanConfig为Dydamic类型，那么就调用
DynaActionFormClass.createDynaActionFormClass(FormBeanConfig)初始化
DynaActionFormClass，并存放到DynaActionFormClass.dynaClasses 的 static HashMap中。这
里的key为FormBeanConfig.getName() + moduleConfig.getPrefix()。

如果当前的ModuleConfig为缺省的ModuleConfig，那么将会调用如下几个方法：
defaultControllerConfig(config)
defaultMessageResourcesConfig(config)
defaultFormBeansConfig(config)
defaultForwardsConfig(config)
defaultMappingsConfig(config)
在struts1.1以后，这个特例将会被废弃：

defaultControllerConfig(config)为ControllerConfig通过getInitParameter(s)方法初始化如
下几个属性：bufferSize，content，locale(true/false)，maxFileSize，nocache(true/false)
，multipartClass，tempDir。

defaultMessageResourcesConfig(config)为MessageResourcesConfig通过getInitParameter(s)
方法初始化如下几个属性：application，factory，null(true/false)。

其它的几个方法就是获取不同的对象，然后把它们相应的存储到servlet中。关心如下：
ActionFormBeans=>FormBeanConfig，ActionForwards=>ForwardConfig，
ActionMappings=>ActionConfig。

六、initModuleMessageResources(ModuleConfig config)
通过存储在ModuleConfig中的MessageResourcesConfig对象，逐个初始化MessageResource，
然后再把初始化好的MessageResources存放到ServletContext中，attributeName为
MessageResourcesConfig.getKey() + ModuleConfig.getPrefix()。

七、initModuleDataSources(ModuleConfig config)
通过存储在ModuleConfig中的DataSourceConfig对象，逐个初始化DataSource。然后对于每一个
DateSource通过BeanUtils.populate(ds, dscs[i].getProperties())方法初始化其属性。再把初
始化好的DateSource存放到ServletContext中，attributeName为
DataSourceConfig.getKey() + ModuleConfig.getPrefix()。同时也存放到名位dataSources的
FastHashMap中，key为DataSourceConfig.getKey()。

这里还会根据生成的DateSource对象是否是GenericDataSource类型，如果是则调用
GenericDataSource.open()方法。GenericDataSource是一个非常简单的数据库连接池，它的
open()方法用来初始化连接池，生成最小数目的GenericConnection，这里的open()方法根据
String driver变量是否为null来判断是否已经被初始化过。需要仔细说明的是getConnection()
方法，它首先从连接池中取出GenericConnection对象，然后检查其是否是可链接的，如果是就
返回，否则继续取出，同时activeCount-1。如果没有取到，则会检查当前可使用的
GenericConnection是否达到最大值(activeCount < maxCount)，如果没有，调用
createConnection()方法声成一个新的GenericConnection，然后检查其是否是可链接，如果可以
则返回。returnConnection(GenericConnection conn)方法则是通过把GenericConnection放回到
连接池，然后activeCount-1。

这个方法中使用到了ServletContextWriter类，DateSource的log信息就通过这个类写入。对这个
类说明如下：
它继承自PrintWriter，而PrintWriter又继承自Writer。Writer类所作的事情就是在同步的情况下
调用abstract方法：abstract public void write(char cbuf[], int off, int len)，这个方法
将会根据调用者的需要由调用者实现。
PrintWriter则首先通过ensureOpen()方法检验这个类中是否有写入的对象(Writer类或其子类)，
如果有则根据不同的情况调用这个写入对象的write方法(out.write(....))。这个类的print(...)
方法就是据不同的情况调用相应的write(...)方法。而println(...)与之的区别就是每次多写入一
个换行字符串。还有一个区别是println(...)会根据是否需要autoflush进行flush，而write(...)
方法不会。
ServletContextWriter类的作用是把字符写入ServletContext中。ServletContextWriter类方法中
真正实现了write方法：
public void write(char c) {
if (c == '\n')
flush();
else if (c != '\r')
buffer.append(c);
}
public void flush() {
if (buffer.length() > 0) {
context.log(buffer.toString());
buffer.setLength(0);
}
}

八、initModulePlugIns(moduleConfig)
通过存储在ModuleConfig中的PlugInConfig对象，逐个初始化PlugIn对象，存放到一个数组中，
然后再把这个数组存放到ServletContext中，attributeName为
Globals.PLUG_INS_KEY + ModuleConfig.getPrefix()。

对每一个生成的PlugIn对象通过
BeanUtils.populate(plugIns[i], plugInConfigs[i].getProperties())方法初始化其属性。然后
再把PlugInConfig对象存放到由其生成的PlugIn对象中。

最后，通过plugIns[i].init(this, (ModuleConfig) config)初始化这个plugIn对象。

九、初始化结束
完成了这个初始化以后，会调用ModuleConfig.freeze()令这个ModuleConfig变得不可改变。然后
会遍历ServletConfig中的initParameterNames，如果有以"config/"开头的，则通过这个parameter
的值继续初始化其它的ModuleConfig，且这个ModuleConfig的prefix为"config/"后的字符串。

同样调用如下方法：
initModuleMessageResources(moduleConfig);
initModuleDataSources(moduleConfig);
initModulePlugIns(moduleConfig);
moduleConfig.freeze();

最后调用destroyConfigDigester()释放内存。

风太少 2005-08-15 12:31 发表评论

既然是说Struts源代码，为什么要讲Commons-Beanutils包呢？原因很简单，Struts的DynaFormBean就是通过这个包里的相关类实现的。同样，留下我的邮箱，方便和大家共同交流。我的邮箱是：mariah_fan@hotmail.com。

Commons-Beanutils（一）

Commons-Beanutils 这个是jakarta commons项目中的一个子项目。这个项目开发的目的是帮助开发者动态的获取/设值Java Bean的属性，同时解决每次都要写getXXX和setXXX的麻烦。

一、XXXConvert
这些类都实现Converter接口，提供把value值转化成为相应XXX类的实现。现在只针对四种类型：数字，时间，Boolean和String。在Converter 接口中只有一个方法convert(Class type, Object value)，把value对象转换为type所要求的类。XXXConvert类中这个方法的思路是：
1、如果value==null，并且自己内部有缺省的值那么就返回这个缺省的值。如果没有缺省值，就抛出ConversionException异常。
2、如果value instanceOf XXX类，那么就直接返回value。
3、如果上面的都不行，那么调用new XXX(value.toString())或者XXX.valueOf(value.toString())方法来返回。转化失败时，抛出ConversionException异常。

二、特殊的实现
1、对于ClassConverter类，当进入第三种情形的时候，实际执行的是

ClassLoader classLoader =Thread.currentThread().getContextClassLoader();
   if (classLoader == null) {
       classLoader = ClassConverter.class.getClassLoader();
   }
   return (classLoader.loadClass(value.toString()));

2、对于BooleanConverter类，当进入第三种情形的时候，实际执行的是，根据value.toString()的值：yes，y，true, on, 1 返回true；no，n，false，off，0 返回false。如果这些情形都不符合，并且有缺省值的时候则返回缺省值。否则抛出ConversionException；

三、XXXArrayConverter
这些类继承自AbstractArrayConverter类。 AbstractArrayConverter 实际只实现了一个List parseElements(String svalue)方法。这个方法接受的是{value1, value2,...}格式的字符串，逐个解析出来后，放入一个ArrayList中。它通过StreamTokenizer解析字符串：StreamTokenizer是用来分离input stream中读取的字符串，并且可以根据标记区分不同的内容，比如数字，字符或者注释。XXXArrayConverter由于要转换的是一个数组，所以convert(....)方法的实现过程有所不同。
1、如果value==null，并且自己内部有缺省的值那么就返回这个缺省的值。如果没有缺省值，就抛出ConversionException异常。
2、如果model.getClass() == value.getClass()，那么就直接返回value。
3、如果上面的都不行，那么就通过parseElements(value.toString())生成一个数组，再对数组的元素逐个调用new XXX(list.get(i))或者XXX.valueOf(list.get(i))方法，转换成为数组对元素要求的类型。转化失败时，抛出ConversionException异常。

Commons-Beanutils（二）

一、LocaleConverter 与 BaseLocaleConverter
LocaleConverter继承自 Converter接口，定义了一个新方法convert(Class type, Object value, String pattern)。
抽象类BaseLocaleConverter实现了LocaleConverter接口。它的locPattern属性用来表示这个对象的pattern是否是本地化的格式。patttern 是指把何种格式的时间或者数字值转换成标准值。convert(...)的执行过程是：
1、如果value==null，并且自己内部有缺省的值那么就返回这个缺省的值。如果没有缺省值，就抛出ConversionException异常。
2、根据参数pattern值是否为null，调用parse(Object value, String pattern)方法：如果这个参数不为null那么就使用这个参数的值，否则使用对象预存的pattern值。如果这
样做引起了异常，会首先判断是否能够返回缺省的值，不能则抛出ConversionException异常。
3、parse(Object value, String
pattern)方法的实现被抛至继承了它的类具体实现。这个方法虽然把value值表述为Object类型，但是最后都是通过强制转换，转换成为String类型。也就是说它实际上需要的
是String类型的value。

二、 XXXLocaleConverter
把pattern格式的value转换成标准格式的相应的XXX类。这些类可以分为两大类：一类为时间，一类为数值。
1、时间类最后都会通过SimpleDateFormat类对值进行转换，程序如下：

 if(pattern == null) {      
       pattern = locPattern ? new SimpleDateFormat().toLocalizedPattern() : 
                 new SimpleDateFormat().toPattern();
   }
   SimpleDateFormat format = new SimpleDateFormat(pattern, locale);
   if (locPattern) {
       formatter.applyLocalizedPattern(pattern);
   }else {
       formatter.applyPattern(pattern);
   }
   return formatter.parse((String) value);

2、数值类最后都会通过DecimalFormat类对值进行转换，程序如下：

DecimalFormat formatter = (DecimalFormat) DecimalFormat.getInstance(locale);
   if (pattern != null) {
       if (locPattern) {
           formatter.applyLocalizedPattern(pattern);
       } else {
           formatter.applyPattern(pattern);
       }
   } 
   return formatter.parse((String) value);

这个转化过程要注意精度的问题。由于Number类是所有的数值类的父类，所以转换完成后要检查最后的结果是否是当前要求的精度：如果大于所要求的精度，则抛出ConversionException异常。

Commons-Beanutils（三）

Dyna开头的类，是专门为DynaFormBean而设计的。

一、DynaBean，DynaClass 与 DynaProperty
DynaBean并不是Java中所定义的Bean，而是一种“假”的Bean。因为它并不是通过getXXX和setXXX方法，对XXX属性进行取值和设值的。它通过一个实现了DynaClass接口的类，帮助管理其所有的属性的类别，而自己则管理对XXX属性值的设定和获取。在设值的时候会通过与name对应的DynaProperty对象，检查赋值的类别是否正确。
DynaProperty类描述的是DynaBean中所包含的属性的类型。DynaProperty类有三个属性：属性的名称：name，属性的名称；type，属性的类别；contentType，如果DynaProperty描述的是个容器对象(List或者Map)，那么这个contentType就代表这个容器内元素的类别。这个类值得关注的地方是writeObject和readObject方法的实现。它会首先判断自己的type是否是一个primitive的类，如果是，则先写入true标志，再写入对应的primitive类的编号；否则写入false标志，再写入type。因为在调用readObject方法时，如果得出的是primitive类型，则type的值为XXX.TYPE而不是XXX.class。
DynaClass 是一个接口，用来管理DynaBean中所有的DynaProperty属性。

二、BasiceDyanBean 与 BasicDynaClass
BasiceDyanBean 实现自DynaBean接口。它包含一个实现了DynaClass接口的类的对象，和一个用来存放值的HashMap。这个HashMap的key与DynaClass中HashMap的key是一一对应的。
BasicDynaClass 实现了DynaClass接口，以DynaProperty的name为key保存所有这些DynaProperty对象。它通过newInstance方法动态生成实现了DynaBean接口的类的对象；注意这个类是可以动态指定的，如果没有，那么就是默认的BasicDynaBean类。动态指定类是通过反射实现的，程序如下：
//dynaBeanClass为任意的实现了DynaBean接口的类，constructorTypes为这个
//类的构造方法所需要的参数的类型
constructor = dynaBeanClass.getConstructor(constructorTypes);
//constructorValues为构造方法的参数值，实际上它的值为当前的BasicDynaClass
return ((DynaBean) constructor.newInstance(constructorValues));

Commons-Beanutils（四）

一、ConvertUtils 和 ConvertUtilsBean
ConvertUtils 是ConvertUtilsBean类的一个简单封装，即ConvertUtils中的所有方法都是通过直接调用ConvertUtilsBean中的同名方法实现的。如果你需要更复杂的功能，就使用ConvertUtilsBean，否则使用ConvertUtils。
ConvertUtilsBean 通过一个HashMap管理所有的XXXConverter。这个HashMap的key为XXX的类全名，值为相应的XXXConverter对象。通过deregister()方法，初始化这个HashMap。这个初始化方法会为每一个XXXConverter类提供一个缺省的值。用户可以动过setDefaultXXX(...)方法来自行设置XXXConverter对象的缺省值。这个类还提供了convert(...)方法，对String value进行相应的转化。

二、PropertyUtils 和 PropertyUtilsBean
PropertyUtils 是PropertyUtilsBean类的一个简单封装，同样它的所有方法都是通过直接调用PropertyUtilsBean 中同名方法实现的。
PropertyUtilsBean 对DynaBean或者一个java标准Bean中的属性动态的赋值和取值(非通过getXXX和setXXX方法)。
1、这个类支持多层嵌套，比如：XXX[i].YYY(key).ZZZ，那么它会为你得到或者设置ZZZ的属性。
2、所有的set/get方法介绍：
//对XXX(key)格式的name设值
setMappedProperty(Object bean, String name,String key, Object value)
//对XXX[i]格式的name设值
setIndexedProperty(Object bean, String name, int index, Object value)
//对XXX格式的name设值
setSimpleProperty(Object bean, String name, Object value)
//对XXX(key).YYY[i].ZZZ格式的名称设值。注意，name必须要遵照这种格式。
//这个方法实际做的就是以“.”为分隔符，逐层的根据情况分别调用上面的几个方法，
//获取相应的bean。
setNestedProperty(Object bean, String name, Object value)
//它直接调用setNestedProperty方法
setProperty(Object bean, String name, Object value)
3、getPropertyType(Object bean, String name)方法中用来获取Bean的某一个property的类型的代码：
PropertyDescriptor descriptor = getPropertyDescriptor(bean, name);
if (descriptor == null) {
return (null);
}else if (descriptor instanceof IndexedPropertyDescriptor) {
return (((IndexedPropertyDescriptor) descriptor).getIndexedPropertyType());
} else if (descriptor instanceof MappedPropertyDescriptor) {
return (((MappedPropertyDescriptor) descriptor).getMappedPropertyType());
} else {
return (descriptor.getPropertyType());
}
4、getIndexedProperty(Object bean, String name, int index)
这个方法用来获取一个数组或者一个List中的属性。它会首先看这个bean是否是DynaBean类型的，如果是，再其检查是否有name这个属性，如果有那么就直接调用get(String name, int index)方法返回值；如果不是DynaBean类型，那么就会执行如下方法：
//有没有为数组的某个特定元素取值的方法
if (descriptor instanceof IndexedPropertyDescriptor) {
Method readMethod = ((IndexedPropertyDescriptor) descriptor).
getIndexedReadMethod();
if (readMethod != null) {
Object subscript[] = new Object[1];
subscript[0] = new Integer(index);
return (invokeMethod(readMethod,bean, subscript));
}
}
// 如果没有，就先取出整个对象
Method readMethod = getReadMethod(descriptor);
if (readMethod == null) {
throw new NoSuchMethodException("Property '" + name +
"' has no getter method");
}
Object value = invokeMethod(readMethod, bean, new Object[0]);
//如果这个对象实际上是一个List，那么调用get()方法
if (!value.getClass().isArray()) {
if (!(value instanceof java.util.List)) {
throw new IllegalArgumentException("Property '" + name
+ "' is not indexed");
} else {
//get the List's value
return ((java.util.List) value).get(index);
}
//否则通过Array类提供的相应方法取值
} else {
//get the array's value
return (Array.get(value, index));
}

三、BeanUtil 和 BeanUtilBean
BeanUtils 是BeanUtilsBean类的一个简单封装，同样它的所有方法都是通过直接调用BeanUtilsBean 中同名方法实现的。
BeanUtilBean中大多数核心方法都是通过调用PropertyUtilsBean中的方法实现的。而populate(Object bean, Map properties)是自己实现的，因为这个赋值过程要首先对value进行格式的转化；这个方法把properties中的key为属性名，value为属性的值，分别对应的设值给bean对象。它通过setProperty(Object bean, String name, Object value)方法实现逐个设值的。由于此时的value不一定符合bean中name属性的类型，所以首先要把value转换成合适的值，然后再设值。具体的类型转换方法如下：

//这种类型转换的原则是：如果value是String或者String[]，那么这个值可能为任意的类型， 
    //需要进行转换。如果为其它的类型，则不进行任何转换。
    if (type.isArray() && (index < 0)) { 
        // 如果是直接对一个数组赋值，则使用convert(String values[], Class clazz)方法转换
        if (value == null) {
            String values[] = new String[1];
            values[0] = (String) value;
            newValue = getConvertUtils().convert((String[]) values, type);
        } else if (value instanceof String) {
            String values[] = new String[1];
            values[0] = (String) value;
            newValue = getConvertUtils().convert((String[]) values, type);
        } else if (value instanceof String[]) {
            newValue = getConvertUtils().convert((String[]) value, type);
        } else {
            newValue = value;
        }
    } else if (type.isArray()) {
        // 如果是对数组的某一个元素赋值，则使用convert(String value, Class clazz)方法转换
        if (value instanceof String) {
            newValue = getConvertUtils().convert((String) value, type.getComponentType());
        } else if (value instanceof String[]) {   
            newValue = getConvertUtils().convert(((String[]) value)[0],type.getComponentType());
        } else {
            newValue = value;     
        }
    } else {                 
        // 否则就是一对一的简单赋值，则使用convert(String value, Class clazz)方法转换
        if ((value instanceof String) || (value == null)) {
            newValue = getConvertUtils().convert((String) value, type);
        } else if (value instanceof String[]) {
            newValue = getConvertUtils().convert(((String[]) value)[0], type);       
        } else if (getConvertUtils().lookup(value.getClass()) != null) {
            newValue = getConvertUtils().convert(value.toString(), type);
        } else {
            newValue = value;        }
    } 

风太少 2005-08-15 12:28 发表评论