Stilistisch korrektes Exception Handling

[nrg]

Hallo Zusammen,

ich habe eine abstrakte Properties Klasse und einen Logger (enthalten nur statische Methoden). Diese werden am Anfang initialisiert und können somit von jeder anderen Klasse aufgerufen werden. Damit gibt es auch überhaupt keine Probleme. Mein Problem bzw meine Frage ist eher von stilistischer Herkunft.

Um eine "lockere Kupplung" der Klassen zu gewährleisten sollte ich eigentlich in keiner Klasse die beiden Klassen direkt verwenden. Bei den Properties ist das recht einfach, indem man alles als Parameter übergibt und dann in der aufrufenden Klasse die Daten von der Properties Klasse holt.

Beim Loggen ist mir das nicht so ganz klar. Mögliche Fehler, die ich selbst abprüfe kann ich natürlich ganz einfach werfen. Z.b. in der Klasse Properties die Methode checkProperties() throws IllegalPropetyException. Dort kann ich dann jeden throw einen spezifischen String mitgeben

1
2
if ( bedingung für eine falsche Property )
   throw new IllegalPropetyException( XXX hat einen falschen Wert XXX );

Allerdings Fehler die sporadisch auftreten (Fehler, wo es nahezu unmöglich/sehr umständlich ist alle "Benutzerfails" abzudecken) möchte ich nicht einfach so weiterschmeissen sondern ihnen natürlich auch individuelle Fehlermeldungen mitgeben.

z.B. eine ArrayIndexOutOfBounds behandle ich derzeit so:

1
2
3
4
5
try {
evtl AIOOB
} catch ( aioob.... ) {
meinLogger.fatal( "meine individuelle meldung" );
}

das gewährleistet natürlich keine "lockere Kupplung" meinee Klassen...

Laaaange Rede kurzer Sinn :

ist es schlechter Stil, wenn ich es so machen:

1
2
3
4
5
try {
evtl AIOOB
} catch ( aioob.... ) {
throw new( "meine individuelle meldung" );
}

somit ist mein Logger zentral nur in der aufrufenden Klasse. Allerdings brauch ich einen try/catch mehr . deshalb dachte ich mir, dass ich vllt irgendwas nicht berücksichtigt habe und es stilistisch schönere Optionen gibt.

Danke schonmal

[musiKk]

Verschiedene Punkte:

Es sieht so aus, als ob Du Deine eigene Logger-Klasse erstellt hast. Ich würde dazu raten, einen bestehenden Logging-Mechanismus wie java.util.logging oder log4j zu verwenden.

Ich weiß jetzt nicht, ob alle Deine Anwendungsfälle wie das Beispiel sind. Eine ArrayIndexOutOfBoundsException ist jedenfalls kein "Benutzerfail", sondern ein "Programmierfail" - ähnlich wie die meisten anderen RuntimeExceptions, die es in der Java-API gibt. So etwas darf einfach nicht auftreten; dazu gibt es length . (Kommst Du vielleicht von Python? Da macht man das wohl so...)

Wenn bestimmter Code etwas macht und es ist würdig, geloggt zu werden (ob nun Fehler oder nicht), dann sollte das auch passieren. Logging ist eine sehr gebräuchliche und legitime Abhängigkeit. Es wirkt auf mich, als ob Du Logging nur in der main() durchführst und das ist definitiv nicht nötig und auch nicht immer möglich. Da weiß man ja auch nicht mehr, als mit einem Stacktrace. Ansonsten kann man durchaus sowas machen wie Fangen, Loggen, Weiterwerfen oder vor dem Werfen auch wieder in eine neue Exception verpacken (z. B. checked Exceptions in RuntimeExceptions stecken o. ä.).

Ich nehme auch mal an, das letzte Codebeispiel soll eher sowas enthalten wie throw new ProgrammerMistakeException("meine individuelle meldung") new("...") geht natürlich nicht.

[nrg]

