Spring IoC Container: BeanFactory vs ApplicationContext

Direct Answer

BeanFactory is Spring's root IoC interface providing basic dependency injection, while ApplicationContext extends it with enterprise features: event publishing, internationalization, AOP auto-proxying, and eager singleton initialization. The practical difference is initialization strategy — BeanFactory initializes beans lazily on first getBean() call; ApplicationContext eagerly creates all singletons at startup, which catches configuration errors immediately. ApplicationContext also auto-detects BeanPostProcessor beans, which is what makes @Autowired, @Transactional, and every annotation-driven feature work. In modern Spring, you never instantiate BeanFactory yourself — SpringApplication.run() creates an AnnotationConfigApplicationContext. BeanFactory exists for the framework-extension API.

Code Example

Running both container types side-by-side makes the differences concrete. BeanFactory does lazy, on-demand instantiation; ApplicationContext eagerly pre-instantiates singletons and publishes lifecycle events.

public class ContainerComparison {

    public static void main(String[] args) {
        System.out.println("--- BeanFactory (lazy) ---");
        DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
        new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
            new ClassPathResource("beans.xml"));
        // Singletons NOT yet instantiated — constructors haven't run.
        UserService svc1 = bf.getBean(UserService.class);   // constructor runs HERE
        UserService svc2 = bf.getBean(UserService.class);   // same instance cached

        System.out.println("--- ApplicationContext (eager + events) ---");
        ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
        // All singletons already constructed, @PostConstruct already executed,
        // ContextRefreshedEvent already published BEFORE this line.
        UserService svc3 = ctx.getBean(UserService.class);
    }
}

@Configuration
@ComponentScan("com.example")
class AppConfig {}

@Component
class UserService {
    @PostConstruct
    void init() { System.out.println("UserService initialized"); }
    @EventListener
    public void onReady(ContextRefreshedEvent e) { /* only ApplicationContext fires this */ }
}

• With BeanFactory, the constructor of UserService does not run until getBean() is called.
• With ApplicationContext, all singleton constructors, @PostConstruct callbacks, and BeanPostProcessor hooks run during new AnnotationConfigApplicationContext(...) — fail-fast on misconfiguration.
• @EventListener only works with ApplicationContext, which is why Spring Boot always uses it.
• Use BeanFactory only for memory-constrained tools where startup time beats safety; use ApplicationContext for every real application.

Common Mistakes & Pitfalls

Thinking they are interchangeable drop-in replacements, or not knowing that BeanFactory initializes beans lazily by default while ApplicationContext initializes singletons eagerly on startup.