Spring源代码分析（5)---propertyEditor(移花接木的自定义属性编辑器)

1.     protected void initBeanWrapper(BeanWrapper bw) {
2.         for (Iterator it = getCustomEditors().entrySet().iterator(); it.hasNext();) {
3.             Map.Entry entry = (Map.Entry) it.next();
4.             Class clazz = (Class) entry.getKey();
5.             PropertyEditor editor = (PropertyEditor) entry.getValue();
6.             bw.registerCustomEditor(clazz, editor);
7.         }
8.     }

在spring中可以把字符串映射成为其他类型的数据：

如：
 

1. <bean name="ResourceInfo" class="org.corey.ResourceInfo">
2.   <property name="resource1" value="classpath:test/corey.class"/>
3.   <property name="resource2" value="classpath:test/corey.class"/>
4. </bean>

气势在，ResourceInfo类中，resource1和resource2都是Resource类型的类，那么这里我们为什么可以将其设定位字符串形式的值呢，难道不会报错吗，那是因为我们同时有一下配置：

1. <bean id="customEditorConfigurer" class="org.spring.framework.beans.factory.config.CustomEditorConfigurer">
3. <property name="custromEditors">
4.  <map>
5.    <entry key="org.corey.ResourceInfo">
6.       <bean class="org.springframework.core.io.ResourceEditor"/>
7.    </entry>
8. </map>
9. </property>
10. /bean>
11.       

在这里，我们看见这个EditorConfigurer实现了我们上一节所说的BeanFactoryPostProcessor接口，那么，在BeanFactory加载类配置文件以前，这个EditorConfigurer到底做了什么呢，我们看一下：

1. public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
2.         if (this.customEditors != null) {
3.             for (Iterator it = this.customEditors.keySet().iterator(); it.hasNext();) {
4.                 Object key = it.next();
5.                 Class requiredType = null;
6.                 if (key instanceof Class) {
7.                     requiredType = (Class) key;
8.                 }
9.                 else if (key instanceof String) {
10.                     String className = (String) key;
11.                     try {
12.                         requiredType = ClassUtils.forName(className);
13.                     }
14.                     catch (ClassNotFoundException ex) {
15.                         throw new BeanInitializationException(
16.                                 "Could not load required type [" + className + "] for custom editor", ex);
17.                     }
18.                 }
19.                 else {
20.                     throw new BeanInitializationException(
21.                             "Invalid key [" + key + "] for custom editor - needs to be Class or String");
22.                 }
23.                 Object value = this.customEditors.get(key);
24.                 if (!(value instanceof PropertyEditor)) {
25.                     throw new BeanInitializationException("Mapped value [" + value + "] for custom editor key [" +
26.                             key + "] is not of required type [" + PropertyEditor.class.getName() + "]");
27.                 }
28.                 beanFactory.registerCustomEditor(requiredType, (PropertyEditor) value);
29.             }
30.         }
31.     }
33. }

EditorConfigurer类把自己的CustomEditors这个Map中的成员，加到了当前BEanFactory的customEditor中了，
key是指目标类，如上文中的 org.corey.ResourceInfo类，value是指属性编辑器；


那么属性编辑器到底是什么呢，我们首先来看看PropertyEditor接口吧；

public interface PropertyEditor{

  public  void setAsText();
 
  public String getAsText();
 
}

他有一个默认实现是：PropertyEditorSupport类，从这个接口的方法，我们可以看出，这个接口可以把一个特定类型的对象序列化成为一个字符串，并且又能够把一个字符串反序列化成为一个对象；

如ResourceEditor:

1. 
   
