🏭 Spring Core: Beans and the IoC Container

The Magic Factory Story

Imagine you own a toy factory. Instead of building every toy yourself, you have a magical factory manager who:

• Knows how to build every toy
• Keeps toys organized in special boxes
• Gives you the exact toy you need, when you need it

This magical factory manager is the IoC Container in Spring! Let’s explore how it works.

🎯 What is the IoC Container?

IoC = Inversion of Control

Think of it this way:

• Without IoC: YOU go to the store, find ingredients, cook your meal
• With IoC: A CHEF brings you the meal ready to eat

// Without IoC - You do everything
Car car = new Car();
Engine engine = new Engine();
car.setEngine(engine);  // You connect things

// With IoC - Spring does it for you
@Autowired
Car car;  // Spring gives you a ready car!

The IoC Container takes control of creating and connecting objects. You just ask, it delivers!

🏪 BeanFactory vs ApplicationContext

Spring has TWO types of factory managers:

BeanFactory - The Basic Manager

📦 BeanFactory
├── Creates beans when asked
├── Uses less memory
└── Basic features only

Like a small corner shop - has what you need, but minimal services.

ApplicationContext - The Super Manager

🏬 ApplicationContext
├── Everything BeanFactory has
├── Auto-detects beans
├── Handles events
├── Supports internationalization
└── Integrates with web apps

Like a supermarket - more features, more convenient!

graph TD
    A[BeanFactory] -->|Basic| B[Creates Beans]
    C[ApplicationContext] -->|Extends| A
    C -->|Extra| D[Events]
    C -->|Extra| E[i18n Support]
    C -->|Extra| F[Web Integration]
    style C fill:#4CAF50,color:white
    style A fill:#2196F3,color:white

When to Use What?

Simple Rule: Always use ApplicationContext unless you have a specific reason not to!

🧱 What is a Bean?

A Bean is simply an object that Spring manages.

Real Life Example:

• Your toys at home = regular objects (you manage them)
• Toys in the factory warehouse = beans (factory manages them)

// This is a regular class
public class MusicPlayer {
    public void play() {
        System.out.println("Playing music!");
    }
}

// Tell Spring "Hey, manage this for me!"
@Component
public class MusicPlayer {
    public void play() {
        System.out.println("Playing music!");
    }
}

The @Component annotation is like putting a “Handle With Care” sticker. Spring sees it and says: “I’ll take care of this one!”

Bean Definition - The Recipe

A bean definition is the recipe Spring uses to create beans:

@Component
public class EmailService {
    private String smtpServer = "mail.example.com";

    public void sendEmail(String to) {
        // send email logic
    }
}

The recipe includes:

• Class name - what to create
• Scope - how many to create
• Dependencies - what it needs
• Properties - its settings

🔄 Bean Lifecycle - From Birth to Goodbye

Every bean goes through a life journey:

graph TD
    A[🥚 Instantiation] --> B[📦 Populate Properties]
    B --> C[🏷️ Set Bean Name]
    C --> D[🏭 Set Factory Reference]
    D --> E[⚙️ Post Process Before]
    E --> F[🚀 Initialize]
    F --> G[⚙️ Post Process After]
    G --> H[✅ Ready to Use!]
    H --> I[💤 Destroy]
    style A fill:#E3F2FD
    style H fill:#C8E6C9
    style I fill:#FFCDD2

The Story of Bean’s Life

1. Birth (Instantiation)

// Spring calls: new MusicPlayer()

2. Getting Dressed (Populate Properties)

@Autowired
private SpeakerService speaker;
// Spring connects the speaker

3. Learning Its Name (Aware Interfaces)

public class MyBean implements BeanNameAware {
    public void setBeanName(String name) {
        // "Hi, I'm MyBean!"
    }
}

4. Growing Up (Initialization)

@PostConstruct
public void init() {
    System.out.println("I'm ready to work!");
}

5. Working Hard (In Use)

musicPlayer.play(); // Bean doing its job

