Vaut-il mieux renvoyer une ImmutableMap ou une Map?

Disons que j'écris une méthode qui devrait renvoyer une Map . Par exemple:

public Map<String, Integer> foo() {
  return new HashMap<String, Integer>();
}

Après y avoir réfléchi pendant un moment, j'ai décidé qu'il n'y avait aucune raison de modifier cette carte une fois qu'elle est créée. Ainsi, je voudrais retourner un ImmutableMap .

public Map<String, Integer> foo() {
  return ImmutableMap.of();
}

Dois-je laisser le type de retour comme une carte générique, ou dois-je spécifier que je retourne une ImmutableMap?

D'un côté, c'est exactement pourquoi les interfaces ont été créées pour; pour masquer les détails d'implémentation.
D'un autre côté, si je laisse ça comme ça, d'autres développeurs pourraient manquer le fait que cet objet est immuable. Ainsi, je n'atteindrai pas un objectif majeur des objets immuables; pour rendre le code plus clair en minimisant le nombre d'objets qui peuvent changer. Pire encore, après un certain temps, quelqu'un pourrait essayer de changer cet objet, ce qui entraînera une erreur d'exécution (le compilateur ne l'avertira pas).

• Si vous écrivez une API publique et que l'immuabilité est un aspect important de votre conception, je le rendrais certainement explicite soit en faisant en sorte que le nom de la méthode indique clairement que la carte retournée sera immuable ou en renvoyant le type concret de la carte. Le mentionner dans le javadoc ne suffit pas à mon avis.

  Puisque vous utilisez apparemment l'implémentation de Guava, j'ai regardé le document et c'est une classe abstraite donc cela vous donne un peu de flexibilité sur le type concret réel.

• Si vous écrivez un outil / une bibliothèque interne, il devient beaucoup plus acceptable de simplement renvoyer un simple Map. Les gens connaîtront les composants internes du code qu'ils appellent ou du moins y auront facilement accès.

Ma conclusion serait qu'explicite est une bonne chose, ne laissez pas les choses au hasard.

Vous devriez avoir ImmutableMapcomme type de retour. Mapcontient des méthodes qui ne sont pas prises en charge par l'implémentation de ImmutableMap(par exemple put) et qui sont marquées @deprecateddans ImmutableMap.

L'utilisation de méthodes obsolètes entraînera un avertissement du compilateur et la plupart des IDE avertiront lorsque des personnes tenteront d'utiliser les méthodes obsolètes.

Cet avertissement avancé est préférable aux exceptions d'exécution comme premier indice que quelque chose ne va pas.

D'un autre côté, si je laisse ça comme ça, d'autres développeurs pourraient manquer le fait que cet objet est immuable.

Vous devriez le mentionner dans les javadocs. Les développeurs les lisent, vous savez.

Ainsi, je n'atteindrai pas un objectif majeur des objets immuables; pour rendre le code plus clair en minimisant le nombre d'objets qui peuvent changer. Pire encore, après un certain temps, quelqu'un pourrait essayer de changer cet objet, ce qui entraînera une erreur d'exécution (le compilateur ne l'avertira pas).

Aucun développeur ne publie son code non testé. Et quand il le teste, il obtient une exception lancée où il voit non seulement la raison, mais aussi le fichier et la ligne où il a essayé d'écrire sur une carte immuable.

Notez cependant que seul le Maplui - même sera immuable, pas les objets qu'il contient.

si je laisse ça comme ça, d'autres développeurs pourraient manquer le fait que cet objet est immuable

C'est vrai, mais les autres développeurs devraient tester leur code et s'assurer qu'il est couvert.

Néanmoins, vous avez 2 autres options pour résoudre ce problème:

• Utiliser Javadoc

  @return a immutable map

• Choisissez un nom de méthode descriptif

  public Map<String, Integer> getImmutableMap()
  public Map<String, Integer> getUnmodifiableEntries()

  Pour un cas d'utilisation concret, vous pouvez même mieux nommer les méthodes. Par exemple

  public Map<String, Integer> getUnmodifiableCountByWords()

Que pouvez vous faire d'autre?!

Vous pouvez retourner un

• copie

  private Map<String, Integer> myMap;
  
  public Map<String, Integer> foo() {
    return new HashMap<String, Integer>(myMap);
  }

  Cette approche doit être utilisée si vous prévoyez que de nombreux clients modifieront la carte et tant que la carte ne contient que quelques entrées.

• CopyOnWriteMap

  Les collections copy on write sont généralement utilisées lorsque vous devez gérer la
  concurrence. Mais le concept vous aidera également dans votre situation, car un CopyOnWriteMap crée une copie de la structure de données interne sur une opération mutative (par exemple, ajouter, supprimer).

  Dans ce cas, vous avez besoin d'un wrapper fin autour de votre carte qui délègue tous les appels de méthode à la carte sous-jacente, à l'exception des opérations mutatives. Si une opération mutative est appelée, elle crée une copie de la carte sous-jacente et toutes les autres invocations seront déléguées à cette copie.

  Cette approche doit être utilisée si vous prévoyez que certains clients modifieront la carte.

  Malheureusement, java n'a pas un tel fichier CopyOnWriteMap. Mais vous pouvez trouver un tiers ou le mettre en œuvre vous-même.

Enfin, vous devez garder à l'esprit que les éléments de votre carte peuvent encore être modifiables.

Renvoyez définitivement un ImmutableMap, la justification étant:

• La signature de la méthode (y compris le type de retour) doit être auto-documentée. Les commentaires sont comme le service client: si vos clients ont besoin de compter sur eux, alors votre produit principal est défectueux.
• Que quelque chose soit une interface ou une classe n'est pertinent que lors de son extension ou de son implémentation. Étant donné une instance (objet), 99% du temps, le code client ne saura pas ou ne se souciera pas si quelque chose est une interface ou une classe. J'ai d'abord supposé qu'ImmutableMap était une interface. Ce n'est qu'après avoir cliqué sur le lien que j'ai réalisé que c'était une classe.

Cela dépend de la classe elle-même. Guava ImmutableMapn'est pas destiné à être une vue immuable dans une classe mutable. Si votre classe est immuable et a une structure qui est essentiellement an ImmutableMap, alors créez le type de retour ImmutableMap. Cependant, si votre classe est modifiable, ne le faites pas. Si vous avez ceci:

public ImmutableMap<String, Integer> foo() {
    return ImmutableMap.copyOf(internalMap);
}

Guava copiera la carte à chaque fois. C'est lent. Mais si internalMapc'était déjà un ImmutableMap, alors tout va bien.

Si vous ne limitez pas votre classe au retour ImmutableMap, vous pouvez à la place revenir Collections.unmodifiableMapcomme suit:

public Map<String, Integer> foo() {
    return Collections.unmodifiableMap(internalMap);
}

Notez qu'il s'agit d'une vue immuable de la carte. En cas de internalMapchangement, une copie en cache de Collections.unmodifiableMap(internalMap). Cependant, je le préfère toujours pour les getters.

Cela ne répond pas à la question exacte, mais cela vaut toujours la peine de se demander si une carte doit être retournée. Si la carte est immuable, la méthode principale à fournir est basée sur get (key):

public Integer fooOf(String key) {
    return map.get(key);
}

Cela rend l'API beaucoup plus stricte. Si une carte est réellement requise, cela pourrait être laissé au client de l'API en fournissant un flux d'entrées:

public Stream<Map.Entry<String, Integer>> foos() {
    map.entrySet().stream()
}

Ensuite, le client peut créer sa propre carte immuable ou mutable selon ses besoins, ou ajouter les entrées à sa propre carte. Si le client a besoin de savoir si la valeur existe, facultatif peut être renvoyé à la place:

public Optional<Integer> fooOf(String key) {
    return Optional.ofNullable(map.get(key));
}

La carte immuable est un type de carte. Donc, laisser le type de retour de Map est correct.

Pour s'assurer que les utilisateurs ne modifient pas l'objet retourné, la documentation de la méthode peut décrire les caractéristiques de l'objet retourné.

C'est sans doute une question d'opinion, mais la meilleure idée ici est d'utiliser une interface pour la classe map. Cette interface n'a pas besoin de dire explicitement qu'elle est immuable, mais le message sera le même si vous n'exposez aucune des méthodes setter de la classe parent dans l'interface.

Jetez un œil à l'article suivant:

Andy Gibson