Does Spring follow any naming convention for application configuration?

• I cannot reproduce your issue in 2.3.1.RELEASE and is working as expected and is overridden by my environment variable.

• However I don't see the spring document where it says, @Value("${myExternal_url}") use relaxed binding as well. All I see is @ConfigurationProperties will use relaxed binding.

  • https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config-relaxed-binding

• So I would update your class as follows (even through it works with and without in 2.3.1.RELEASE) @Value annotation removed

    public class ApplicationProperties {

      private String myExternalUrl;

      public String getMyExternalUrl() {
        return this.myExternalUrl;
      }

      public void setMyExternalUrl(String myExternalUrl) {
        this.myExternalUrl = myExternalUrl;
      }
    }  

• Please note, both properties will be still present in the Environment but when it is binding, it seems to decide if one overrides the other. You can see this by printing. Here I am getting the environment from applicationContext but you can autowire Environment and test this

        System.out.println(context.getEnvironment()
                             .getProperty("myExternal_url"));
        System.out.println(context.getEnvironment()
                             .getProperty("my_external_url"));

• To confirm the above point that only @ConfigurationProperties support relaxed binding but not @Value. I created the following class

   @Component
   public class ValueInjection {
    // This prints application properties.
    @Value("${myExternal_url}")
    private String myExternal_url;

    // This prints the environment variable
    @Value("${my_external_url}")
    private String my_external_url;

// If you uncomment this the application will not start saying 
// there is no such property.
// 
//    @Value("${myExternalUrl}")
//    private String myExternalUrl;

 //   ... getters and setters
    }

Spring indeed supports some sort of naming convention in the form of relaxed binding (as pointed by @Kavithakaran Kanapathippillai). In case of @ConfigurationProperties and @Value annotation, Spring tries to resolve variable from Configuration Source in the order as defined in Externalized Configuration using relaxed binding.

As answered @夢のの夢 - spring correctly match property using @Value("${myExternal_url}") with environment variable but later overridden by @ConfigurationProperties(prefix = "").

As bean ApplicationProperties is defined as @ConfigurationProperties(prefix = ""), Spring tries to match variable with configuration source (using relaxed binding) and finds match in application.propertied variable myExternalUrl and overrides property resolved using @Value("${myExternal_url}"). Problem lies in using both @Value and @ConfigurationProperties(prefix = "").

Side note - @Value supports limited relaxed binding and Spring recommends @Value property names to be defined using kebab-case.

From documentation -

If you do want to use @Value, we recommend that you refer to property names using their canonical form (kebab-case using only lowercase letters). This will allow Spring Boot to use the same logic as it does when relaxed binding @ConfigurationProperties. For example, @Value("{demo.item-price}") will pick up demo.item-price and demo.itemPrice forms from the application.properties file, as well as DEMO_ITEMPRICE from the system environment. If you used @Value("{demo.itemPrice}") instead, demo.item-price and DEMO_ITEMPRICE would not be considered.

TL;DR @Value has correct myExternal_Url from system variables injected, but its value is later set by @ConfigurationProperties.

The trace log is correct in that the ordering from Spring will place systemEnvironment before classpath:/application.properties in the propertySource list.

The issue you are having is because of a combination of using both @Value and @ConfigurationProperties to inject/bind your properties. Say these are the values you provide:

system:
  myExternal_Url: foo
  my_external_url: bar
applications.properties:
  myExternal_url: aaa

In your ApplicationProperties:

  @Value("${myExternal_url}")
  private String myExternalUrl; // injected with foo

myExternalUrl is injected correctly with value (foo) you defined in your Environment Variables. However, @ConfigurationProperties binds the values after by using the setter methods. Since it uses relaxed bindings, it checks for different variations of myExternalUrl, it first looks for what's in your system variables and finds that myExternal_url(both camel and Underscore) isn't in one of relaxed binding forms , but then my_external_url (underscore only) is. So my_external_url's value is provided to setter:

public void setMyExternalUrl(String myExternalUrl) { // bar
  this.myExternalUrl = myExternalUrl; // myExternalUrl is reassigned from foo to bar
}

So it should be clear that your @Value would always be overridden since @ConfigurationProperties binds values after. Simply have:

public class ApplicationProperties {
    private String myExternalUrl;
    ...

then have one of binding forms - MY_EXTERNAL_URL, my-external-url, or my_external_url(Maybe there is more) - defined in your system. Then have consistent case in your application.yml in case you don't want your system variables.

my-external-url=aaa

Side Note. It is recommended that you use the form MY_EXTERNAL_URL as system environment variables.