Comment instancier un objet paramétré par réflexion ?

Version imprimable

Bonjour,

J'ai une classe :

Code:

1
2
3
4
5
6
7
public class ClasseMere {
	private Map<String, ClasseFille1> map1; // Probablement une HashMap
	private Map<Integer, ClasseFille2> map2; // Probablement une HashMap
	private ClasseFille3<ClasseFille4, ClasseFille5> classeFille3;
 
	// les assesseurs associés
}

Je voudrai écrire une méthode qui instancie map1 et map2 par réflexion en fonction du type paramétré.

Code:

1
2
3
4
5
6
7
8
9
public void populate() {
	for (Field field : classeMere.getClass().getDeclaredFields()) {
		// Instanciation de l'objet correspondant au field et je ne sais pas comment écrire cette ligne de code
 
		// Remplissage de la map
 
		// Appel du setter de la map correspondante
	}
}

17/01/2016, 15h06
jdevbe

Dans la méthode populate(), classeMere est, je suppose type ClasseMere.
Dans ce cas le type des champs map1 et map2 sont des interfaces (peut-être ClasseFille3 aussi). Il ne sera donc pas possible d'en créer des instances ...
Je ne comprends trop le but de la ' méthode qui instancie map1 et map2 par réflexion en fonction du type paramétré.'
Pourquoi ne pas créer vos champs normalement : classeMere.map1 = new HashMap<>(); ?
17/01/2016, 18h03
Gugelhupf

Salut sql_ingorant, tu peux tu peux récupérer le type générique de ton field (ParametrizedType), puis le décortiquer pour récupérer le type de tes key et value de ta Map.
Je t'invite à voir cet exemple (méthode Form#fillField).
17/01/2016, 18h38
thelvin

Ouais enfin, en ce qui concerne instancier la Map, ses paramètres ça nous sert à rien de les chercher par réflexion.

- Soit on les connaissait déjà et on fait un truc genre Map<String, ClasseFille1> laMap = new HashMap<>(); .

- Soit on les connaît pas à l'avance, et dans ce cas on ne peut pas être type-safe, donc ils ne servent à rien et on fait juste Map<?, ?> laMap = new HashMap<Object, Object>(); .

Il reste effectivement, que quand on se retrouve à instancier un champ de type Map, il va falloir choisir une implémentation de Map, comme par exemple HashMap. Impossible d'instancier directement Map, qui est une interface.
17/01/2016, 22h36
sql_ignorant

Citation:

Envoyé par thelvin

Impossible d'instancier directement Map, qui est une interface.

Oui, on est d'accord.

Mais en instanciant l'implémentation via newInstance(), il faut caster car les types paramétrés ne sont que disponible au runtime. N'est-il pas possible de mettre autre chose que (HashMap<Object, Object>)HashMap.newInstance() si on connait le type de Field à passer au cast de HashMap ?
18/01/2016, 02h27
thelvin

Je ne crois pas, mais plus important : je ne vois pas à quoi ça servirait. Si tu peux m'éclairer, j'aurai peut-être une réponse plus utile.

Citation:
Envoyé par sql_ignorant
Je voudrai écrire une méthode qui instancie map1 et map2 par réflexion en fonction du type paramétré.
Code:

1 2 3 4 5 6 7 8 9 public void populate() { for (Field field : classeMere.getClass().getDeclaredFields()) { // Instanciation de l'objet correspondant au field et je ne sais pas comment écrire cette ligne de code // Remplissage de la map // Appel du setter de la map correspondante } }
Grosso modo
Code:

1 2 3 4 5 6 7 public void populate() { for (Field field : classeMere.getClass().getDeclaredFields()) { if (field.getType() == Map.class){ field.set(tonObjet,new HashMap<Object,Object>(); } } }
Les paramètre n'ont aucun intérêt dans le réflection, le compilateur ne peux pas checker l'introspection et les types générique ne servent que au compilateur.

Ca donne un truc comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
	public T convertFromModel(S model, T bean) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException {
		for (Field field : model.getClass().getDeclaredFields()) {
		        Method getter = getGetter(model, field);
		        Object convertedField = null;
			    if (Map.class.isAssignableFrom(field.getType())) {
			        convertedField = convertMap((Map<Object, Object>)getter.invoke(model, null));
			    }
			    else if (Collection.class.isAssignableFrom(field.getType())) {
                    convertedField = convertCollection((Collection<Object>)getter.invoke(model, null));
                }
			    else {
			        convertedField = convertSimpleObject(getter.invoke(model, null));
			    }
                Method setter = getSetter(bean, field);
                setter.invoke(bean, convertedField);
		}
 
		return bean;
	}
 
	private Map<?, ?> convertMap(Map<?, ?> map) throws IllegalAccessException, InstantiationException {
	    Map<Object, Object> convertedMap = null;
 
	    if (map != null) {
	        convertedMap = (Map<Object, Object>)map.getClass().newInstance();
 
	        for (Map.Entry<Object, Object> entry : ((Map<Object, Object>)map).entrySet()) {
	            Object convertedKey = null;
 
                if (entry.getKey() instanceof Map) {
                    convertedKey = convertMap((Map)entry.getKey());
                }
                else if (entry.getKey() instanceof Collection) {
	                convertedKey = convertCollection((Collection)entry.getKey());
	            }
	            else {
	                convertedKey = convertSimpleObject(entry.getKey());
	            }
 
	            Object convertedValue = null;
	            if (entry.getValue() instanceof Map) {
	                convertedValue = convertMap((Map)entry.getValue());
                }
                else if (entry.getValue() instanceof Collection) {
	                convertedValue = convertCollection((Collection)entry.getValue());
                }
                else {
                    convertedValue = convertSimpleObject(entry.getValue());
                }
	            convertedMap.put(convertedKey, convertedValue);
	        }
	    }
 
	    return convertedMap;
	}
 
	private Collection<?> convertCollection(Collection<?> collection) throws IllegalAccessException, InstantiationException {
	    Collection<Object> convertedCollection = null;
 
	    if (collection != null) {
    	    convertedCollection = (Collection<Object>)collection.getClass().newInstance();
    	    for (Object object : collection) {
    	        Object convertedObject = null;
 
    	        if (object instanceof Map) {
    	            convertedObject = convertMap((Map)object);
                }
                else if (object instanceof Collection) {
    	            convertedObject = convertCollection((Collection)object);
    	        }
    	        else {
    	            convertedObject = convertSimpleObject(object);
    	        }
 
    	        convertedCollection.add(convertedObject);
    	    }
	    }
 
	    return convertedCollection;
	}
 
	private Object convertSimpleObject(Object object) {
	    // Nothing to do
	    return object;
	}