Granularität von Ausnahmen

Ich bin in eine Debatte zwischen ein paar Freunden und mir geraten. Sie bevorzugen allgemeine Ausnahmen wie ClientErrorExceptionund ServerErrorExceptionmit Details als Ausnahmefelder, während ich es vorziehe, die Dinge spezifischer zu gestalten. Zum Beispiel könnte ich eine Handvoll Ausnahmen haben wie:

• BadRequestException
• AuthenticationFailureException
• ProductNotFoundException

Jedes dieser Elemente basiert auf dem von der API zurückgegebenen Fehlercode.

Nach den Vorteilen von Ausnahmen erscheint dies Java idiomatisch. Die Meinung meiner Freunde ist jedoch nicht gerade ungewöhnlich.

Gibt es einen bevorzugten Weg in Bezug auf Code-Lesbarkeit und API-Benutzerfreundlichkeit oder kommt es wirklich nur auf die Präferenz an?

Der Hauptunterschied zwischen vielen verschiedenen Ausnahmeklassen und nur wenigen mit detaillierteren Informationen im Fehlertext (zum Beispiel) besteht darin, dass der aufrufende Code aufgrund vieler verschiedener Ausnahmeklassen unterschiedlich auf verschiedene Arten von Fehlern reagieren kann Nur wenige Klassen erleichtern es, alle Arten von Ausnahmen einheitlich zu behandeln.

Dies ist normalerweise ein Kompromiss. Es kann bis zu einem gewissen Grad durch Verwendung der Vererbung gemildert werden (eine allgemeine Basisausnahmeklasse für diejenigen Anrufer, die alles generisch abfangen und protokollieren möchten, und abgeleitete Ausnahmen von dieser Basisklasse für diejenigen Anrufer, die unterschiedliche Reaktionen benötigen), aber selbst das kann a erzeugen viel unnötige Komplexität, wenn Sie nicht vorsichtig sind und sich an das YAGNI-Prinzip halten. Die Leitfrage sollte also hier sein:

• Erwarten Sie wirklich, dass der Aufrufer Ihres Codes unterschiedlich und mit unterschiedlichem Kontrollfluss auf diese unterschiedlichen Fehler reagiert?

Es gibt keine einheitliche Lösung für dieses Problem, keine "Best Practice", die Sie überall anwenden können. Die Antwort auf diese Frage hängt stark davon ab, welche Art von Software oder Komponente Sie entwerfen:

• eine Anwendung, bei der Sie oder das Team die gesamte Codebasis unter Ihrer Kontrolle haben?

• oder eine wiederverwendbare Komponente für Dritte, bei der Sie nicht alle potenziellen Anrufer kennen?

• eine lange laufende Serveranwendung, bei der verschiedene Arten von Fehlern nicht sofort das gesamte System beschädigen sollten und möglicherweise verschiedene Arten der Fehlerminderung erfordern?

• ein kurzlebiger Anwendungsprozess, bei dem es im Fehlerfall ausreicht, dem Benutzer eine Fehlermeldung anzuzeigen und den Prozess dann neu zu starten?

Je mehr Sie über die potenziellen Anrufer Ihrer Komponente wissen, desto besser können Sie sich für den richtigen Detaillierungsgrad für Ihre Ausnahmen entscheiden.

Die Antwort hängt davon ab, über welchen Grad der Fehlerberichterstattung wir sprechen.

Im Allgemeinen stimme ich Ihren Freunden zu, Sie sollten sie nicht detaillierter als nötig gestalten, um die Ursache des Problems zu vermitteln.

Wenn es eine allgemeine, bekannte Ausnahme für die Referenzierung von null gibt (NullReferenceException), sollten Sie keine eigene MyObjectIsNullException erstellen. Das würde den menschlichen Dolmetscher nur verwirren, eine zusätzliche Sache zu lernen, die nichts klarstellt.

Nur wenn Ihre Ausnahme so besonders ist, dass es keine vordefinierte gibt, die die Grundursache abdeckt, sollten Sie Ihre eigene erstellen.

Sie müssen hier jedoch nicht aufhören. Der häufig auftretende Fehler kann in einer Ihrer Komponenten auftreten, und Sie möchten möglicherweise mitteilen, dass in Ihrer Komponente ein Problem aufgetreten ist . Also nicht nur was schief gelaufen ist sondern auch wo. Dann wäre es angebracht, die erste Ausnahme in eine MyComponentException zu verpacken. Das gibt Ihnen das Beste aus beiden Welten.

Zuerst wird klar sein, dass Ihre Komponente in Schwierigkeiten geraten ist. Bei einem unteren Hebel liegt die spezifische Ursache in der inneren Ausnahme.