@Component annotation in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a class is annotated with @Component in Spring Boot?

Consider a class annotated with @Component in a Spring Boot application. What is the main effect of this annotation?

A The class is ignored during component scanning and no bean is created.

B The class is compiled into a separate executable jar file.

C Spring automatically detects the class and creates a singleton bean instance for dependency injection.

D The class is only used for configuration properties and not for beans.

💡 Hint

Think about what Spring does with classes marked as components during startup.

The @Component annotation tells Spring to detect the class during component scanning and create a singleton bean instance. This bean can then be injected into other parts of the application.

📝 Syntax

intermediate

Which of the following is the correct way to annotate a class as a Spring component?

Choose the correct syntax to mark a class as a Spring component using the @Component annotation.

A

import org.springframework.Component;

@Component
public class MyService {}

B

import org.springframework.stereotype.Component;

@Component
public class MyService {}

C

import org.springframework.stereotype.Component;

@Component()
public class MyService {}

D

import org.springframework.stereotype.Component;

@Component class MyService {}

💡 Hint

Check the correct package for the @Component annotation and Java syntax rules.

The @Component annotation is in the org.springframework.stereotype package. It is used above the class declaration with no parentheses needed unless specifying attributes.

❓ state_output

advanced

What is the scope of a bean created by @Component by default?

When you annotate a class with @Component in Spring Boot without specifying any scope, what is the default scope of the bean?

A Singleton - a single shared instance is created and reused.

B Prototype - a new instance is created every time it is requested.

C Request - a new instance is created per HTTP request.

D Session - a new instance is created per user session.

💡 Hint

Think about how Spring manages beans by default unless told otherwise.

By default, Spring creates beans with singleton scope, meaning one shared instance is used throughout the application context.

🔧 Debug

advanced

Why does Spring fail to inject a @Component bean in this example?

Given the following code, why does Spring fail to inject MyService into MyController?

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

@Component
public class MyService {}

@Controller
public class MyController {
    private final MyService myService;

    public MyController(MyService myService) {
        this.myService = myService;
    }
}

A The package containing MyService is not scanned by Spring component scanning.

B MyService is missing the @Service annotation instead of @Component.

C Constructor injection is not supported in Spring Boot.

D MyController must be annotated with @Component instead of @Controller.

💡 Hint

Check if Spring can find the classes during scanning.

If the package where MyService is located is not included in component scanning, Spring will not create the bean and injection will fail. The annotations used are correct and constructor injection is supported.

🧠 Conceptual

expert

How does @Component differ from @Service and @Repository in Spring Boot?

Which statement best describes the difference between @Component, @Service, and @Repository annotations in Spring Boot?

A <code>@Component</code> disables component scanning, while <code>@Service</code> and <code>@Repository</code> enable it.

B <code>@Component</code> creates prototype beans, <code>@Service</code> creates singleton beans, and <code>@Repository</code> creates request-scoped beans.

C <code>@Component</code> is used only for configuration classes, <code>@Service</code> for controllers, and <code>@Repository</code> for data models.

D <code>@Component</code> is a generic stereotype for any Spring-managed component, while <code>@Service</code> and <code>@Repository</code> are specializations that add semantic meaning and specific behaviors.

💡 Hint

Think about the purpose and behavior of these annotations beyond just creating beans.

@Component is a general annotation for Spring beans. @Service and @Repository are specialized stereotypes that also help with readability and may add extra behaviors, like exception translation in @Repository.