Código de ejemplo para manejar Excepciones

Question

Soy nuevo en el desarrollo de aplicaciones móviles Android. Me gustaría saber, ¿cómo puedo manejar excepciones como HttpConnection, excepciones relacionadas o cualquier otra excepción? ¿Debo mostrar un AlertDialog al usuario?

Proporcione un código de ejemplo o código fuente del proyecto sobre cómo puedo manejar HttpConnection o un tipo similar de excepciones.

Answer 1

El manejo de la excepción depende de la excepción. Si la excepción es algo que no puede recuperarse, y el usuario necesita saber acerca de entonces se podría detectar la excepción y mostrarla en un AlertDialog:

try { 
    // do something 
} catch (SomeImportantException e) { 
    AlertDialog.Builder builder = new AlertDialog.Builder(this); 
    builder.setMessage("User friendly text explaining what went wrong."); 
    AlertDialog alert = builder.create(); 
    alert.show(); 
} 

Para obtener más información sobre el cuadro de diálogo, vea creating dialogs.

Alternativamente, si la excepción es algo que puede tratar, puede simplemente registrar información sobre la excepción y continuar.

try { 
    // do something 
} catch (SomeLessImportantException e) { 
    Log.d(tag, "Failed to do something: " + e.getMessage()); 
} 

Answer 2

Existen 2 tipos diferentes de excepciones en Java: marcadas y sin marcar. Hay un gran debate sobre cuál es mejor usar, ambos argumentos son buenos.

Básicamente una excepción comprobada se deriva de java.lang.Exception y requiere que si no especifica su método como "arroja MyCheckedException", debe capturar y manejar la excepción dentro de su método.

// throw the exception 

void foo() throws MyCheckedException 
{ 
    throw new MyCheckedException(); 
} 

// or handle the exception 

void foo() 
{ 
    try { 
     throw new MyCheckedException(); 
    } catch (MyRuntimeException e) { 
     e.printStackTrace(); 
    } 
} 

Una excepción no se controla, derivado de java.lang.RuntimeException, no requiere ni que especifique "lanza" en la definición del método ni que lo maneja.

void foo() 
{ 
    throw new MyUncheckedException(); 
} 

La ventaja de Checked es que el compilador le avisará cuando no haya manejado una excepción.

La desventaja es que debe declarar un bloque de prueba/captura o un lanzamiento para cada excepción Controlada, y el código de nivel superior puede ser bastante engorroso, tratando de manejar todos los diferentes tipos de Excepciones.

Por esta razón, si tiene cuidado, es posible que prefiera usar Excepciones no verificadas.

Por cierto, solo puede elegir su tipo de excepción cuando defina la suya propia.

Al encontrar excepciones de Java o una biblioteca de terceros, debe decidir cómo manejarlas. p.ej. Si un método de terceros arroja CheckedException1, entonces debe manejarlo o declarar el método de llamada como "throws CheckedException1". Si desea evitar el uso de Excepciones marcadas, puede envolverlo en una Excepción sin marcar y lanzarlo.

void foo() // no throws declaration 
{ 
    try { 
     thirdPartyObj.thirdPartyMethod(); // this throws CheckedException1 
    } 
    catch (CheckedException1 e) { 
     throw new MyUncheckedException(e); // this will wrap the checked in an unchecked. 
    } 
} 

Tenga en cuenta que usted puede lanzar la excepción no comprobada y sin la declaración "tiros". Para acceder al CheckedException1 original desde un nivel superior, puede usar el método .getCause() de su excepción no marcada.

void caller() 
{ 
    try { 
     foo(); 
    } catch (MyUncheckedException e) { 
     CheckedException1 ce1 = e.getCause(); 
     ce1.printStackTrace(); 
    } 
} 

... sino porque la excepción de foo() no está marcada, ¿no tienen de manejar o declarar "tiros".

En cuanto a la explotación forestal, existen diferentes escuelas de pensamiento sobre esto.

1. Entrar cuando se produce la excepción (baja - nivel)
2. registrarlo cuando llega a la parte superior (alta - nivel)
3. de registro cuando se tiene suficiente información para tomar una acción apropiada y/o un mensaje de registro. (nivel medio)

Una buena política que he encontrado es instalar un controlador de excepciones no capturadas que se encargará de todas las excepciones no detectadas (obviamente sin marcar). De esta forma, cualquier cosa que se pierda será registrada y potencialmente manejada antes de bloquear el sistema.

public class MyExceptionHandler implements UncaughtExceptionHandler 
{  
    @Override 
    public void uncaughtException(Thread thread, Throwable ex) 
    { 
     ex.printStackTrace(); 
    } 
} 

// In your high-level code 
Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler()); 

y todo por excepciones que se pueden manejar con gracia, capturar y manejar en un módulo donde se sabe lo suficiente sobre la situación de corregir posiblemente el problema y vuelva a intentarlo.

Answer 3

Puede usar el complemento ACRA que ofrece esta funcionalidad o BugSense para recopilar informes de errores. Descargo de responsabilidad: soy un fundador en BugSense.