@Scope for bean scope in Spring Boot

Introduction

The @Scope annotation controls how Spring creates and manages instances of a bean. It helps decide if a new object is made each time or if the same one is reused.

When you want a single shared instance of a service across the whole application.

When you need a new instance of a bean every time it is requested.

When you want a bean to be created once per user session in a web app.

When you want a bean to be created once per HTTP request.

When you want to manage bean lifecycles differently for testing or performance.

Syntax

Spring Boot

@Scope("scopeName")
public class BeanClass {
    // bean code
}

The scopeName is usually a string like singleton or prototype.

Common scopes include singleton, prototype, request, and session.

Examples

This bean is created once and shared everywhere.

Spring Boot

@Scope("singleton")
public class MyService {
    // shared instance
}

A new bean instance is created every time it is requested.

Spring Boot

@Scope("prototype")
public class MyPrototypeBean {
    // new instance each time
}

In web apps, this bean is created once per HTTP request.

Spring Boot

@Scope("request")
public class MyRequestBean {
    // one instance per HTTP request
}

This bean is created once per user session in a web application.

Spring Boot

@Scope("session")
public class MySessionBean {
    // one instance per user session
}

Sample Program

This Spring Boot app defines a MessagePrinter bean with prototype scope. When the app runs, it injects two instances of MessagePrinter. Because of the prototype scope, these two instances are different objects. The program prints their references to show they are not the same.

Spring Boot

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

@Component
@Scope("prototype")
public class MessagePrinter {
    public void printMessage() {
        System.out.println("Hello from MessagePrinter instance: " + this);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ScopeExampleApplication implements CommandLineRunner {

    @Autowired
    private MessagePrinter printer1;

    @Autowired
    private MessagePrinter printer2;

    public static void main(String[] args) {
        SpringApplication.run(ScopeExampleApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        printer1.printMessage();
        printer2.printMessage();
    }
}

Important Notes

Singleton scope is the default in Spring, meaning one shared instance.

Prototype scope creates a new instance every time the bean is requested.

Web scopes like request and session only work in web-aware Spring contexts.

Summary

@Scope controls how many instances of a bean Spring creates.

Use singleton for shared beans and prototype for new instances each time.

Web apps can use request and session scopes for per-request or per-user beans.

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