Un comando di tipo Spring può essere una mappa?

Question

Un comando di tipo Spring può essere una mappa? Ho eseguito il comando su una mappa estendendo HashMap e facendo riferimento alle proprietà utilizzando la notazione ['property'] ma non ha funzionato.

Comando: forma

public class MyCommand extends HashMap<String, Object> { 
} 

HTML:

Name: <form:input path="['name']" /> 

genera l'errore:

org.springframework.beans.NotReadablePropertyException: Invalid property '[name]' of bean class [com.me.MyCommand]: Bean property '[name]' is not readable or has an invalid getter method: Does the return type of the getter match the parameter type of the setter? 

E` non consentito o devo sintassi non corretta?

Answer 1

I comandi MVC di Springn devono utilizzare i nomi di convein di JavaBeans (ad esempio getXXX() e setXXX()), quindi non è possibile utilizzare una mappa per questo.

Un'alternativa è quella di avere un fagiolo con una singola mappa di proprietà ovvero:

public class MyCommand { 
    private final Map<String, Object> properties = new HashMap<String, Object>(); 

    public Map<String, Object> getProperties() { return properties; } 
    // setter optional 
} 

allora si può fare qualcosa di simile (non sicuro al 100% sulla sintassi, ma è possibile):

Name: <form:input path="properties['name']" /> 

Answer 2

Sì, ma ... È necessario fare riferimento come <form:input path="name[index].key|value"/> ad es.

<form:input path="name[0].value"/>

Answer 3

Ok Ho una soluzione che funziona per me io uso MapUtils.lazyMap

// Il mio dominio Root

public class StandardDomain { 

     private Map<String, AnotherDomainObj> templateMap= MapUtils.lazyMap(new HashMap<String, AnotherDomainObj>(),FactoryUtils.instantiateFactory(AnotherDomainObj.class)); 

     public Map<String, AnotherDomainObj> getTemplateContentMap() { 
      return templateMap; 
     } 

     public void setTemplateContentMap(Map<String, AnotherDomainObj > templateMap) { 
      templateMap = templateMap; 
     } 

    } 

// mio secondo dominio

public class AnotherDomainObj { 

    String propertyValue=""; 

     public String getPropertyValue() { 
      return propertyValue; 
     } 

     public void setPropertyValue(String propertyValue) { 
      this.propertyValue = propertyValue; 
    } 



} 

// Nel mio JSP

<input type="text" value="testthis" name="templateMap['keyName'].propertyValue"/> 

Answer 4

Combinando la risposta di Cletus e dbell ho potuto effettivamente farlo funzionare e vorrebbe condividere la soluzione con voi (compreso legame di valori al momento della presentazione del modulo, un difetto segnalato per soluzione Cletus)

Non è possibile utilizzare direttamente una mappa come di comando, tuttavia hanno un altro oggetto di dominio che ha bisogno di avvolgere una mappa pigro

public class SettingsInformation { 

    private Map<String, SettingsValue> settingsMap= MapUtils.lazyMap(new HashMap<String, SettingsValue>(),FactoryUtils.instantiateFactory(SettingsValue.class)); 

    public Map<String, SettingsValue> getSettingsMap() { 
     return settingsMap; 
    } 

    public void setSettingsMap(Map<String, SettingsValue > settingsMap) { 
     this.settingsMap = settingsMap; 
    } 

} 

SettingsValue è una classe che in realtà avvolge il valore.

public class SettingsValue { 

private String value; 

public SettingsValue(String value) { 
    this.value = value; 
} 


public SettingsValue() { 

} 

public String getValue() { 

    return value; 
} 

public void setValue(String propertyValue) { 

    this.value = propertyValue; 
} 

Il metodo di controllo che fornisce il modello si presenta così:

@RequestMapping(value="/settings", method=RequestMethod.GET) 
public ModelAndView showSettings() { 

    ModelAndView modelAndView = new ModelAndView("settings"); 

    SettingsDTO settingsDTO = settingsService.getSettings(); 
    Map<String, String> settings = settingsDTO.getSettings(); 

    SettingsInformation settingsInformation = new SettingsInformation(); 

    for (Entry<String, String> settingsEntry : settings.entrySet()) { 
     SettingsValue settingsValue = new SettingsValue(settingsEntry.getValue()); 
     settingsInformation.getSettingsMap().put(settingsEntry.getKey(), settingsValue); 
    } 

    modelAndView.addObject("settings", settingsInformation); 

    return modelAndView; 
} 

Il modulo dovrebbe essere simile

<form:form action="${actionUrl}" commandName="settings"> 
     <form:input path="settingsMap['exampleKey'].value"/> 
     <input type="submit" value="<fmt:message key="settings.save"/>"/> 
</form:form> 

La forma movimentazione metodo di controllo presentazione funziona come al solito

@RequestMapping(value="/settings", method=RequestMethod.POST) 
public ModelAndView updateSettings(@ModelAttribute(value="settings") SettingsInformation settings) { 
[...] 
} 

Ho verificato che il bean di SettingsInformation sia effettivamente riempito con i valori nel modulo.

Grazie per avermi aiutato con questo; Se avete domande non esitate a chiedere.