Resource Handling in Spring

Applications frequently need to read files — configuration files, templates, data files — from various locations: the classpath, the filesystem, a URL, or even inside a JAR. Java's own APIs for this differ depending on the source, which makes portable code awkward. Spring solves this with the Resource abstraction: a single interface that represents a handle to a resource, regardless of where that resource physically lives.

Rather than writing separate code paths for "a file on disk" versus "a file bundled inside the JAR on the classpath," Spring code can depend on the Resource interface and let Spring choose (or be told) the concrete implementation, making resource-loading logic portable across environments and packaging formats.

The Resource Interface and Its Implementations

org.springframework.core.io.Resource defines methods like getInputStream(), exists(), getFilename(), and getURL(). Spring ships several concrete implementations, each suited to a different resource origin.

• ClassPathResource — loads a resource from the classpath (e.g. a file packaged inside src/main/resources), the most common choice for bundled config/templates.
• FileSystemResource — loads a resource from an absolute or relative filesystem path outside the packaged application.
• UrlResource — wraps a java.net.URL, letting you load resources over HTTP, FTP, or other URL-addressable protocols.
• ByteArrayResource — wraps an in-memory byte array as a Resource, useful for testing or dynamically generated content.

Injecting Resources with @Value

Instead of manually constructing a Resource implementation, Spring lets you inject one directly using @Value("classpath:data.txt") or @Value("file:/etc/app/config.properties") on a field of type Resource. The prefix ("classpath:", "file:", "http:") tells Spring which Resource implementation to create, keeping the calling code identical regardless of source.

ResourceLoader and ResourcePatternResolver

Every ApplicationContext implements ResourceLoader, exposing a getResource(String location) method that resolves a location string using the same prefix conventions as @Value. For loading multiple resources matching a pattern (e.g. all ".xml" files in a directory), Spring provides ResourcePatternResolver, which supports Ant-style wildcards like classpath*:config/*.xml.

Example

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

class GreetingLoader {

    @Value("classpath:greeting.txt")
    private Resource greetingResource;

    String readGreeting() throws Exception {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(greetingResource.getInputStream(), StandardCharsets.UTF_8))) {
            return reader.readLine();
        }
    }
}

@Configuration
class AppConfig {
    @Bean
    public GreetingLoader greetingLoader() {
        return new GreetingLoader();
    }
}

public class ResourceDemo {
    public static void main(String[] args) throws Exception {
        // Assumes src/main/resources/greeting.txt contains: Hello from a Spring Resource!
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(context.getBean(GreetingLoader.class).readGreeting());
    }
}

Hello from a Spring Resource!

Exercise

Using the lesson's Reading a classpath resource injected with @Value example, create a small implementation or design sketch that demonstrates Resource is Spring's unified abstraction for reading data regardless of its physical location.. Add a test case or scenario that would catch Hardcoding an absolute filesystem path for a resource that is actually bundled on the classpath, breaking as soon as the app is packaged into a JAR., and describe the expected result.

Quick quiz

Interview questions