@Scope for bean scope in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when using @Scope("prototype") on a Spring bean?

Consider a Spring bean annotated with @Scope("prototype"). What happens when you request this bean multiple times from the application context?

Spring Boot

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

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

// In main or test:
MyBean bean1 = context.getBean(MyBean.class);
MyBean bean2 = context.getBean(MyBean.class);
System.out.println(bean1 == bean2);

A Prints false because each getBean call returns a new instance.

B Prints true because Spring caches the bean and returns the same instance.

C Throws a runtime exception because prototype scope is invalid here.

D Prints null because the bean is not created until explicitly initialized.

💡 Hint

Think about how prototype scope differs from singleton scope in Spring.

Beans with @Scope("prototype") create a new instance every time they are requested from the context. So, bean1 and bean2 are different objects, making bean1 == bean2 false.

📝 Syntax

intermediate

Which @Scope annotation value is correct to define a singleton bean in Spring?

Choose the correct way to specify singleton scope using the @Scope annotation in Spring.

A @Scope("single")

B @Scope("singleton")

C @Scope("global")

D @Scope("prototype")

💡 Hint

Singleton is the default scope but can be explicitly declared.

The correct scope name for singleton beans is "singleton". Other values like "single" or "global" are invalid.

❓ state_output

advanced

What is the output of this Spring bean with @Scope("request") in a non-web application?

Given a Spring bean annotated with @Scope("request"), what happens when you try to get this bean in a non-web Spring application?

Spring Boot

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

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

// In main or test:
RequestBean bean = context.getBean(RequestBean.class);
System.out.println(bean);

A Throws an exception because request scope requires a web context.

B Returns a singleton instance of the bean.

C Returns null because the bean is not created outside a web request.

D Creates a new instance but with default singleton behavior.

💡 Hint

Consider what 'request' scope means and where it is valid.

The 'request' scope is only valid in a web-aware Spring context. Trying to get a request-scoped bean outside a web request context causes an exception.

🔧 Debug

advanced

Why does this Spring bean with @Scope("session") cause an error in a console app?

Examine the code below and explain why it causes an error when run in a console (non-web) Spring Boot application.

Spring Boot

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

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

// In main or test:
SessionBean bean = context.getBean(SessionBean.class);
System.out.println(bean);

A Session scope defaults to prototype in non-web apps, so no error occurs.

B The bean is null because session scope is not supported.

C The bean is created as singleton ignoring the session scope.

D Session scope requires a web session, so it throws an exception in a non-web app.

💡 Hint

Think about what session scope means and where it is applicable.

Session scope beans require an active HTTP session, which only exists in web applications. Without it, Spring throws an error when trying to create such a bean.

🧠 Conceptual

expert

How does Spring handle a prototype-scoped bean injected into a singleton bean?

Consider a singleton-scoped Spring bean that has a dependency on a prototype-scoped bean injected via constructor or field injection. What is the behavior of the prototype bean inside the singleton?

Spring Boot

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

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

@Component
@Scope("singleton")
public class SingletonBean {
    private final PrototypeBean prototypeBean;
    public SingletonBean(PrototypeBean prototypeBean) {
        this.prototypeBean = prototypeBean;
    }
    public PrototypeBean getPrototypeBean() {
        return prototypeBean;
    }
}

// In main or test:
SingletonBean singleton = context.getBean(SingletonBean.class);
PrototypeBean p1 = singleton.getPrototypeBean();
PrototypeBean p2 = singleton.getPrototypeBean();
System.out.println(p1 == p2);

A Prints null because prototype beans are not created automatically.

B Prints false because a new prototype bean is created each time getPrototypeBean() is called.

C Prints true because the prototype bean is created once and reused inside the singleton.

D Throws an exception because prototype beans cannot be injected into singletons.

💡 Hint

Think about when Spring creates prototype beans during injection.

When a prototype bean is injected into a singleton, Spring creates the prototype bean once at injection time. The singleton holds that same instance, so repeated calls return the same object.