Crear un vínculo simbólico con Java

Programación

1. Información general

En este tutorial, exploraremos diferentes formas de crear un enlace simbólico en Java utilizando la API NIO.2 y exploraremos las diferencias entre los enlaces de archivos físicos y blandos.

2. Vínculos duros vs blandos / simbólicos

Primero, definamos qué son los enlaces a archivos y cuál es su comportamiento esperado. Un enlace de archivo es un puntero que hace referencia de forma transparente a un archivo almacenado en el sistema de archivos .

Un malentendido común es pensar que el enlace de un archivo es un atajo, así que revisemos su comportamiento:

  • Un atajo es un archivo normal que hace referencia a un archivo de destino
  • El enlace suave / simbólico es un puntero de archivo que se comporta como el archivo al que se está vinculando; si el archivo de destino se elimina, el enlace no se puede utilizar
  • Un vínculo físico es un puntero de archivo que refleja el archivo al que se vincula, por lo que es básicamente como un clon. Si el archivo de destino se elimina, el archivo de enlace sigue siendo válido

La mayoría de los sistemas operativos (Linux, Windows, Mac) ya admiten enlaces de archivos físicos / blandos, por lo que no debería ser un problema trabajar con ellos utilizando la API NIO.

3. Creación de enlaces

Primero, tenemos que crear un archivo de destino para enlazar, así que secuenciamos algunos datos en un archivo:

public Path createTextFile() throws IOException { byte[] content = IntStream.range(0, 10000) .mapToObj(i -> i + System.lineSeparator()) .reduce("", String::concat) .getBytes(StandardCharsets.UTF_8); Path filePath = Paths.get("", "target_link.txt"); Files.write(filePath, content, CREATE, TRUNCATE_EXISTING); return filePath; }

Creemos un enlace simbólico a un archivo existente, asegurándonos de que el archivo creado sea un enlace simbólico:

public void createSymbolicLink() throws IOException { Path target = createTextFile(); Path link = Paths.get(".","symbolic_link.txt"); if (Files.exists(link)) { Files.delete(link); } Files.createSymbolicLink(link, target); }

A continuación, echemos un vistazo a la creación de un enlace físico:

public void createHardLink() throws IOException { Path target = createTextFile(); Path link = Paths.get(".", "hard_link.txt"); if (Files.exists(link)) { Files.delete(link); } Files.createLink(link, target); }

Al enumerar los archivos con sus diferencias, podemos ver que el tamaño del archivo del enlace suave / simbólico es pequeño, mientras que el enlace físico usa el mismo espacio que el archivo vinculado:

 48K target_link.txt 48K hard_link.txt 4.0K symbolic_link.txt

Para comprender claramente cuáles son las posibles excepciones que se pueden lanzar, veamos las excepciones marcadas en las operaciones:

  • UnsupportedOperationException : cuando la JVM no admite enlaces de archivos en un sistema específico
  • FileAlreadyExistsException : cuando el archivo de vínculo ya existe, la anulación no es compatible de forma predeterminada
  • IOException : cuando se produce un error de IO, por ejemplo, una ruta de archivo no válida
  • SecurityException : cuando no se puede crear el archivo de enlace o no se puede acceder al archivo de destino debido a permisos de archivo limitados

4. Operaciones con enlaces

Ahora, si tenemos un sistema de archivos dado con enlaces de archivos existentes, es posible identificarlos y mostrar sus archivos de destino:

public void printLinkFiles(Path path) throws IOException { try (DirectoryStream stream = Files.newDirectoryStream(path)) { for (Path file : stream) { if (Files.isDirectory(file)) { printLinkFiles(file); } else if (Files.isSymbolicLink(file)) { System.out.format("File link '%s' with target '%s' %n", file, Files.readSymbolicLink(file)); } } } }

Si lo ejecutamos en nuestra ruta actual:

printLinkFiles(Paths.get("."));

Obtendríamos la salida:

File link 'symbolic_link.txt' with target 'target_link.txt'

Tenga en cuenta que los archivos de vínculo físico no son simplemente identificables con la API de NIO , se requieren operaciones de bajo nivel para trabajar con ese tipo de archivos.

5. Conclusión

Este artículo describe los diferentes tipos de enlaces de archivos, su diferencia con los accesos directos y cómo crearlos y operar sobre ellos utilizando una API Java pura que funciona con los sistemas de archivos principales del mercado.

La implementación de estos ejemplos y fragmentos de código se puede encontrar en GitHub.