Types of IoC Containers

Spring Framework uses IoC (Inversion of Control) Containers to manage the creation, configuration, and lifecycle of objects called beans.

These containers remove the responsibility of object management from the application code and handle it centrally.

Spring provides two main types of IoC containers:

1. BeanFactory (Basic IoC Container)

BeanFactory is the simplest and most lightweight IoC container in Spring.

What it does

• Manages basic dependency injection
• Creates beans only when they are requested

Key Characteristics

• Interface: org.springframework.beans.factory.BeanFactory
• Uses lazy initialization
• Low memory usage
• Provides only core DI functionality
• Does not support enterprise features by default

When to use

• Very small applications
• Memory-constrained environments
• Rarely used in modern Spring Boot applications

Example: BeanFactory (Lazy Initialization)

Step 1: Create a Bean Class

public class HelloService {
    public void sayHello() {
        System.out.println("Hello from BeanFactory");
    }
}

Step 2: XML Configuration (beans.xml)

<beans xmlns="<http://www.springframework.org/schema/beans>"
       xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
       xsi:schemaLocation="
        <http://www.springframework.org/schema/beans>
        <http://www.springframework.org/schema/beans/spring-beans.xsd>">

    <bean id="helloService" class="com.example.HelloService"/>
</beans>

Step 3: Use BeanFactory

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanFactoryExample {
    public static void main(String[] args) {

        BeanFactory factory =
                new ClassPathXmlApplicationContext("beans.xml");

        HelloService service =
                factory.getBean("helloService", HelloService.class);

        service.sayHello();
    }
}

What Happens Internally

• Bean is NOT created at application startup
• Bean is created only when getBean() is called
• This behavior is called Lazy Initialization

Output

Hello from BeanFactory

Limitations of BeanFactory

• No AOP support
• No event handling
• No i18n support
• Not used directly in Spring Boot

Note: In Spring Boot, developers almost never use BeanFactory directly.

2. ApplicationContext (Advanced IoC Container)

ApplicationContext is a powerful and feature-rich IoC container built on top of BeanFactory.

What it does

• Manages beans and their lifecycle
• Provides enterprise-level features required for real-world applications

Key Characteristics

• Interface: org.springframework.context.ApplicationContext
• Uses eager initialization (singleton beans created at startup)
• Fully supports annotations and Java configuration
• Default IoC container used in Spring Boot

Additional Features

• AOP (Aspect-Oriented Programming)
• Event handling
• Internationalization (i18n)
• Bean lifecycle callbacks
• Integration with Spring MVC, Security, Data JPA

Example: ApplicationContext (Annotation-Based)

Step 1: Create Bean Class

import org.springframework.stereotype.Component;

@Component
public class HelloService {
    public void sayHello() {
        System.out.println("Hello from ApplicationContext");
    }
}

Step 2: Create Configuration & Main Class

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

@Configuration
@ComponentScan("com.example")
public class ApplicationContextExample {

    public static void main(String[] args) {

        ApplicationContext context =
                new AnnotationConfigApplicationContext(ApplicationContextExample.class);

        HelloService service = context.getBean(HelloService.class);
        service.sayHello();
    }
}

What Happens Internally

• Beans are created automatically at startup
• Spring scans @Component
• Full support for:
  • AOP
  • Events
  • Profiles
  • Lifecycle callbacks

Output

Hello from ApplicationContext

Spring Boot Real Example (ApplicationContext by Default)

@SpringBootApplication
public class MySpringBootApp {

    public static void main(String[] args) {
        ApplicationContext context =
                SpringApplication.run(MySpringBootApp.class, args);

        HelloService service = context.getBean(HelloService.class);
        service.sayHello();
    }
}

Important: Every Spring Boot application automatically runs using ApplicationContext.

BeanFactory vs ApplicationContext

Both BeanFactory and ApplicationContext are IoC containers in Spring, but they differ in features, behavior, and real-world usage.

Conclusion

Spring provides two IoC containers:

• BeanFactory → Lightweight, basic, and rarely used today
• ApplicationContext → Powerful, feature-rich, and default in Spring Boot

👉 For modern Spring and Spring Boot applications, ApplicationContext is the recommended and industry-standard choice.