2. public class ResourceEditor extends PropertyEditorSupport {
3. 
   
4.     private final ResourceLoader resourceLoader;
5. 
   
6. 
   
7.     public ResourceEditor() {
8.         this.resourceLoader = new DefaultResourceLoader();
9.     }
10. 
    
11.     public ResourceEditor(ResourceLoader resourceLoader) {
12.         this.resourceLoader = resourceLoader;
13.     }
14. 
    
15. 
    
16.     public void setAsText(String text) {
17.         if (StringUtils.hasText(text)) {
18.             String locationToUse = resolvePath(text).trim();
19.             setValue(this.resourceLoader.getResource(locationToUse));
20.         }
21.         else {
22.             setValue(null);
23.         }
24.     }
25. 
    
26.     
27.     protected String resolvePath(String path) {
28.         return SystemPropertyUtils.resolvePlaceholders(path);
29.     }
30. 
    
31. }

那到底，BeanFactory中在什么时候自动的把字符串替换成为了Resource类型的对象呢，这时候我们就必须看BeanFactory类了:

transformedBeanName(name);：bean名字转换，比如去掉&，把别名改写位正式的名字等等；
transformedBeanName(name);根据名字拿到这个Beanname对应的BeanDefinition(已介绍)；
checkMergedBeanDefinition(mergedBeanDefinition, beanName, requiredType, args);查看这个bean定义是不是抽象的；
createBean(beanName, mergedBeanDefinition, args)：正式建立一个实例；



createBean()是在AbstractAutoWireBeanFactory中实现的，在这个里面做了创建实例bean的工作，如下：


*[mergedBeanDefinition.getDependsOn().length]getBean(mergedBeanDefinition.getDependsOn());：循环这个bean所依赖的bean，然后getBean（）；达到预先createBean();这个被依赖类的作用；

instantiateBean(beanName, mergedBeanDefinition);根据所提供的构造函数，或者默认构造函数，或相应的诸如规则调用构造函数生成实例；

populateBean(beanName, mergedBeanDefinition, instanceWrapper);对属性进行注入；

applyBeanPostProcessorsBeforeInitialization(bean, beanName);调用 BeanPostProcessorsBeforeInitialization

invokeInitMethods(beanName, bean, mergedBeanDefinition);调用初始化方法；

applyBeanPostProcessorsAfterInitialization(bean, beanName);;调用 BeanPostProcessorsAfterInitialization

我们重点来看下 instantiateBean:

1.     protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mergedBeanDefinition)
2.             throws BeansException {
4.         Object beanInstance = getInstantiationStrategy().instantiate(mergedBeanDefinition, beanName, this);
5.         BeanWrapper bw = new BeanWrapperImpl(beanInstance);
6.         initBeanWrapper(bw);
7.         return bw;
8.     }

1.     protected void initBeanWrapper(BeanWrapper bw) {
2.         for (Iterator it = getCustomEditors().entrySet().iterator(); it.hasNext();) {
3.             Map.Entry entry = (Map.Entry) it.next();
4.             Class clazz = (Class) entry.getKey();
5.             PropertyEditor editor = (PropertyEditor) entry.getValue();
6.             bw.registerCustomEditor(clazz, editor);
7.         }
8.     }

 BeanWrapper bw中 含有cachedIntrospectionResults，包括这个pojo类的所有属性的米的描述；


populateBean：

1.     protected void populateBean(String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw)
2.             throws BeansException {
3. 
   
4.         PropertyValues pvs = mergedBeanDefinition.getPropertyValues();
5. 
   
6.         if (mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
7.                 mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
8.             MutablePropertyValues mpvs = new MutablePropertyValues(pvs);
9. 
   
10.             // Add property values based on autowire by name if applicable.
11.             if (mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
12.                 autowireByName(beanName, mergedBeanDefinition, bw, mpvs);
13.             }
14. 
    
15.             // Add property values based on autowire by type if applicable.
16.             if (mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
17.                 autowireByType(beanName, mergedBeanDefinition, bw, mpvs);
18.             }
19. 
    
20.             pvs = mpvs;
21.         }
22. 
    
23.         checkDependencies(beanName, mergedBeanDefinition, bw, pvs);
24.         applyPropertyValues(beanName, mergedBeanDefinition, bw, pvs);
25.     }

