@Component, @Service, @Repository, @Controller in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the primary role of the @Service annotation in Spring Boot?

Choose the option that best describes what @Service does in a Spring Boot application.

A Indicates a class is responsible for handling HTTP requests and returning responses.

B Marks a class as a service provider to hold business logic and be managed by Spring's container.

C Designates a class as a data access object that interacts with the database.

D Marks a class as a generic component without any specific role.

💡 Hint

Think about where you put your business rules and logic in a Spring app.

The @Service annotation marks a class as a service layer component. It holds business logic and is managed by Spring's container for dependency injection.

📝 Syntax

intermediate

Which annotation should you use to mark a class that directly accesses the database?

Select the correct Spring annotation for a class that handles database operations.

A @Repository

B @Service

C @Controller

D @Component

💡 Hint

This annotation also helps with exception translation for database errors.

The @Repository annotation marks a class as a data access object (DAO). It also enables Spring to translate database exceptions into Spring's data access exceptions.

❓ component_behavior

advanced

What happens if you annotate a class with @Component but also annotate it with @Controller in Spring Boot?

Choose the correct statement about the behavior of a class annotated with both @Component and @Controller.

A Spring treats it as a controller, and @Component is redundant but harmless.

B Spring throws a runtime error due to conflicting annotations.

C Spring treats it only as a generic component and ignores @Controller.

D The class will not be registered as a bean in the Spring container.

💡 Hint

Consider how Spring handles meta-annotations and specialization.

@Controller is a specialized form of @Component. Annotating a class with both is redundant but Spring treats it as a controller.

🔧 Debug

advanced

Why does Spring fail to inject a bean annotated only with @Component in a package outside the main application package?

Given a Spring Boot app, a class annotated with @Component is in a package not scanned by Spring. What is the cause of the injection failure?

A Spring requires explicit XML configuration to inject @Component beans.

B @Component beans cannot be injected unless also annotated with @Service.

C Spring only scans packages under the main application class package by default.

D The class must be annotated with @Repository to be injected.

💡 Hint

Think about how Spring Boot finds beans automatically.

By default, Spring Boot scans the package of the main application class and its subpackages. Classes outside these packages are not detected unless explicitly configured.

❓ lifecycle

expert

In what order does Spring instantiate and inject beans annotated with @Component, @Service, @Repository, and @Controller during application startup?

Select the correct order of bean instantiation and injection by Spring Boot for these annotations.

A @Component beans first, then @Repository, then @Service, then @Controller

B @Repository beans first, then @Component, then @Service, then @Controller

C @Controller beans first, then @Service, then @Repository, then @Component

D Spring does not guarantee a specific order; it instantiates beans as needed based on dependencies.

💡 Hint

Think about how Spring resolves dependencies and manages bean lifecycle.

Spring creates beans in an order based on dependency needs, not annotation type. It ensures dependencies are ready before injection but does not follow a fixed annotation order.

Practice

1. Which annotation is the most general one used to mark a Spring bean in a Spring Boot application?

easy

A. @Service

B. @Component

C. @Repository

D. @Controller

Solution

1. Step 1: Understand the purpose of each annotation

   @Component is the base annotation for any Spring-managed bean. @Service, @Repository, and @Controller are specialized stereotypes built on top of @Component.

2. Step 2: Identify the most general annotation

   Since @Component is the general-purpose annotation for any Spring bean, it is the correct answer.

3. Final Answer:

   @Component -> Option B

4. Quick Check:

   General Spring bean marker = @Component [OK]

Hint: General bean annotation is @Component, others are special cases [OK]

Common Mistakes:

• Confusing @Service as the general bean annotation
• Thinking @Repository is for all beans
• Assuming @Controller is the general annotation

2. Which annotation should you use to mark a class that handles HTTP requests in a Spring Boot application?

easy

A. @Repository

B. @Service

C. @Controller

D. @Component

Solution

1. Step 1: Recall the role of each annotation

   @Controller is specifically designed for classes that handle web requests and return views or data.

