Registre des convertisseurs et des converterFactories avec des annotations au Printemps 3

Printemps n'ont pas d'annotation de soutien pour les Convertisseurs, mais vous pouvez construire votre propre.

Tous vous avez besoin est une coutume qualifier d'annotation (appelons cela @AutoRegistered ) et une sorte de Convertisseur/Formateur Greffier (implémente FormatterRegistrar) qui enregistre toutes les Beans Spring avec cette @AutoRegistered annotation (et un peu de xml pour enregistrer ce service d'enregistrement).

Alors vous avez besoin d'annoter votre conveter avec cette annotation (et quelques autres annotation pour le faire
un printemps bean) et c'est tout.

@AutoRegistered annotation:

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

Service d'enregistrement:

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);
            }
        }
    }
}

De configuration XML pour le greffier:

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

BTW pour votre enum convertisseur vous n'avez pas besoin d'un ConversionFactory - un convertisseur simple suffit:

@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 "";
         }
     }   
}

OriginalL'auteur Ralph

L'enregistrement automatique du Convertisseur de haricots est également prévu pour le Printemps de Démarrage lorsque @EnableAutoConfiguration est activée - voir Caractéristiques des bottes de printemps. Il semble qu'aucune annotations supplémentaires (autres que le marquage de chaque convertisseur de haricots comme une @Component) est nécessaire pour cela.

OriginalL'auteur Steve Chambers

Avec Spring MVC, 3.2, vous pouvez créer un service de conversion de classe qui étend la 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());
    }

}

et le spécifier dans le printemps config e.g

dispatcher-servlet.xml

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

OriginalL'auteur Timothy Anyona