Register converters and converterFactories with annotations in Spring 3

Question

First of all ... Im relatively new in Spring, I use spring 3.x and I DONT LIKE SPRING'S XML CONFIGURATION FILES ... I dont want for every refactoring I do, to run into XML file for updates ...

I'm trying to configure spring in a way that for any request, if I have some @RequestParam/@RequestBody/@PathVariable etc with type other than String in my hadlers, spring will convert values to that type correctly or put null to handler's args (I never use primitive types in handler arguments). So far so good ...

Until now I've registered all converter/converterFactory classes like this:

 <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
     <property name="converters">
         <list>
             <!-- converters is a set of both converters and converterfactories -->
             <bean class="controller.converters.enumConverter" />
             <bean class="controller.converters.integerConverter" />
             <bean class="controller.converters.objects.FooConverter" />
             ...
         </list>
     </property>
 </bean>

Is there any way to register converters with annotations?

Can anything (or just basic stuff) about spring XML be done with annotations only, and get rid of XML configuration once and for all? ... and how?

Answer 1

Spring does not have annotation support for Converters, but you can build your own.

All you need is an custom qualifier annotation (lets call it @AutoRegistered ) and some kind of Converter/Formatter Registrar (implements FormatterRegistrar) that registers all the Spring Beans with this @AutoRegistered annotation (and some xml to register this registration service).

Then you need to annotate your conveter with this annotation (and some other annotation to make it a spring bean) and that is all.

@AutoRegistered annotation:

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface AutoRegistered {}

Registration service:

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.convert.converter.Converter;
import org.springframework.format.FormatterRegistrar;
import org.springframework.format.FormatterRegistry;

public class AutoregisterFormatterRegistrar implements FormatterRegistrar {

    /**
     * All {@link Converter} Beans with {@link AutoRegistered} annotation.
     * If spring does not find any matching bean, then the List is {@code null}!.
     */
    @Autowired(required = false)
    @AutoRegistered
    private List<Converter<?, ?>> autoRegisteredConverters;


    @Override
    public void registerFormatters(final FormatterRegistry registry) {
        if (this.autoRegisteredConverters != null) {
            for (Converter<?, ?> converter : this.autoRegisteredConverters) {
                registry.addConverter(converter);
            }
        }
    }
}

XML configuration for the registrar:

<bean id="applicationConversionService"
    class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="formatterRegistrars">
        <set>
            <bean
                class="AutoregisterFormatterRegistrar"
                autowire="byType" />
        </set>
    </property>
</bean>

BTW for your enum converter you do not need a ConversionFactory - a simple converter is enough:

@AutoRegistered
@Component
public class EnumConverter implements Converter<Enum<?>, String> {

    /** Use the same immutable value instead of creating an new array every time. */
    private static final Object[] NO_PARAM = new Object[0];

    /** The prefix of all message codes. */
    private static final String PREFIX = "label_";

    /** The separator in the message code, between different packages
        as well as between package can class. */
    private static final String PACKAGE_SEPARATOR = "_";

    /** The separator in the message code, between the class name
        and the enum case name. */
    private static final String ENUM_CASE_SEPARATOR = "_";

    /** The message source. */
    private MessageSource messageSource;

    @Autowired
    public EnumConverter(final MessageSource messageSource) {
        if (messageSource == null) {
            throw new RuntimeException("messageSource must not be null");
        }

        this.messageSource = messageSource;
    }

    @Override
    public String convert(final Enum<?> source) {
        if (source != null) {
            String enumValueName = source.name();
            String code = PREFIX + source.getClass().getName().toLowerCase().
                  replace(".", PACKAGE_SEPARATOR)
            + ENUM_CASE_SEPARATOR + enumValueName.toLowerCase();

            String message = messageSource.getMessage(code, NO_PARAM, enumValueName,
                                                  LocaleContextHolder.getLocale());

             return message;
         } else {
            return "";
         }
     }   
}

