Discussion :

[Opsse]

Bonsoir,

Je suis entrain de refactoriser un gros projet et un problème de redondance me casse la tête. Je m'en remets à vous pour me donner des idées.

J'ai constaté que des méthodes sont présentes à l'identique dans plusieurs de mes énumérations, je voudrais logiquement les avoir en un seul exemplaire. Le problème est qu'il n'est pas possible de faire hériter une énumération et que les interfaces ne m'aident pas.

Un exemple sera peut être plus parlant :

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
public enum A
{
	TRUC("coucou"),
	MACHIN("hello");
 
	private String label;
 
	private A(String label)
	{
		this.label = label;
	}
 
	public static A parse(String str)
	{
		for (A e : A.values())
		{
			if (e.label.equalsIgnoreCase(str))
				return e;
		}
 
		return null;
	}
}

Et j'ai d'autres énumérations, disons B et C, qui fonctionnent avec le même principe de label avec la même fonction parse.

J'ai essayer plusieurs approches en exploitant Enum<T> ou des interfaces mais je ne trouve pas de solution.

Toutes les suggestions sont les bienvenues !

[joel.drigo]

Salut,

Je ne comprends pas trop pourquoi assigner un label à une enum qui a elle-même déjà un nom (et pour lequel on pourrait mettre en place cette méthode parse pour avoir un équivalent non sensible à la casse de valueOf(), mais quoiqu'il en soit tu peux faire comme ça :

1. Déclarer une interface pour l'accès commun au label :
   

   Code :

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

   1
   2
   3
   4
   5
   public interface ILabelable {
    
   	String getLabel();
    
   }

2. Déclarer ton enum pour qu'elle implémente l'interface :
   

   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
   public enum MyEnum implements ILabelable {
    
   	VALUE1("label1"),
   	VALUE2("label2"),
   	;
    
   	private final String label;
   	private MyEnum(String label) {
   		this.label=label;
   	}
    
   	@Override
   	public String getLabel() {
   		return label;
   	}
    
   }

3. Déclarer dans une classe utilitaire la méthode de parsing (avec l'exemple d'usage joint) :
   

   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
   public class Utils {
    
   	public static <T extends Enum<T>&ILabelable> T parse(Class<T> enumClass, String label) {
    
   		for(T value : enumClass.getEnumConstants()){
   			if ( value.getLabel().equalsIgnoreCase(label) ) {
   				return value;
   			}
   		}
   		throw new IllegalArgumentException();
    
   	}
    
   	// test-déom d'usage
   	public static void main(String[] args) {
    
   		System.out.println(Utils.parse(MyEnum.class, "LaBeL1"));
    
   		MyEnum value = Utils.parse(MyEnum.class, "Label2");
    
   	}	
    
   }

[Opsse]

Merci c'est exactement ce que je voulais.
J'avais pensé à cette solution mais je n'avais réussi à implémenté la méthode parse générique, la gestion des types est vraiment tordue dans ce genre de cas.

Pour ce qui est du pourquoi, j'en suis arrivé à faire cette méthode parse car je veux être capable de gérer le cas suivant :

J'ai plusieurs modes d'exécution pour mon application (par exemple : lente, normale rapide) qui changent le comportement de celle-ci. Et je veux pouvoir lancer mon application de cette façon "java -jar appli.jar lente". Au lancement je dois bien convertir la chaîne de caractère en élément de mon énumération. Dans la même idée je veux aussi récupérer des informations depuis une base de données, le problème est le même.
Mon approche du problème est peut être critiquable, si c'est le cas je veux bien que tu me dises comment tu aurais fait.

[joel.drigo]

Dans la même idée je veux aussi récupérer des informations depuis une base de données, le problème est le même.
Mon approche du problème est peut être critiquable, si c'est le cas je veux bien que tu me dises comment tu aurais fait.

Dans ce cas, oui, il est nécessaire d'associer un nom différent de celui de la constante d'enumération. Mais attention à la problématique de l'instanciation : il faudra toujours faire appel à l'enum forcément après la connexion à la base, (sans parler des problèmes si la connexion à la base plante), donc c'est assez hasardeux. J'aurais simplement fait une fabrique. Dans ta base tu stockes ton label et le nom de la constante dans le même record (ou un système de double codes pour pouvoir faire évoluer l'enum sans toucher à la base) et tu fais une fabrique :

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
public class EnumFactory<T extends Enum<T>> {
 
	private final Map<String, T> map;
 
	public EnumFactory(Class<T> enumClass, String table, Connection connection) throws SQLException {
		map = Collections.unmodifiableMap(loadMap(enumClass, table, connection));
	}
 
	private static <T extends Enum<T>> Map<String, T> loadMap(Class<T> enumClass, String table, Connection connection) throws SQLException {
		final Map<String, T> map = new HashMap<>();
		try(ResultSet set = retrieve(connection, table) ) {
                        while( set.next() ) {
			   final String label = set.getString("label").toLowerCase();
			   final String name = set.getString("code");
			   for(T value : enumClass.getEnumConstants()) {
				if ( value.name().equalsIgnoreCase(name) ) {
					map.put(label, value);
					break;
				}
			   }
                        }
		}
		return map;
	}
 
	private static ResultSet retrieve(Connection connection, String table) throws SQLException {
		/*...*/
	}
 
	public T parse(String label) {
		label = label.toLowerCase(); // pour l'insensibilité à la casse
		if ( map.containsKey(label) ) {
			return map.get(label);
		}
		throw new IllegalArgumentException();
	}
 
}

Et je veux pouvoir lancer mon application de cette façon "java -jar appli.jar lente". Au lancement je dois bien convertir la chaîne de caractère en élément de mon énumération. Dans la même idée je veux aussi récupérer des informations depuis une base de données, le problème est le même.

Tu peux procéder également de la même façon, en préparant une map avec tes valeurs (en particulier si elles sont dynamiques), ou en déclarant des variables statiques. Si tes variables sont statiques, on peut également faire 2 enum :

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
public enum Enum1 {
 
	VAL1,
	VAL2;
 
	private enum DecodeEnum {
 
		LABEL1(VAL1),
		LABEL2(VAL2),
		;
 
		private final Enum1 val;
		private DecodeEnum(Enum1 val) {
			this.val=val;
		}
 
	}
 
        // cette méthode peut être aussi rendue générique (et placer dans une classe utilitaire), avec un peu de réflexion pour aller chercher la DecodeEnum
	public static Enum1 decode(String label ) {
		return DecodeEnum.valueOf(label.toUpperCase()).val;
	}
 
}

NB la méthode avec la map peut être appliquée également dans l'exemple de mon précédent post, pour avoir un cache, si beaucoup de constantes d'enum

[Opsse]

Je ne suis pas très à l'aise avec les fabriques, il faudrait que je prenne le temps de regarder ca.

J'ai vu que la classe Enum avait la méthode name(), je pourrais utiliser ca plutôt que d'ajouter les labels. Penses tu que c'est une bonne idée ?

[joel.drigo]

Je ne suis pas très à l'aise avec les fabriques, il faudrait que je prenne le temps de regarder ca.

Il n'y a rien de spécialement complexe à ce sujet.

J'ai vu que la classe Enum avait la méthode name(), je pourrais utiliser ca plutôt que d'ajouter les labels. Penses tu que c'est une bonne idée ?

C'était bien mon premier conseil, pour faire quelque chose 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
public enum Exemple {
 
	VAL1,
	VAL2,
	;
 
	public static Exemple of(String val) {
		for(Exemple value : values()) {
			if ( value.name().equalsIgnoreCase(val) ) {
				return value;
			}
		}
		throw new NoSuchElementException();
	}
 
}

Ou dans une classe utilitaire, avec une méthode plus générique :

Code :

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

1
2
3
4
5
6
7
8
public static <T extends Enum<T>> T of(Class<T> enumClass, String val) {
		for(T value : enumClass.getEnumConstants()) {
			if ( value.name().equalsIgnoreCase(val) ) {
				return value;
			}
		}
		throw new NoSuchElementException();
	}

Attention, si ton idée est de redéfinir name() pour que ça renvoit autre chose que le nom (ce qui serait une mauvaise idée de toute manière), tu ne pourras pas : elle est final.

Autre solution, sinon, la réflexion :

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
public enum Exemple {
 
	VAL1,
	VAL2,
	;
 
	public static final Exemple LABEL1 = VAL1;
	public static final Exemple LABEL2 = VAL2;
 
	public static Exemple of(String val) {
		for(Field field : Exemple.class.getFields()) {
			if ( Modifier.isStatic(field.getModifiers()) && field.getType()==Exemple.class && field.getName().equalsIgnoreCase(val) ) {
				try {
					return (Exemple)field.get(null);
				} catch (IllegalAccessException e) {
					throw new IllegalStateException(e);
				}
			}
		}
		throw new NoSuchElementException();
	}
 
	public static void main(String[] args) {
 
		System.out.println(Exemple.of("label1"));
		System.out.println(Exemple.of("val1"));
 
	}
 
}

La méthode peut être sortie et rendue générique de la même manière que l'autre cas (et on pourrait même la faire fonctionner pour autre chose qu'une enum).

[adiGuba]

Salut,

J'ai vu que la classe Enum avait la méthode name(), je pourrais utiliser ca plutôt que d'ajouter les labels. Penses tu que c'est une bonne idée ?

Heu... Dans ce cas tout est déjà fait automatiquement :

Code :

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

1
2
3
4
5
public enum Exemple {
 
	VAL1,
	VAL2;
}

Code :

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

Exemple exemple = Exemple.valueOf("VAL1"); // Exemple.VAL1

a++

[joel.drigo]

Heu... Dans ce cas tout est déjà fait automatiquement :

C'est sensible à la casse, alors que dans le premier code de @Opsse, il utilise equalsIgnoreCase, d'où la supposition de ma part qu'il cherche quelque chose de non sensible à la casse. Bien sûr, si la convention est sure d'être respectée, on pourrait tout simplement faire Exemple.valueOf( machin.toUpperCase() ).