Discussion :

[sql_ignorant]

Bonjour,

J'ai une classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	}
}

[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<>(); ?

[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).

[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.

[sql_ignorant]

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 ?

[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.

[tchize_]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[sql_ignorant]

Ca donne un truc comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
	}