checkDependencies：检查dependcheck,确保制定的属性被设置；

applyPropertyValues：

1. private void applyPropertyValues(
2.             String beanName, RootBeanDefinition mergedBeanDefinition, BeanWrapper bw, PropertyValues pvs)
3.             throws BeansException {
5.         if (pvs == null) {
6.             return;
7.         }
9.         BeanDefinitionValueResolver valueResolver =
10.                 new BeanDefinitionValueResolver(this, beanName, mergedBeanDefinition);
12.         // Create a deep copy, resolving any references for values.
13.         MutablePropertyValues deepCopy = new MutablePropertyValues();
14.         PropertyValue[] pvArray = pvs.getPropertyValues();
15.         for (int i = 0; i < pvArray.length; i++) {
16.             PropertyValue pv = pvArray[i];
17.             Object resolvedValue =
18.                     valueResolver.resolveValueIfNecessary("bean property '" + pv.getName() + "'", pv.getValue());
19.             deepCopy.addPropertyValue(pvArray[i].getName(), resolvedValue);
20.         }
22.         // Set our (possibly massaged) deep copy.
23.         try {
24.             // Synchronize if custom editors are registered.
25.             // Necessary because PropertyEditors are not thread-safe.
26.             if (!getCustomEditors().isEmpty()) {
27.                 synchronized (this) {
28.                     bw.setPropertyValues(deepCopy);
29.                 }
30.             }
31.             else {
32.                 bw.setPropertyValues(deepCopy);
33.             }
34.         }
35.         catch (BeansException ex) {
36.             // Improve the message by showing the context.
37.             throw new BeanCreationException(
38.                     mergedBeanDefinition.getResourceDescription(), beanName, "Error setting property values", ex);
39.         }
40.     }

