Wie gehe ich mit ungeprüften Besetzungswarnungen um?

Question

Eclipse gibt mir eine Warnung der folgenden Form:

Typ Sicherheit: Ungeprüfter Cast von Object nach HashMap

Dies stammt aus einem Aufruf an eine API, über die ich keine Kontrolle habe und die Object zurückgibt:

HashMap<String, String> getItems(javax.servlet.http.HttpSession session) {
  HashMap<String, String> theHash = (HashMap<String, String>)session.getAttribute("attributeKey");
  return theHash;
}

Ich möchte Eclipse-Warnungen nach Möglichkeit vermeiden, da sie theoretisch zumindest auf ein potenzielles Codeproblem hinweisen. Ich habe allerdings noch keine gute Möglichkeit gefunden, dieses Problem zu beseitigen. Ich kann die einzelne betroffene Zeile in eine eigene Methode auslagern und Folgendes hinzufügen @SuppressWarnings("unchecked") zu dieser Methode, wodurch die Auswirkungen eines Codeblocks, in dem ich Warnungen ignoriere, begrenzt werden. Gibt es bessere Möglichkeiten? Ich möchte diese Warnungen in Eclipse nicht ausschalten.

Bevor ich zu dem Code kam, war es einfacher, aber es gab trotzdem Warnungen:

HashMap getItems(javax.servlet.http.HttpSession session) {
  HashMap theHash = (HashMap)session.getAttribute("attributeKey");
  return theHash;
}

Das Problem war, dass an anderer Stelle, wenn man versuchte, den Hash zu verwenden, Warnungen angezeigt wurden:

HashMap items = getItems(session);
items.put("this", "that");

Type safety: The method put(Object, Object) belongs to the raw type HashMap.  References to generic type HashMap<K,V> should be parameterized.

Answer 1

Die offensichtliche Antwort ist natürlich, dass man den unkontrollierten Wurf nicht machen sollte.

Wenn es unbedingt notwendig ist, dann sollten Sie zumindest versuchen, den Umfang der @SuppressWarnings Bemerkung. Gemäß seiner Javadocs kann sie auf lokale Variablen angewendet werden; auf diese Weise wirkt sie sich nicht einmal auf die gesamte Methode aus.

Beispiel:

@SuppressWarnings("unchecked")
Map<String, String> myMap = (Map<String, String>) deserializeMap();

Es gibt keine Möglichkeit festzustellen, ob die Map wirklich die allgemeinen Parameter haben sollte <String, String> . Sie müssen vorher wissen, wie die Parameter lauten sollen (oder Sie werden es herausfinden, wenn Sie eine ClassCastException ). Aus diesem Grund erzeugt der Code eine Warnung, da der Compiler unmöglich wissen kann, ob er sicher ist.

Answer 2

Leider gibt es hier keine großartigen Möglichkeiten. Denken Sie daran, dass das Ziel all dieser Maßnahmen darin besteht, die Sicherheit des Typs zu erhalten. " Java-Generika " bietet eine Lösung für den Umgang mit nicht-generierten Legacy-Bibliotheken, und es gibt insbesondere eine, die "Leerschleifentechnik" in Abschnitt 8.2. Im Grunde machen Sie den unsicheren Cast und unterdrücken die Warnung. Führen Sie dann eine Schleife durch die Map wie folgt:

@SuppressWarnings("unchecked")
Map<String, Number> map = getMap();
for (String s : map.keySet());
for (Number n : map.values());

Wenn ein unerwarteter Typ angetroffen wird, erhalten Sie eine Laufzeit ClassCastException aber zumindest wird es in der Nähe der Problemquelle geschehen.

Answer 3

Wow; ich glaube, ich habe die Antwort auf meine eigene Frage gefunden. Ich bin mir nur nicht sicher, ob es das wert ist! :)

Das Problem ist, dass die Besetzung nicht überprüft wird. Sie müssen es also selbst überprüfen. Sie können einen parametrisierten Typ nicht einfach mit instanceof überprüfen, da die Informationen über den parametrisierten Typ zur Laufzeit nicht verfügbar sind, da sie zur Kompilierzeit gelöscht wurden.

Aber Sie können jedes einzelne Element im Hash mit instanceof überprüfen und so einen neuen Hash konstruieren, der typsicher ist. Und Sie werden keine Warnungen provozieren.

Dank mmyers und Esko Luontola habe ich den Code, den ich ursprünglich hier geschrieben habe, parametrisiert, so dass er irgendwo in eine Utility-Klasse verpackt und für jede parametrisierte HashMap verwendet werden kann. Wenn Sie es besser verstehen wollen und nicht sehr vertraut mit Generika sind, empfehle ich Ihnen, die Bearbeitungshistorie dieser Antwort anzusehen.

public static <K, V> HashMap<K, V> castHash(HashMap input,
                                            Class<K> keyClass,
                                            Class<V> valueClass) {
  HashMap<K, V> output = new HashMap<K, V>();
  if (input == null)
      return output;
  for (Object key: input.keySet().toArray()) {
    if ((key == null) || (keyClass.isAssignableFrom(key.getClass()))) {
        Object value = input.get(key);
        if ((value == null) || (valueClass.isAssignableFrom(value.getClass()))) {
            K k = keyClass.cast(key);
            V v = valueClass.cast(value);
            output.put(k, v);
        } else {
            throw new AssertionError(
                "Cannot cast to HashMap<"+ keyClass.getSimpleName()
                +", "+ valueClass.getSimpleName() +">"
                +", value "+ value +" is not a "+ valueClass.getSimpleName()
            );
        }
    } else {
        throw new AssertionError(
            "Cannot cast to HashMap<"+ keyClass.getSimpleName()
            +", "+ valueClass.getSimpleName() +">"
            +", key "+ key +" is not a " + keyClass.getSimpleName()
        );
    }
  }
  return output;
}

Das ist eine Menge Arbeit, möglicherweise für sehr wenig Lohn... Ich bin mir nicht sicher, ob ich es benutzen werde oder nicht. Ich würde mich über Kommentare freuen, ob die Leute denken, dass es das wert ist oder nicht. Außerdem würde ich mich über Verbesserungsvorschläge freuen: Gibt es etwas Besseres, das ich tun kann, als AssertionErrors zu werfen? Gibt es etwas Besseres, das ich auslösen könnte? Sollte ich es eine geprüfte Exception machen?

Answer 4

In Eclipse Preferences, gehen Sie zu Java->Compiler->Errors/Warnings->Generic types und markieren Sie die Ignore unavoidable generic type problems Kontrollkästchen.

Dies entspricht dem Zweck der Frage, d. h.

Ich würde gerne Eclipse-Warnungen vermeiden...

wenn nicht der Geist.

Answer 5

Sie können eine Hilfsklasse wie die folgende erstellen und sie verwenden, um die ungeprüfte Warnung zu unterdrücken.

public class Objects {

    /**
     * Helps to avoid using {@code @SuppressWarnings({"unchecked"})} when casting to a generic type.
     */
    @SuppressWarnings({"unchecked"})
    public static <T> T uncheckedCast(Object obj) {
        return (T) obj;
    }
}

Sie können es wie folgt verwenden:

import static Objects.uncheckedCast;
...

HashMap<String, String> getItems(javax.servlet.http.HttpSession session) {
      return uncheckedCast(session.getAttribute("attributeKey"));
}

Weitere Informationen zu diesem Thema finden Sie hier: http://cleveralias.blogs.com/thought_spearmints/2006/01/suppresswarning.html