Difference Between @Component, @Service, and @Repository in Spring Boot

@Component, @Service, and @Repository are commonly used Spring annotations.

All three annotations create Spring Beans and are managed by the Spring IoC Container.

However, they are used for different layers and purposes in an application.

Simple Definition

• @Component → Generic Spring Bean
• @Service → Business Logic Layer
• @Repository → Database Access Layer

All are Spring Beans, but each represents a different application layer.

Common Point

All three annotations:

• Create Spring-managed Beans
• Support Dependency Injection
• Are detected during Component Scanning
• Are managed by the IoC Container

Main Difference Table

1. @Component

@Component is a generic annotation used to create Spring Beans.

It is mainly used for:

• Utility classes
• Helper classes
• Common reusable components

Example

@Component
public class JwtUtil {

    public String generateToken() {

        return "JWT_TOKEN";
    }
}

Real-Time Example

• JWT Utility
• Email Utility
• Date Utility
• Common Validators

2. @Service

@Service is used for business logic classes.

It represents the Service Layer in application architecture.

Example

@Service
public class PaymentService {

    public String processPayment() {

        return "Payment Successful";
    }
}

Real-Time Example

• PaymentService
• UserService
• CourseService
• NotificationService

Responsibilities

• Business rules
• Application logic
• Service orchestration
• Calling repositories

3. @Repository

@Repository is used for database access layer classes.

It represents the Persistence Layer.

Example

@Repository
public interface UserRepository
extends JpaRepository<User, Long> {

}

Real-Time Example

• UserRepository
• PaymentRepository
• CourseRepository

Responsibilities

• Database operations
• CRUD operations
• JPA queries
• Data persistence

Special Feature of @Repository

@Repository provides:

Database Exception Translation

It converts database-specific exceptions into Spring DataAccessException.

Architecture Flow Example

Suppose we are developing Dhanish Empower.

Controller
    ↓
Service
    ↓
Repository
    ↓
Database

Real-Time Example Flow

Controller

@RestController
@RequestMapping("/api/courses")
public class CourseController {

    @Autowired
    private CourseService courseService;

}

Service Layer

@Service
public class CourseService {

    @Autowired
    private CourseRepository courseRepository;

}

Repository Layer

@Repository
public interface CourseRepository
extends JpaRepository<Course, Long> {

}

How Spring Handles These Annotations

During Component Scanning:

1. Spring scans classes.
2. Detects annotations.
3. Creates Beans.
4. Stores them in IoC Container.
5. Performs Dependency Injection.

Are @Service and @Repository internally @Component?

Yes.

Both annotations are specialized forms of:

@Component

Internally:

@Service
@Component

@Repository
@Component

Why Separate Annotations are Used?

Separate annotations improve:

• Code readability
• Layer identification
• Maintainability
• Architecture clarity

Developers can immediately understand the purpose of the class.

When to Use Which Annotation?

Advantages of Using Proper Annotations

• Better project structure
• Improved maintainability
• Clear architecture
• Easier debugging
• Cleaner code organization
• Supports layered architecture

Production-Level Importance

In enterprise applications and microservices:

• @Service manages business operations
• @Repository handles database access
• @Component manages utility and helper classes

This separation helps large applications remain scalable and maintainable.

Interview Answer

@Component is a generic Spring Bean annotation used for common components.

@Service is used for business logic layer classes.

@Repository is used for database access layer classes and provides exception translation.

Both @Service and @Repository are specialized forms of @Component.

Short Interview Answer

@Component is generic, @Service is for business logic, and @Repository is for database operations.

Frequently Asked Questions

Is @Service a type of @Component?

Yes, @Service internally extends @Component.

What is special about @Repository?

It provides database exception translation.

Can we use @Component instead of @Service?

Yes, technically possible, but not recommended.

Why use separate annotations?

To improve architecture clarity and maintainability.

Which annotation is used for utility classes?

@Component.

Conclusion

@Component, @Service, and @Repository are important Spring annotations used for different application layers.

Using them properly helps create clean, scalable, maintainable, and enterprise-level Spring Boot applications.