1. protected Object doTypeConversionIfNecessary(String propertyName, String fullPropertyName,
2.             Object oldValue, Object newValue, Class requiredType) throws TypeMismatchException {
4.         Object convertedValue = newValue;
6.         // Custom editor for this type?
7.         PropertyEditor pe = findCustomEditor(requiredType, fullPropertyName);
9.         // Value not of required type?
10.         if (pe != null ||
11.                 (requiredType != null &&
12.                 (requiredType.isArray() || !requiredType.isInstance(convertedValue)))) {
14.             if (requiredType != null) {
15.                 if (pe == null) {
16.                     // No custom editor -> check BeanWrapperImpl's default editors.
17.                     pe = (PropertyEditor) getDefaultEditor(requiredType);
18.                     if (pe == null) {
19.                         // No BeanWrapper default editor -> check standard JavaBean editors.
20.                         pe = PropertyEditorManager.findEditor(requiredType);
21.                     }
22.                 }
23.             }
25.             if (pe != null && !(convertedValue instanceof String)) {
26.                 // Not a String -> use PropertyEditor's setValue.
27.                 // With standard PropertyEditors, this will return the very same object;
28.                 // we just want to allow special PropertyEditors to override setValue
29.                 // for type conversion from non-String values to the required type.
30.                 try {
31.                     pe.setValue(convertedValue);
32.                     Object newConvertedValue = pe.getValue();
33.                     if (newConvertedValue != convertedValue) {
34.                         convertedValue = newConvertedValue;
35.                         // Reset PropertyEditor: It already did a proper conversion.
36.                         // Don't use it again for a setAsText call.
37.                         pe = null;
38.                     }
39.                 }
40.                 catch (IllegalArgumentException ex) {
41.                     throw new TypeMismatchException(
42.                             createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType, ex);
43.                 }
44.             }
46.             if (requiredType != null && !requiredType.isArray() && convertedValue instanceof String[]) {
47.                 // Convert String array to a comma-separated String.
48.                 // Only applies if no PropertyEditor converted the String array before.
49.                 // The CSV String will be passed into a PropertyEditor's setAsText method, if any.
50.                 if (logger.isDebugEnabled()) {
51.                     logger.debug("Converting String array to comma-delimited String [" + convertedValue + "]");
52.                 }
53.                 convertedValue = StringUtils.arrayToCommaDelimitedString((String[]) convertedValue);
54.             }
56.             if (pe != null && convertedValue instanceof String) {
57.                 // Use PropertyEditor's setAsText in case of a String value.
58.                 if (logger.isDebugEnabled()) {
59.                     logger.debug("Converting String to [" + requiredType + "] using property editor [" + pe + "]");
60.                 }
61.                 try {
62.                   //转换的点在这里，你可以清晰的看见；；；；；
    
63.                     pe.setValue(oldValue);
64.                     pe.setAsText((String) convertedValue);
65.                     convertedValue = pe.getValue();
66.                 }
67.                 catch (IllegalArgumentException ex) {
68.                     throw new TypeMismatchException(
69.                             createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType, ex);
70.                 }
71.             }
73.             if (requiredType != null) {
74.                 // Array required -> apply appropriate conversion of elements.
75.                 if (requiredType.isArray()) {
76.                     Class componentType = requiredType.getComponentType();
77.                     if (convertedValue instanceof Collection) {
78.                         // Convert Collection elements to array elements.
79.                         Collection coll = (Collection) convertedValue;
80.                         Object result = Array.newInstance(componentType, coll.size());
81.                         int i = 0;
82.                         for (Iterator it = coll.iterator(); it.hasNext(); i++) {
83.                             Object value = doTypeConversionIfNecessary(
84.                                     propertyName, propertyName + PROPERTY_KEY_PREFIX + i + PROPERTY_KEY_SUFFIX,
85.                                     null, it.next(), componentType);
86.                             Array.set(result, i, value);
87.                         }
88.                         return result;
89.                     }
90.                     else if (convertedValue != null && convertedValue.getClass().isArray()) {
91.                         // Convert Collection elements to array elements.
92.                         int arrayLength = Array.getLength(convertedValue);
93.                         Object result = Array.newInstance(componentType, arrayLength);
94.                         for (int i = 0; i < arrayLength; i++) {
95.                             Object value = doTypeConversionIfNecessary(
96.                                     propertyName, propertyName + PROPERTY_KEY_PREFIX + i + PROPERTY_KEY_SUFFIX,
97.                                     null, Array.get(convertedValue, i), componentType);
98.                             Array.set(result, i, value);
99.                         }
100.                         return result;
101.                     }
102.                     else if (convertedValue != null) {
103.                         // A plain value: convert it to an array with a single component.
104.                         Object result = Array.newInstance(componentType, 1);
105.                         Object value = doTypeConversionIfNecessary(
106.                                 propertyName, propertyName + PROPERTY_KEY_PREFIX + 0 + PROPERTY_KEY_SUFFIX,
107.                                 null, convertedValue, componentType);
108.                         Array.set(result, 0, value);
109.                         return result;
110.                     }
111.                 }
113.                 // If the resulting value definitely doesn't match the required type,
114.                 // try field lookup as fallback. If no matching field found,
115.                 // throw explicit TypeMismatchException with full context information.
116.                 if (convertedValue != null && !requiredType.isPrimitive() &&
117.                         !requiredType.isInstance(convertedValue)) {
119.                     // In case of String value, try to find matching field (for JDK 1.5
120.                     // enum or custom enum with values defined as static fields).
121.                     if (convertedValue instanceof String) {
122.                         try {
123.                             Field enumField = requiredType.getField((String) convertedValue);
124.                             return enumField.get(null);
125.                         }
126.                         catch (Exception ex) {
127.                             if (logger.isDebugEnabled()) {
128.                                 logger.debug("Field [" + convertedValue + "] isn't an enum value", ex);
129.                             }
130.                         }
131.                     }
133.                     // Definitely doesn't match: throw TypeMismatchException.
134.                     throw new TypeMismatchException(
135.                             createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType);
136.                 }
137.             }
138.         }
140.         return convertedValue;
141.     }