Exploring Spring's PropertyEditor

Transferred from: Exploring Spring's PropertyEditor - a short book

Introduction to propertyeditor & propertyeditorsupport

java.beans.PropertyEditor is a JDK built-in class and is provided to AWT. What is it used for? It means that the string input by the user in the graphic face converts the value (object) of the corresponding type. Similar to a converter.

public interface PropertyEditor {

    void setValue(Object value);

    Object getValue();

    boolean isPaintable();

    String getJavaInitializationString();

    String getAsText();

    void setAsText(String text) throws java.lang.IllegalArgumentException;

    String[] getTags();

    java.awt.Component getCustomEditor();

    boolean supportsCustomEditor();

    void addPropertyChangeListener(PropertyChangeListener listener);

    void removePropertyChangeListener(PropertyChangeListener listener);


There are four main methods

  • void setValue(Object value); Set attribute value
  • Object getValue(); Get property value
  • String getAsText(); Convert property value to string
  • void setAsText(String text); Convert string to property value

Java also provides us with a default implementation class java.beans.PropertyEditorSupport

private Object value;
public void setValue(Object value) {
    this.value = value;

public Object getValue() {
    return value;
public void setAsText(String text) throws java.lang.IllegalArgumentException {
    if (value instanceof String) {
    throw new java.lang.IllegalArgumentException(text);
public String getAsText() {
    return (this.value != null)
    ? this.value.toString()
    : null;

As long as we override setAsText and getAsText methods, we can realize the conversion from String type to specific type

Relationship with Spring

After talking for so long, does this have anything to do with Spring?

Let's think, when you use the xml configuration file to set a Value for an attribute (or use the @ Value annotation to give a default Value), whether we enter a string, but the type of the attribute we correspond to is not necessarily a character string type. In this scenario, is it the same as the AWT scenario. Therefore, Spring's property interpretation is inherited from PropertyEditorSupport, and then rewrites setAsText and getAsText

for instance

public class CustomBooleanEditor extends PropertyEditorSupport {

   public static final String VALUE_TRUE = "true";

   public static final String VALUE_FALSE = "false";

   public static final String VALUE_ON = "on";

   public static final String VALUE_OFF = "off";

   public static final String VALUE_YES = "yes";

   public static final String VALUE_NO = "no";

   public static final String VALUE_1 = "1";

   public static final String VALUE_0 = "0";

    // When it is true, the string is null by default
   private final String trueString;
    // When it is false, the string is null by default
   private final String falseString;
    // Allow null s 
    // Empty strings are not allowed when the basic type is boolean
    // Null strings are allowed when referencing type Boolean
   private final boolean allowEmpty;

   public CustomBooleanEditor(boolean allowEmpty) {
      this(null, null, allowEmpty);
   public CustomBooleanEditor(@Nullable String trueString, @Nullable String falseString, boolean allowEmpty) {
      this.trueString = trueString;
      this.falseString = falseString;
      this.allowEmpty = allowEmpty;

   public void setAsText(@Nullable String text) throws IllegalArgumentException {
      String input = (text != null ? text.trim() : null);

      if (this.allowEmpty && !StringUtils.hasLength(input)) {
         // Treat empty String as null value.
      } else if (this.trueString != null && this.trueString.equalsIgnoreCase(input)) {
      } else if (this.falseString != null && this.falseString.equalsIgnoreCase(input)) {
      } else if (this.trueString == null &&
            (VALUE_TRUE.equalsIgnoreCase(input) || VALUE_ON.equalsIgnoreCase(input) ||
                  VALUE_YES.equalsIgnoreCase(input) || VALUE_1.equals(input))) {
      } else if (this.falseString == null &&
            (VALUE_FALSE.equalsIgnoreCase(input) || VALUE_OFF.equalsIgnoreCase(input) ||
                  VALUE_NO.equalsIgnoreCase(input) || VALUE_0.equals(input))) {
      } else {
         throw new IllegalArgumentException("Invalid boolean value [" + text + "]");

   public String getAsText() {
      if (Boolean.TRUE.equals(getValue())) {
         return (this.trueString != null ? this.trueString : VALUE_TRUE);
      } else if (Boolean.FALSE.equals(getValue())) {
         return (this.falseString != null ? this.falseString : VALUE_FALSE);
      } else {
         return "";


The method is also very simple. I won't explain it in detail

for instance

public class Job {

   private boolean completed;

   private Boolean started;
   // get and set ...........

<bean class="com.demo.property.editor.Job" id="job">
   <property name="completed" value="on" />
   <property name="started" value=""/>

Get this bean and print Job{completed=true, started=null}

Introduction to related components


You can see from the name that it is a registered interface

void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor);

void registerCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath, PropertyEditor propertyEditor);

PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath);


Implementation Class of PropertyEditorRegistry. When we try to get the corresponding PropertyEditor through the Class object, it will initialize a series of default propertyeditors for us

In the populateBean of doCreateBean, getDefaultEditor will be called to obtain the corresponding PropertyEditor for value type conversion

// The property editor provided by spring by default
private Map<Class<?>, PropertyEditor> defaultEditors;

// To override the default property editor
private Map<Class<?>, PropertyEditor> overriddenDefaultEditors;

// Some custom property editor s
private Map<Class<?>, PropertyEditor> customEditors;

// Path / property name of the property. CustomEditorHolder contains Class and PropertyEditor
private Map<String, CustomEditorHolder> customEditorsForPath;

// If the registered parent class and the child class cannot be found, the parent class will be returned and the relationship will be saved in
// In this map
private Map<Class<?>, PropertyEditor> customEditorCache;

    public PropertyEditor getDefaultEditor(Class<?> requiredType) {
        if (!this.defaultEditorsActive) {
            return null;
        if (this.overriddenDefaultEditors != null) {
            PropertyEditor editor = this.overriddenDefaultEditors.get(requiredType);
            if (editor != null) {
                return editor;
        if (this.defaultEditors == null) {
        return this.defaultEditors.get(requiredType);

    private void createDefaultEditors() {
        this.defaultEditors = new HashMap<>(64);

        // Simple editors, without parameterization capabilities.
        // The JDK does not contain a default editor for any of these target types.
        this.defaultEditors.put(Charset.class, new CharsetEditor());
        this.defaultEditors.put(Class.class, new ClassEditor());
        this.defaultEditors.put(Class[].class, new ClassArrayEditor());
        this.defaultEditors.put(Currency.class, new CurrencyEditor());
        this.defaultEditors.put(File.class, new FileEditor());
        this.defaultEditors.put(InputStream.class, new InputStreamEditor());
        this.defaultEditors.put(InputSource.class, new InputSourceEditor());
        this.defaultEditors.put(Locale.class, new LocaleEditor());
        this.defaultEditors.put(Path.class, new PathEditor());
        this.defaultEditors.put(Pattern.class, new PatternEditor());
        this.defaultEditors.put(Properties.class, new PropertiesEditor());
        this.defaultEditors.put(Reader.class, new ReaderEditor());
        this.defaultEditors.put(Resource[].class, new ResourceArrayPropertyEditor());
        this.defaultEditors.put(TimeZone.class, new TimeZoneEditor());
        this.defaultEditors.put(URI.class, new URIEditor());
        this.defaultEditors.put(URL.class, new URLEditor());
        this.defaultEditors.put(UUID.class, new UUIDEditor());
        this.defaultEditors.put(ZoneId.class, new ZoneIdEditor());

        // Default instances of collection editors.
        // Can be overridden by registering custom instances of those as custom editors.
        this.defaultEditors.put(Collection.class, new CustomCollectionEditor(Collection.class));
        this.defaultEditors.put(Set.class, new CustomCollectionEditor(Set.class));
        this.defaultEditors.put(SortedSet.class, new CustomCollectionEditor(SortedSet.class));
        this.defaultEditors.put(List.class, new CustomCollectionEditor(List.class));
        this.defaultEditors.put(SortedMap.class, new CustomMapEditor(SortedMap.class));

        // Default editors for primitive arrays.
        this.defaultEditors.put(byte[].class, new ByteArrayPropertyEditor());
        this.defaultEditors.put(char[].class, new CharArrayPropertyEditor());

        // The JDK does not contain a default editor for char!
        this.defaultEditors.put(char.class, new CharacterEditor(false));
        this.defaultEditors.put(Character.class, new CharacterEditor(true));

        // Spring's CustomBooleanEditor accepts more flag values than the JDK's default editor.
        this.defaultEditors.put(boolean.class, new CustomBooleanEditor(false));
        this.defaultEditors.put(Boolean.class, new CustomBooleanEditor(true));

        // The JDK does not contain default editors for number wrapper types!
        // Override JDK primitive number editors with our own CustomNumberEditor.
        this.defaultEditors.put(byte.class, new CustomNumberEditor(Byte.class, false));
        this.defaultEditors.put(Byte.class, new CustomNumberEditor(Byte.class, true));
        this.defaultEditors.put(short.class, new CustomNumberEditor(Short.class, false));
        this.defaultEditors.put(Short.class, new CustomNumberEditor(Short.class, true));
        this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));
        this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));
        this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));
        this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));
        this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));
        this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));
        this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));
        this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));
        this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));
        this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));

        // Only register config value editors if explicitly requested.
        if (this.configValueEditorsActive) {
            StringArrayPropertyEditor sae = new StringArrayPropertyEditor();
            this.defaultEditors.put(String[].class, sae);
            this.defaultEditors.put(short[].class, sae);
            this.defaultEditors.put(int[].class, sae);
            this.defaultEditors.put(long[].class, sae);


In Spring, the bean wrapper type is used to encapsulate beans, and it indirectly inherits PropertyEditorRegistry. BeanWrapperImpl is the implementation class of BeanWrapper. Most of the propertyeditorregistrys we see in the system are BeanWrapperImpl objects. BeanWrapperImpl also inherits the implementation class PropertyEditorRegistrySupport


Registry of property editor

void registerCustomEditors(PropertyEditorRegistry registry);


The only default implementation class

public class ResourceEditorRegistrar implements PropertyEditorRegistrar {

   private final PropertyResolver propertyResolver;

   private final ResourceLoader resourceLoader;

   public ResourceEditorRegistrar(ResourceLoader resourceLoader, PropertyResolver propertyResolver) {
      this.resourceLoader = resourceLoader;
      this.propertyResolver = propertyResolver;

   public void registerCustomEditors(PropertyEditorRegistry registry) {
      ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);
      doRegisterEditor(registry, Resource.class, baseEditor);
      doRegisterEditor(registry, ContextResource.class, baseEditor);
      doRegisterEditor(registry, InputStream.class, new InputStreamEditor(baseEditor));
      doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));
      doRegisterEditor(registry, File.class, new FileEditor(baseEditor));
      doRegisterEditor(registry, Path.class, new PathEditor(baseEditor));
      doRegisterEditor(registry, Reader.class, new ReaderEditor(baseEditor));
      doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));

      ClassLoader classLoader = this.resourceLoader.getClassLoader();
      doRegisterEditor(registry, URI.class, new URIEditor(classLoader));
      doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));
      doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));

      if (this.resourceLoader instanceof ResourcePatternResolver) {
         doRegisterEditor(registry, Resource[].class,
               new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));

   private void doRegisterEditor(PropertyEditorRegistry registry, Class<?> requiredType, PropertyEditor editor) {
      if (registry instanceof PropertyEditorRegistrySupport) {
         ((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(requiredType, editor);
      else {
         registry.registerCustomEditor(requiredType, editor);


First, let's talk about where this class is used. This Registrar will be used only when ApplicationContext is used. The above PropertyEditor will register or override the default value of PropertyEditorRegistry

The calling relationship chain is

ClassPathXmlApplicationContext Constructor -> refresh -> prepareBeanFactory() -> establish ResourceEditorRegistrar increase to Set in

Then it will register the default PropertyEditor of resourceeditorregister in the createbean instance of doCreateBean



public class Job {

    private boolean completed;

    private Content content;
    // get and set method

public class Content {
    private String details;
    private String type;
    private int priority;
    // get and set method

<bean class="com.demo.property.editor.Job" id="job" lazy-init="true">
   <property name="completed" value="off" />
   <property name="content" value="Pay attention to me:urgent:100"/>

ClassPathXmlApplicationContext classPathXmlApplicationContext =
      new ClassPathXmlApplicationContext("property.editor/coderLi.xml");

classPathXmlApplicationContext.getBeanFactory().addPropertyEditorRegistrar(registry -> {
   if (registry instanceof PropertyEditorRegistrySupport) {
      ((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(Content.class, new ContentPropertyEditor());
   } else {
      registry.registerCustomEditor(Content.class, new ContentPropertyEditor());

Object job = classPathXmlApplicationContext.getBean("job");

There are many methods to achieve the same effect, such as CustomEditorConfigurer, beanfactoryprocessor interface, and so on

As I implemented in the above code, one thing to note is that this bean must be a delayed instantiation, because ApplicationContext will instantiate all non lazy beans by default. At this time, our PropertyEditor has not been registered, and an error will be reported

Author: official account CoderLi
Link: https://www.jianshu.com/p/a0ce60d05778

Tags: Spring

Posted on Tue, 19 Oct 2021 15:03:37 -0400 by Donny Bahama