@Component

#Introduction

If there is one annotation you must completely understand before learning Spring Boot, it is @Component. Why? Because almost every other stereotype annotation (@Service, @Repository, @Controller, @RestController) is built on top of @Component.

#What is @Component?

@Component tells the Spring container:

import org.springframework.stereotype.Component;

@Component
public class EmailService {

    public void sendEmail() {
        System.out.println("Email Sent");
    }
}

That's all you write. You never call new EmailService() — Spring creates and manages the instance.

#Life Without Spring

public class EmailService {

    public void sendEmail() {
        System.out.println("Sending...");
    }
}

public class UserService {

    private EmailService emailService = new EmailService();
}

You are responsible for creating objects, managing dependencies, managing lifecycle and reusing objects. As applications grow, this becomes difficult to maintain.

#Life With Spring

@Component
public class EmailService {
}

@Service
public class UserService {

    @Autowired
    private EmailService emailService;
}

Now Spring handles object creation, dependency injection, lifecycle, singleton management and memory management (bean scope).

#What Happens Internally?

#Where Is the Bean Stored?

Inside the IoC container (ApplicationContext). Think of it like a warehouse:

Whenever anyone needs EmailService, Spring returns this managed instance.

#How Does Spring Discover @Component?

Spring scans packages using component scanning.

@SpringBootApplication
public class DemoApplication {
}

#Reflection vs Metadata Reading

Conceptually:

if (class.hasAnnotation(Component.class)) {
    registerBean();
}

In reality, Spring reads the annotation information from bytecode before loading the class.

#Bean Naming

@Component
public class EmailService {
}

Default bean name: emailService. The rule is class name with the first letter lowercased.

Custom Bean Name

@Component("gmailService")
public class EmailService {
}

The container now stores gmailService → EmailService object. Inject it with:

@Autowired
@Qualifier("gmailService")
private EmailService emailService;

#What Is a Bean?

// Normal object
EmailService service = new EmailService();

// Spring bean
@Component
public class EmailService {
}

#Singleton Behaviour

By default, only one instance is created:

@Service
public class UserService {

    @Autowired
    EmailService emailService;
}

@RestController
public class UserController {

    @Autowired
    EmailService emailService;
}

What If There Are 100 Requests?

Even with 100 concurrent HTTP requests, all requests share the same singleton bean. Because singleton beans are shared, they should generally be stateless.

#Stateless vs Stateful Beans

✅ Good (stateless) — no instance variables hold request-specific data:

@Component
public class EmailService {

    public void sendEmail(String email) {
        System.out.println(email);
    }
}

❌ Bad (stateful):

@Component
public class EmailService {

    private String currentEmail;

    public void send(String email) {
        currentEmail = email;
    }
}

If multiple threads call send() simultaneously, currentEmail may be overwritten, leading to race conditions.

#Can @Component Be Used Everywhere?

Technically, yes:

@Component
class PaymentService {}

@Component
class UserRepository {}

But Spring provides specialized stereotypes for better readability and additional behaviour:

#Meta-Annotation

Internally, @Service is defined (conceptually) as:

@Component
public @interface Service {
}

Likewise @Repository → @Component and @Controller → @Component. This is why component scanning detects all of them.

#Real-World Example

@RestController
public class UserController {

    @Autowired
    UserService service;
}

@Service
public class UserService {

    @Autowired
    UserRepository repository;
}

@Repository
public class UserRepository {
}

All three classes are discovered through component scanning because they are stereotype annotations built on @Component.

#Summary

• @Component marks a class as a Spring-managed bean.
• Component scanning discovers candidate classes.
• Spring registers a BeanDefinition, then creates and manages the bean.
• By default, @Component beans are singleton-scoped.
• @Service, @Repository and @Controller are built on top of @Component.
• Stateless singleton beans are the recommended design for most services.