Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
bei SQLException's gibts ja die Methode getNextException um weitere (bei Query/Update entstandene) Fehler handeln zu können.
Meine Frage: Woher weiß das einzelne Exception-Objekt, was die die nexte/weitere Exception ist? Wird da eine Liste der aufgetretenen SQL-Fehler im Anweisungsobjekt (z.B. Statement) gespeichert, auf die das voherige Exception-Objekt beim Aufruf von getNextException zugreift?
getNextException heißt nicht 'nächster später auftretender Fehler'
sondern 'nächste detaillierte Information beim aktuellen Fehler'
die HauptException wird den Gesamtzustand beschreiben, die weitere Exception könnte eine der internen Verarbeitungen sein,
die trat zuerst auf, kann man aber dem User nicht zumuten, daher wird sie an höherer Stelle abgefangen und eine andere, allgemeine Exception geworfen,
die Originalexception aber noch dazu, quasi als Anhang in einer Email
achsoo, ich dachte, wenn man die Fehler listen würde, wäre es wie z.B. mehrer Compiler/Syntaxfehler: "undefinierter bezeichner", "} erwartet", "inkompatible Typen", ...
aber trotzdem... wo wird die "Liste" der Exceptions gespeichert?
es gibt keine Liste, weil die erste Exception zum Abbruch führt, danach gibts genau gar nix mehr,
außer geordnetem Abbruch, und wenn dabei eine Exception auftreten sollte, dann is eh alles im Eimer,
dann wird wahrscheinlich die erste untergehen und nur die zweite zurückgegeben werden
falls eine Syntaxüberprüfung gleich mehrere Dinge anmeckert, was zu wünschen wäre aber meist doch nicht passiert,
so würden diese intern sicherlich in Strings oder anderen Variablen gesammelt und am Ende in einer Exception gemeldet werden
sorry, aber woher nimmt denn dann die Methode getNextException die nächste Exception? Wenn eine Exception auftritt, dann tritt sie doch auf, ich behandle sie und danach gibts nichts mehr, wie du sagst.
also nochmal erklären kann ich es nicht, hier im Code wie ich es meinte
Java:
public class Test
{
public static void main(String[] args)
{
try
{
new DBSimulator().doComplexThings();
}
catch (DBException e)
{
System.out.println("DBException: " + e);
if (e.getNext() != null)
{
System.out.println("next is: " + e.getNext());
}
}
}
}
class DBSimulator
{
public void doComplexThings()
{
try
{
doEvenComplexerThings();
}
catch (VeryComplexDBException e)
{
DBException x = new DBException("Generic error");
x.setNext(e);
throw x;
}
}
private void doEvenComplexerThings()
{
throw new VeryComplexDBException("DB Speicherfehler 382473947890232-3");
}
}
class DBException
extends RuntimeException
{
private DBException next;
public DBException(String message)
{
super(message);
}
public DBException getNext()
{
return this.next;
}
public void setNext(DBException next)
{
this.next = next;
}
}
class VeryComplexDBException
extends DBException
{
public VeryComplexDBException(String message)
{
super(message);
}
}
->
Code:
DBException: test.DBException: Generic error
next is: test.VeryComplexDBException: DB Speicherfehler 382473947890232-3
das es aber in Exception allgemein schon eine Verkettung mit getCause() gibt
bin ich mir nach all deinen Zweifeln auch nicht mehr ganz sicher
vielleicht ist es doch bisschen anders gemeint, ich möchte da jetzt nichts mehr beschwören,
was mir aber weiterhin sehr wahrscheinlich erscheint ist, dass falls weitere Exceptions auftreten, die erste noch bekannt ist, dort also gut
erste.setNextException(zweite); aufgerufen werden kann (oder andersrum),
der Anwendungsbereich mag etwas fraglich sein, die Verknüpfung scheint es mir nicht
getCause() ist anders als getNextException()
beim "cause" geht es um die Ursache, bei nextException schlicht um die nächste Exception.
Wann sowas nützlich sein kann? zB. bei einem Batch statement, in dem mehrere statements auf einmal an den DB Server geschickt werden.
Wie die nextException gesetzt wird? na mit setNextException.
@maki: hmm, getCause() gibt doch auch das nächste Throwable (= Vorfahre von Exception) zurück.
Genauso wie getNextException(); wo ist da der Unterschied? Liefert getNextException() vllt doch den nächsten "Syntaxfehler" vom SQL-Befehl?
@SlaterB: danke für deinen Quellcode. Es gibt also keine "Liste" wie ich zuerst dachte. Eine Exception hat jeweils die nächste gespeichert, und nur die nächste. Die Nächste wiederum hat auch eine/ihre nächste gespeichert...
Wäre praktische, wenn es den Kompletten Quellcode zu den SQLException's öffentlich geben würde. Dann hätten wir im Nu die Antwort.
@maki: hmm, getCause() gibt doch auch das nächste Throwable (= Vorfahre von Exception) zurück.
Genauso wie getNextException(); wo ist da der Unterschied? Liefert getNextException() vllt doch den nächsten "Syntaxfehler" vom SQL-Befehl?
Nein, da hast du etwas falsch verstanden, hab ich doch bereits gesagt.
getCause liefert die Ursache für die jetztige Exception, getNextException liefert eine Exception die mit der jetzigen eigentlich nix zu tun hat.
In einem Batch statement kannst du mehrere SQl Statements haben, jedes kann seine eigenen Fehler/Exeption verursachen, dafür ist getNextException gut, während getCause eben die Ursache für die jetzige Exception liefert, suche mal nach "Exception Chaining" und "Exception Translation".
Es gibt also keine "Liste" wie ich zuerst dachte. Eine Exception hat jeweils die nächste gespeichert, und nur die nächste. Die Nächste wiederum hat auch eine/ihre nächste gespeichert...
Der Quellode ist offen, unter Windows im JDK Verzeichnis als src.zip, unter Linux meist als eigenes Packet.
Du wärst jedenfalls entäuscht, getNextExceoption ist nur ein Getter, setNextException nur ein Setter.
