@Scope for bean scope in Spring Boot - Mini Project: Build & Apply

@Scope for bean scope in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that manages user sessions. You want to control how Spring creates and manages your beans using the @Scope annotation.This helps you decide if a bean should be created once for the whole app or a new one each time it is needed.

🎯 Goal: Learn how to use the @Scope annotation to define bean scopes in Spring Boot.You will create a bean with singleton scope and then change it to prototype scope.

📋 What You'll Learn

Create a Spring Boot bean class named MyBean

Add @Component annotation to MyBean

Add @Scope annotation with ConfigurableBeanFactory.SCOPE_SINGLETON to MyBean

Change the scope to ConfigurableBeanFactory.SCOPE_PROTOTYPE using @Scope

💡 Why This Matters

🌍 Real World

Controlling bean scope is important in real applications to manage resources and behavior, like creating a new bean for each user request or sharing one bean for the whole app.

💼 Career

Understanding <code>@Scope</code> is essential for Spring developers to write efficient, maintainable, and scalable applications.

1

Create a Spring bean class with singleton scope

Create a class named MyBean in package com.example.demo. Annotate it with @Component and @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON). Import org.springframework.stereotype.Component, org.springframework.context.annotation.Scope, and org.springframework.beans.factory.config.ConfigurableBeanFactory.

Spring Boot

package com.example.demo;

// Your code here

Hint

Remember to import the correct classes and use @Component and @Scope annotations.

2

Add a simple method to MyBean

Inside the MyBean class, add a public method named getMessage that returns the string "Singleton Bean".

Spring Boot

package com.example.demo;

import org.springframework.stereotype.Component;
import org.springframework.context.annotation.Scope;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;

@Component
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class MyBean {
    // Add getMessage method here
}

Hint

Define a public method named getMessage that returns the exact string "Singleton Bean".

3

Change the bean scope to prototype

Modify the @Scope annotation on MyBean to use ConfigurableBeanFactory.SCOPE_PROTOTYPE instead of SCOPE_SINGLETON.

Spring Boot

package com.example.demo;

import org.springframework.stereotype.Component;
import org.springframework.context.annotation.Scope;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;

@Component
// Change scope to prototype below
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class MyBean {
    public String getMessage() {
        return "Singleton Bean";
    }
}

Hint

Replace SCOPE_SINGLETON with SCOPE_PROTOTYPE inside the @Scope annotation.

4

Add a Spring Boot application class to test the bean scope

Create a class named DemoApplication in package com.example.demo. Annotate it with @SpringBootApplication. Add a main method that runs SpringApplication.run(DemoApplication.class, args). Import org.springframework.boot.SpringApplication and org.springframework.boot.autoconfigure.SpringBootApplication.

Spring Boot

package com.example.demo;

// Add DemoApplication class here
// Your code here

Hint

Create the main Spring Boot application class with @SpringBootApplication and a main method that starts the app.

Practice

1. What does the @Scope("prototype") annotation do in a Spring Boot bean?

easy

A. Creates a new bean instance per HTTP request

B. Creates only one shared instance of the bean for the entire application

C. Creates a new bean instance per HTTP session

D. Creates a new instance of the bean every time it is requested

Solution

1. Step 1: Understand the prototype scope meaning

   The prototype scope means Spring creates a new bean instance each time it is requested from the container.

2. Step 2: Compare with other scopes

   Unlike singleton which shares one instance, prototype always returns a fresh object.

3. Final Answer:

   Creates a new instance of the bean every time it is requested -> Option D

4. Quick Check:

   @Scope("prototype") = new instance each request [OK]

Hint: Prototype means new bean each request, singleton means shared [OK]

Common Mistakes:

• Confusing prototype with singleton scope
• Thinking prototype beans are shared
• Mixing prototype with web scopes like session or request

2. Which of the following is the correct way to declare a singleton scoped bean using @Scope annotation in Spring Boot?

easy

A. @Scope("session")

B. @Scope("prototype")

C. @Scope("singleton")

D. @Scope("request")

Solution

1. Step 1: Recall default and explicit singleton scope

   Singleton is the default scope in Spring, but explicitly it is declared as @Scope("singleton").

2. Step 2: Verify other scopes

   prototype creates new instances, session and request are web scopes, not singleton.

3. Final Answer:

   @Scope("singleton") -> Option C

4. Quick Check:

   Singleton scope = @Scope("singleton") [OK]

Hint: Singleton scope is default but use @Scope("singleton") explicitly [OK]

Common Mistakes:

• Using @Scope("prototype") for singleton beans
• Confusing web scopes with singleton
• Omitting @Scope and expecting prototype behavior

3. Consider this Spring Boot bean declaration:

@Component
@Scope("request")
public class UserRequestBean { }

What happens when this bean is injected into two different HTTP requests?

medium

A. Each request gets a new bean instance

B. Both requests share the same bean instance

C. Only the first request gets a bean, others get null

D. Bean is created once per session, shared across requests

Solution

1. Step 1: Understand request scope behavior

   The request scope means Spring creates a new bean instance for each HTTP request.

2. Step 2: Apply to two different requests

   Since the requests are different, each gets its own separate bean instance.

3. Final Answer:

   Each request gets a new bean instance -> Option A

4. Quick Check:

   @Scope("request") = new bean per HTTP request [OK]

Hint: Request scope means new bean per HTTP request [OK]

Common Mistakes:

• Assuming request scope shares bean across requests
• Confusing request scope with session scope
• Thinking request scope behaves like singleton

4. Given this bean declaration:

@Component
@Scope("session")
public class ShoppingCart { }

What is the likely error if you try to inject this bean into a singleton scoped bean without special handling?

medium

A. No error, injection works normally

B. Runtime error due to incompatible scopes

C. Compilation error due to missing @Scope annotation

D. Bean is created once and shared across all sessions

Solution

1. Step 1: Understand scope mismatch problem

   Injecting a session-scoped bean into a singleton bean causes a scope mismatch because singleton lives longer than session beans.

2. Step 2: Result of mismatch without proxy

   Without proxy or special configuration, Spring throws a runtime error as it cannot inject a shorter-lived bean into a longer-lived one safely.

3. Final Answer:

   Runtime error due to incompatible scopes -> Option B

4. Quick Check:

   Session bean into singleton without proxy = runtime error [OK]

Hint: Injecting shorter scope bean into singleton causes runtime error [OK]

Common Mistakes:

• Assuming injection always works regardless of scope
• Ignoring need for proxyMode in such injections
• Confusing compilation and runtime errors

5. You want a Spring Boot bean to create a new instance for each HTTP session but share the same instance within that session. Which @Scope annotation and configuration should you use?

hard

A. @Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)

B. @Scope("prototype")

C. @Scope("singleton")

D. @Scope(value = "request", proxyMode = ScopedProxyMode.INTERFACES)

Solution

1. Step 1: Identify session scope for per-session bean

   The session scope creates one bean instance per HTTP session, which fits the requirement.

2. Step 2: Use proxyMode for injection into singleton beans

   Adding proxyMode = ScopedProxyMode.TARGET_CLASS allows safe injection into other beans by creating a proxy that resolves the correct session instance.

3. Final Answer:

   @Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS) -> Option A

4. Quick Check:

   Session scope + proxyMode = new instance per session shared inside session [OK]

Hint: Use session scope with proxyMode for per-session shared bean [OK]

Common Mistakes:

• Using prototype scope which creates new instance every injection
• Using singleton scope which shares one instance globally
• Using request scope which creates new instance per HTTP request