Encapsulando una excepción

3. Encapsulando excepciones

Las excepciones comprobadas parecían geniales en teoría, pero resultaron ser una gran frustración en la práctica.

Supongamos que tiene un método súper popular en su proyecto. Se llama desde cientos de lugares en su programa. Y decide agregar una nueva excepción comprobada a ella. Y bien podría ser que esta excepción comprobada sea realmente importante y tan especial que solo el método main() sabe qué hacer si se captura.

Eso significa que tendrá que agregar la excepción comprobada a la cláusula throws de cada método que llama a su método súper popular. Así como en la cláusula throws de todos los métodos que llaman a esos métodos. Y de los métodos que llaman a esos métodos.

Como resultado, las cláusulas throws de la mitad de los métodos en el proyecto obtienen una nueva excepción comprobada. Y por supuesto, su proyecto está cubierto por pruebas, y ahora las pruebas no se compilan. Y ahora también debe editar las cláusulas throws en sus pruebas.

Y luego todo su código (todos los cambios en cientos de archivos) tendrá que ser revisado por otros programadores. Y en este punto nos preguntamos por qué hicimos tantos cambios sangrientos en el proyecto. ¿Día(s?) de trabajo y pruebas rotas, todo por agregar una excepción comprobada?

Y, por supuesto, todavía existen problemas relacionados con la herencia y la anulación de métodos. Los problemas que provienen de las excepciones comprobadas son mucho mayores que el beneficio. En resumen, ahora poca gente las ama y poca gente las usa.

Sin embargo, todavía hay mucho código (incluido el código de la biblioteca Java estándar) que contiene estas excepciones comprobadas. ¿Qué se debe hacer con ellas? No podemos ignorarlas y no sabemos cómo manejarlas.

Los programadores de Java propusieron encapsular las excepciones comprobadas en RuntimeException. En otras palabras, capturar todas las excepciones comprobadas y luego crear excepciones no comprobadas (por ejemplo, RuntimeException) y lanzarlas en su lugar. Haciendo esto se ve algo así:

try
{
   // Code where a checked exception might occur
}
catch(Exception exp)
{
   throw new RuntimeException(exp);
}

No es una solución muy bonita, pero no hay nada ilegal aquí: simplemente se metió la excepción dentro de una RuntimeException.

Si se desea, se puede recuperar fácilmente de allí. Ejemplo:

try
{
   // Code where we wrap the checked exception
   // in a RuntimeException
}
catch(RuntimeException e)
{
   Throwable cause = e.getCause();
   if (cause instanceof Exception)
   {
      Exception exp = (Exception) cause;
      // Exception handling code goes here
   }
}