Bind de um HashMap num formulário HTML com SpringFramework

Assuntos Gerais Agile
#1

Daí gurizada,

Seguinte, fucei pelo fórum todo e não achei nada que pudesse ajudar.
Eis a minha situação:
Eu tenho uma classe que tem um atributo do tipo HashMap.

O que eu preciso:
Utilizar esse HashMap em um formulário pra depois alterar/salvar.

O que eu to utilizando:
Curto e grosso: Spring.
Mais detalhado, SimpleFormController e PropertyEditorSupport.

Onde to apanhando:
Não to sabendo como fazer o bind do HashMap com o formulário.
Até tive idéias de criar um combobox e vincular nele o valor como “key = value” pra ficar exibindo e tudo mais, só que o sofrimento tá na hora de fazer o bind.

Sugestões ?

[]s

#2

Daí rapaziada!

Achei a solução, mas esqueci de postar.
Basicamente eu tive que extender a classe PropertyEdditorSupport e criar (copiar adaptando as classes) os métodos para utilizarem Map ao invés de Collection.
Não é a mais linda das classes, mas me serviu direitinho.
Abaixo segue o código.

import java.beans.PropertyEditorSupport;
import java.lang.reflect.Array;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.hibernate.collection.PersistentMap;
import org.springframework.core.CollectionFactory;

public class ParameterMapEditor extends PropertyEditorSupport
{

    private final Class mapType;

    public ParameterMapEditor(Class mapType)
    {
        if (mapType == null)
        {
            throw new IllegalArgumentException("Map type is required");
        }
        if (!Set.class.isAssignableFrom(mapType))
        {            
            if (!Map.class.isAssignableFrom(mapType))
            {
                throw new IllegalArgumentException("Map type [" + mapType.getName() + "] does not implement [java.util.Map]");
            }
        }
        this.mapType = mapType;
    }

    @SuppressWarnings("unchecked")
    public void setValue(Object value)
    {
        if (value == null)
        {
            super.setValue(createMap(this.mapType, 0));
        }

        else if (this.mapType.isInstance(value))
        {
            super.setValue(value);
        }
        else if (value instanceof PersistentMap)
        {
            Map source = (PersistentMap) value;
            Map target = createMap(this.mapType, source.size());
            
            target.putAll((Map) convertElement(value));
            
            super.setValue(target);
        }
        else if (value instanceof Map)
        {
            Map source = (Map) value;
            Map target = createMap(this.mapType, source.size());

            target.putAll((Map) convertElement(source));

            super.setValue(target);
        }
        else if (value.getClass().isArray())
        {
            Map target = (Map) convertElement(value);
            
            super.setValue(target);
        }
        else
        {
            Map target = createMap(this.mapType, 1);
            Map convertedSource = (Map) convertElement(value);

            target.putAll(convertedSource);

            super.setValue(target);
        }
    }

    protected Map createMap(Class collectionType, int initialCapacity)
    {
        if (!collectionType.isInterface())
        {
            try
            {
                return (Map) collectionType.newInstance();
            }
            catch (Exception ex)
            {
                throw new IllegalArgumentException("Could not instantiate map class [" + collectionType.getName() + "]: " + ex.getMessage());
            }
        }
        else
        {
            return CollectionFactory.createLinkedMapIfPossible(initialCapacity);
        }
    }

    @SuppressWarnings("unchecked")
    protected Object convertElement(Object element)
    {
        Map<String, String> aux = new HashMap<String, String>(0);
        
        if (element.getClass().isArray())
        {
            int tamanhoLista;
            tamanhoLista = Array.getLength(element);
            aux = new HashMap<String, String>(tamanhoLista);
            
            StringTokenizer st;
            for (int i = 0; i < tamanhoLista; i++)
            {
                st = new StringTokenizer(String.valueOf(Array.get(element, i)), "#");
                aux.put(st.nextToken(), st.nextToken());
            }
        }
        else if (element instanceof String)
        {
            aux = new HashMap<String, String>(1);
            StringTokenizer st = new StringTokenizer((String)element, "#");
            aux.put(st.nextToken(), st.nextToken());
        }
        else 
        {
            Class[] classes = element.getClass().getInterfaces();
            for (Class class1 : classes)
            {
                if (class1.equals(Map.class))
                {
                    aux.putAll( (Map<String, String>) element );
                }
                
            }
        }

        return aux;
    }
    
    public void setAsText(String text) throws IllegalArgumentException 
    {
        setValue(text);
    }
    
    public String getAsText() 
    {
        return null;
    }

}

[]s

#3