Primavera 3.0 MVC vincolante Enums Case Sensitive

Question

Se ho un RequestMapping in un controller primavera in questo modo ...

@RequestMapping(method = RequestMethod.GET, value = "{product}") 
public ModelAndView getPage(@PathVariable Product product) 

e di prodotto è un enum. per esempio. Product.Home

Quando ho richiedere la pagina, mysite.com/home

ottengo

Unable to convert value "home" from type 'java.lang.String' to type 'domain.model.product.Product'; nested exception is java.lang.IllegalArgumentException: No enum const class domain.model.product.Product.home 

c'è un modo per avere il convertitore tipo enum a capire che minuscolo casa è in realtà casa ?

Mi piacerebbe mantenere l'url case insensitive e le mie enumerazioni Java con lettere maiuscole standard.

Grazie

Soluzione

public class ProductEnumConverter extends PropertyEditorSupport 
{ 
    @Override public void setAsText(final String text) throws IllegalArgumentException 
    { 
     setValue(Product.valueOf(WordUtils.capitalizeFully(text.trim()))); 
    } 
} 

registrandolo

<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer"> 
     <property name="customEditors"> 
      <map> 
       <entry key="domain.model.product.Product" value="domain.infrastructure.ProductEnumConverter"/> 
      </map> 
     </property> 
    </bean> 

Aggiungi ai controllori che hanno bisogno di conversione speciale

@InitBinder 
public void initBinder(WebDataBinder binder) 
{ 
    binder.registerCustomEditor(Product.class, new ProductEnumConverter()); 
} 

Answer 1

In generale, si vuole creare un nuovo PropertyEditor che fa la normalizzazione per voi, e poi registrare che nel vostro controller in questo modo:

@InitBinder 
public void initBinder(WebDataBinder binder) { 

    binder.registerCustomEditor(Product.class, 
    new CaseInsensitivePropertyEditor()); 
} 

Answer 2

penso che si dovrà implement a Custom PropertyEditor.

Qualcosa di simile a questo:

public class ProductEditor extends PropertyEditorSupport{ 

    @Override 
    public void setAsText(final String text){ 
     setValue(Product.valueOf(text.toUpperCase())); 
    } 

} 

Vedi GaryF's answer su come legarlo

Ecco una versione più tollerante nel caso in cui si utilizza lettere minuscole nelle costanti enum (che probabilmente non dovrebbe, ma ancora):

@Override 
public void setAsText(final String text){ 
    Product product = null; 
    for(final Product candidate : Product.values()){ 
     if(candidate.name().equalsIgnoreCase(text)){ 
      product = candidate; 
      break; 
     } 
    } 
    setValue(product); 
} 

Answer 3

per aggiungere a @ di GaryF risposta, e di affrontare il tuo commento ad esso, è possibile dichiarare editor di proprietà personalizzati globali iniettando loro in un personalizzato AnnotationMethodHandlerAdapter. Spring MVC registra normalmente uno di questi per impostazione predefinita, ma puoi dargli uno appositamente configurato se lo desideri, ad es.

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
    <property name="webBindingInitializer"> 
    <bean class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer"> 
     <property name="propertyEditorRegistrars"> 
     <list> 
      <bean class="com.xyz.MyPropertyEditorRegistrar"/> 
     </list> 
     </property> 
    </bean> 
    </property> 
</bean> 

MyPropertyEditorRegistrar è un'istanza di PropertyEditorRegistrar, che a sua volta registra personalizzati PropertyEditor oggetti con Spring.

Dichiarare semplicemente che questo dovrebbe essere sufficiente.

Answer 4

E 'anche possibile creare un convertitore generico che funziona con tutte le enumerazioni come questo:

public class CaseInsensitiveConverter<T extends Enum<T>> extends PropertyEditorSupport { 

    private final Class<T> typeParameterClass; 

    public CaseInsensitiveConverter(Class<T> typeParameterClass) { 
     super(); 
     this.typeParameterClass = typeParameterClass; 
    } 

    @Override 
    public void setAsText(final String text) throws IllegalArgumentException { 
     String upper = text.toUpperCase(); // or something more robust 
     T value = T.valueOf(typeParameterClass, upper); 
     setValue(value); 
    } 
} 

Usage:

@InitBinder 
public void initBinder(WebDataBinder binder) { 
    binder.registerCustomEditor(MyEnum.class, new CaseInsensitiveConverter<>(MyEnum.class)); 
} 

O a livello mondiale come skaffman spiega