🌱 Spring Boot Bean Scopes

Understanding Bean Scopes in Spring Boot is essential for controlling how and when objects are created inside the Spring IoC container.

📌 1. What is Bean Scope?

A Bean Scope defines:

🧠 How many instances of a bean are created
⏳ How long the bean lives
🔄 How it is shared across the application

🏗 2. Default Scope: Singleton

✅ Definition

Only one instance per Spring Container
Shared across the entire application
Default scope in Spring Boot

📦 Example

import org.springframework.stereotype.Component;

@Component
public class EmailService {

    public EmailService() {
        System.out.println("EmailService instance created");
    }
}

🔍 Behavior

@Autowired
private EmailService emailService;

✔ Only one object is created and reused everywhere.

🧠 Internal Working Diagram

Spring Container
       |
       |----> [ EmailService ]  (Single Instance)
       |           ↑
       |           ↑
 Controller1   Controller2

🟢 When to Use Singleton?

Stateless services
Utility classes
Shared configurations
Database repositories

🔁 3. Prototype Scope

✅ Definition

A new instance every time the bean is requested

📦 Example

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class PaymentService {

    public PaymentService() {
        System.out.println("PaymentService instance created");
    }
}

🔍 Behavior

@Autowired
private PaymentService paymentService;

Every injection or manual getBean() call → creates a new object

🧠 Internal Working Diagram

Request 1 → [ PaymentService Instance 1 ]
Request 2 → [ PaymentService Instance 2 ]
Request 3 → [ PaymentService Instance 3 ]

⚠ Important Warning

When injecting prototype into singleton:

@Component
public class OrderService {

    @Autowired
    private PaymentService paymentService;
}

❗ Only one prototype instance is injected at startup.

To get new instance every time, use:

ObjectProvider
ApplicationContext
@Lookup

Example:

@Autowired
private ObjectProvider<PaymentService> provider;

public void process() {
    PaymentService service = provider.getObject();
}

🌐 4. Web Scopes (Used in Web Applications)

These require Spring Web dependency.

🔹 Request Scope

✅ Definition

One bean instance per HTTP request

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;

@Component
@Scope(WebApplicationContext.SCOPE_REQUEST)
public class RequestBean {
}

🧠 Diagram

HTTP Request 1 → [ RequestBean Instance 1 ]
HTTP Request 2 → [ RequestBean Instance 2 ]

🔹 Session Scope

✅ Definition

One bean per HTTP session

@Scope(WebApplicationContext.SCOPE_SESSION)
@Component
public class SessionBean {
}

🧠 Diagram

User A Session → [ SessionBean A ]
User B Session → [ SessionBean B ]

🔹 Application Scope

✅ Definition

One bean per ServletContext
Shared across entire web app

@Scope(WebApplicationContext.SCOPE_APPLICATION)
@Component
public class ApplicationBean {
}

📊 5. Scope Comparison Table

Scope	Instances Created	Shared Across	Typical Use Case
Singleton	1 per container	Entire app	Services, Repos
Prototype	Every request	Not shared	Stateful objects
Request	Per HTTP request	Per request	Request data
Session	Per session	Per user	User session data
Application	Per web app	Entire app	Global web data

⚙ 6. How Spring Manages Scopes Internally

           Spring IoC Container
                    |
        -----------------------------
        |            |             |
    Singleton    Prototype      Web Scopes
        |            |             |
   Created at    Created on     Created per
   startup       demand         HTTP lifecycle

🧪 7. Real-World Scenario Example

🛒 E-Commerce Application

Component	Recommended Scope
ProductService	Singleton
Cart (per user)	Session
PaymentTransaction	Prototype
RequestLogger	Request

🎯 8. Best Practices

✔ Use Singleton by default
✔ Use Prototype for stateful objects
✔ Avoid storing user data in Singleton
✔ Use ObjectProvider when mixing scopes
✔ Be careful with memory leaks in Session scope

❓ 9. Interview Questions

What is the default scope in Spring Boot?
Difference between Singleton and Prototype?
What happens when Prototype is injected into Singleton?
How do you create a new prototype bean every time?

🚀 Summary

Bean scopes control:

🧩 Object creation
🔄 Object lifecycle
👥 Object sharing behavior

Understanding scopes helps you:

Write memory-efficient applications
Avoid concurrency issues
Design clean architecture

If you would like this exported, say:

Download as PDF / DOCX / PPT / Markdown / TXT 📄

🧩 10. Advanced Scope Handling Techniques

🔹 Using ObjectProvider

ObjectProvider allows you to lazily fetch a new bean instance when required.

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final ObjectProvider<PaymentService> provider;

    public OrderService(ObjectProvider<PaymentService> provider) {
        this.provider = provider;
    }

    public void processOrder() {
        PaymentService paymentService = provider.getObject();
        paymentService.toString();
    }
}

✔ Each call to getObject() returns a new Prototype instance.

🔹 Using @Lookup

@Lookup lets Spring override a method to return a new Prototype bean each time.

