@Service

#Introduction

In the previous chapter we learned that @Component is the foundation of Spring's component model. A natural interview question arises:

#What is @Service?

@Service marks a class as the business logic layer of your application. It tells developers (and Spring): "This class contains business rules and application logic."

@Service
public class UserService {

    public User getUser(Long id) {
        return repository.findById(id)
                .orElseThrow(() -> new UserNotFoundException(id));
    }
}

Spring creates this class as a bean exactly like @Component. The difference is its semantic meaning, not its bean-creation behaviour.

#What is Business Logic?

Business logic is the set of rules that solve a business problem. Imagine an e-commerce application where a customer places an order. The system must:

• Validate the customer
• Check product availability
• Calculate discount
• Calculate tax
• Reserve inventory
• Save the order
• Send a confirmation email

These are business rules. They belong inside a service.

#Application Layers

#Example Without a Service Layer

❌ Bad design:

@RestController
public class UserController {

    @Autowired
    UserRepository repository;

    @PostMapping("/users")
    public User create(@RequestBody User user) {

        if (user.getAge() < 18) {
            throw new RuntimeException();
        }

        repository.save(user);
        emailService.send();

        return user;
    }
}

Problems: the controller becomes huge, is difficult to test and reuse, and mixes HTTP with business logic.

#Proper Design

Controller:

@RestController
public class UserController {

    @Autowired
    UserService service;

    @PostMapping("/users")
    public User create(@RequestBody User user) {
        return service.createUser(user);
    }
}

Service:

@Service
public class UserService {

    @Autowired
    UserRepository repository;

    @Autowired
    EmailService emailService;

    public User createUser(User user) {

        if (user.getAge() < 18) {
            throw new IllegalArgumentException("Invalid age");
        }

        User saved = repository.save(user);
        emailService.sendEmail();

        return saved;
    }
}

Now each class has a single responsibility.

#Internal Working

#Is @Service Different from @Component?

Conceptually, @Service is:

@Component
public @interface Service {
}

So bean creation is identical. The difference is meaning:

#Why Not Use @Component Everywhere?

Technically you can — Spring will create the bean. But imagine a project with 300 classes all marked @Component. Can you immediately identify the business classes, controllers and database layer? No.

Now compare a codebase using @Service, @Repository, @Controller and @RestController: the architecture becomes self-documenting.

#Real Enterprise Example

An online banking application:

@Service
public class TransferService {

    public void transfer() {
        validateSender();
        validateReceiver();
        checkBalance();
        debit();
        credit();
        sendNotification();
    }
}

Everything here is business logic.

#A Service Can Call Multiple Repositories

A common misconception is one service = one repository. Not true:

@Service
public class OrderService {

    @Autowired
    OrderRepository orderRepository;

    @Autowired
    ProductRepository productRepository;

    @Autowired
    CustomerRepository customerRepository;
}

One business operation may require multiple repositories.

#A Service Can Call Other Services

@Service
public class PaymentService {
}

@Service
public class OrderService {

    @Autowired
    PaymentService paymentService;
}

#Transactions Usually Start Here

@Transactional
@Service
public class OrderService {
}

Reason: a business operation often updates multiple tables — e.g. update account + insert transaction + update balance. These operations should either all succeed or all fail together. The service layer is the appropriate place to define that transaction boundary.

#Dependency Injection

@Service
public class UserService {

    @Autowired
    UserRepository repository;
}

Spring injects the UserRepository bean into the UserService bean. No manual object creation is needed.

#Singleton Nature

Like @Component, services are singleton by default — UserController and AdminController both receive the same UserService instance. Because of this, services should generally remain stateless.

// ✅ Good
@Service
public class DiscountService {

    public double calculate(double price) {
        return price * 0.9;
    }
}

// ❌ Bad — mutable shared state can cause thread-safety issues
@Service
public class DiscountService {

    private double currentPrice;
}

#Package Structure

A common project layout:

#Key Takeaways

• @Service represents the business layer.
• It is a stereotype annotation built on top of @Component.
• Controllers should delegate business work to services.
• Services coordinate repositories, external APIs, validations and transactions.
• Services are singleton beans by default and should generally be stateless.
• The service layer is the heart of enterprise Spring Boot applications.