05 - Control de Errores y Configuración de Aplicaciones
1. Gestión de Excepciones y Control de Flujo
Las excepciones son eventos anómalos que ocurren durante la ejecución de un programa y rompen el flujo normal de las instrucciones. Java proporciona un mecanismo orientado a objetos para capturar y gestionar estos errores de forma controlada.
1.1 Jerarquía de Excepciones
Todas las excepciones derivan de la clase base java.lang.Throwable, que se divide en dos ramas principales:
Error: Fallos graves e irrecuperables a nivel de entorno o Máquina Virtual (ej.OutOfMemoryError,StackOverflowError). La aplicación no debe intentar capturarlos.
Exception: Errores que la aplicación puede (y debe) gestionar:
- Excepciones Verificadas (
Checked Exceptions): Se verifican en tiempo de compilación. El compilador obliga a gestionarlas explícitamente mediantetry-catcho a declararlas en la firma del método conthrows(ej.IOException,FileNotFoundException). Heredan deException
- Excepciones No Verificadas (
Unchecked/RuntimeExceptions): Ocurren en tiempo de ejecución y heredan deRuntimeException. Suelen indicar errores de programación o lógica (ej.NullPointerException,IllegalArgumentException).
1.2 Tratamiento de Excepciones
La estrategia para gestionar una excepción varía fundamentalmente según si se trata de una excepción verificada (Checked) o no verificada (Unchecked).
Tratamiento de Checked Exceptions: La regla "Catch or Declare"
Dado que el compilador verifica la presencia de estas excepciones, la sintaxis de Java obliga a tomar una de las siguientes dos decisiones ante cualquier instrucción que pueda lanzarlas:
- Capturar la excepción (
try-catch): El método asume la responsabilidad de gestionar el fallo localmente en el momento en que ocurre.
- Propagar la excepción (
throws): El método delega la responsabilidad al nivel superior en la cadena de llamadas, indicando en su firma que puede lanzar dicha excepción.
public class GestorConfiguracion { // OPCIÓN A: Captura local mediante try-catch public void cargarDesdeFicheroLocal() { try { // FileReader lanza FileNotFoundException (Checked Exception) FileReader reader = new FileReader("config.json"); } catch (FileNotFoundException e) { IO.println("Fichero no encontrado. Cargando valores por defecto..."); } } // OPCIÓN B: Propagación hacia el llamador mediante 'throws' public void cargarDesdeFicheroDelegado() throws FileNotFoundException { // Se traslada la obligación de tratamiento al método que invoque a 'cargarDesdeFicheroDelegado' FileReader reader = new FileReader("config.json"); } }
Tratamiento de Unchecked Exceptions: Programación Defensiva
Al derivar de RuntimeException, el compilador no exige el uso de try-catch ni la declaración con throws. Aunque la sintaxis permite capturarlas, la buena práctica establece que las Unchecked Exceptions no deben enmascararse con try-catch, sino prevenirse mediante validaciones previas (programación defensiva).
// MALA PRÁCTICA: Usar try-catch para tapar un error de lógica del programador public void mostrarLongitudIncorrecto(String texto) { try { IO.println("Longitud: " + texto.length()); // Si texto es null, lanza NullPointerException } catch (NullPointerException e) { IO.println("Error: La cadena recibida era nula."); } } // BUENA PRÁCTICA: Programación defensiva (validación explícita de condiciones) public void mostrarLongitudCorrecto(String texto) { if (texto != null) { IO.println("Longitud: " + texto.length()); } else { IO.println("Aviso: No se puede procesar una cadena nula."); } }
Resumen de Estrategias de Tratamiento
| Tipo de Excepción | Control del Compilador | Estrategia Recomendada |
|---|---|---|
| Checked Exception | Obligatorio | Usar try-catch para recuperarse localmente o throws para delegar la gestión a capas superiores. |
| Unchecked Exception | Opcional | Evitar su aparición mediante validaciones preliminares (if). Evitar el abuso de try-catch. |
@ControllerAdvice).
Por este motivo, la arquitectura moderna favorece crear excepciones personalizadas que hereden de RuntimeException (Unchecked). De este modo, evitamos llenar las clases de negocio y servicios con bloques try-catch repetitivos o firmas de métodos sobrecargadas con throws. La excepción se interrumpe de forma limpia, vuela hasta el manejador global, y este se encarga automáticamente de capturarla, registrar el log y devolver la respuesta HTTP adecuada (por ejemplo, un código 400 Bad Request o 404 Not Found en formato JSON) al cliente web.
1.3 Sintaxis y Estructura: try, catch, finally y try-with-resources
Para capturar y gestionar las excepciones en tiempo de ejecución, Java proporciona una estructura de bloques bien definida.
El bloque clásico: try - catch - finally
try: Delimita el bloque de código que contiene operaciones susceptibles de lanzar una excepción. Si ocurre un fallo, la ejecución del bloque se interrumpe inmediatamente en la línea del error.
catch: Captura la excepción producida en el bloquetry. Se pueden encadenar múltiples bloquescatchpara gestionar distintos tipos de excepciones de forma específica. Regla de orden: deben colocarse siempre desde la excepción más específica (hija) hasta la más genérica (padre).
finally: Bloque de ejecución garantizada. El código dentro definallyse ejecutará siempre, independientemente de si se lanzó una excepción, si esta fue capturada o si el bloquetryejecutó unreturn. Históricamente se utilizaba para liberar recursos críticos (cerrar ficheros, desconectar bases de datos o liberar sockets).
public class GestionTradicional { public void leerFicheroClasico() { FileReader reader = null; try { reader = new FileReader("datos.txt"); int caracter = reader.read(); IO.println("Primer carácter: " + (char) caracter); } catch (IOException e) { // Captura de errores de Entrada/Salida IO.println("Error al procesar el archivo: " + e.getMessage()); } finally { // Limpieza manual obligatoria: Garantizamos el cierre del recurso if (reader != null) { try { reader.close(); } catch (IOException e) { IO.println("Error al cerrar el lector."); } } IO.println("Operación finalizada (bloque finally ejecutado)."); } } }
Simplificación moderna: try-with-resources (Java 7+)
La gestión manual de cierre de recursos en el bloque finally genera un código redundante, propenso a errores y difícil de leer. Para solucionarlo, Java introduce el bloque try-with-resources.
Cualquier clase que implemente la interfaz java.lang.AutoCloseable (o java.io.Closeable) puede instanciarse dentro de los paréntesis del try. Java se encargará de invocar automáticamente su método close() al finalizar el bloque, se haya producido una excepción o no.
1.4 Lanzamiento de Excepciones y Excepciones Personalizadas
Además de capturar las excepciones lanzadas por el propio API de Java, podemos provocar nuestras propias excepciones o crear tipos de error específicos para nuestro dominio de negocio.
Las palabras clave throw y throws
throw(Acción): Se utiliza dentro del cuerpo de un método para lanzar explícitamente una instancia de excepción (throw new MiExcepcion(“Detalle…”);). Detiene inmediatamente la ejecución normal del método.
throws(Declaración): Se añade en la firma del método para avisar a los invocadores de que este método puede propagar unaChecked Exceptionque no ha sido capturada internamente.
Excepciones Personalizadas
Crear clases de excepción propias permite dar nombres significativos a los fallos de nuestra aplicación (ej. UsuarioNoEncontradoException, SaldoInsuficienteException).
Para crearlas, basta con extender de Exception (si queremos que sea verificada) o de RuntimeException (si queremos que sea no verificada, opción recomendada en arquitectura moderna).
public class ConfigurationException extends RuntimeException { // Constructor básico con mensaje public ConfigurationException(String mensaje) { super(mensaje); } // Constructor con mensaje y causa (Exception Chaining) // Permite envolver una excepción de bajo nivel dentro de una de nuestro dominio public ConfigurationException(String mensaje, Throwable causa) { super(mensaje, causa); } }
public void validarClave(String clave) { if (clave == null || clave.isEmpty()) { // Lanzamiento explícito mediante 'throw' throw new ConfigurationException("La clave de configuración no puede estar vacía."); } } public void procesarFichero(String ruta) { try { FileReader fr = new FileReader(ruta); } catch (IOException e) { // Encadenamiento de excepciones (Exception Chaining): // Capturamos una IOException de bajo nivel y lanzamos nuestra excepción de dominio preservando la causa 'e' throw new ConfigurationException("Error al cargar la configuración desde " + ruta, e); } }
super(mensaje, causa);). De este modo, no se perderá la traza original del problema cuando se registre en el archivo de log.
2. Formatos Estructurados y Archivos de Configuración
En las aplicaciones web modernas y arquitecturas de microservicios, la lectura de ficheros se centra en la carga de archivos de configuración y el intercambio de datos. Para ello se utilizan formatos estructurados estandarizados: JSON, YAML y XML.
2.1 Comparativa de Formatos
| Formato | Sintaxis Base | Casos de Uso Principales | Ventajas |
|---|---|---|---|
| JSON | Clave-Valor, Arrays {} [] | APIS REST, intercambio de datos web, configs simples | Ligero, nativo en la web, fácil parseo |
| YAML | Indentación por espacios | Configuración de aplicaciones (Spring Boot, Docker, K8s) | Altamente legible por humanos, admite comentarios |
| XML | Etiquetas anidadas <tag></tag> | Configuración empresarial (Log4j2, Maven pom.xml), SOAP | Validación estricta con esquemas (XSD), estándares robustos |
2.2 Proceso de Parseo y Deserialización
El proceso de convertir un fichero en cualquiera de estos formatos a objetos Java de nuestro dominio se denomina deserialización (y la operación inversa, serialización).
Durante este proceso, es donde ocurren la mayoría de las excepciones de entrada/salida y parseo que la aplicación debe controlar:
FileNotFoundException/IOException: El archivo no existe en la ruta indicada, el nombre está mal escrito o el proceso no tiene permisos de lectura.
- Excepciones de Formato/Sintaxis: El archivo contiene caracteres inválidos, etiquetas sin cerrar (XML) o claves mal formadas.
- Excepciones de Conversión de Tipos (
NumberFormatException): Ocurre cuando la aplicación espera leer un parámetro numérico (ej. un puerto o número de conexiones) pero en el fichero se ha escrito un texto no válido.
Para leer archivos de configuración sin necesidad de librerías externas ni mapeadores complejos, Java proporciona la clase nativa java.util.Properties. Podemos diseñar una clase de utilidad para realizar esta lectura de forma limpia:
public class ConfigurationLoader { /** * Carga un archivo de propiedades y valida sus valores clave. * @param filePath Ruta relativa o absoluta del archivo .properties * @return Objeto Properties cargado, o null si ocurrió un error crítico */ public Properties loadSettings(String filePath) { Properties config = new Properties(); // Uso de try-with-resources para garantizar el cierre del fichero try (FileInputStream file = new FileInputStream(filePath)) { // Carga el contenido del fichero en el objeto Properties config.load(file); // Lectura y conversión explícita con control de errores de tipo String url = config.getProperty("db.url"); int maxConnections = Integer.parseInt(config.getProperty("db.max_connections")); IO.println("Configuration loaded successfully. Max connections: " + maxConnections); return config; } catch (FileNotFoundException e) { IO.println("Critical error: Configuration file not found at " + filePath); } catch (IOException e) { IO.println("I/O error while reading configuration file: " + e.getMessage()); } catch (NumberFormatException e) { IO.println("Format error: db.max_connections must be a valid integer."); } return null; // Si ocurre cualquier excepción, devolvemos null } }
Esta aproximación facilita la sustitución de componentes y la realización de pruebas unitarias en el futuro:
static void main() { // Instanciación del servicio de configuración ConfigurationLoader configLoader = new ConfigurationLoader(); // Carga de ajustes desde el fichero Properties config = configLoader.loadSettings("config.properties"); if (config != null) { // Uso de los valores leídos String dbUrl = config.getProperty("db.url"); IO.println("Connecting to database at: " + dbUrl); } else { IO.println("Application failed to start due to invalid configuration."); } }
Ejercicios
Ejercicio 1
Crea un programa que calcule el coste total de una compra a partir del precio unitario en céntimos y el número de unidades, ambos enteros.
Implementa un método que reciba los dos valores y devuelva el producto. Utiliza Math.multiplyExact para detectar un resultado que no quepa en un int. En main, captura ArithmeticException y muestra un mensaje si se produce un desbordamiento.
Prueba:
| Precio en céntimos | Unidades | Resultado esperado |
|---|---|---|
| 250 | 3 | Total: 750 céntimos |
| 0 | 10 | Total: 0 céntimos |
| 2000000000 | 2 | Mensaje de desbordamiento |
Para estas pruebas, los dos valores son no negativos.
Ejercicio 2
Crea un programa que interprete una orden para controlar una luz. El programa recibe una cadena y devuelve el nuevo estado:
encenderproduceencendida.apagarproduceapagada.- Cualquier otra orden provoca una
IllegalArgumentExceptioncon un mensaje que indique la orden no reconocida.
Organiza el procesamiento en dos métodos auxiliares: uno recibe la orden y llama al otro, que la comprueba y devuelve el estado. Deja que la excepción se propague hasta main.
En main, muestra el estado o el mensaje de error y utiliza finally para mostrar Orden procesada después de cualquiera de los dos resultados.
Prueba:
| Orden | Resultado antes de finally |
|---|---|
encender | Estado: encendida |
apagar | Estado: apagada |
alternar | Mensaje de orden no reconocida |
Comprueba que Orden procesada aparece al final en los tres casos.
Ejercicio 3
Crea un programa que reciba dos cadenas, las convierta en números enteros y divida el primero entre el segundo mediante división entera.
Captura por separado NumberFormatException y ArithmeticException en main. Muestra un mensaje diferente para cada error; si la operación es válida, muestra el resultado.
Prueba estas entradas:
| Primera cadena | Segunda cadena | Resultado esperado |
|---|---|---|
“12” | “3” | Resultado: 4 |
“doce” | “3” | Mensaje de número no válido |
“12” | “0” | Mensaje de división no válida |
Ejercicio 4
Crea un programa con un método que reciba un array de enteros y un índice, y devuelva el elemento solicitado. Antes de acceder al array, comprueba que:
- La referencia al array no sea
null. - El índice esté dentro de sus límites.
Si alguna comprobación falla, lanza una RuntimeException o una subclase adecuada, con un mensaje que explique el problema. Captura la excepción en main y muestra su mensaje.
Prueba el método con el array {10, 20, 30}:
| Array | Índice | Resultado esperado |
|---|---|---|
{10, 20, 30} | 1 | Muestra 20 |
{10, 20, 30} | -1 | Mensaje de índice no válido |
{10, 20, 30} | 3 | Mensaje de índice no válido |
null | 0 | Mensaje de array no disponible |
Ejercicio 5
En el directorio desde el que ejecutes el programa, crea notas.txt con estas dos líneas:
Primera nota Segunda nota
Escribe dos variantes de un método que reciba el nombre de un fichero y devuelva una lista con todas sus líneas:
- La primera captura la posible
IOExceptiondentro del método y devuelvenullpara indicar que la lectura ha fallado. - La segunda declara
IOExceptionconthrowsy deja que se propague.
Cierra el recurso utilizado para leer. En ambos casos, main muestra las líneas devueltas o, si falla la lectura, muestra un mensaje de error: en la primera variante comprueba el valor devuelto y en la segunda captura la excepción. Explica la diferencia entre las dos estrategias.
Prueba ambas variantes con:
notas.txt: deben mostrarse las dos líneas, en orden.no-existe.txt: asegúrate antes de que no existe; debe mostrarse un mensaje de error de lectura.
Ejercicio 6
Crea un programa que reciba dos cadenas y:
- Convierta ambas a enteros.
- Rechace un primer número negativo lanzando
IllegalArgumentException. - Divida el primer número entre el segundo mediante división entera.
En main, utiliza capturas distintas para NumberFormatException, ArithmeticException e IllegalArgumentException. Recuerda que NumberFormatException es una subclase de IllegalArgumentException: su captura debe aparecer antes. Añade un bloque finally que muestre Operación terminada.
Prueba:
| Entradas | Resultado esperado antes de finally |
|---|---|
“12”, “3” | Resultado: 4 |
“doce”, “3” | Mensaje de número no válido |
“12”, “0” | Mensaje de división no válida |
“-12”, “3” | Mensaje de primer número negativo |
En los cuatro casos, comprueba que Operación terminada se muestra después del resultado o del mensaje de error.
Ejercicio 7
Crea dos ficheros de texto en el directorio de ejecución:
correcto.txt:
Uno Dos
fallo.txt:
Uno FALLO
Implementa una clase que gestione la lectura de un fichero e implemente AutoCloseable. Cuando lea una línea igual a FALLO, debe lanzar una IOException para simular un fallo reproducible.
Para comprobar el orden de los acontecimientos sin imprimir desde la clase:
- Comparte con ella una lista de eventos accesible desde
main. - Cuando
close()cierre el lector, añade a la listaRecurso cerrado. - En
main, dentro detry-with-resources, añade a la lista cada línea leída. - Fuera del bloque, captura la excepción en
mainy añade a la lista un mensaje de error. - Después, muestra la lista desde
main, en orden.
Prueba ambos ficheros y comprueba estos eventos:
| Fichero | Eventos esperados, en orden |
|---|---|
correcto.txt | Uno, Dos, Recurso cerrado |
fallo.txt | Uno, Recurso cerrado, mensaje de error de lectura |
Comprueba que el cierre se produce tanto en la lectura completa como cuando se lanza la excepción.
Ejercicio 8
Crea una excepción propia comprobada llamada SaldoInsuficienteException y un método withdraw que reciba un saldo y una cantidad entera positiva.
El método debe devolver el saldo restante si hay fondos suficientes. Si la cantidad supera el saldo, debe lanzar la excepción con un mensaje que indique el saldo y la cantidad solicitada. Declara la excepción con throws y captúrala en main.
Prueba:
| Saldo | Cantidad | Resultado esperado |
|---|---|---|
100 | 40 | Saldo restante: 60 |
100 | 100 | Saldo restante: 0 |
100 | 120 | Mensaje de saldo insuficiente |
Para este ejercicio, considera que el saldo no es negativo y que la cantidad solicitada siempre es positiva.
Ejercicio 9
Crea una excepción propia comprobada llamada LecturaDocumentoException. Escribe un método que reciba el nombre de un fichero de texto, lo abra con FileReader y devuelva una lista con sus líneas.
Si se produce una IOException, el método debe lanzar una LecturaDocumentoException con un mensaje que identifique el fichero y conserve la excepción original como causa. Cierra el recurso de lectura.
En main, muestra las líneas devueltas o captura la excepción propia y muestra su mensaje y el tipo de su causa.
Prepara y prueba estos casos:
- Crea
documento.txtcon la líneaHola: debe mostrarse esa línea sin error. - Asegúrate de que
documento-inexistente.txtno existe y solicita su lectura: debe mostrarse el mensaje de la excepción propia y el tipo de la causa original,FileNotFoundException.