2. Step 2: Match the annotation to the web controller role

   Since the question asks about handling HTTP requests, @Controller is the correct annotation.

3. Final Answer:

   @Controller -> Option C

4. Quick Check:

   Web request handler = @Controller [OK]

Hint: Web controllers use @Controller annotation [OK]

Common Mistakes:

• Using @Service for web controllers
• Confusing @Repository with @Controller
• Using @Component instead of @Controller for HTTP handling

3. Consider the following Spring Boot class:

@Service
public class UserService {
    public String getUser() {
        return "Alice";
    }
}

What is the role of this class in the application?

medium

A. Contains business logic related to users

B. Accesses the database to retrieve user data

C. General Spring bean without specific role

D. Handles HTTP requests and responses

Solution

1. Step 1: Identify the annotation and its meaning

   The class is annotated with @Service, which is used for business logic components in Spring.

2. Step 2: Understand the method and class purpose

   The method getUser() returns a user name, indicating business logic rather than database access or HTTP handling.

3. Final Answer:

   Contains business logic related to users -> Option A

4. Quick Check:

   @Service = business logic class [OK]

Hint: @Service means business logic, not web or data access [OK]

Common Mistakes:

• Thinking @Service accesses the database directly
• Confusing @Service with @Controller
• Assuming @Service is a generic bean without role

4. What is wrong with this Spring Boot repository class?

@Repository
public class UserRepository {
    public void saveUser(String user) {
        // save logic
    }
}

Options: A) Class should be an interface extending JpaRepository B) Missing @Service annotation C) @Repository cannot be used on classes D) Method saveUser must return a value

medium

A. Class should be an interface extending JpaRepository

B. Missing @Service annotation

C. @Repository cannot be used on classes

D. Method saveUser must return a value

Solution

1. Step 1: Understand typical repository pattern in Spring Boot

   Spring Data JPA repositories are usually interfaces extending JpaRepository or CrudRepository to get built-in methods.

2. Step 2: Identify the issue with the class declaration

   The class is a concrete class, not an interface extending JpaRepository, so it misses Spring Data JPA features.

3. Final Answer:

   Class should be an interface extending JpaRepository -> Option A

4. Quick Check:

   Repositories usually extend JpaRepository interface [OK]

Hint: Repositories are interfaces extending JpaRepository, not plain classes [OK]

Common Mistakes:

• Thinking @Repository cannot be on classes
• Assuming @Service is needed for repositories
• Believing saveUser must return a value

5. You have a Spring Boot application with these classes:

@Component
public class UtilityHelper { }

@Service
public class OrderService { }

@Repository
public interface OrderRepository extends JpaRepository { }

@Controller
public class OrderController { }

Which statement correctly describes the roles and how Spring manages these beans?

hard

A. @Component manages data access; @Service handles web requests; @Repository is for business logic; @Controller is a utility bean

B. @Component handles web requests; @Service manages data access; @Repository is for utility beans; @Controller handles business logic

C. All annotations are interchangeable and have the same role in Spring

D. @Component is for utility beans; @Service handles business logic; @Repository manages data access; @Controller handles web requests

Solution

1. Step 1: Recall the purpose of each annotation

   @Component is a general-purpose bean, often used for utilities. @Service is for business logic. @Repository is for data access layers. @Controller is for handling web requests.

2. Step 2: Match each class role to its annotation

   UtilityHelper is a utility bean, so @Component fits. OrderService contains business logic, so @Service fits. OrderRepository accesses data, so @Repository fits. OrderController handles HTTP requests, so @Controller fits.

3. Final Answer:

   @Component is for utility beans; @Service handles business logic; @Repository manages data access; @Controller handles web requests -> Option D

4. Quick Check:

   Annotations match roles: Component-utility, Service-logic, Repository-data, Controller-web [OK]

Hint: Match annotation to role: Component-utility, Service-logic, Repository-data, Controller-web [OK]

Common Mistakes:

• Mixing up @Service and @Controller roles
• Thinking all annotations are interchangeable
• Confusing @Component with @Repository