Get a list of resources from classpath directory

java

resource-management

classpath-resources

reflection-library

byAlex Kataev·Feb 8, 2025

Utilize Spring's PathMatchingResourcePatternResolver for a no-nonsense method to retrieve resources from a classpath directory:

import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.Resource;

// Because someone has to resolve these poor, neglected patterns!
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

Resource[] resources = resolver.getResources("classpath*:your/dir/**");

for (Resource resource : resources) {
    // Print them all. No resource left behind! 
    System.out.println(resource.getFilename());
}

Substitute your/dir with your targeted directory path to fetch filenames of resources within the classpath location.

Comprehensive approach for resource retrieval

Every project comes with unique constraints and requirements. Here, we present various strategies to meet your needs:

Spring Framework to the rescue

PathMatchingResourcePatternResolver, an unsung hero of the Spring Framework that can list files reliably from classpath.

Precompiled searching with Reflections

Use Reflections library by ronmamo for compile-time scanning. It's like getting the answers before the exam starts!

Bundle up with JARs

The methods differ for files on the filesystem and those in JARs. Always know which 'JAR' you're dealing with!

Maximising existing libraries

Leverage Spring, Apache CommonsIO, dance on the shoulders of giants, instead of doing all the legwork!

Using `getResourceAsStream` with BufferedReader

This JDK-standard method works well, but watch out for any performance drag in larger applications.

Seizing the thread context

‘Why switch class loaders?’ they asked. ‘Why not!’ we answer. Introducing, getContextClassLoader()!

Wielding Regular Expressions

Complex resource naming? Fear not! Regular expressions are your white knight for precision matching.

Cautious of performance impact

No one likes a slowpoke, nor a tool with a heavy runtime overhead.

Compatibility checks for safe surfing

Party responsibly. Always verify community feedback and library compatibility before choosing a solution.

Dealing with resource patterns

Exhibit mastery over resource patterns!

Reflections for classpath scanning

import org.reflections.Reflections;
import org.reflections.scanners.ResourcesScanner;
Reflections reflections = new Reflections("your/dir", new ResourcesScanner());

Set<String> resourcePaths = reflections.getResources(Pattern.compile(".*"));
resourcePaths.forEach(System.out::println);

// Because there's nothing like listing files you didn't remember existed!

Have your Reflections library up-to-date to avoid reported difficulties. Reports indicate it gets emotionally sensitive if neglected.

Apache Commons IO for filesystem resources

import org.apache.commons.io.FileUtils;
File dir = new File("src/main/resources/your/dir");
Collection<File> files = FileUtils.listFiles(dir, null, true);
files.forEach(System.out::println);
// "FILE-nom-nom-nom-nom-nom!" said the byte monster happily.

If your resources are guaranteed to be on the filesystem and not loitering inside a JAR, this is your game.

Optimal strategies for peculiar needs

Does your dilemma seem singularly complex? Fear not! We've got you covered:

Unmasking the directory

Don't know the whereabouts of the resource – filesystem or classpath? Simple, we locate before choosing the pot of gold:

String path = "/your/dir";
URL dirURL = Thread.currentThread().getContextClassLoader().getResource(path);
if (dirURL != null && dirURL.getProtocol().equals("file")) {
    /* Use File-based approach */
} else if (dirURL != null && "jar".equals(dirURL.getProtocol())) {
    /* Handle Jar file */
}

Alphabetically ordered resource access

Access resources in a specified order? From A to Z, receive a sorted list of resources with a clever usage of File and ZipFile classes:

List<Resource> sortedResources = Arrays.stream(resources).sorted(Comparator.comparing(Resource::getFilename)).collect(Collectors.toList());
// Because taking turns is a good habit!

Using Spring to autowire resources

In a Spring context, resources can also be injected:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ResourceLoader;

@Autowired
ResourceLoader resourceLoader;

public void doTheResourceMamba() {
    // And then the music started....
}