Answer 2

Automatic registration of Converter beans is also provided by Spring Boot when @EnableAutoConfiguration is turned on - see Spring Boot features. It appears that no additional annotations (other than marking each converter bean as a @Component) is required for this.

Answer 3

First you have to define an annotation: TypeConverter

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface TypeConverter {
}

Then you have to register the conversion service and add all of the beans that have the annotation. This will be done with the following post processor:

public class ConverterRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    registry.registerBeanDefinition("conversionService", BeanDefinitionBuilder.rootBeanDefinition(ConversionServiceFactoryBean.class).getBeanDefinition());
}

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    Map<String, Object> beansWithAnnotation = beanFactory.getBeansWithAnnotation(TypeConverter.class);
    Collection converters = beansWithAnnotation.values();
    DefaultConversionService conversionService = (DefaultConversionService) beanFactory.getBean("conversionService");
    for (Object converter : converters) {
        conversionService.addConverter((Converter<?, ?>) converter);
    }
}
}

If you need more details check this blog entry

Answer 4

The approach outlined by @Ralph is neat, I have +1'd his answer. Let me also recommend an alternative approach which is using @Configuration support - essentially a way to configure Spring beans using Java instead of xml. With this approach the message converters can be registered this way:

 @Configuration
 @EnableWebMvc
 @ComponentScan(...)
 public class CustomConfig extends WebMvcConfigurerAdapter {


    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new EnumConverter());
                converters.add(new FooConverter());
                ...
    }

 }

Answer 5

With Spring MVC 3.2, you can create a conversion service class that extends the DefaultFormattingConversionService e.g

ApplicationConversionService.java

import org.springframework.format.support.DefaultFormattingConversionService;
import org.springframework.stereotype.Component;

@Component("conversionService")
public class ApplicationConversionService extends DefaultFormattingConversionService  { 

    public ApplicationConversionService(){
        //DefaultFormattingConversionService's default constructor
        //creates default formatters and converters
        super(); //no need for explicit super()?

        //add custom formatters and converters
        addConverter(new MyConverter());
    }

}

and specify it in the spring config e.g

dispatcher-servlet.xml

<mvc:annotation-driven conversion-service="conversionService"/>

Answer 6

I am not sure if this works in Spring 3 but this is the solution for Spring 4:

@Configuration
@EnableWebMvc
class WebMvcContext extends WebMvcConfigurerAdapter {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new DateConverter("yyyy-MM-dd HH:mm:ss"));
        //registry.addConverter(anotherConverter);
    }
}

DateConverter is a custom converter:

public class DateConverter implements Converter<String, Date>{
    private static final Logger LOGGER = LoggerFactory.getLogger(DateConverter.class);
    private final String dateFormat;
    private final SimpleDateFormat formatter;
    public DateConverter(String dateFormatPattern) {
        this.dateFormat = dateFormatPattern;
        this.formatter = new SimpleDateFormat(dateFormatPattern);
    }

    @Override
    public Date convert(String source) {
        Date date = null;
        try {
            date = formatter.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

Answer 7

Do the following:

@SpringBootApplication
@PropertySources({ @PropertySource("classpath:application.properties") })
public class YourApplication {

public static void main(String[] args) {
    SpringApplication.run(YourApplication.class, args);

    ConversionService conversionService = DefaultConversionService.getSharedInstance();
    ConverterRegistry converters = (ConverterRegistry) conversionService;
    converters.addConverter(new LocalDateToStringConverter());

    }

}

Where LocalDateToStringConverter looks like this.

public class LocalDateToStringConverter implements Converter<LocalDate, String> {

@Override
public String convert(LocalDate localDate) {
    try {

        String date = localDate.format(DateTimeFormatter.ofPattern("dd-MM-yyyy"));
        return date;
    } catch(DateTimeParseException ex) {
    }
    return null;
  }
}