JavaBean详解

最新推荐文章于 2024-09-16 20:20:54 发布

xiaoyuzzy

最新推荐文章于 2024-09-16 20:20:54 发布

阅读量5.7k

点赞数 1

文章标签： javabean

本文链接：https://blog.csdn.net/xiaoyuzzy/article/details/70174633

版权

JavaBean详解

内省(Introspector) 是Java 语言对JavaBean类属性、事件的一种缺省处理方法。
　　JavaBean是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”(Value Object)，或“VO”。方法比较少。这些信息储存在类的私有变量中，通过set()、get()获得。
　　例如类UserInfo ：
　　

package com.peidasoft.instrospector;

public class UserInfo {

    private long userId;
    private String userName;
    private int age;
    private String emailAddress;

    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

在类UserInfo中有属性userName，那我们可以通过getUserName, setUserName来得到其值或者设置新的值。通过getUserName/setUserName来访问userName属性，这就是默认的规则。Java JDK中提供了一套API用来访问某个属性的getter/setter方法，这就是内省。
JDK内省类库：

PropertyDescriptor类：
　　PropertyDescriptor类表示JavaBean类通过存储器导出一个属性。主要方法：
　　1. getPropertyType()，获得属性的Class对象；
　　2. getReadMethod()，获得用于读取属性值的方法；
　　　3. getWriteMethod()，获得用于写入属性值的方法；
　　4. hashCode()，获取对象的哈希值；
　　5. setReadMethod(Method readMethod)，设置用于读取属性值的方法；
　　6. setWriteMethod(Method writeMethod)，设置用于写入属性值的方法。
　　实例代码如下：
　　

package com.peidasoft.instrospector;  

import java.beans.BeanInfo;  
import java.beans.Introspector;  
import java.beans.PropertyDescriptor;  
import java.lang.reflect.Method;  

public class BeanInfoUtil {  

    // 设置bean的某个属性值  
    public static void setProperty(UserInfo userInfo, String userName) throws Exception {  
        // 获取bean的某个属性的描述符  
        PropertyDescriptor propDesc = new PropertyDescriptor(userName, UserInfo.class);  
        // 获得用于写入属性值的方法  
        Method methodSetUserName = propDesc.getWriteMethod();  
        // 写入属性值  
        methodSetUserName.invoke(userInfo, "wong");  
        System.out.println("set userName:" + userInfo.getUserName());  
    }  

