Troubleshooting and Solutions for Spring Boot Application Failing to Read application.properties

Problem Phenomenon Analysis

In Spring Boot application development, proper loading of configuration files is fundamental for successful application startup. This article analyzes a configuration loading failure that occurs when an application is launched via "Run as Spring Boot App" in Spring Tools Suite (STS), based on an actual case study.

The specific error manifests as: org.springframework.beans.factory.BeanCreationException: Could not resolve placeholder 'solr.host' in string value "${solr.host}". This indicates that the Spring container cannot resolve property placeholders defined in the configuration file during Bean initialization.

Environment Comparison Analysis

Notably, the same application runs normally when started via the command line using mvn spring-boot:run, but fails to load configurations when launched in the IDE. This discrepancy suggests that the root cause may lie in configuration differences between build and runtime environments.

Analysis of the application structure shows that the configuration file application.properties is located in the standard src/main/resources directory, with contents including:

# SPRING MVC
spring.view.suffix=.jsp
spring.view.prefix=/WEB-INF/views/

# SOLR
solr.host=http://192.168.56.11:8983/solr

Core Problem Identification

Through thorough investigation, the issue was traced to the project's build path configuration. In the Project Properties → Java Build Path → Source tab's Exclusion section, there was an exclusion rule: **/application.properties.

This exclusion rule caused the application.properties file to be excluded from the classpath during IDE builds, preventing Spring Boot from locating and loading the configuration file at startup. Command-line builds using Maven's standard build process are unaffected by this exclusion rule.

Solution Implementation

Removing the exclusion rule from the build path is the direct solution to this problem. The specific steps are:

1. Right-click the project in the IDE and select Properties
2. Navigate to Java Build Path → Source
3. Remove **/application.properties from the Exclusion patterns section
4. Apply changes and restart the application

After implementing this solution, the application starts normally in the IDE, with configuration properties being loaded correctly.

In-depth Analysis of Related Configuration Mechanisms

Spring Boot follows a specific configuration loading order, where application.properties on the classpath is the default configuration source. When this file is excluded from the classpath, Spring Boot cannot find configuration properties, leading to placeholder resolution failures.

In configuration classes, when using the @Value("${solr.host}") annotation to inject configuration values, Spring searches all available PropertySources for the corresponding property value. If the configuration file is not properly loaded, an IllegalArgumentException is thrown.

Analysis of Other Common Causes

Beyond build path exclusion issues, other scenarios that may cause configuration loading failures in practice include:

Maven Packaging Configuration Issues: When <packaging>pom</packaging> is set in pom.xml, resource files may not be packaged correctly. Solutions include removing this configuration, executing mvn clean and rebuilding, and verifying that configuration files exist in the target/classes/ directory.

Spring Boot Version Differences: Different versions of Spring Boot may have variations in configuration loading mechanisms. Particularly when using the -Dspring.config.location parameter to specify custom configuration locations, note behavioral changes. In newer versions, explicitly specifying configuration locations overrides default search paths, so default paths must be included: -Dspring.config.location=file:/app/application-prod.yml,classpath:application.yml.

Prevention and Best Practices

To avoid similar issues, developers are advised to:

• Regularly check project build path configurations to ensure critical resource files are not accidentally excluded
• Standardize build configurations across team development environments to minimize issues caused by environmental differences
• Use standard Maven directory structures, adhering to Spring Boot's convention-over-configuration principle
• Add default values or validation logic at critical configuration points to enhance application fault tolerance

Through systematic problem analysis and solution implementation, developers can better understand Spring Boot's configuration loading mechanism and quickly identify and resolve similar issues when encountered.