@Service

@Service — Business Logic Layer

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;

    public OrderService(OrderRepository orderRepository,
                       PaymentService paymentService,
                       NotificationService notificationService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }

    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        // 1. Validate business rules
        validateOrder(request);

        // 2. Process payment
        paymentService.charge(request.getPaymentMethod(), request.getTotal());

        // 3. Save order
        Order order = new Order(request);
        orderRepository.save(order);

        // 4. Send confirmation
        notificationService.sendOrderConfirmation(order);

        return order;
    }
}

Service Layer Responsibilities

Responsibility	Description
Business logic	Apply rules, calculations, validations
Transaction management	@Transactional boundaries
Orchestration	Coordinate multiple repositories/services
Data transformation	Convert between DTOs and entities
Error handling	Business-level error handling

Service Best Practices

1. Single responsibility — One service per domain concept
2. Interface + implementation — Define contracts
3. Constructor injection — Immutable dependencies
4. Transactional boundaries — @Transactional on public methods
5. No HTTP concepts — Services shouldn't know about HTTP

Configuration

• Use properties over YAML for simple configs
• Externalize configuration
• Use profiles for environments
• Validate on startup

Bean Management

• Prefer constructor injection
• Use appropriate scope
• Implement lazy initialization
• Clean up resources

Security

• Use Spring Security
• Implement CSRF protection
• Use method-level security
• Log security events

Key Points

• Understanding @Service Annotation is essential for production systems
• Always consider scalability and maintainability
• Test thoroughly before deploying to production
• Monitor performance and set up alerting

Common Patterns

1. Validation: Always validate input at the boundary
2. Error Handling: Use structured error responses
3. Logging: Log key events for debugging
4. Testing: Unit, integration, and load tests
5. Documentation: Keep docs updated with code changes