Buenas prácticas para trabajar con archivos

1. Gestión de errores: ¡no ignores las excepciones!

Trabajar con archivos siempre es interactuar con el mundo exterior, que puede ser muy impredecible. Los discos pueden llenarse, los archivos — desaparecer, los permisos — cambiar, y los usuarios — hacer lo inimaginable (por ejemplo, ejecutar tu programa desde una carpeta con espacios en el nombre o desde una memoria USB que están a punto de retirar). Si tu código no está preparado para ello, corre el riesgo no solo de «caerse», sino también de dejar al usuario sin los datos necesarios.

Las buenas prácticas no son simples «consejos de moda», sino un conjunto de técnicas probadas por el tiempo que ayudan a evitar los escenarios más desagradables: pérdida de datos, fugas de memoria, exposición de información privada y errores tontos que luego avergüenzan ante los colegas (y, especialmente, ante los usuarios).

¿Por qué no debes escribir un catch vacío?

En Java (y no solo) es muy tentador escribir algo como:

try {
    // trabajo con el archivo
} catch (IOException e) {
    // bueno, no funcionó — no pasa nada
}

Esto es lo peor que se puede hacer. Ese código no solo «se traga» el error: lo vuelve invisible para el usuario y para ti mismo. Como resultado, si algo va mal, nunca sabrás qué exactamente y cuándo.

¿Cómo hacerlo bien?

• Registra los errores: al menos muestra un mensaje en la consola o escríbelo en un archivo de registro.
• Comunica al usuario: si el error es crítico, muestra un mensaje amigable.
• No reveles información innecesaria: no muestres al usuario detalles internos del sistema (por ejemplo, un stack trace completo — eso es más bien para el desarrollador).

Ejemplo:

try {
    List<String> lines = Files.readAllLines(Path.of("data.txt"));
    // procesamiento de datos
} catch (IOException e) {
    System.err.println("Error al leer el archivo: " + e.getMessage());
    // Se pueden guardar los detalles en un archivo de registro
    e.printStackTrace(System.err);
}

¿Por qué es importante capturar excepciones concretas?
Porque diferentes errores requieren diferentes reacciones. Por ejemplo, si no se encuentra el archivo — se puede proponer al usuario elegir otro archivo (NoSuchFileException o FileNotFoundException). Si no hay permisos — pide ejecutar el programa con los permisos necesarios (AccessDeniedException). Si el disco está lleno — sugiere liberar espacio (IOException al escribir).

2. Permisos de acceso y seguridad

Comprueba los permisos de acceso antes de operar

Antes de leer o escribir un archivo, conviene asegurarse de que tienes permisos para ello. En Java existen los métodos:

• File.canRead()
• File.canWrite()

Incluso si estos métodos devuelven true, no garantizan el éxito — los permisos pueden cambiar en cualquier momento (por ejemplo, otro proceso los modificó). Por eso, siempre debes estar preparado para excepciones.

Ejemplo:

File file = new File("config.properties");
if (!file.canRead()) {
    System.err.println("No hay permisos para leer el archivo!");
    return;
}
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
    // lectura del archivo
} catch (IOException e) {
    System.err.println("Error al leer: " + e.getMessage());
}

No expongas detalles internos

Si tu programa trabaja con archivos confidenciales (por ejemplo, contraseñas), no muestres las rutas a esos archivos ni su contenido en errores visibles para el usuario.

3. No utilices rutas relativas para operaciones críticas

Una ruta relativa (new File("data.txt")) es una ruta respecto al directorio de trabajo actual, que puede variar según cómo se ejecute el programa (por ejemplo, desde un IDE o desde la línea de comandos). Esto puede llevar a confusiones y errores.

Buena práctica: para archivos importantes utiliza rutas absolutas o define explícitamente el directorio de trabajo.

Ejemplo:

String userHome = System.getProperty("user.home");
Path configPath = Path.of(userHome, "myapp", "config.properties");

4. Trabajo con archivos y directorios temporales

¿Para qué sirven los archivos temporales?

Los archivos temporales sirven para distintas tareas. A veces se usan para operaciones intermedias: por ejemplo, primero se escriben los datos en un archivo temporal y después ese archivo reemplaza al principal. Otro caso — los archivos temporales ayudan a almacenar información que no es necesaria tras finalizar el programa y puede eliminarse con seguridad.

