Spring Boot: How to Read a File from Resources

Introduction

Reading a file from the resources folder in a Spring Boot application is a common requirement, especially for loading configurations, test files, or other static resources at runtime. Spring Boot provides several mechanisms to achieve this, making the process both efficient and straightforward. Understanding these methods will help you leverage Spring’s rich resource support effectively.

Solution

Using ResourceLoader to Read Files

ResourceLoader is a fundamental interface provided by Spring for loading resources. You can autowire ResourceLoader into your bean and use it to read files from the resources directory.

Sample Code in Kotlin

import org.springframework.core.io.ResourceLoader
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct

@Service
class ResourceService(private val resourceLoader: ResourceLoader) {

    @PostConstruct
    fun readFileFromResources() {
        val resource = resourceLoader.getResource("classpath:sample.txt")
        val fileContent = resource.inputStream.bufferedReader().use { it.readText() }
        println(fileContent)
    }
}

Output

Assuming sample.txt contains the text “Hello, world!”, the output will be:

Hello, world!

Advantages

• Flexibility: Can load resources from various locations (e.g., classpath, file system).
• Easy to Integrate: Works seamlessly with Spring’s dependency injection.

Disadvantages

• Additional Dependency: Requires injecting ResourceLoader.
• Performance: Might have a slight overhead due to the abstraction layer.

Using Resource to Read Files Directly

Spring provides the Resource interface, which is a powerful abstraction for working with different types of resources. This approach eliminates the need for ResourceLoader.

Sample Code in Kotlin

import org.springframework.core.io.ClassPathResource
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct

@Service
class ResourceService {

    @PostConstruct
    fun readFileFromResources() {
        val resource = ClassPathResource("sample.txt")
        val fileContent = resource.inputStream.bufferedReader().use { it.readText() }
        println(fileContent)
    }
}

Output

For sample.txt containing “Hello, world!”, the output will be:

Hello, world!

Advantages

• Simplicity: Less code by not requiring an additional loader.
• Direct Access: Useful for straightforward resource access needs.

Disadvantages

• Classpath Dependency: Only works well for classpath resources. For other resource types, additional handling might be needed.

Using Spring’s @Value Annotation

With the @Value annotation, you can inject the content of a resource file directly into your beans. This is particularly useful for configurations and small-sized resource content.

Sample Code in Kotlin

import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct

@Service
class ResourceService {

    @Value("classpath:sample.txt")
    private lateinit var resource: org.springframework.core.io.Resource

    @PostConstruct
    fun readFileFromResources() {
        val fileContent = resource.inputStream.bufferedReader().use { it.readText() }
        println(fileContent)
    }
}

Output

For sample.txt with “Hello, world!”, the output will be:

Hello, world!

Advantages

• Ease of Use: Simplifies code by using Spring annotations.
• Integration: Perfect for injecting property values or small resource contents directly.

Disadvantages

• Limited Use Case: Best suited for small-sized files; large files might cause performance issues.
• Readability: Annotation-based configuration could reduce readability for complex resource handling logic.

Using Spring’s Environment Interface

Sometimes, you might need to read property files or other configurations from the resources folder dynamically. Spring’s Environment interface provides a convenient way for such tasks.

Sample Code in Kotlin

import org.springframework.context.annotation.PropertySource
import org.springframework.core.env.Environment
import org.springframework.stereotype.Service
import javax.annotation.PostConstruct

@Service
@PropertySource("classpath:application.properties")
class ResourceService(private val environment: Environment) {

    @PostConstruct
    fun readProperties() {
        val value = environment.getProperty("my.property")
        println(value)
    }
}

Output

If application.properties contains my.property=Hello, world!, the output will be:

Hello, world!

Advantages

• Dynamic Configuration: Great for loading properties dynamically.
• Integration: Works well with Spring’s environment abstraction.

Disadvantages

• Complexity: May be overkill for simple file reads.
• Dependency: Requires defining properties in a specific format.

Similar Topics

• How to Read a CSV File in Spring Boot
• Working with YAML Files in Spring Boot
• Loading JSON Configuration Files in Spring Boot
• Injecting Property Values in Spring Boot
• Using @ConfigurationProperties for Type-safe Configuration
• Handling Environment Variables in Spring Boot
• Reading Files in Spring Boot REST Controllers
• Static Resource Mapping in Spring Boot
• Using ResourceLoader in Spring Boot
• Spring Boot File Upload and Download
• Working with MultipartFile in Spring Boot
• Serving Static Content with Spring Boot
• Caching Static Resources in Spring Boot
• Spring Boot: Externalizing Configuration
• Working with Application Properties in Spring Boot
• Spring Boot: Reading and Writing XML
• Reading Files from the Filesystem in Spring Boot
• Using @Value for File Injection in Spring Boot