    // 获取bean的某个属性值  
    public static void getProperty(UserInfo userInfo, String userName) throws Exception {  
        // 获取Bean的某个属性的描述符  
        PropertyDescriptor proDescriptor = new PropertyDescriptor(userName, UserInfo.class);  
        // 获得用于读取属性值的方法  
        Method methodGetUserName = proDescriptor.getReadMethod();  
        // 读取属性值  
        Object objUserName = methodGetUserName.invoke(userInfo);  
        System.out.println("get userName:" + objUserName.toString());  
    }  
}  
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Introspector类:
　　将JavaBean中的属性封装起来进行操作。在程序把一个类当做JavaBean来看，就是调用Introspector.getBeanInfo()方法，得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息，即属性的信息。
　　getPropertyDescriptors()，获得属性的描述，可以采用遍历BeanInfo的方法，来查找、设置类的属性。具体代码如下：
　　

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class BeanInfoUtil {

    // 通过内省设置bean的某个属性值
    public static void setPropertyByIntrospector(UserInfo userInfo, String userName) throws Exception {
        // 获取bean信息
        BeanInfo beanInfo = Introspector.getBeanInfo(UserInfo.class);
        // 获取bean的所有属性列表
        PropertyDescriptor[] proDescrtptors = beanInfo.getPropertyDescriptors();
        // 遍历属性列表，查找指定的属性
        if (proDescrtptors != null && proDescrtptors.length > 0) {
            for (PropertyDescriptor propDesc : proDescrtptors) {
                // 找到则写入属性值
                if (propDesc.getName().equals(userName)) {
                    Method methodSetUserName = propDesc.getWriteMethod();
                    methodSetUserName.invoke(userInfo, "alan");  // 写入属性值
                    System.out.println("set userName:" + userInfo.getUserName());
                    break;
                }
            }
        }
    }

    // 通过内省获取bean的某个属性值
    public static void getPropertyByIntrospector(UserInfo userInfo, String userName) throws Exception {
        BeanInfo beanInfo = Introspector.getBeanInfo(UserInfo.class);
        PropertyDescriptor[] proDescrtptors = beanInfo.getPropertyDescriptors();
        if (proDescrtptors != null && proDescrtptors.length > 0) {
            for (PropertyDescriptor propDesc : proDescrtptors) {
                if (propDesc.getName().equals(userName)) {
                    Method methodGetUserName = propDesc.getReadMethod();
                    Object objUserName = methodGetUserName.invoke(userInfo);
                    System.out.println("get userName:" + objUserName.toString());
                    break;
                }
            }
        }
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

通过这两个类的比较可以看出，都是需要获得PropertyDescriptor，只是方式不一样：前者通过创建对象直接获得，后者需要遍历，所以使用PropertyDescriptor类更加方便。
　　使用实例：
　　

package com.peidasoft.instrospector;

public class BeanInfoTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName("peida");
        try {
            BeanInfoUtil.getProperty(userInfo, "userName");
            BeanInfoUtil.setProperty(userInfo, "userName");
            BeanInfoUtil.getProperty(userInfo, "userName");
            BeanInfoUtil.setPropertyByIntrospector(userInfo, "userName");
            BeanInfoUtil.getPropertyByIntrospector(userInfo, "userName");
            BeanInfoUtil.setProperty(userInfo, "age");  // IllegalArgumentException
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

BeanUtils工具包

由上述可看出，内省操作非常的繁琐，所以所以Apache开发了一套简单、易用的API来操作Bean的属性——BeanUtils工具包。
　　BeanUtils工具包：下载：http://commons.apache.org/beanutils/，注意：应用的时候还需要一个logging包http://commons.apache.org/logging/
　　使用BeanUtils工具包完成上面的测试代码：
　　

package com.peidasoft.instrospector;

import java.lang.reflect.InvocationTargetException;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class BeanInfoTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName("peida");
        try {
            BeanUtils.setProperty(userInfo, "userName", "peida");
            System.out.println("set userName:" + userInfo.getUserName());
            System.out.println("get userName:" + BeanUtils.getProperty(userInfo, "userName"));
            BeanUtils.setProperty(userInfo, "age", 18);
            System.out.println("set age:" + userInfo.getAge());
            System.out.println("get age:" + BeanUtils.getProperty(userInfo, "age"));
            System.out.println("get userName type:" + BeanUtils.getProperty(userInfo, "userName").getClass().getName());
            System.out.println("get age type:" + BeanUtils.getProperty(userInfo, "age").getClass().getName());
            PropertyUtils.setProperty(userInfo, "age", 8);
            System.out.println(PropertyUtils.getProperty(userInfo, "age"));
            System.out.println(PropertyUtils.getProperty(userInfo, "age").getClass().getName());
            PropertyUtils.setProperty(userInfo, "age", "8");  // IllegalArgumentException
        } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

说明：
　　1. 获得属性的值，例如，BeanUtils.getProperty(userInfo, “userName”)，返回字符串。
　　2. 设置属性的值，例如，BeanUtils.setProperty(userInfo, “age”, 8)，参数是字符串或基本类型自动包装。设置属性的值是字符串，获得的值也是字符串，不是基本类型。　　　3. BeanUtils的特点：
　　1). 对基本数据类型的属性的操作：在WEB开发、使用中，录入和显示时，值会被转换成字符串，但底层运算用的是基本类型，这些类型转到动作由BeanUtils自动完成。
　　2). 对引用数据类型的属性的操作：首先在类中必须有对象，不能是null，例如，private Date birthday=new Date();。操作的是对象的属性而不是整个对象，例如，BeanUtils.setProperty(userInfo, “birthday.time”, 111111);

package com.peidasoft.Introspector;
import java.util.Date;

public class UserInfo {

    private Date birthday = new Date(); // 引用类型的属性，不能为null

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public Date getBirthday() {
        return birthday;
    }      
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.peidasoft.Beanutil;

import java.lang.reflect.InvocationTargetException;
import org.apache.commons.beanutils.BeanUtils;
import com.peidasoft.Introspector.UserInfo;

public class BeanUtilTest {
    public static void main(String[] args) {
        UserInfo userInfo=new UserInfo();
         try {
            BeanUtils.setProperty(userInfo, "birthday.time","111111");  // 操作对象的属性，而不是整个对象
            Object obj = BeanUtils.getProperty(userInfo, "birthday.time");  
            System.out.println(obj);          
        } 
         catch (IllegalAccessException e) {
            e.printStackTrace();
        } 
         catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

PropertyUtils类和BeanUtils不同在于，运行getProperty、setProperty操作时，没有类型转换，使用属性的原有类型或者包装类。由于age属性的数据类型是int，所以方法PropertyUtils.setProperty(userInfo,”age”, “8”)会爆出数据类型不匹配，无法将值赋给属性。

JavaBean的编辑器

在Spring配置文件里，我们往往通过字面值为Bean各种类型的属性提供设置值：不管是double类型还是int类型，在配置文件中都对应字符串类型的字面值。BeanWrapper填充Bean属性时如何将这个字面值转换为对应的double或int等内部类型呢？我们可以隐约地感觉到一定有一个转换器在其中起作用，这个转换器就是属性编辑器。
　　“属性编辑器”这个名字可能会让人误以为是一个带用户界面的输入器，其实属性编辑器不一定非得有用户界面，任何实现java.beans.PropertyEditor接口的类都是属性编辑器。属性编辑器的主要功能就是将外部的设置值转换为JVM内部的对应类型，所以属性编辑器其实就是一个类型转换器。
　　PropertyEditor是JavaBean规范定义的接口，JavaBean规范中还有其他一些PropertyEditor配置的接口。为了彻底理解属性编辑器，必须对JavaBean中有关属性编辑器的规范进行学习，相信这些知识对学习和掌握Spring中的属性编辑器会大有帮助。
　　Sun所制定的JavaBean规范，很大程度上是为IDE准备的——它让IDE能够以可视化的方式设置JavaBean的属性。如果在IDE中开发一个可视化应用程序，我们需要通过属性设置的方式对组成应用的各种组件进行定制，IDE通过属性编辑器让开发人员使用可视化的方式设置组件的属性。
　　一般的IDE都支持JavaBean规范所定义的属性编辑器，当组件开发商发布一个组件时，它往往将组件对应的属性编辑器捆绑发行，这样开发者就可以在IDE环境下方便地利用属性编辑器对组件进行定制工作。
　　JavaBean规范通过java.beans.PropertyEditor定义了设置JavaBean属性的方法，通过BeanInfo描述了JavaBean哪些属性是可定制的，此外还描述了可定制属性与PropertyEditor的对应关系。
　　BeanInfo与JavaBean之间的对应关系，通过两者之间规范的命名确立，对应JavaBean的BeanInfo采用如下的命名规范：BeanInfo。如ChartBean对应的BeanInfo为ChartBeanBeanInfo，Car对应的BeanInfo为CarBeanInfo。当JavaBean、其各属性的编辑器、和BeanInfo信息一起注册到IDE中后，当在开发界面中对JavaBean进行定制时，IDE就会根据JavaBean规范找到对应的BeanInfo，再根据BeanInfo中的描述信息找到JavaBean属性描述（是否开放、使用哪个属性编辑器），进而为JavaBean生成特定开发编辑界面。
　　JavaBean规范提供了一个管理默认属性编辑器的管理器：PropertyEditorManager，该管理器内保存着一些常见类型的属性编辑器，如果某个JavaBean的常见类型属性没有通过BeanInfo显式指定属性编辑器，IDE将自动使用PropertyEditorManager中注册的对应默认属性编辑器。
　　由于JavaBean对应的属性编辑器等IDE环境相关的资源和组件需要动态加载，所以在纯Java的IDE中开发基于组件的应用时，总会感觉IDE反应很迟钝，不像Delphi、C++ Builder一样灵敏快捷。但在Eclipse开发环境中，设计包括可视化组件的应用时却很快捷，原因是Eclipse没有使用Java的标准用户界面组件库，当然也就没有按照JavaBean的规范开发设计GUI组件了。

PropertyEditor

PropertyEditor是属性编辑器的接口，它规定了将外部设置值转换为内部JavaBean属性值的转换接口方法。PropertyEditor主要的接口方法说明如下：

Object getValue()：返回属性的当前值。基本类型被封装成对应的包装类实例；
void setValue(Object newValue)：设置属性的值，基本类型以包装类传入（自动装箱）；
String getAsText()：将属性对象用一个字符串表示，以便外部的属性编辑器能以可视化的方式显示。缺省返回null，表示该属性不能以字符串表示；
void setAsText(String text)：用一个字符串去更新属性的内部值，这个字符串一般从外部属性编辑器传入；
String[] getTags()：返回表示有效属性值的字符串数组（如boolean属性对应的有效Tag为true和false），以便属性编辑器能以下拉框的方式显示出来。缺省返回null，表示属性没有匹配的字符值有限集合；
String getJavaInitializationString()：为属性提供一个表示初始值的字符串，属性编辑器以此值作为属性的默认值。
　　可以看出PropertyEditor接口方法是内部属性值和外部设置值的沟通桥梁。此外，我们可以很容易地发现该接口的很多方法是专为IDE中的可视化属性编辑器提供的：如getTags()、getJavaInitializationString()以及另外一些我们未此介绍的接口方法。
　　Java为PropertyEditor提供了一个方便的实现类：PropertyEditorSupport，该类实现了PropertyEditor接口并提供默认实现，一般情况下，用户可以通过扩展这个方便类设计自己的属性编辑器。

BeanInfo

BeanInfo主要描述了JavaBean哪些属性可以编辑以及对应的属性编辑器，每一个属性对应一个属性描述器PropertyDescriptor。PropertyDescriptor的构造函数有两个入参：PropertyDescriptor(String propertyName, Class beanClass) ，其中propertyName为属性名；而beanClass为JavaBean对应的Class。
　　此外PropertyDescriptor还有一个setPropertyEditorClass(Class propertyEditorClass)方法，为JavaBean属性指定编辑器。BeanInfo接口最重要的方法就是：PropertyDescriptor[] getPropertyDescriptors() ，该方法返回JavaBean的属性描述器数组。
　　BeanInfo接口有一个常用的实现类：SimpleBeanInfo，一般情况下，可以通过扩展SimpleBeanInfo实现自己的功能。

Spring默认属性编辑器

Spring的属性编辑器和传统的用于IDE开发时的属性编辑器不同，它们没有UI界面，仅负责将配置文件中的文本配置值转换为Bean属性的对应值，所以Spring的属性编辑器并非传统意义上的JavaBean属性编辑器。
Spring为常见的属性类型提供了默认的属性编辑器。从图5-4中，我们可以看出BeanWrapperImpl类扩展了PropertyEditorRegistrySupport类，Spring在PropertyEditor RegistrySupport中为常见属性类型提供了默认的属性编辑器，这些“常见的类型”共32个，可分为3大类，总结如下：
表5-1 Spring提供的默认属性编辑器
类别说明
基础数据类型分为几个小类： 1）基本数据类型，如：boolean、byte、short、int等；2）基本数据类型封装类，如：Long、Character、Integer等； 3）两个基本数据类型的数组，char[]和byte[]；4）大数类，BigDecimal和BigInteger
集合类为5种类型的集合类Collection、Set、SortedSet、List和SortedMap提供了编辑器
资源类用于访问外部资源的8个常见类Class、Class[]、File、InputStream、Locale、Properties、Resource[]和URL

PropertyEditorRegistrySupport中有两个用于保存属性编辑器的Map类型变量：
defaultEditors：用于保存默认属性类型的编辑器，元素的键为属性类型，值为对应的属性编辑器实例；
customEditors：用于保存用户自定义的属性编辑器，元素的键值和defaultEditors相同。
　　PropertyEditorRegistrySupport通过类似以下的代码定义默认属性编辑器：

this.defaultEditors.put(char.class, new CharacterEditor(false));  
this.defaultEditors.put(Character.class, new CharacterEditor(true));  
this.defaultEditors.put(Locale.class, new LocaleEditor());  
this.defaultEditors.put(Properties.class, new PropertiesEditor()); 
  
  1
2
3
4

这些默认的属性编辑器解决常见属性类型的注册问题，如果用户的应用包括一些特殊类型的属性，且希望在配置文件中以字面值提供配置值，那么就需要编写自定义属性编辑器并注册到Spring容器中。这样，Spring才能将配置文件中的属性配置值转换为对应的属性类型值。

自定义属性编辑器

Spring大部分默认属性编辑器都直接扩展于java.beans.PropertyEditorSupport类，用户也可以通过扩展PropertyEditorSupport实现自己的属性编辑器。比起用于IDE环境的属性编辑器来说，Spring环境下使用的属性编辑器的功能非常单一：仅需要将配置文件中字面值转换为属性类型的对象即可，并不需要提供UI界面，因此仅需要简单覆盖PropertyEditorSupport的setAsText()方法就可以了。
　　看一个实例。我们继续使用第4章中Boss和Car的例子，假设我们现在希望在配置Boss时，不通过引用Bean的方式注入Boss的car属性，而希望直接通过字符串字面值提供配置。为了方便阅读，这里再次列出Boss和Car类的简要代码：
　　

public class Car {    
    private int maxSpeed;    
    public String brand;    
    private double price;    
    //省略get/setter    
}    
  
  1
2
3
4
5
6

public class Boss {    
    private String name;    
    private Car car = new Car();    
    //省略get/setter    
}   
  
  1
2
3
4
5

Boss有两个属性：name和car，分别对应String类型和Car类型。Spring拥有String类型的默认属性编辑器，因此对于String类型的属性我们不用操心。但Car类型是我们自定义的类型，要配置Boss的car属性，有两种方案：
1）在配置文件中为car专门配置一个，然后在boss的中通过ref引用car Bean，这正是我们上一章中所用的方法；
2）为Car类型提供一个自定义的属性编辑器，这样，我们就通过字面值为Boss的car属性提供配置值。

    package com.baobaotao.editor;  
    import java.beans.PropertyEditorSupport;  

    public class CustomCarEditor extends PropertyEditorSupport {  

        //1. 将字面值转换为属性类型对象  
        public void setAsText(String text){   
            if(text == null || text.indexOf(",") == -1){  
                throw new IllegalArgumentException("设置的字符串格式不正确");  
            }  
            String[] infos = text.split(",");  
            Car car = new Car();  
            car.setBrand(infos[0]);  
            car.setMaxSpeed(Integer.parseInt(infos[1]));  
            car.setPrice(Double.parseDouble(infos[2]));  

             //2. 调用父类的setValue()方法设置转换后的属性对象  
            setValue(car);   
        }  
    }  
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

CustomCarEditor很简单，它仅覆盖PropertyEditorSupport便利类的setAsText(String text)方法，该方法负责将配置文件以字符串提供的字面值转换为Car对象。字面值采用逗号分隔的格式同时为brand、maxSpeed和price属性值提供设置值，setAsText()方法解析这个字面值并生成对应的Car对象。由于我们并不需要将Boss内部的car属性反显到属性编辑器中，因此不需要覆盖getAsText()方法。

注册自定义的属性编辑器

在IDE环境下，自定义属性编辑器在使用之前必须通过扩展组件功能进行注册，在Spring环境中也需要通过一定的方法注册自定义的属性编辑器。
　　如果使用BeanFactory，用户需要手工调用registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)方法注册自定义属性编辑器；如果使用ApplicationContext，则只需要在配置文件通过CustomEditorConfigurer注册就可以了。CustomEditorConfigurer实现BeanFactoryPostProcessor接口，因此是一个Bean工厂后处理器。我们知道Bean工厂后处理器在Spring容器加载配置文件并生成BeanDefinition半成品后就会被自动执行。因此CustomEditorConfigurer有容器启动时有机会注入自定义的属性编辑器。下面的配置片断定义了一个CustomEditorConfigurer：
　　

    <!--①配置自动注册属性编辑器的CustomEditorConfigurer -->  
    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">  
            <property name="customEditors">  
                <map>  
                       <!--②-1属性编辑器对应的属性类型-->  
                       <entry key="com.baobaotao.editor.Car">   

                             <!--②-2对应的属性编辑器Bean -->  
                        <bean class="com.baobaotao.editor.CustomCarEditor" />  
                    </entry>  
                </map>  
            </property>  
        </bean>  
     <bean id="boss" class="com.baobaotao.editor.Boss">  
           <property name="name" value="John"/>   
           <!--③该属性将使用②处的属性编辑器完成属性填充操作-->  
           <property name="car" value="红旗CA72,200,20000.00"/>   
    </bean>  
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在①处，我们定义了用于注册自定义属性编辑器的CustomEditorConfigurer，Spring容器将通过反射机制自动调用这个Bean。CustomEditorConfigurer通过一个Map属性定义需要自动注册的自定义属性编辑器。在②处，我们为Car类型指定了对应属性编辑器CustomCarEditor，注意键是属性类型，而值是对应的属性编辑器Bean，而不是属性编辑器的类名。
　　最精彩的部分当然是③处的配置，我们原来通过一个元素标签配置好car Bean，然后在boss的中通过ref引用car Bean，但是现在我们直接通过value为car属性提供配置。BeanWrapper在设置boss的car属性时，它将检索自定义属性编辑器的注册表，当发现Car属性类型拥有对应的属性编辑器CustomCarEditor时，它就会利用CustomCarEditor将“红旗CA72,200,20000.00”转换为Car对象。
　　
引用：
　　按照JavaBeans的规范，JavaBeans的基础设施会在JavaBean相同类包下查找是否存在Editor的类，如果存在，自动使用Editor作为该JavaBean的PropertyEditor。
　　如com.baobaotao.domain.UserEditor会自动成为com.baobaotao.domain.User对应的PropertyEditor。Spring也支持这个规范，也即如果采用这种规约命令PropertyEditor，就无须显式在CustomEditorConfigurer中注册了，Spring将自动查找并注册这个PropertyEditor。
　　另：Spring 3.0除支持PropertyEditor外，还在核心包中引入了自建的ConversionService，它提供了更为强大的类型转换的能力，可以完成任意类型之间的转换，还可以在转换过程中参考目标对象所在宿主类的上下文信息。Spring的类型转换同时支持PropertyEditor和ConversionService。