IoC Container

🔍 What Is It?

The Spring IoC Container is the core runtime of the Spring Framework.

What it does:

• →Creates objects (beans) based on your configuration
• →Wires dependencies between beans (Dependency Injection)
• →Manages lifecycle — initializes, uses, and destroys beans
• →Provides beans to whoever requests them

Two container implementations:

• →BeanFactory — basic container (lazy initialization, rarely used directly)
• →ApplicationContext — enhanced container with events, AOP, i18n, eager init (always use this)

ApplicationContext implementations:

• →AnnotationConfigApplicationContext — Java config, no XML
• →ClassPathXmlApplicationContext — XML config (legacy)
• →WebApplicationContext — for web applications
• →SpringApplication.run() creates the right one automatically in Spring Boot

Bean definition sources:

• →@Component, @Service, @Repository, @Controller — classpath scanning
• →@Bean methods in @Configuration classes
• →Auto-configuration classes

🎯 Why Do We Need It?

Without IoC, you manually create and wire every object:

// Without Spring — tight coupling, untestable
UserRepository repo = new JpaUserRepository(dataSource);
EmailService email = new SmtpEmailService(smtpConfig);
PasswordEncoder encoder = new BCryptPasswordEncoder(12);
UserService service = new UserServiceImpl(repo, email, encoder);
UserController controller = new UserController(service);
// If UserService changes constructor, every caller must change

With IoC:

@Service
public class UserServiceImpl implements UserService {
    // Spring injects these — you don't create them
    public UserServiceImpl(UserRepository repo, EmailService email, PasswordEncoder encoder) { ... }
}
// Spring handles the wiring graph automatically

Benefits:

• →Loose coupling — components don't create their dependencies
• →Testability — inject mock dependencies in unit tests
• →Centralized config — change implementations without changing consumers
• →Lifecycle management — Spring handles initialization and cleanup

🏗️ What Happens in Real Projects?

IoC is invisible but everywhere in a Spring Boot app:

• →Your @Service doesn't create its @Repository — Spring injects it
• →Your @Controller doesn't create its @Service — Spring injects it
• →DataSource, EntityManagerFactory, TransactionManager — Spring creates from your config
• →KafkaTemplate, RestTemplate, RedisTemplate — Spring creates and injects

In a microservice with 50 classes, Spring manages all 50 objects and their dependencies automatically.

⚙️ How It Works

Container startup:

1. Scan classpath for @Component, @Service, @Repository, @Controller
2. Process @Configuration classes and @Bean methods
3. Build a dependency graph of all beans
4. Create beans in dependency order (dependencies first)
5. Inject dependencies (constructor, setter, or field)
6. Call @PostConstruct methods
7. Application is ready

On shutdown:

1. Call @PreDestroy methods
2. Close resources (DB connections, thread pools)
3. JVM exits

Bean naming:

• →Default: camelCase class name (UserServiceImpl → userServiceImpl)
• →Custom: @Service("userService") or @Bean("myBean")

💻 Example

IoC Container in Practice — How Spring creates and wires beans in a real application.

// These annotations tell Spring to create and manage these objects

@Repository  // Data access layer — also enables exception translation
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;

    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate; // Spring injects JdbcTemplate
    }
}

@Service  // Business logic layer
public class UserService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final EmailService emailService;

    // Constructor injection — Spring calls this
    public UserService(
            UserRepository userRepository,
            PasswordEncoder passwordEncoder,
            EmailService emailService) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.emailService = emailService;
    }
}

@Controller  // Web layer
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService; // Spring injects UserService
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits