Meilleure pratique pour rechercher Java Enum

Question

Nous avons une API REST dans laquelle les clients peuvent fournir des paramètres représentant les valeurs définies sur le serveur dans les Enums Java.

Donc, nous pouvons fournir une erreur descriptive, nous ajoutons cette méthode lookup à chaque Enum. On dirait que nous ne faisons que copier du code (mauvais). Y a-t-il une meilleure pratique?

public enum MyEnum { 
    A, B, C, D; 

    public static MyEnum lookup(String id) { 
     try { 
      return MyEnum.valueOf(id); 
     } catch (IllegalArgumentException e) { 
      throw new RuntimeException("Invalid value for my enum blah blah: " + id); 
     } 
    } 
} 

Mise à jour: Le message d'erreur par défaut fourni par valueOf(..) serait No enum const class a.b.c.MyEnum.BadValue. Je voudrais fournir une erreur plus descriptive de l'API.

Answer 1

Vous pouvez probablement implémenter la méthode statique générique lookup.

Comme si

public class LookupUtil { 
    public static <E extends Enum<E>> E lookup(Class<E> e, String id) { 
     try {   
     E result = Enum.valueOf(e, id); 
     } catch (IllegalArgumentException e) { 
     // log error or something here 

     throw new RuntimeException(
      "Invalid value for enum " + e.getSimpleName() + ": " + id); 
     } 

     return result; 
    } 
} 

Ensuite, vous pouvez

public enum MyEnum { 
    static public MyEnum lookup(String id) { 
     return LookupUtil.lookup(MyEnum.class, id); 
    } 
} 

ou appeler explicitement la méthode de recherche de classe utilitaire. Pourquoi faut-il écrire ce code de 5 lignes?

Answer 2

public class EnumTest { 
public enum MyEnum { 
    A, B, C, D; 
} 

@Test 
public void test() throws Exception { 
    MyEnum.valueOf("A"); //gives you A 
    //this throws ILlegalargument without having to do any lookup 
    MyEnum.valueOf("RADD"); 
} 
} 

Answer 3

Si vous voulez que la recherche soit insensible à la casse, vous pouvez faire une boucle à travers les valeurs qui en fait un peu plus convivial:

public enum MyEnum { 
    A, B, C, D; 

     public static MyEnum lookup(String id) { 
     boolean found = false; 
     for(MyEnum enum: values()){ 
      if(enum.toString().equalsIgnoreCase(id)) found = true; 
     } 
     if(!found) throw new RuntimeException("Invalid value for my enum: " +id); 
     } 
} 

Answer 4

On dirait que vous avez une mauvaise pratique ici, mais pas là où vous pensez.

Attraper un IllegalArgumentException pour relancer un autre RuntimeException avec un message plus clair pourrait sembler une bonne idée mais ce n'est pas le cas. Parce que cela signifie que vous vous souciez des messages dans vos exceptions.

Si vous vous souciez des messages dans vos exceptions, cela signifie que votre utilisateur voit d'une manière ou d'une autre vos exceptions. C'est mauvais. Si vous souhaitez fournir un message d'erreur explicite à votre utilisateur, vous devez vérifier la validité de la valeur enum lors de l'analyse de l'entrée utilisateur et envoyer le message d'erreur approprié dans la réponse si l'entrée de l'utilisateur est incorrecte.

Quelque chose comme:

// This code uses pure fantasy, you are warned! 
class MyApi 
{ 
    // Return the 24-hour from a 12-hour and AM/PM 

    void getHour24(Request request, Response response) 
    { 
     // validate user input 
     int nTime12 = 1; 
     try 
     { 
      nTime12 = Integer.parseInt(request.getParam("hour12")); 
      if(nTime12 <= 0 || nTime12 > 12) 
      { 
       throw new NumberFormatException(); 
      } 
     } 
     catch(NumberFormatException e) 
     { 
      response.setCode(400); // Bad request 
      response.setContent("time12 must be an integer between 1 and 12"); 
      return; 
     } 

     AMPM pm = null; 
     try 
     { 
      pm = AMPM.lookup(request.getParam("pm")); 
     } 
     catch(IllegalArgumentException e) 
     { 
      response.setCode(400); // Bad request 
      response.setContent("pm must be one of " + AMPM.values()); 
      return; 
     } 

     response.setCode(200); 
     switch(pm) 
     { 
      case AM: 
       response.setContent(nTime12); 
       break; 
      case PM: 
       response.setContent(nTime12 + 12); 
       break; 
     } 
     return; 
    } 
} 

Answer 5

Le message d'erreur dans IllegalArgumentException est déjà assez descriptif.

Votre méthode crée une exception générique à partir d'une exception spécifique avec le même message simplement reformulé. Un développeur préfère le type d'exception spécifique et peut gérer le cas de manière appropriée au lieu d'essayer de gérer RuntimeException.

Si l'intention est de rendre le message plus convivial, alors les références aux valeurs d'énumération ne leur sont d'aucune façon utiles. Laissez le code de l'interface utilisateur déterminer ce qui doit être affiché à l'utilisateur, et le développeur de l'interface utilisateur serait mieux avec l'exception IllegalArgumentException.

Answer 6

mise à jour: Comme GreenTurtle fait remarquer correctement, ce qui suit est erroné

---

Je voudrais juste écrire

boolean result = Arrays.asList(FooEnum.values()).contains("Foo"); 

Ceci est peut-être moins performant que d'attraper une exception d'exécution, mais fait pour le code beaucoup plus propre . Attraper de telles exceptions est toujours une mauvaise idée, car il est sujet à un mauvais diagnostic. Que se passe-t-il lorsque la récupération de la valeur comparée provoque elle-même une exception IllegalArgumentException? Ceci serait alors traité comme une valeur non correspondante pour l'énumérateur.

Answer 7

Nous faisons tous nos énumérations comme cela quand il s'agit de Rest/Json etc Il a l'avantage que l'erreur est lisible par l'homme et vous donne également la liste des valeurs acceptées. Nous utilisons une méthode personnalisée MyEnum.fromString au lieu de MyEnum.valueOf, espérons que cela aide.

public enum MyEnum { 

    A, B, C, D; 

    private static final Map<String, MyEnum> NAME_MAP = Stream.of(values()) 
      .collect(Collectors.toMap(MyEnum::toString, Function.identity())); 

    public static MyEnum fromString(final String name) { 
     MyEnum myEnum = NAME_MAP.get(name); 
     if (null == myEnum) { 
      throw new IllegalArgumentException(String.format("'%s' has no corresponding value. Accepted values: %s", name, Arrays.asList(values()))); 
     } 
     return myEnum; 
    } 
} 

donc par exemple si vous appelez

MyEnum value = MyEnum.fromString("X"); 

vous obtiendrez un IllegalArgumentException avec le message suivant:

'X' n'a pas de valeur correspondante. Valeurs acceptées: [A, B, C, D]

Vous pouvez modifier l'exception IllegalArgumentException en valeur personnalisée.