Comment faire pour convertir un objet Java (haricot) de paires clé-valeur (et vice versa)?

Il y a toujours apache communes beanutils mais bien sûr, il utilise la réflexion sous le capot

De génération de Code serait le seul moyen d'autres je pense. Personnellement, j'avais obtenu avec un généralement réutilisables réflexion solution (à moins que cette partie du code est absolument la performance est critique). À l'aide de JMS sonne comme overkill (en plus de la dépendance, et c'est même pas ce que cela signifiait pour). En outre, il utilise probablement une réflexion aussi bien sous le capot.

Avec Java 8, vous pouvez essayer ceci :

public Map<String, Object> toKeyValuePairs(Object instance) {
    return Arrays.stream(Bean.class.getDeclaredMethods())
            .collect(Collectors.toMap(
                    Method::getName,
                    m -> {
                        try {
                            Object result = m.invoke(instance);
                            return result != null ? result : "";
                        } catch (Exception e) {
                            return "";
                        }
                    }));
}

Simplement à l'aide de la réflexion et Groovy :

def Map toMap(object) {             
return object?.properties.findAll{ (it.key != 'class') }.collectEntries {
            it.value == null || it.value instanceof Serializable ? [it.key, it.value] : [it.key,   toMap(it.value)]
    }   
}

def toObject(map, obj) {        
    map.each {
        def field = obj.class.getDeclaredField(it.key)
        if (it.value != null) {
            if (field.getType().equals(it.value.class)){
                obj."$it.key" = it.value
            }else if (it.value instanceof Map){
                def objectFieldValue = obj."$it.key"
                def fieldValue = (objectFieldValue == null) ? field.getType().newInstance() : objectFieldValue
                obj."$it.key" = toObject(it.value,fieldValue) 
            }
        }
    }
    return obj;
}

Lors de l'utilisation de Printemps, on peut aussi utiliser le Printemps de l'Intégration de l'objet-pour-carte-transformateur. Ce n'est probablement pas utile d'ajouter de Printemps comme une dépendance pour cette seule raison.

Pour la documentation, de la recherche pour "Object-to-Carte Transformateur" sur http://docs.spring.io/spring-integration/docs/4.0.4.RELEASE/reference/html/messaging-transformation-chapter.html

Essentiellement, il traverse l'ensemble de l'objet graphique accessible à partir de l'objet donné en entrée, et produit une carte de tous type primitif/les champs de type Chaîne sur les objets. Il peut être configuré pour une sortie:

• un plat à la carte: {rootObject.someField=Joe, rootObject.leafObject.someField=Jane}, ou
• structurée de la carte: {someField=Joe, leafObject={someField=Jane}}.

Voici un exemple à partir de leur page:

public class Parent{
    private Child child;
    private String name; 
    //setters and getters are omitted
}

public class Child{
   private String name; 
   private List<String> nickNames;
   //setters and getters are omitted
}

Sortie sera:

{personne.nom=George, personne.enfant.nom=Jenna,
personne.enfant.surnoms[0]=Bimbo . . . etc}

Inverse transformateur est également disponible.

Si vous ne souhaitez pas coder en dur les appels à chaque getter et setter, la réflexion est le seul moyen pour appeler ces méthodes, mais il n'est pas difficile).

Pouvez-vous refactoriser la classe en question d'utiliser un objet de Propriétés pour contenir les données réelles, et de laisser chaque getter et setter suffit d'appeler get/set sur elle? Ensuite, vous avez une structure bien adaptée pour ce que vous voulez faire. Il en est de même des méthodes pour enregistrer et charger dans la clé-valeur.

Il y a bien sûr l'absolu moyen le plus simple de conversion possible - pas de conversion à tous!

au lieu d'utiliser des variables privées définies dans la classe, faire la classe ne contient qu'une table de hachage qui stocke les valeurs de l'instance.

Alors votre getters et les setters de retour et de définir des valeurs dans et hors de la table de hachage, et quand il est temps de le convertir à une carte, le tour est joué! - c'est déjà une carte.

Avec un peu de l'AOP magie, vous risquez même de maintenir la rigidité inhérente à un haricot en vous permettant de continuer à utiliser les accesseurs et mutateurs spécifiques à chacune des valeurs de nom, sans avoir à écrire la personne getters et setters.

Probablement à la fin de la partie. Vous pouvez utiliser Jackson et de le convertir en un objet de Propriétés. Ceci est adapté pour les classes Imbriquées et si vous voulez la clé dans la pour un.b.c=valeur.

JavaPropsMapper mapper = new JavaPropsMapper();
Properties properties = mapper.writeValueAsProperties(sct);
Map<Object, Object> map = properties;

si vous voulez un peu de suffixe, puis il suffit de faire

SerializationConfig config = mapper.getSerializationConfig()
                .withRootName("suffix");
mapper.setConfig(config);

il faut ajouter à cette dépendance

<dependency>
  <groupId>com.fasterxml.jackson.dataformat</groupId>
  <artifactId>jackson-dataformat-properties</artifactId>
</dependency>

Vous devriez écrire un générique Service de transformation! Utiliser des génériques pour le garder de type libre (donc vous pouvez convertir tous les objets de la clé=>valeur et à l'arrière).

Ce champ doit être la clé? Obtenir que le champ de la fève et ajouter les autres non transitoire valeur dans une carte de valeur.

Le chemin du retour est assez facile. Touche de lecture(x) et écrire d'abord sur la touche, puis chaque entrée de la liste de retour pour un nouvel objet.

Vous pouvez obtenir les noms des propriétés d'un bean avec la apache commons beanutils!

Une autre voie possible est ici.

La BeanWrapper propose une fonctionnalité pour définir et obtenir les valeurs de propriété (individuellement
ou en vrac), obtenir la propriété des descripteurs, et aux propriétés de la requête pour déterminer si elles
sont lisibles ou à l'écriture.

Company c = new Company();
 BeanWrapper bwComp = BeanWrapperImpl(c);
 bwComp.setPropertyValue("name", "your Company");

Avec l'aide de Jackson bibliothèque, j'ai été en mesure de trouver toutes les propriétés de la classe de type String/integer/double, et les valeurs respectives dans une classe Map. (sans l'aide de réflexions api!)

TestClass testObject = new TestClass();
com.fasterxml.jackson.databind.ObjectMapper m = new com.fasterxml.jackson.databind.ObjectMapper();

Map<String,Object> props = m.convertValue(testObject, Map.class);

for(Map.Entry<String, Object> entry : props.entrySet()){
    if(entry.getValue() instanceof String || entry.getValue() instanceof Integer || entry.getValue() instanceof Double){
        System.out.println(entry.getKey() + "-->" + entry.getValue());
    }
}