Werfen Sie eine Verknüpfte Liste von Ausnahmen in Java

Ich habe eine Funktion, die Schleifen, während etwas zu tun, könnte eine exception werfen. Sieht ungefähr so aus:

public void myFunction() throws MyException {
    while(stuff) {
        try {
            DoSomething() //throws an exception
        }
        catch (Exception ex) {
            throw new MyException(some, stuff, of, mine, ex);
        }
    }
}

Den Fehler verursacht die Ausnahme ist erstattungsfähig. Es kann so etwas wie ein SQL-Fehler in einem einzigen update-Anweisung, wo die while-Schleife führt eine Reihe von update-Anweisungen. Oder ein parsing-Fehler in einem einzigen Stück von Daten, wobei die Schleife ist die Verarbeitung mehrerer Daten. Ich übergeben zu müssen, die Ausnahme weiter oben in der Kette, so dass der GUI-Teil des Programms kann es verarbeiten, verarbeiten ihn und leiten die Fehler an den Benutzer. Aber ich will nicht zu töten, die Schleife in dieser bestimmten Funktion. Die anderen Dinge, die es tut vielleicht nicht ungültig. Der Fehler, der die Ausnahme verursacht hat, könnte nicht fatale Folgen für die Funktion.

Also meine Frage ist: Ist es eine akzeptable Praxis zu bauen Linklisten von benutzerdefinierten Ausnahmen (jede Ausnahme ist ein Knoten, und die Ausnahme, die ausgelöst wird der Kopf der Liste) und dann werfen Sie den Kopf der Liste (falls vorhanden), sobald die Schleife beendet wird?

Hat sich schon mal jemand gesehen, der das gemacht? Kann jemand denken, mögliche Probleme dabei? Kann jemand denken, der andere, bessere Möglichkeiten zur Bewältigung der root-problem: die brauchen um darauf zu verzichten, mehrere unterschiedliche exceptions mit heraus verlassen der Funktion, bis es fertig ist?

Hier ist ein Beispiel, wie die Verknüpfung und werfen Sie umgesetzt werden könnten, sehr einfach:

public void myFunction() throws MyException {
    MyException head = null;
    while(stuff) {
        try {
            DoSomething() //throws an exception
        }
        catch (Exception ex) {
            MyException tmp = new MyException(some, stuff, of, mine, ex);
            tmp.next(head);
            head = tmp;
        }
    }
    if(head != null)
       throw head;
}

Durch die Art und Weise. Darüber hinaus verwenden Sie eine verknüpfte Liste hier ist oder nicht. Es gibt eine Klasse java.util.LinkedList bereit zu verwenden, so dass Sie nicht haben, um das Programm seine Funktion in Ihrem Element-Objekte (in diesem Fall MyException).
Ich bin mir dessen bewusst. Ich glaube nicht, Sie können es verwenden, in diesem Fall, denn die Liste muss geworfen werden und LinkedList ist nicht ein throwable.

InformationsquelleAutor Daniel Bingham | 2010-02-04

exception-handling java

16

Meine ersten Gedanken (außer ich habe es nicht gesehen) ist das eine Ausnahme ist potentiell ein Recht großes Objekt (mit stacktrace) und ich würde lieber nicht speichern eine Menge von Ihnen.

Ich würde stattdessen erstellen Sie eine Liste der fehlerhaften Parametern/Argumenten als Ausnahmen auftreten, und nach Beendigung der Schleife, werfen Sie eine eigene exception aufgefüllt, mit dieser Liste (sofern die Liste mehr als 0 Elemente). Das scheint eine überschaubare Weise der Umgang mit diesem Szenario.
```
public void myFunction() throws CustomException {
    List<MyError> errors = new ArrayList<MyError>();
    while(stuff) {
        try {
            DoSomething() //throws an exception
        }
        catch (Exception ex) {
            errors.add(new MyError(some, stuff, of, mine, ex));
        }
    }
    if (errors.size() > 0) {
       throw new CustomException(errors);
    }
}
```
- Die vorhandene Funktion Unterschrift gibt void zurück. Sie könnte einfach wieder die Liste der fehlerhaften Objekte, oder irgendeine andere Struktur, die sammelt, Erfolg und Versagen, etc.
- Ich bin mir ziemlich sicher, das ist ein Beispiel, nicht die eigentliche Methode
- +1, das ist eleganter als meine. Ich fixierte Ihren code zu erklären throws CustomException. Oh, bewusst sein, dass Error ist eine vorhandene Klasse in java.lang. Sie würden vielleicht gerne den Namen ändern, um Verwechslungen zu vermeiden.
- Error-Klasse geändert, um MyError
- wenn die Ausnahme ist serialisiert, in Deserialisierung der Liste der MyErrors wird null sein
- Wo kommt das serialisieren Anforderung her ?
InformationsquelleAutor Brian Agnew
3

