Comments on: Java: BeanUtils Enum Support - generic Enum converter

By: steff

steff — Wed, 14 Dec 2011 08:28:37 +0000

Another way is to overrider register and lookup methods:

@Override
public void register(Converter converter, Class aClass) {
if (aClass.equals(Enum.class)){
enumConverter = converter;
}
super.register(converter, aClass);

}

@Override
public Converter lookup(Class aClass) {

if (aClass.isEnum() && enumConverter != null){
return enumConverter;
}
return super.lookup(aClass);
}

In that scenario you are free to implement and regiseter more complex converters.

By: jeremychone

jeremychone — Sat, 25 Jul 2009 05:03:43 +0000

@greg, tx for your comments. I like your proposal. (I also fixed your layout).

By: greg

greg — Fri, 17 Jul 2009 20:04:57 +0000

While writing the above, I came up with a possibly slightly more elegant and performant version. It should avoid checking for class.isEnum for each and every conversion.

class EnumAwareConvertUtilsBean extends ConvertUtilsBean {
    private final EnumConverter enumConverter = new EnumConverter();

    public Converter lookup(Class clazz) {
        final Converter converter = super.lookup(clazz);
        // no specific converter for this class, so it's neither a String, (which has a default converter),
        // nor any known object that has a custom converter for it. It might be an enum !
        if (converter == null && clazz.isEnum()) {
            return enumConverter;
        } else {
            return converter;
        }
    }

    private class EnumConverter implements Converter {
        public Object convert(Class type, Object value) {
            return Enum.valueOf(type, (String) value);
        }
    }
}

By: greg

greg — Fri, 17 Jul 2009 19:52:00 +0000

Thanks for this ! So far, I was using the static BeanUtils.convert() method, and all I could do was ConvertUtil.register(…, String.class) - overriding the default String converter with a custom converter that would essentially do the same as above if the target was an enum. I hated the all-static nature of this (if I register the converter at some point during the lifetime of my application, the behaviour basically changes globally and randomly) and the ugliness of it (replacing the default String2String converter!?)

An intermediate approach might be to use the non-static methods like here, the default ConvertUtilsBean implementation, but register the default String converter on a “controlled” instance of it.