ich benutze log4j. Weil das Programm aber einmal im systray und einmal als task ausgeführt werden kann, kann es gut sein, dass eine Console nicht vorhanden ist bzw für Fatale Fehler ein MessageDialog erscheinen soll. Somit hab ich eine statische Klasse, die das l4j-LoggerObjekt enthält und zb auch eine Methode fatal, die die logger.fatal aufruft und falls das Prog im systray läuft einen MessageDialog anzeigt. Die Appender sind natürlich auch davon abhängig.

Zitat: musiKk

	Ich weiß jetzt nicht, ob alle Deine Anwendungsfälle wie das Beispiel sind. Eine ArrayIndexOutOfBoundsException ist jedenfalls kein "Benutzerfail", sondern ein "Programmierfail" - ähnlich wie die meisten anderen RuntimeExceptions, die es in der Java-API gibt. So etwas darf einfach nicht auftreten; dazu gibt es length . (Kommst Du vielleicht von Python? Da macht man das wohl so...)

und wenn ich Befehle aus den Properties lese, die z.b. so ausehen:

FIELD1 = sql~SELECT*FROM table WHERE ID='%3%'

da wird in Feld1 der Ausgabedatei das Ergebnis des Statements geschrieben. %3% steht für das Feld3 in der Eingabedatei. Wenn der Benutzer jetzt ein FIELD angibt, dass er in der Ausgabedatei garnicht vorgesehn hat. Also z.b. FIELD10 = (gibt noch einen Parameter für die größe der Ausgabedatei -> ausgabeArray) dann wird das wohl knallen. Andersrum wenn er eine %VAR% angibt, die nicht in der Eingabedatei exisiert. (ist bissle konfus das jetzt auf die Schnelle zu erklären aber denke das ist schon verständlich). Natürlich könnte ich diesen einen Fall abprüfen aber das war mir zu unsicher. Deshalb catch ich lieber die AIOOB...

edit: ja gut, bei aioob hast du recht. das sollte ich wohl besser abprüfen und dann kann ich ja eine IllegalArgumentException schmeissen. Dann wären noch zb FileNotFoundExceptions oder NumberFormatExceptions offen, die ich natürlich nicht schmeissen will, weil ich die Lokalen informationen mitloggen will. Natürlich - wie schon gesagt - kann ichs lokal loggen. aber ich würde gerne die Koppelung so gering wie möglich halten...

[nrg]

also um vllt meine Frage nochmal expliziter in die Runde zu stellen (jetzt mal abgesehn von der AIOOB. Da hat musiKk recht. die sollte ich durch meine Programmlogik ausschließen - war ein blödes Beispiel)

- Soll ich Exceptions (z.B. FileNotFound IO NumberFormat SQL) lokal behandeln und sofort loggen (dh meine Klassen benötigen immer einen initialisierten Logger in meiner abstrakten Loggerklasse (was ich irgendwie blöd finde)
- Soll ich die Exceptions einfach werfen und in meiner aufrufenden Klasse behandeln. Somit kann ich allerdings keine genaueren Informationen loggen, was mir auch nicht gefällt
- Soll ich die Exception lokal catchen, im catch wieder mit der genauen Fehlermeldung werfen und in der aufrufenden Klasse behandeln. Somit besteht keine Koppelung und ich hab trotzdem alle Infos geloggt, die ich haben will. Für mich bis jetzt die schönste Option. Allerdings mehr Code... (frag mich halt, ob das nicht stilistisches total unschön ist)

[musiKk]

Wie gesagt: Einen Logger als Abhängigkeit zu haben ist OK. Man kann prinzipiell loggen, wo man will (und es sinnvoll ist). Es ist schwierig, Pauschalaussagen zu treffen.
Wenn Dein Programm oder Deine Bibliothek einen Logger verwendet, dann ist es ja auch egal, wo. Die Abhängigkeit ist insgesamt da oder nicht. Von daher finde ich es auch schwer, die Aussage "der aufgerufene Code wirft Exceptions und der aufrufende Code soll loggen" einzuordnen. Damit ist die Abhängigkeit ja bereits da.