Tun, die Sie wirklich brauchen, um zu werfen, alle die Ausnahmen? Wie erwarten Sie, um die einzelnen, unzusammenhängenden Ausnahmen behandelt werden? In der Regel in Fällen wie diesem, wird das system nur Fehler und mit ihm getan werden.

Wenn ja, möchten Sie vielleicht sammeln Sie nur die Fehlermeldungen und fügen Sie Sie in einer benutzerdefinierten Exception Klasse und werfen.

InformationsquelleAutor Kevin

Wenn diese Ausnahmen sind eigentlich nichts miteinander zu tun, so dass Sie nicht profitieren Sie von get/setCause() würde, dann würde ich eher sammeln diese Informationen in einer MyException.

E. g.

public void myFunction() throws MyException {
    MyException myException = null;
    while(stuff) {
        try {
            DoSomething() //throws an exception
        }
        catch (Exception ex) {
            if (myException == null) {
                myException = new MyException();
            }
            myException.addException(some, stuff, of, mine, ex);
        }
    }
    if (myException != null) {
        throw myException;
    }
}

Update: Brian behandelt genau diesen Ansatz in eine nett Art und Weise. Ich würde entscheiden, dass anstelle 🙂

InformationsquelleAutor BalusC

2

Tatsächlich werfen von Ausnahmen von einer solchen Funktion ist wohl nicht der richtige Weg zu umgehen, wenn es wird erwartet, dass es sein Fehler. Ich würde vorschlagen, entweder zurückgeben einer Liste (Array) aller Ausnahmen/Fehler auftrat, oder besser, einen Fehler-handler-Objekt an die Funktion, die mit den Ausnahmen. also:
```
public interface ErrorHandler
{
    public void handleError( Throwable ex /*, add some context info */ );
}

public void myFunction( ErrorHandler eh )
{   
    while(stuff) {   
        try {   
            DoSomething() //throws an exception   
        }   
        catch (Exception ex) {
            if( eh != null )
                eh.handleError( ex );
        }   
    }   
}   
```
Dieser lässt auch den Fehler-handler entweder sammeln die Fehler, um Sie für den Benutzer oder zu entscheiden, dass der gesamte batch-operation hat, für ungültig erklärt werden, weil einige Fehler und werfen eine Ausnahme von seinen eigenen Abbruch der Verarbeitung zu früh.
- Ich sehe, dieser Ansatz ist besser als @Brain Agnew Antwort aus den folgenden Gründen 1.Fehler-handler bietet Ihnen die Handhabung der verschiedenen Ausnahmen, die sich anders, wenn benötigt 2. Nicht mehr Gebäude von array-Fehler (oder irgendeine Art von Indikatoren), wie Sie sind handling-Fehler, wie Sie geschehen.
InformationsquelleAutor x4u
1

Wenn die Ausnahme, die ausgelöst durch DoSomething(); könnte die sehr gleiche Methode, um zu werfen eine Ausnahme; das könnte ein problem sein. In anderen Worten, wenn DoSomething(); wirft eine Ausnahme weil Sie hat nicht mit den vorherigen, es könnte unnecesarry Fehler zu behandeln.
- Wahr. In dem Szenario, das ich bin, Fragen über diese würde nicht (theoretisch) der Fall sein, aber dies ist definitiv etwas im Auge zu behalten.
InformationsquelleAutor Erkan Haspulat
1

Ich denke, man kann einige passieren Rückruf oder Zuhörer zu der Methode oder eine Klasse variable und anstatt einen Wurf in die Liste, wie x4u haben.

In Java gibt es eine Schnittstelle für diese schon: java.Bohnen.ExceptionListener

InformationsquelleAutor Dudaskank
0

IMO, eine Ausnahme sollte sein, die Letzte Ressource, die Sie haben Umgang mit einem Fehler. Es sollte vermieden werden, wenn möglich. Also, möchten Sie vielleicht passieren die Fehler Beschreibung (erstellen von Fehler-codes, übergeben Sie die Nachricht, oder etwas sinnvolles) auf die GUI, und nicht die Ausnahme selbst.

InformationsquelleAutor Carlos Blanco

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.