¿Cómo crear archivos temporales de forma segura?

Usa métodos de java.nio.file.Files:

Path tempFile = Files.createTempFile("myapp_", ".tmp");
// ... trabajo con el archivo
Files.deleteIfExists(tempFile);

Directorios temporales

Path tempDir = Files.createTempDirectory("myapp_");

5. Fiabilidad: copias de seguridad y control de integridad

Usa copias de seguridad al modificar archivos importantes

Antes de sobrescribir un archivo importante (por ejemplo, de configuración), crea su copia:

Path config = Path.of("config.properties");
Path backup = Path.of("config.properties.bak");
if (Files.exists(config)) {
    Files.copy(config, backup, StandardCopyOption.REPLACE_EXISTING);
}

Si algo sale mal al escribir, siempre podrás restaurar desde la copia de seguridad.

Verifica la integridad de los datos

Para datos especialmente importantes se pueden usar sumas de verificación (por ejemplo, MD5 o SHA-256). Tras escribir el archivo, calcula la suma y guárdala junto a él. Al leer, comprueba si el archivo ha cambiado.

Ejemplo de cálculo de SHA-256 (para los amantes de la criptografía):

import java.security.MessageDigest;
import java.nio.file.Files;
import java.nio.file.Path;

byte[] data = Files.readAllBytes(Path.of("important.dat"));
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(data);
// Guardamos el hash en un archivo aparte o lo comparamos al leer

6. Minimiza la ventana entre la comprobación y el uso del archivo

Esto es la clásica y conocida problemática TOCTOU (Time Of Check To Time Of Use): entre el momento en que compruebas que el archivo existe y cuando empiezas a leerlo, el archivo puede desaparecer o cambiar.

Así que intenta siempre hacer la comprobación y el uso en el mismo bloque try. Y maneja las excepciones, incluso si acabas de comprobar el archivo.

Ejemplo:

Path filePath = Path.of("data.txt");
if (Files.exists(filePath)) {
    try (BufferedReader reader = Files.newBufferedReader(filePath)) {
        // lectura del archivo
    } catch (IOException e) {
        System.err.println("Error al leer el archivo (es posible que el archivo haya desaparecido): " + e.getMessage());
    }
}

7. Algunos consejos útiles adicionales

Usa try-with-resources para todos los recursos
Todas las clases que implementan la interfaz AutoCloseable (y eso incluye casi todos los flujos de Java IO/NIO) se pueden usar con try-with-resources. Esto protege contra fugas de recursos.

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    // lectura
}

No olvides eliminar los archivos temporales

Files.deleteIfExists(tempFile);

No cierres un recurso dos veces
Si usas try-with-resources, no invoques close() manualmente — puede provocar errores e intentos de cierre duplicados.

8. Errores típicos al trabajar con archivos

Error n.º 1: ignorar las excepciones.
Escribir un catch vacío es como atrapar moscas con la mano y soltarlas de nuevo. Registra siempre los errores o, al menos, informa al usuario de qué ha ido mal.

Error n.º 2: no cerrar los flujos.
Si olvidas cerrar un flujo, el archivo puede quedar bloqueado y el sistema — sin descriptores libres. Usa try-with-resources.

Error n.º 3: usar rutas relativas para archivos importantes.
No confíes en que el directorio de trabajo sea siempre el que esperas. Es mejor establecer la ruta explícitamente o usar directorios especiales (user.home, java.io.tmpdir).

Error n.º 4: sobrescribir archivos importantes sin copia de seguridad.
Antes de borrar algo importante, crea una copia de seguridad. Te ahorrará nervios y protegerá los datos del usuario.

Error n.º 5: no comprobar los permisos de acceso.
Comprueba que el usuario tiene permisos de lectura/escritura para los archivos o directorios necesarios — de lo contrario, obtendrás AccessDeniedException inesperadas.

Error n.º 6: ventana TOCTOU.
Entre la comprobación y el uso del archivo, alguien más puede modificarlo o eliminarlo. Maneja siempre las excepciones, incluso después de comprobar.

Error n.º 7: dejar archivos temporales y basura.
Tras cierres anómalos del programa o errores, pueden quedar archivos temporales. No olvides eliminarlos, especialmente si contienen datos sensibles.