🧠 Understanding Spring Bean Scopes — What I Learned This Week

Last week, I delved deeper into Spring, focusing on a concept that frequently appeared in tutorials — Bean Scopes. Initially, I thought, "Isn't every bean just created once and used everywhere?" But I discovered that Spring provides significant control over how many times a bean is created, how long it lives, and where it's used — that's the essence of bean scopes. Here's my learning breakdown from a fellow learner trying to get comfortable with the Spring ecosystem one step at a time 😄.

---

📚 Resources I Used

• 🎥 YouTube Playlist (Easy Programming)

• 📄 Spring Official Documentation

• 🎓 Udemy Course by Navin Reddy

• 💻 GitHub - All my code for this topic

---

🌱 So What Are Bean Scopes?

In Spring, a bean scope defines the lifecycle and visibility of a bean. Basically, it tells Spring how many instances of a bean should be created and where those instances should be stored.

When you annotate a class with @Component or declare it as a bean, it’s by default singleton — which means one shared instance is created and reused.

But that’s not always ideal. Different use cases need different scopes.

---

🔍 Types of Bean Scopes I Learned About

1. 🧍 Singleton (Default)

• What it means: Only one instance of the bean exists in the Spring container.

• When to use: For stateless services or components that don't hold user-specific data.

• Config:

    @Scope("singleton")
    @Component
    public class MyBean { ... }
  

2. 🧪 Prototype

• What it means: A new bean instance is created every time it’s requested.

• When to use: When you need separate state for each use (e.g., a form object).

• Config:

    @Scope("prototype")
    @Component
    public class MyBean { ... }
  

  ✅ The container only creates it — no further lifecycle management (like destroy).

3. 🌐 Request (Web Only)

• What it means: One bean per HTTP request.

• When to use: Useful in web apps when you want one bean per user request.

• Config:

    @Scope("request")
    @Component
    public class MyBean { ... }
  

4. 💬 Session (Web Only)

• What it means: One bean per user session.

• When to use: When you want to maintain user state (like a shopping cart).

• Config:

    @Scope("session")
    @Component
    public class MyBean { ... }
  

5. 🌀 GlobalSession (Web + Portlet Context)

• What it means: Like session, but for global session scope in a portlet-based environment.

• Not used much in basic Spring apps — just good to know it exists.

---

🛠 XML vs Annotation-Based Config

I mostly worked with annotations, but here’s how they look in both styles:

✅ Annotation-based

@Component
@Scope("prototype") // or "singleton", "request", "session"
public class MyBean { ... }

📝 XML-based

<bean id="myBean" class="com.example.MyBean" scope="prototype" />

Honestly, I prefer the annotation style. Feels cleaner and easier to manage — but both get the job done.

---

💡 Real-World Use Cases I Noted

---

🔎 How Scope Affects Lifecycle?

This was an interesting part. I thought all beans go through the same lifecycle, but the scope actually changes how Spring manages the bean lifecycle:

• Singleton beans are fully managed (init + destroy).

• Prototype beans are only created — Spring doesn’t call their @PreDestroy.

• For request/session/globalSession, Spring manages them based on HTTP lifecycle, not your main() method.

So if you’re using @PreDestroy or custom destroy-method, it won’t work for prototype or request/session beans unless you're doing manual handling.

---

🚀 What's Next?

Still continuing my Spring journey. Up next, I’m planning to:

• Dive into @ComponentScan and how Spring auto-wires things

• Start working with Spring Boot and REST APIs

• Understand better how all this config works behind the scenes

This week was mostly about understanding the behavior of beans — next week will be about putting them to work in real apps.

---

💾 My Practice Code

Everything I tried out for this topic is here:
👉 GitHub - Spring Bean Scopes & Lifecycle Code

---

🥜 In a nutshell (TL;DR)

• Spring gives multiple bean scopes like singleton, prototype, request, session, and globalsession.

• Scope decides how many instances of a bean exist and for how long.

• singleton is default and ideal for stateless services.

• Use prototype when you want a new object every time.

• Request/session scopes are perfect for web apps.

• Lifecycle management differs depending on the scope.

• You can configure scope using annotations (@Scope) or XML.

• Understanding scopes = writing better, memory-friendly, bug-free Spring apps.

---

Hope this helped someone who’s just getting started like me! Spring has a lot of layers, but bit by bit, it’s making more sense.

If you’re learning Spring too — let’s connect and share learnings! 🚀