import org.springframework.beans.factory.annotation.Lookup;
import org.springframework.stereotype.Component;

@Component
public abstract class ReportService {

    public void generate() {
        PrototypeBean bean = createPrototypeBean();
        bean.toString();
    }

    @Lookup
    protected abstract PrototypeBean createPrototypeBean();
}

✔ Spring dynamically generates implementation at runtime.

🔹 Using @Lazy

@Lazy delays bean initialization until it is actually needed.

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class HeavyService {

    public HeavyService() {
        System.out.println("HeavyService initialized");
    }
}

✔ Bean is NOT created at application startup.

✔ It is created only when first requested.

@Autowired
@Lazy
private HeavyService heavyService;

✔ Useful for performance optimization and breaking circular dependencies.

🆚 11. When to Prefer ObjectProvider Over @Lookup

Both ObjectProvider and @Lookup solve the same problem:

Getting a fresh Prototype bean inside a Singleton bean

📊 Quick Comparison

Feature	ObjectProvider	@Lookup
Type	Programmatic (explicit call)	Declarative (method override)
Flexibility	Very High	Limited
Optional Beans	Supported	Not Supported
Stream Support	Yes	No
Testing Friendly	Easier to mock	Harder
Recommended in modern apps	Yes	Rarely

🥇 Prefer ObjectProvider When

1️⃣ You Want Explicit Control

@Service
public class OrderService {

    private final ObjectProvider<PaymentService> provider;

    public OrderService(ObjectProvider<PaymentService> provider) {
        this.provider = provider;
    }

    public void process() {
        PaymentService service = provider.getObject();
        service.processPayment();
    }
}

✔ Clear and explicit bean retrieval

✔ Easier debugging

2️⃣ You Need Optional Beans

PaymentService service = provider.getIfAvailable();

✔ No exception if bean does not exist

3️⃣ You Need Default Fallback

PaymentService service =
        provider.getIfAvailable(DefaultPaymentService::new);

4️⃣ You Need Stream Support

provider.stream()
        .forEach(PaymentService::processPayment);

5️⃣ You Care About Testability

when(provider.getObject()).thenReturn(mockPaymentService);

✔ Easy to mock in unit tests

🥈 When to Use @Lookup

@Component
public abstract class ReportService {

    public void generate() {
        PrototypeBean bean = createPrototypeBean();
        bean.generate();
    }

    @Lookup
    protected abstract PrototypeBean createPrototypeBean();
}

⚠ Spring overrides method at runtime using CGLIB subclassing.

🧠 Internal Difference Diagram

ObjectProvider

Singleton Bean
      |
      | calls getObject()
      ↓
Spring Container → NEW Prototype instance

@Lookup

Spring creates subclass
      |
Overrides method
      |
Each call → Container → NEW Prototype

🎯 Final Recommendation

✔ Use ObjectProvider in most real-world cases
⚠ Use @Lookup only when method injection style is required

🧩 12. @Lookup Deep Dive – Legacy Behavior & Multiple Beans Handling

📌 What is @Lookup Internally?

@Lookup is method injection. Spring overrides the method at runtime using CGLIB and performs a BeanFactory lookup every time the method is called.

@Lookup
protected abstract PrototypeBean createPrototypeBean();

Internally behaves like:

@Override
protected PrototypeBean createPrototypeBean() {
    return applicationContext.getBean(PrototypeBean.class);
}

🕰 @Lookup in Legacy XML Configuration

Before annotations, lookup method injection was configured in XML:

<lookup-method name="createPrototypeBean" bean="prototypeBean"/>

Example:

<bean id="reportService" class="com.example.ReportService">
    <lookup-method name="createPrototypeBean" bean="prototypeBean"/>
</bean>

Modern	Legacy
@Lookup	<lookup-method>

🔀 Multiple Beans Scenario

If two prototype beans exist:

@Component
@Scope("prototype")
public class PaymentService { }

@Component
@Scope("prototype")
public class StripePaymentService extends PaymentService { }

Using:

@Lookup
protected abstract PaymentService createPaymentService();

Spring throws:

NoUniqueBeanDefinitionException:
Expected single matching bean but found 2

Fix by specifying bean name:

@Lookup("stripePaymentService")
protected abstract PaymentService createPaymentService();

🔁 How This Differs from ObjectProvider

@Autowired
private ObjectProvider<PaymentService> provider;

provider.getObject()

Throws exception if multiple beans exist.

provider.stream()

provider.stream()
        .forEach(PaymentService::processPayment);

✔ Returns all matching beans
✔ No exception
✔ More flexible resolution

📊 Behavior Comparison

Scenario	@Lookup	ObjectProvider
Single Bean	Works	Works
Multiple Beans	Exception (unless name specified)	Exception for getObject()
Stream All Beans	No	Yes
Optional Bean	No	Yes
Fallback Default	No	Yes

🎯 Final Recommendation

✔ Prefer ObjectProvider for modern Spring Boot applications
⚠ Use @Lookup mainly for legacy or strict method injection requirements