ApplicationContext vs BeanFactory

Every Spring application is backed by a container that holds and manages beans. Spring actually offers two levels of container abstraction: the low-level BeanFactory interface, and the more capable ApplicationContext interface that extends it. Nearly every real Spring application — and certainly every Spring Boot application — uses an ApplicationContext, but understanding the distinction clarifies what the container is actually doing under the hood.

BeanFactory represents the most basic form of IoC container: it can create beans and resolve their dependencies, but that's essentially all it does, and it uses lazy initialization by default. ApplicationContext builds on top of BeanFactory and adds enterprise-level services — event publishing, internationalization support, AOP integration, environment/property abstraction, and eager initialization of singleton beans at startup — which is why it is the standard choice in practice.

BeanFactory — the Core Container

BeanFactory is the root interface for accessing a Spring IoC container. It provides basic dependency injection capability and lazily initializes beans — meaning a bean is not actually created until it is first requested via getBean(). This lazy behavior can be useful for very resource-constrained environments, but it also means configuration errors in a bean definition might not surface until much later in the application's life, when that specific bean is finally requested.

ApplicationContext — the Full-Featured Container

ApplicationContext extends BeanFactory and adds capabilities that almost every non-trivial application needs: automatic BeanPostProcessor and BeanFactoryPostProcessor registration, message resolution for internationalization (i18n), an event publication mechanism (ApplicationEventPublisher), and access to the Environment abstraction for reading properties and active profiles. Crucially, ApplicationContext eagerly instantiates all singleton beans at startup, which surfaces configuration problems immediately rather than at some unpredictable later point.

• ClassPathXmlApplicationContext — loads XML bean definitions from the classpath (legacy XML-based configuration).
• AnnotationConfigApplicationContext — loads beans from Java @Configuration classes, the standard approach in modern Spring.
• WebApplicationContext — a specialization used within web applications, tied to the servlet lifecycle; Spring Boot configures this automatically.

Why ApplicationContext Is the Practical Default

In real projects you almost never instantiate a raw BeanFactory directly. Spring Boot's SpringApplication.run(), for instance, builds and returns a fully configured ApplicationContext behind the scenes. The eager singleton instantiation, built-in event system, and environment/profile support make ApplicationContext the correct choice for anything beyond an educational example of the bare container.

Example

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
class AppConfig {
    @Bean
    public GreetingService greetingService() {
        return new GreetingService("Welcome to Spring");
    }
}

class GreetingService {
    private final String message;
    GreetingService(String message) { this.message = message; }
    void greet() { System.out.println(message); }
}

public class ContextDemo {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // Singleton beans, including greetingService, are already created by this point.
        GreetingService service = context.getBean(GreetingService.class);
        service.greet();
    }
}

Welcome to Spring

Exercise

A teammate is about to make this mistake: Assuming BeanFactory and ApplicationContext behave identically regarding initialization timing — BeanFactory is lazy by default, ApplicationContext eagerly creates singletons at startup. Use BeanFactory — the Core Container to review the decision. Write a corrected implementation or design sketch that follows BeanFactory is the basic IoC container: lazy bean initialization, minimal features., then name one edge case you would check.

Quick quiz

Interview questions