Générer Map<String,String> à partir de POJO

J'ai un POJO, et une (actuellement n'est pas encore construit) de la classe qui sera de retour les Listes. J'aimerais générer automatiquement le code nécessaire pour le POJO être consulté sur une Carte. Est-ce une bonne idée, est-il possible de le faire automatiquement, et ai-je besoin de le faire manuellement pour chaque POJO j'ai envie de le traiter de cette façon?

Grâce,
Andy

OriginalL'auteur Andrew Toulouse | 2010-07-09

  1. 16

    Vous pouvez utiliser Communes BeanUtils BeanMap pour cela.

    Map map = new BeanMap(someBean);

    Mise à jour: puisque ce n'est pas une option en raison de certains apparente de la bibliothèque des problèmes de dépendance à Android, voici une base de lancement pour exemple la façon dont vous pourriez le faire avec un peu d'aide de La réflexion de l'API:

    public static Map<String, Object> mapProperties(Object bean) throws Exception {
    Map<String, Object> properties = new HashMap<>();
    for (Method method : bean.getClass().getDeclaredMethods()) {
        if (Modifier.isPublic(method.getModifiers())
            && method.getParameterTypes().length == 0
            && method.getReturnType() != void.class
            && method.getName().matches("^(get|is).+")
        ) {
            String name = method.getName().replaceAll("^(get|is)", "");
            name = Character.toLowerCase(name.charAt(0)) + (name.length() > 1 ? name.substring(1) : "");
            Object value = method.invoke(bean);
            properties.put(name, value);
        }
    }
    return properties;
}

    Si java.haricots API sont disponibles, alors vous pourriez faire:

    public static Map<String, Object> mapProperties(Object bean) throws Exception {
    Map<String, Object> properties = new HashMap<>();
    for (PropertyDescriptor property : Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors()) {
        String name = property.getName();
        Object value = property.getReadMethod().invoke(bean);
        properties.put(name, value);
    }
    return properties;
}
    Holy crap! Qui a l'air super utile! Savez-vous quelque chose à propos de ses implications sur les performances?
    La réflexion a toujours un coût. Rien à faire contre. Mais vous pouvez faire confiance que le BeanUtils les gars ont optimisé autant que possible. C'est un très populaire de la bibliothèque.
    Cool. Dois-je mettre en œuvre toute sorte d'interface sur mon Pojo, ou à l'aide de get* nommage assez (je suis en utilisant immuable Pojo w/ les constructeurs privés instancié en utilisant un Générateur de rapports)?
    Il suit le JavaBean™ spécification, oui. Pas sûr au sujet de privé c'tors bien, mais un public de non-arg constructeur n'a logiquement pas semblent être nécessaires pour générer une carte basée sur une instance existante.
    Je suis d'accord. *croise les doigts*. Merci pour votre aide!

    OriginalL'auteur BalusC

  2. 1

    Voici ma propre mise en œuvre, sans dépendances. Plutôt que de faire une copie de l'état de l'objet, il met en place une Carte en direct sur le pojo. Android ne prend pas en charge java.les haricots, mais vous pouvez utiliser openbeans à la place.

    import java.beans.*;  //Or, import com.googlecode.openbeans.*
import java.util.*;
public class BeanMap extends AbstractMap<String, Object> {
private static final Object[] NO_ARGS = new Object[] {};
private HashMap<String, PropertyDescriptor> properties;
private Object bean;
public BeanMap(Object bean) throws IntrospectionException {
this.bean = bean;
properties = new HashMap<String, PropertyDescriptor>();
BeanInfo info = Introspector.getBeanInfo(bean.getClass());
for(PropertyDescriptor property : info.getPropertyDescriptors()) {
properties.put(property.getName(), property);
}
}
@Override public Object get(Object key) {
PropertyDescriptor property = properties.get(key);
if(property == null)
return null;
try {
return property.getReadMethod().invoke(bean, NO_ARGS);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override public Object put(String key, Object value) {
PropertyDescriptor property = properties.get(key);
try {
return property.getWriteMethod().invoke(bean, new Object[] {value});
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override public Set<Map.Entry<String, Object>> entrySet() {
HashSet<Map.Entry<String, Object>> result = new HashSet<Map.Entry<String, Object>>(properties.size() * 2);
for(PropertyDescriptor property : properties.values()) {
String key = property.getName();
Object value;
try {
value = property.getReadMethod().invoke(bean, NO_ARGS);
} catch (Exception e) {
throw new RuntimeException(e);
}
result.add(new PropertyEntry(key, value));
}
return Collections.unmodifiableSet(result);
}
@Override public int size() { return properties.size(); }
@Override public boolean containsKey(Object key) { 
return properties.containsKey(key);
}
class PropertyEntry extends AbstractMap.SimpleEntry<String, Object> {
PropertyEntry(String key, Object value) {
super(key, value);
}
@Override public Object setValue(Object value) {
super.setValue(value);
return BeanMap.this.put(getKey(), value);
}
}
}

    OriginalL'auteur mikeslattery