Beste Weg, um zu überprüfen, ob ein bestimmter exception-Typ war die Ursache (der Ursache, etc ...) in eine geschachtelte Ausnahme?

Schreibe ich einige JUnit-tests, die überprüfen, ob eine Ausnahme des Typs MyCustomException geworfen wird. Aber diese Ausnahme ist eingewickelt in anderen Ausnahmen, die eine Anzahl von Zeiten, z.B. in eine InvocationTargetException, die wiederum verpackt in eine RuntimeException.

Was ist der beste Weg, um zu bestimmen, ob MyCustomException irgendwie die Ausnahme verursacht hat, die ich eigentlich fangen? Ich möchte so etwas wie dies tun (siehe Unterstrichen):


try {
    doSomethingPotentiallyExceptional();
    fail("Expected an exception.");
} catch (RuntimeException e) {
     if (!e.wasCausedBy(MyCustomException.class)
        fail("Expected a different kind of exception.");
}

Ich würde gerne vermeiden, fordern getCause() ein paar "Ebenen" tief, und ähnlich hässlichen Workarounds. Gibt es einen schöneren Weg?

(Offenbar, der Frühling hat NestedRuntimeException.enthält(Klasse)die tut, was ich will - aber ich bin nicht mit Spring.)

GESCHLOSSEN:
OK, ich denke, es ist wirklich kein Weg um eine utility-Methode 🙂 vielen Dank an alle die geantwortet!

InformationsquelleAutor der Frage Yang Meyer | 2009-03-04

  1. 22

    Warum würden Sie wollen, um zu vermeiden getCause. Sie können natürlich auch selbst schreiben, eine Methode, um die Aufgabe zu erfüllen, so etwas wie:

    public static boolean isCause(
    Class<? extends Throwable> expected,
    Throwable exc
) {
   return expected.isInstance(exc) || (
       exc != null && isCause(expected, exc.getCause())
   );
}

    InformationsquelleAutor der Antwort Tom Hawtin - tackline

  2. 21

    Wenn Sie Apache Commons Langdann können Sie die folgenden verwenden:

    (1) Wenn die Ursache sollte genau den angegebenen Typ

    if (ExceptionUtils.indexOfThrowable(exception, ExpectedException.class) != -1) {
    //exception is or has a cause of type ExpectedException.class
}

    (2) Wenn die Ursache sollte entweder den angegebenen Typ oder seiner Unterklasse Typ

    if (ExceptionUtils.indexOfType(exception, ExpectedException.class) != -1) {
    //exception is or has a cause of type ExpectedException.class or its subclass
}

    InformationsquelleAutor der Antwort Patrick Boos

  3. 5

    Ich glaube nicht, dass Sie keine Wahl haben, aber zu nennen, durch die Schichten der getCause. Wenn man sich den Quellcode für das Frühjahr NestedRuntimeException, den Sie erwähnen, ist, wie es umgesetzt wird.

    InformationsquelleAutor der Antwort Mark

  4. 2

    Nachahmung ist die aufrichtigste form der Schmeichelei. Basierend auf einer schnellen Inspektion der Quelledas ist genau das, was NestedRuntimeException:

    /**
 * Check whether this exception contains an exception of the given type:
 * either it is of the given class itself or it contains a nested cause
 * of the given type.
 * @param exType the exception type to look for
 * @return whether there is a nested exception of the specified type
 */
public boolean contains(Class exType) {
    if (exType == null) {
        return false;
    }
    if (exType.isInstance(this)) {
        return true;
    }
    Throwable cause = getCause();
    if (cause == this) {
        return false;
    }
    if (cause instanceof NestedRuntimeException) {
        return ((NestedRuntimeException) cause).contains(exType);
    }
    else {
        while (cause != null) {
            if (exType.isInstance(cause)) {
                return true;
            }
            if (cause.getCause() == cause) {
                break;
            }
            cause = cause.getCause();
        }
        return false;
    }
}

    VORBEHALT: Das oben ist der code, der als vom 4. März 2009, so, wenn Sie wirklich wollen, zu wissen, was im Frühjahr ist, jetzt tun, Sie sollten die Forschung der code, wie es heute existiert (Wann immer das ist).

    InformationsquelleAutor der Antwort Bob Cross

  5. 1

    Gut, ich denke, es gibt keinen Weg, dies zu tun, ohne getCause(). Es Sie denken, es ist hässlich Umsetzung einer utility Klasse, dies zu tun:

    public class ExceptionUtils {
     public static boolean wasCausedBy(Throwable e, Class<? extends Throwable>) {
         //call getCause() until it returns null or finds the exception
     }
}

    InformationsquelleAutor der Antwort bruno conde

  6. 1

    Können Sie dies mit Guave:

    FluentIterable.from(Throwables.getCausalChain(e))
                        .filter(Predicates.instanceOf(ConstraintViolationException.class))
                        .first()
                        .isPresent();

    InformationsquelleAutor der Antwort emannuelbs

  7. 1

    Basierend auf Patrick Boos Antwort:
    Wenn Sie mithilfe von Apache Commons Lang 3 Sie prüfen können:

    indexOfThrowable: liefert die (null-basiert) index des ersten Throwable, die der angegebenen Klasse (genau) in der exception-chain. Unterklassen von der Klasse nicht überein

    if (ExceptionUtils.indexOfThrowable(e, clazz) != -1) {
    //your code
}

    oder

    indexOfType: liefert die (null-basiert) index des ersten Throwable, entspricht die angegebene Klasse oder Unterklasse in der exception-chain. Unterklassen der angegebenen Klasse übereinstimmen

    if (ExceptionUtils.indexOfType(e, clazz) != -1) {
    //your code
}

    Beispiel für mehrere Typen mit Java-8:

    Class<? extends Throwable>[] classes = {...}
boolean match = Arrays.stream(classes)
            .anyMatch(clazz -> ExceptionUtils.indexOfType(e, clazz) != -1);

    InformationsquelleAutor der Antwort Nagy Attila

Schreibe einen Kommentar