@Component annotation in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark the class as a Spring component.

Spring Boot

@[1]
public class MyService {
    // service methods
}

Drag options to blanks, or click blank then click option'

ARepository

BService

CComponent

DController

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service or @Repository instead of @Component when a generic component is needed.

Forgetting the @Component annotation, so Spring does not detect the class.

The @Component annotation tells Spring to treat this class as a component and manage its lifecycle.

2fill in blank

medium

Complete the code to inject the component into another class using Spring's annotation.

Spring Boot

public class MyController {
    @[1]
    private MyService myService;
}

Drag options to blanks, or click blank then click option'

AInject

BAutowired

CResource

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Autowired for injection.

Forgetting to annotate the field or constructor for injection.

The @Autowired annotation tells Spring to inject the component automatically.

3fill in blank

hard

Fix the error in the code by completing the annotation to register the class as a Spring component.

Spring Boot

@[1]
public class DataRepository {
    public void save() {
        // save data
    }
}

Drag options to blanks, or click blank then click option'

ARepository

BComponent

CService

DController

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Repository for data access classes.

Not annotating the class, so Spring does not manage it.

The @Repository annotation is a specialized form of @Component for data access classes.

4fill in blank

hard

Fill both blanks to create a Spring component and inject it into another class.

Spring Boot

@[1]
public class NotificationService {
    public void notifyUser() {
        // notify logic
    }
}

public class UserController {
    @[2]
    private NotificationService notificationService;
}

Drag options to blanks, or click blank then click option'

AComponent

BAutowired

CService

DInject

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up @Service and @Component annotations.

Forgetting to use @Autowired for injection.

The @Component annotation registers the class as a Spring bean, and @Autowired injects it where needed.

5fill in blank

hard

Fill all three blanks to define a Spring component with a method and inject it properly.

Spring Boot

@[1]
public class EmailSender {
    public void sendEmail() {
        // send email logic
    }
}

public class NotificationController {
    @[2]
    private EmailSender [3];
}

Drag options to blanks, or click blank then click option'

AComponent

BAutowired

CemailSender

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service instead of @Component when a generic component is intended.

Not matching the variable name to the injected type.

@Component registers the class as a Spring bean, @Autowired injects it, and emailSender is the variable name used for the injected instance.

Practice

1. What is the main purpose of the @Component annotation in Spring Boot?

easy

A. To mark a class so Spring automatically creates and manages its instance

B. To define a database entity

C. To configure application properties

D. To handle HTTP requests

Solution

1. Step 1: Understand the role of @Component

   The @Component annotation tells Spring to create an instance of the class and manage it automatically.

2. Step 2: Compare with other options

   The other options relate to other Spring features like entities, properties, or controllers, not @Component.

3. Final Answer:

   To mark a class so Spring automatically creates and manages its instance -> Option A

4. Quick Check:

   @Component = automatic management [OK]

Hint: Remember: @Component means Spring manages the class [OK]

Common Mistakes:

• Confusing @Component with @Entity
• Thinking it handles HTTP requests
• Assuming it configures properties

2. Which of the following is the correct way to declare a Spring component class?

easy

A. @Component public class MyService {}

B. @Service public void MyService() {}

C. public class MyService {}

D. @Component void MyService() {}

Solution

1. Step 1: Check annotation placement and class declaration

   The @Component annotation must be placed above a class declaration, like @Component public class MyService {}.

2. Step 2: Identify incorrect syntax

   A plain public class misses the annotation, annotating a method with @Service or @Component is invalid since components must be classes.

3. Final Answer:

   @Component public class MyService {} -> Option A

4. Quick Check:

   Annotation + class declaration = correct syntax [OK]

Hint: Always put @Component above a class, not a method [OK]

Common Mistakes:

• Annotating methods instead of classes
• Missing the annotation entirely
• Using wrong annotations for components

3. Given the code below, what will be the output when app.run() is called?

@Component
public class App {
  @Autowired
  private ServiceA serviceA;

  public void run() {
    System.out.println(serviceA.getName());
  }
}

@Component
public class ServiceA {
  public String getName() {
    return "ServiceA";
  }
}

medium

A. Runtime NullPointerException

B. null

C. ServiceA

D. Compilation error

Solution

1. Step 1: Understand component scanning and injection

   Both App and ServiceA are annotated with @Component, so Spring creates and manages their instances. The @Autowired injects ServiceA into App.

2. Step 2: Trace the method call

   Calling app.run() prints the result of serviceA.getName(), which returns "ServiceA".

3. Final Answer:

   ServiceA -> Option C

4. Quick Check:

   Autowired injects component = output string [OK]

Hint: If both classes are @Component, autowired works and prints value [OK]

Common Mistakes:

• Assuming serviceA is null without injection
• Confusing compilation vs runtime errors
• Forgetting to annotate both classes

4. What is the problem with the following code snippet?

@Component
public class MyComponent {
  @Autowired
  private ServiceB serviceB;

  public void doWork() {
    serviceB.perform();
  }
}

Assuming ServiceB is not annotated with @Component or any stereotype, what will happen?

medium

A. Compilation error due to missing import

B. The code will compile and run fine

C. ServiceB will be automatically created by Spring

D. Spring will throw a runtime error due to missing bean

Solution

1. Step 1: Check bean creation requirements

   Spring only manages classes annotated with @Component or similar. Since ServiceB lacks this, Spring won't create its bean.

2. Step 2: Understand autowiring consequences

   When Spring tries to inject serviceB, it finds no bean and throws a runtime error (NoSuchBeanDefinitionException).

3. Final Answer:

   Spring will throw a runtime error due to missing bean -> Option D

4. Quick Check:

   Missing @Component = runtime injection error [OK]

Hint: All injected classes must be annotated for Spring to manage [OK]

Common Mistakes:

• Assuming Spring creates beans without annotation
• Confusing compile errors with runtime errors
• Forgetting to annotate dependencies

5. You want to create two different implementations of an interface PaymentService and have Spring inject the correct one based on a custom qualifier. How should you use @Component to achieve this?

hard

A. Annotate only one implementation with @Component and inject by interface type

B. Annotate both implementations with @Component and use @Qualifier to specify which to inject

C. Use @Component only on the interface, not implementations

D. Create instances manually without @Component

Solution

1. Step 1: Annotate both implementations

   Both classes implementing PaymentService must be annotated with @Component so Spring manages them.

2. Step 2: Use @Qualifier to distinguish

   When injecting, use @Qualifier with the component name to tell Spring which implementation to use.

3. Final Answer:

   Annotate both implementations with @Component and use @Qualifier to specify which to inject -> Option B

4. Quick Check:

   Multiple components + qualifier = correct injection [OK]

Hint: Use @Component on all, @Qualifier to pick one [OK]

Common Mistakes:

• Annotating only one implementation
• Annotating interface instead of classes
• Not using @Qualifier when multiple beans exist