Ist es eine gute Praxis, spezifische Ausnahmen für alles zu haben? Oder ist es besser, eine etwas abstraktere Ausnahme wiederzuverwenden?

Question

Ich arbeite an einem Projekt, in dem ich für jede mögliche Ausnahmesituation eine eigene Ausnahme geschrieben habe. Der Punkt ist, dass ich es für leserlicher halte, aber ich bekomme eine unüberschaubare Anzahl verschiedener Ausnahmen.

Wird es als gute Praxis angesehen, es so zu machen? Oder sollte ich die Ausnahmen etwas abstrakter schreiben, um nicht so viele zu haben?

Vielen Dank für Ihre Zeit.

Answer 1

Welche Variante besser ist, hängt davon ab, wie wahrscheinlich es ist, dass Ihr Code die spezifischen Ausnahmen abfangen wird. Wenn Sie wahrscheinlich nur die allgemeineren (Superklassen-)Ausnahmen abfangen (oder anderweitig unterscheiden), dann erreichen Sie mit vielen spezifischeren (Unterklassen-)Ausnahmen nicht viel. In diesem Fall ist es wahrscheinlich besser, weniger Ausnahmen zu definieren und Ausnahmemeldungen zu verwenden, um die genauen Details dessen auszudrücken, was schief gelaufen ist.

Andererseits, wenn spezifische Ausnahmen bereits existieren, macht es Sinn, sie zu verwenden. Einfach java.lang.Exception oder java.lang.RuntimeException zu werfen, ist meiner Meinung nach einfach faul.

NACHFRAGE

Nun, ich fange immer spezifische Ausnahmen ab, aber das Problem ist, dass ich in anderen "catches" ebenfalls spezifische Ausnahmen verwende, die irgendwie ähnlich sind (sie können sich zum Beispiel auf "Datenbank" beziehen, sind aber nicht identisch). Also die Frage ist, ob es sinnvoll wäre, eine "DatabaseException" zu erstellen und zu verwenden, anstatt zum Beispiel "DatabaseConnectionException" und "DatabaseDataException" zu verwenden, was lesbarer ist, aber am Ende hätte ich Millionen von expliziten Ausnahmen.

Wenn Ihr Code häufig so aussieht:

try {
    ... 
} catch (DatabaseConnectionException ex) {
    // etwas tun
} catch (DatabaseDataException ex) {
    // dasselbe tun
} catch (DatabaseTangoException ex) {
    // dasselbe tun
}

... dann helfen Ihnen Ihre fein granulierten Ausnahmen nicht. Aber wenn es so aussieht:

try {
    ... 
} catch (DatabaseConnectionException ex) {
    // etwas tun
} catch (DatabaseDataException ex) {
    // etwas völlig anderes tun
} catch (DatabaseTangoException ex) {
    // etwas völlig Außergewöhnliches tun
}

... dann funktionieren vielleicht Ihre fein granulierten Ausnahmen für Sie. Und wenn Sie diese drei Ausnahmen als Unterklassen von DatabaseDataException deklarieren, können Sie die Fälle gemeinsam oder separat behandeln, je nach Bedarf.

Letztendlich liegt es an Ihnen, Ihr eigenes Urteil zu fällen, im Kontext Ihrer Anwendung.

Answer 2

Ich würde vorschlagen, eine abstrakte DomainException zu haben (wo Domain Ihre Organisation oder die Anwendungsebene widerspiegelt, in der das Problem liegt), von der alle Ihre spezifischen Ausnahmen abgeleitet werden.

Dann können Sie einfach DomainException abfangen, um zu sagen, dass dies ein Problem mit Ihrem Code ist, und dann bei Bedarf verfeinern.

Answer 3

Bloch, J., 2008. Effective Java. 2. Aufl:

Punkt 60: Bevorzugen Sie die Verwendung von Standardausnahmen

Die Wiederverwendung von vorherigen Ausnahmen hat mehrere Vorteile. Vor allem macht es Ihre API leichter zu lernen und zu verwenden, da sie etablierten Konventionen entspricht, mit denen Programmierer bereits vertraut sind. Ein weiterer Vorteil ist, dass Programme, die Ihre API verwenden, leichter zu lesen sind, weil sie nicht mit unvertrauten Ausnahmen überladen sind. Zuletzt (und am wenigsten) bedeutet weniger Ausnahme-Klassen einen kleineren Speicherfußabdruck und weniger Zeit, die zum Laden von Klassen benötigt wird.

Answer 4

Dass du Ausnahmen erweitern kannst bedeutet nicht, dass du es tun solltest. Dogbanes Antwort liefert gute Gründe für die Verwendung von Standard-Ausnahmen. (Beachte, dass er von der Verwendung von "Standard"-Ausnahmen spricht, nicht von "generischen"! Verwende so spezifisch wie möglich eine Standard-Ausnahme.)

Ich glaube, dass du deine eigene Ausnahmen-Unterklasse nur dann verwenden solltest, wenn beide dieser Bedingungen zutreffen:

• Du möchtest etwas Spezifisches tun, wenn du eine bestimmte Kategorie von Ausnahmen abfangen; die Verwendung einer spezifischen Unterklasse ermöglicht es dir, sie abzufangen, während andere Ausnahmen problemlos weitergeleitet werden können.
• Keine Standard-Ausnahme deckt deine Kategorie genau genug ab.

Answer 5

Warum nicht einfach eine kleine Anzahl von Ausnahmen erstellen und ihnen einen beschreibenden String im Konstruktor übergeben lassen?

throw new GenericException("Fehler: Problem mit....");

Und lassen Sie die toString() Methode den übergebenen String ausgeben.