Why does `SpringApplication.run` not create the beans lazily?

If you have defined component classes in your project with singleton scope and do nothing in your main() besides bringing up the application context, e.g with:

ConfigurableApplicationContext context = SpringBootApplication.run(MyMainClass.class, args)

context will already be pointing to an ApplicationContext that contains a singleton instance of those classes. So no matter how many times you type context.getBean(MyContainerClass.class) you will get the same instance of MyContainerClass.

But the creation of that object might be quite heavy, and even dependent on runtime constraints (database connections, network socket management, the works). I understand that it is not very good programming practice to overload a constructor but, even in POJO, it can happen.

I was wondering whether there was a particular kind of logic to creating the singletons immediately when the context is created, instead of the first time getBean() is called. Maybe there's a contract from SpringBoot to the programmer that says: "If you have annotated a class with @Component, you really should retrieve the bean at some point: I will assume you know this and are willing to eat the construction cost when the context is being brought up." Maybe not. Not sure.

actually the Spring Boot (2.3.3) can load the @Beans lazily. Just add the property below to your application.properties file. The initialization should be performed lazily.

spring.main.lazy-initialization = true

Enabling lazy initialization in the whole application could produce both positive and negative effects. See the effects of Lazy Initialization described by Baeldung:

1. Lazy initialization may reduce the number of beans created when the application is starting – therefore, we can improve the startup time of the application

2. As none of the beans are created until they are needed, we could mask issues, getting them in run time instead of startup time

3. The issues can include out of memory errors, misconfigurations, or class-definition-found errors

4. Also, when we're in a web context, triggering bean creation on demand will increase the latency of HTTP requests – the bean creation will affect only the first request, but this may have a negative impact in load-balancing and auto-scaling.