Create a Symbolic Link with Java

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this tutorial, we’ll explore different ways of creating a symbolic link in Java using the NIO.2 API, and explore the differences between hard and soft file links.

2. Hard vs Soft/Symbolic Links

First, let’s define what file links are and what is their expected behavior. A file link is a pointer that transparently references a file stored in the file system.

A common misunderstanding is thinking that a file link is a shortcut, so let’s check their behavior:

A shortcut is a regular file that references a target file
Soft/Symbolic link is a file pointer that behaves as the file that is linking to – if the target file gets deleted then the link is unusable
A hard link is a file pointer that mirrors the file that it’s linking to, so it’s basically like a clone. If the target file gets deleted, the link file is still valid

Most operating systems (Linux, Windows, Mac) already support soft/hard file links, so it shouldn’t be a problem to work over them using the NIO API.

3. Creating Links

First, we have to create a target file to link to, so let’s sequence some data into a file:

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;		
}

Let’s create a symbolic link to an existing file, ensuring that the created file is a symbolic link:

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);
}

Next, let’s take a look at a hard link creation:

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);
}

By listing the files with their differences, we can see that the soft/symbolic link file size is small, while the hard link is using the same space as the linked file:

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

To clearly understand what are the possible exceptions that can be thrown, let’s see the checked exceptions on the operations:

UnsupportedOperationException – when the JVM doesn’t support file links in a specific system
FileAlreadyExistsException – when the link file already exists, the override is not supported by default
IOException – when an IO error occurs, e.g. invalid file path
SecurityException – when the link file can’t be created or the target file can’t be accessed because of limited file permissions

4. Operations With Links

Now, if we have a given file system with existing file links, it’s possible to identify them and show their target files:

public void printLinkFiles(Path path) throws IOException {
    try (DirectoryStream<Path> 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));
            }
        }
    }
}

If we execute it in our current path:

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

We would get the output:

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

Note that hard link files aren’t simply identifiable with NIO’s API, low-level operations are required to work over that kind of files.

5. Conclusion

This article describes the different type of file links, their difference with shortcuts, and how to create and operate over them using a pure Java API that works over the mainstream file systems on the market.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.