practice - java exception hierarchy

Controlador de excepción global no capturado de Java

Question

Tengo una aplicación y necesito codificar un controlador de excepciones globales no detectadas. He leído todos los subprocesos de stackoverflow y a cada uno de ellos le falta un ejemplo claro y sencillo de cómo se implementará esto.

Considere este simple ejemplo siguiente:

public static void log(String msg) throws Exception {
String logPath = "/application/logs/java.log";
Calendar c = new GregorianCalendar();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String now = format.format(c.getTime());
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(logPath, true)));
out.println(now + " " + msg);
out.close();
}

Lanza una excepción estándar que es solo una salida estándar. ¿Cómo implemento mi propia excepción que anula la estándar por algo tan simple como generar el error en un archivo de registro? Obviamente, la aplicación real es mucho más grande y estamos hablando de excepciones no detectadas, por lo que try / catch blocks no es la opción.

ACTUALIZACIÓN: Si pudiera responder con un ejemplo completo muy claro, porque encontré docenas de ejemplos como el que proporciona @RamonBoza, pero no tengo idea de cómo implementarlos, de lo que se trata esta pregunta.

ACTUALIZACIÓN2: Intenté probar el único ejemplo en la siguiente respuesta, obviamente no funciona. Creé un nuevo archivo de clase "MyRunnable" y pegué el código en él:

package mypackage;
Thread t = new Thread(new MyRunnable());
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
LOGGER.error(t + " throws exception: " + e);
}
});
t.start();
//outside that class
class MyRunnable implements Runnable(){
public void run(){
throw new RuntimeException("hey you!");
}
}

No hace falta decir que tengo un montón de errores con esto. ¿Cómo puede algo estar fuera de la clase de todos modos?

ACTUALIZACIÓN3: esta es la solución que finalmente funciona:

package mypackage;
public class MyClass {
public static void main(String[] args) throws Exception {
Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
String stacktrace = sw.toString();
System.out.println(stacktrace);
}
});
//main method code
}
//Rest of the methods here
}

Answer 1

Puede configurar UncaughtExceptionHandler para la secuencia que controla el código anterior:

// t is the parent code thread
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
LOGGER.error(t + " throws exception: " + e);
}
});

Documentos Java para UncaughtExceptionHandler -

Cuando un hilo está a punto de terminar debido a una excepción no detectada, la Máquina Virtual Java consultará el hilo para su UncaughtExceptionHandler utilizando Thread.getUncaughtExceptionHandler () e invocará el método uncaughtException del manejador, pasando el hilo y la excepción como argumentos

el setUncaughtExceptionHandler se usa comúnmente para liberar memoria o matar hilos que el sistema no podrá matar y, tal vez, seguir siendo zombie.

Un verdadero ejemplo:

Thread t = new Thread(new MyRunnable());
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
LOGGER.error(t + " throws exception: " + e);
}
});
t.start();
//outside that class
class MyRunnable implements Runnable(){
public void run(){
throw new RuntimeException("hey you!");
}
}

Answer 2

Puede usar UncaughtExceptionHandler para manejar la excepción que hace que un hilo termine abruptamente. Java doc para UncaughtExceptionHandler -

Interfaz para manejadores invocada cuando un hilo termina bruscamente debido a una excepción no detectada. Cuando un hilo está a punto de terminar debido a una excepción no detectada, la Máquina Virtual Java consultará el hilo para su UncaughtExceptionHandler utilizando Thread.getUncaughtExceptionHandler () e invocará el método uncaughtException del manejador, pasando el hilo y la excepción como argumentos

Debe implementar esta interfaz y configurar su implementación de UncaughtExceptionHandler para un hilo utilizando el método setUncaughtExceptionHandler. Hay dos maneras de hacer esto -

1. setUncaughtExceptionHandler
2. setDefaultUncaughtExceptionHandler

1) setUncaughtExceptionHandler - Este será un manejador de excepciones específico de subprocesos. Entonces, en caso de que este hilo termine por alguna excepción no controlada, se usará este controlador.

2) setDefaultUncaughtExceptionHandler - Este será un manejador de excepciones predeterminado en caso de que no exista un manejador de excepciones no detectadas específicas para un hilo.

Ejemplo -

class MyExceptionHandler implements UncaughtExceptionHandler{
@Override
public void uncaughtException(Thread arg0, Throwable arg1) {
System.out.println("[DEFAULT EXCEPTION HANDLER] Caught some exception");
}
}
class MyThread extends Thread{
public MyThread() {
setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("[THREAD SPECIFIC] My exception handler");
}
});
}
public void run(){
throw new RuntimeException();
}
}
public class Test {
public static void main(String[] args) {
Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler());
new MyThread().start();
// current thread does not have a thread specific exception handler
throw new RuntimeException();
}
}

Answer 3

Puedes intentar configurar tu propio manejador de excepciones no detectado , sin embargo, desaconsejo encarecidamente. Si su aplicación tiene partes que potencialmente pueden romperse y si esa excepción no se maneja adecuadamente en la ubicación donde se rompe su código, su programa entero funcionará mal con frecuencia.