How to Access and Modify Files in a Dockerized Spring Boot App: Fixing FileNotFoundException

If you’re encountering FileNotFoundException when Dockerizing your Spring Boot app that reads/writes files, you’re not alone. This common issue arises because files packaged inside a JAR aren’t accessible via traditional File paths. In this guide, we’ll solve this problem step-by-step, ensuring your app works seamlessly in Docker while adhering to best practices.

Why Does the FileNotFoundException Occur?

When you build a Spring Boot JAR:

• Locally: Files in src/main/resources are directly accessible from the filesystem.
• In Docker: These files are embedded inside the JAR. Using new File("./src/main/resources/...") fails because Docker can’t access internal JAR paths.

Solution 1: Reading Files from the Classpath

Use Spring’s ClassPathResource to read files embedded in the JAR:

import org.springframework.core.io.ClassPathResource;

@GetMapping("/")
public String homePage(Model model) throws IOException {
    List<Message> messageList = new ArrayList<>();
    ClassPathResource resource = new ClassPathResource("/data/messages.txt");

    try (Scanner scanner = new Scanner(resource.getInputStream())) {
        while (scanner.hasNext()) {
            messageList.add(new Message(scanner.nextLine(), scanner.nextLine()));
        }
    }

    // Add messages to model
    return "index";
}

Key Change: Replace File with ClassPathResource to load files from the classpath.

Solution 2: Writing Files in Docker with External Storage

Writing to src/main/resources is not allowed in production. Instead, configure an external directory:

Step 1: Externalize the File Path

Create a configuration class to define where files should be stored:

@Configuration
@ConfigurationProperties(prefix = "storage")
public class StorageConfig {
    private String path = "data"; // Default: 'data' directory

    // Getters and setters
}

Step 2: Use the Configurable Path in Your Controller

@Autowired
private StorageConfig storageConfig;

@PostMapping("/submit")
public String postMessage(...) throws IOException {
    String filePath = storageConfig.getPath() + "/messages.txt";
    File file = new File(filePath);

    // Ensure directory exists
    file.getParentFile().mkdirs();

    try (PrintWriter writer = new PrintWriter(new FileOutputStream(file, true))) {
        writer.println(message.getTitle());
        writer.println(message.getContent());
    }

    return "redirect:/";
}

Step 3: Update Dockerfile and Mount a Volume

Modify your Dockerfile to create a data directory and set the path via environment variables:

FROM openjdk:17-jdk-alpine

# Create a directory for persistent data
RUN mkdir /appdata

WORKDIR /app
COPY ./target/DockerApp.jar .

ENV STORAGE_PATH=/appdata
EXPOSE 8080

CMD ["java", "-jar", "DockerApp.jar", "--storage.path=${STORAGE_PATH}"]

Step 4: Run Docker with a Persistent Volume

Mount a host directory to preserve data across container restarts:

docker run -d \
  -v /host/machine/data:/appdata \
  -p 8080:8080 \
  your-docker-image

Key Takeaways

1. Reading Files:

• Use ClassPathResource for files in src/main/resources.
• Avoid File for JAR-embedded resources.

1. Writing Files:

• Externalize file paths using @ConfigurationProperties.
• Store data in Docker volumes for persistence.

1. Best Practices:

• Never write to src/main/resources in production.
• Use databases (e.g., PostgreSQL, MySQL) for critical data instead of files.

Why This Works in Docker

• ClassPathResource: Accesses files inside the JAR via the classloader.
• External Volumes: Docker volumes map to host directories, allowing safe read/write operations.

Troubleshooting Tips

• Permission Issues: Ensure the Docker user has write access to the mounted directory.

  RUN chmod 755 /appdata

• Logging: Add logging to verify file paths:

  @PostMapping("/submit")
  public String postMessage(...) {
      LOGGER.info("Writing to: {}", file.getAbsolutePath());
      // ...
  }

Keywords

Spring Boot Docker FileNotFoundException, Dockerize Spring Boot file access, ClassPathResource Docker, external configuration Spring Boot, Docker volumes Spring Boot, persistent storage Docker, Spring Boot file read/write.

By following these steps, you’ll resolve file access issues in Dockerized Spring Boot apps and ensure your data persists correctly. For scalable solutions, consider integrating databases like H2 (for testing) or PostgreSQL (production).