6. Retirement (Destruction)

@PreDestroy
public void cleanup() {
    System.out.println("Goodbye, cleaning up!");
}

📦 Bean Scopes - How Many Copies?

Scope decides how many copies of a bean exist.

Singleton (Default) - One for All

🎭 Singleton Scope
Everyone gets the SAME toy

Request 1 → 🎸 Guitar #1
Request 2 → 🎸 Guitar #1 (same one!)
Request 3 → 🎸 Guitar #1 (still same!)

@Component
@Scope("singleton")  // optional, it's default
public class ConfigService {
    // Only ONE instance ever!
}

Prototype - Fresh Copy Each Time

🎨 Prototype Scope
Everyone gets a NEW toy

Request 1 → 🎸 Guitar #1
Request 2 → 🎸 Guitar #2 (new one!)
Request 3 → 🎸 Guitar #3 (another new!)

@Component
@Scope("prototype")
public class ShoppingCart {
    // Each user gets their own cart!
}

Web Scopes (For Web Apps)

@Component
@Scope("session")
public class UserPreferences {
    private String theme = "dark";
}

🔒 Singleton Thread Safety

Warning! Singleton doesn’t mean thread-safe!

The Problem

👤 User A ──────┐
                ├──→ 🏠 Same Singleton ←──┤
👤 User B ──────┘                         │
                                          ↓
                                    💥 CONFLICT!

If two users change the same data at once, things break!

Bad Example - Not Thread Safe

@Component
public class Counter {
    private int count = 0;  // DANGER!

    public void increment() {
        count++;  // Two threads = trouble!
    }
}

Good Example - Thread Safe Solutions

Solution 1: No Shared State

@Component
public class Calculator {
    // No instance variables
    public int add(int a, int b) {
        return a + b;  // Safe!
    }
}

Solution 2: Use Synchronized

@Component
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;  // Only one at a time
    }
}

Solution 3: Use AtomicInteger

@Component
public class Counter {
    private AtomicInteger count =
        new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();  // Safe!
    }
}

Golden Rule

🏆 Keep singletons stateless (no changing data) or make them thread-safe!

😴 Lazy Initialization - Wake Up Later!

By default, Spring creates all singletons at startup. But sometimes that’s wasteful!

Eager (Default) - Create Now!

🚀 App Starts
   ↓
📦 Create Bean A
📦 Create Bean B
📦 Create Bean C
   ↓
✅ Ready (even if we never use Bean C)

Lazy - Create When Needed

🚀 App Starts
   ↓
✅ Ready (no beans created yet!)
   ↓
🔍 Someone needs Bean A
   ↓
📦 Create Bean A (just in time!)

@Component
@Lazy
public class ExpensiveService {
    public ExpensiveService() {
        // Takes 10 seconds to initialize
        // Only runs when actually needed!
    }
}

When to Use Lazy?

Global Lazy Mode

@SpringBootApplication
@Lazy  // All beans are lazy now!
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class);
    }
}

🎯 Quick Summary

🏭 IoC Container
   └── Manages all your beans

📦 BeanFactory vs ApplicationContext
   └── Basic vs Full-featured (use AppContext!)

🧱 Bean = Object managed by Spring
   └── Use @Component to register

🔄 Lifecycle = Birth → Init → Use → Destroy
   └── Use @PostConstruct and @PreDestroy

📐 Scopes
   ├── Singleton = One shared instance
   ├── Prototype = Fresh copy each time
   └── Web = request, session, application

🔒 Thread Safety
   └── Singletons need care with shared state!

😴 Lazy Initialization
   └── Create beans only when needed

🚀 You’re Ready!

You now understand the heart of Spring! The IoC Container is your magical factory manager that:

1. Creates beans from your recipes
2. Connects them together automatically
3. Manages their entire lifecycle
4. Controls how many copies exist
5. Decides when to create them

Remember: Spring does the heavy lifting so you can focus on building amazing apps!

Next up: Learn how Spring automatically connects beans with Dependency Injection!