How Spring invokes @Bean methods if @Configuration class contains unresolvable class refs

Question

Spring can parse @Configuration classes using ClassReaders

Assuming that we have the following scenario

We have an autoconfiguration class with multiple @Bean definitions

One of the @Bean has all conditions passed while second @Bean have @ConditionalOnClass & the class is not present in the class path

@Configuration
class CustomConfiguration {
  @Bean
  @ConditionalOnClass(String.class)
  String knownClass() {
    return "Hello";
  }

  @Bean
  @ConditionalOnClass(MissingClass.class)
  MissingClass secondBean() {
    return new MissingClass();
  }
}

In this scenario, I have couple of questions

Does Spring Boot AutoConfiguration register the first bean into the ApplicationContext?
If (1) is true, will my breakpoint inside first @Bean method be hit during debug
If (2) is true, how is the *AutoConfiguration class get loaded into JVM as this class will refers to other classes (from second @Bean) which cant be resolved at class load time
If (2) is false, does spring generate a class at runtime with just the first @Bean method and invoke the method?

Thanks

Andy Wilkinson · Accepted Answer · 2019-02-05T14:52:17.830

Generally speaking you should avoid using @ConditionalOnClass on a @Bean method for this exact reason. This situation is covered in the reference documentation where using a separate @Configuration class to isolate the @ConditionalOnClass condition is recommended.

To answer your specific questions:

Yes, the first bean will be registered as long as the configuration class can be loaded
Yes, a breakpoint in the first @Bean method should be hit during debugging
It depends on how the class that cannot be resolved is referenced. If it's only used within the body of a @Bean method, the class should load successfully. If the unresolvable class is used in the signature of a @Bean method (typically the return type), the class will fail to load.
N/A

As noted in the documentation linked to above, rather than worrying about the scenarios described in 3 and what will and will not work, using a separate, probably nested @Configuration class with a class-level condition is the recommended approach. For your specific example, that would look like this:

@Configuration
class CustomConfiguration {

  @Bean
  @ConditionalOnClass(String.class)
  String knownClass() {
    return "Hello";
  }

  @Configuration
  @ConditionalOnClass(MissingClass.class)
  static class DoubtfulBeanConfiguration {

    @Bean
    MissingClass missingClass() {
      return new MissingClass();
    }

  }

}

I believe the sample in my example will throw NoClassDefFound error — Ashok Koyi, Feb 05 '19 at 14:46
Yes, it will. Hence the recommendation not to do what your example is doing. — Andy Wilkinson, Feb 05 '19 at 14:47
I added an example with the solution you proposed to the question itself. If it is correct, can you add that to your answer so that I can remove it from question. Thanks for your help!! — Ashok Koyi, Feb 05 '19 at 14:48
I've added the specific example of how things should be structured. — Andy Wilkinson, Feb 05 '19 at 14:52

Ashok Koyi · Answer 2 · 2019-02-05T16:32:47.227

Andy above answered the "how question", i.e how to use the library. But in this answer I've attempted to answer the why question

Here is my understanding

Spring reads the autoconfiguration file metadata from /META-INF/spring-autoconfigure-metadata.properties from classpath (one such file is present in spring-boot-autoconfigure)
- This file is generated by a plugin based on the @Configuration classes listed under org.springframework.boot.autoconfigure.EnableAutoConfiguration key within /META-INF/spring.factories file by spring-boot-autoconfigure-processor plugin
- The generated file contains @Configuration class level annotations such as @ConditionalOnClass, @AutoConfigureBefore, e.t.c]
Spring builds metadata about each of @Configuration classes retrieved from the above properties file
Spring then evaluates all @Configuration class level conditions including @ConditionalOnClass against current classpath & bean factory. If conditions succeed, it loads the @Configuration class using standard java class loading
If we keep @ConditionalOnClass(MissingClass.class) at @Configuration level, spring simply does not load the class load the configuration class if the class level conditions does not evaluate to true, say if the class is not there in classpath
But if we keep @ConditionalOnClass(MissingClass.class) at @Bean level, spring will attempt to load our @Configuration class (assuming all conditions at @Configuration class level are satisfied) & we will get NoClassDefFoundError during class load

Overall, we need to follow @Andy solution because of this reason

@Andy

Appreciate if you can give your view on whether this is how Spring internally implemented the @ConditionalOnClass feature

Thanks

How Spring invokes @Bean methods if @Configuration class contains unresolvable class refs

2 Answers2