personalizadas - propagacion de excepciones en java

Lanzar una lista enlazada de excepciones en Java

Question

Tengo una función que hace un bucle mientras hago algo que podría lanzar una excepción. Parece algo como esto:

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

El error que causa la excepción es recuperable. Puede ser algo así como un error de SQL en una sola instrucción de actualización donde el bucle while ejecuta una serie de instrucciones de actualización. O un error de análisis en una sola pieza de datos, donde el bucle está procesando múltiples piezas de datos. Necesito pasar la excepción más arriba en la cadena para que la parte de la GUI del programa pueda procesarla, manejarla y transmitir el error al usuario. Pero no quiero matar el bucle en esta función en particular. Las otras cosas que está haciendo pueden no ser inválidas. El error que causó la excepción podría no ser fatal para la función.

Así que mi pregunta es la siguiente: ¿es una práctica aceptable construir listas vinculadas de excepciones personalizadas (donde cada excepción es un nodo, y la excepción lanzada es el encabezado de la lista) y luego lanzar el encabezado de la lista (si corresponde) una vez? el bucle termina?

¿Alguna vez alguien ha visto esto hecho? ¿Alguien puede pensar en algún problema potencial al hacer esto? ¿Alguien puede pensar en otras formas mejores de manejar el problema raíz: la necesidad de pasar por alto múltiples excepciones no relacionadas sin salir de la función hasta que se haga?

Aquí hay un ejemplo de cómo la vinculación y el lanzamiento podrían implementarse de manera muy simple:

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;
}

Answer 1

¿Realmente necesitas tirar todas las excepciones? ¿Cómo espera que se manejen las excepciones individuales y no relacionadas? Por lo general, en casos como este, el sistema solo informará los errores y terminará con ellos.

Si es así, es posible que desee simplemente recoger los mensajes de error y agregarlos a una clase de Exception personalizada y lanzarlos.

Answer 2

Creo que puedes pasar algo de devolución de llamada o escucha al método, o establecerlo en una variable de clase y en lugar de lanzar la lista, como hizo x4u.

En Java ya hay una interfaz para esto: java.beans.ExceptionListener

Answer 3

En mi opinión, una excepción debe ser el último recurso que tiene para manejar un error. Debe evitarse si es posible. Por lo tanto, es posible que desee pasar la descripción del error (crear códigos de error, pasar el mensaje o algo significativo) a la GUI, y no a la excepción en sí.

Answer 4

En realidad, lanzar excepciones de esta función probablemente no sea la forma correcta de manejar esto si se espera que haya errores. Yo sugeriría devolver una Lista (Array) de todas las excepciones / errores que ocurrieron o mejor para proporcionar un objeto de controlador de errores a la función que puede hacer frente a las excepciones. es decir:

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 );
        }   
    }   
}   

Esto también permite que el manejador de errores recopile los errores para presentarlos al usuario o para decidir que toda la operación por lotes se ha anulado debido a algún error y lanzar una excepción propia para abortar el procesamiento temprano.

Answer 5

Mi pensamiento inicial (aparte de que no he visto esto) es que una excepción es potencialmente un objeto bastante grande (que contiene el seguimiento de la pila) y prefiero no almacenar muchos de ellos.

En su lugar, crearía una lista de los parámetros / argumentos erróneos a medida que se producen las excepciones, y una vez finalizado el bucle, lanzar una excepción personalizada rellenada con esta lista (si la lista tiene más de 0 elementos). Esa parece una forma más manejable de manejar este escenario.

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);
    }
}

Answer 6

Si esas excepciones realmente no están relacionadas entre sí para que no pueda beneficiarse de get/setCause() , entonces preferiría recopilar esta información en una MyException .

P.ej

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;
    }
}

Actualización: Brian maneja exactamente este enfoque de una manera más ordenada. Yo optaría por eso en su lugar :)

Answer 7

Si la excepción lanzada por DoSomething(); podría causar que el mismo método lance otra excepción; esto podria ser un problema. En otras palabras, si DoSomething(); lanza una excepción porque no manejó la anterior, podría haber un error innecesario para manejar.