Какая область ответственности у Service в Spring?

Какая область ответственности у Service в Spring?

Это вопрос про архитектурные паттерны в Spring и разделение ответственности между слоями. Service — это один из ключевых слоев приложения.

Основная область ответственности Service

Service — это бизнес-логика приложения.

Service занимается:

1. Бизнес-логика — правила, которые определяют как работает приложение
2. Транзакции — @Transactional, управление транзакциями БД
3. Оркестрация — координация между repositories, других сервисов
4. Валидация бизнес-правил — более сложная, чем на границе API
5. Трансформация данных — из DTOs в domain entities и наоборот

Архитектурные слои Spring приложения

Presentation Layer (Controllers)
        ↓ (использует)
Application Layer (Services)  ← Бизнес-логика
        ↓ (использует)
Domain Layer (Entities, Repositories)
        ↓ (использует)
Infrastructure Layer (Database, External APIs)

Зависимости должны идти только ВНИЗ!

Структура Service класса

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;  // Доступ к данным
    
    @Autowired
    private EmailService emailService;      // Зависимость на другой сервис
    
    @Autowired
    private PasswordEncoder passwordEncoder; // Инструменты
    
    /**
     * Основная ответственность: бизнес-логика регистрации
     * Не должна находиться в Controller!
     */
    @Transactional
    public UserResponse registerUser(RegisterUserRequest request) {
        // 1. Валидация бизнес-правил
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new UserAlreadyExistsException("Email already registered");
        }
        
        // 2. Трансформация (DTO → Entity)
        User user = new User();
        user.setEmail(request.getEmail());
        user.setName(request.getName());
        user.setPasswordHash(passwordEncoder.encode(request.getPassword()));
        user.setCreatedAt(LocalDateTime.now(ZoneId.of("UTC")));
        
        // 3. Сохранение (interaction с Repository)
        User savedUser = userRepository.save(user);
        
        // 4. Side-effects (отправка email через другой сервис)
        emailService.sendWelcomeEmail(savedUser.getEmail());
        
        // 5. Трансформация ответа (Entity → DTO)
        return new UserResponse(savedUser.getId(), savedUser.getEmail(), savedUser.getName());
    }
    
    /**
     * Service может быть вызван из разных мест:
     * - REST controller
     * - Schedule task
     * - другой service
     */
    @Transactional
    public void updateUserStatus(Long userId, UserStatus newStatus) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
        
        // Бизнес-правила
        if (user.getStatus() == UserStatus.BLOCKED) {
            throw new BusinessRuleException("Cannot change status of blocked user");
        }
        
        user.setStatus(newStatus);
        user.setUpdatedAt(LocalDateTime.now(ZoneId.of("UTC")));
        userRepository.save(user);
    }
}

Что НЕ должно быть в Service?

❌ Неправильно:

@Service
public class BadUserService {
    
    // ❌ HTTP логика — это для Controller!
    @GetMapping("/users")
    public List<User> getUsers() { ... }
    
    // ❌ Логирование ошибок — это для AOP/Interceptors!
    public void updateUser(User user) {
        try {
            userRepository.save(user);
        } catch (Exception e) {
            System.out.println("Error: " + e);  // ❌ ПЛОХО
        }
    }
    
    // ❌ HTML генерация — это для Templates!
    public String generateHTML(User user) {
        return "<h1>" + user.getName() + "</h1>";
    }
    
    // ❌ Прямое преобразование JSON — это для Controller/REST!
    public String userToJSON(User user) {
        return "{\"id\":" + user.getId() + "}";
    }
}

Правильная структура проекта

// 1. CONTROLLER — только HTTP логика
@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @PostMapping
    public ResponseEntity<UserResponse> register(@Valid @RequestBody RegisterUserRequest request) {
        // Только HTTP: parsing, validation, response wrapping
        UserResponse response = userService.registerUser(request);
        return ResponseEntity.ok(response);
    }
}

// 2. SERVICE — бизнес-логика
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public UserResponse registerUser(RegisterUserRequest request) {
        // Бизнес-логика, валидация, оркестрация
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new UserAlreadyExistsException();
        }
        // ... остальная логика
    }
}

// 3. REPOSITORY — доступ к данным
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    boolean existsByEmail(String email);
}

// 4. ENTITY — представление данных
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String email;
    private String name;
}

Примеры правильного использования Service

Пример 1: Комплексная операция (оркестрация)

@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private NotificationService notificationService;
    
    /**
     * Главная ответственность Service: оркестрация нескольких операций
     */
    @Transactional
    public OrderResponse createOrder(CreateOrderRequest request) {
        // 1. Валидация бизнес-правил
        validateOrder(request);
        
        // 2. Создание заказа
        Order order = new Order();
        order.setStatus(OrderStatus.PENDING);
        order.setItems(request.getItems());
        order.setCreatedAt(LocalDateTime.now(ZoneId.of("UTC")));
        
        // 3. Оркестрация: вызов других сервисов
        Payment payment = paymentService.processPayment(
            order.getTotalPrice(),
            request.getPaymentMethod()
        );
        
        inventoryService.reserveItems(order.getItems());
        
        // 4. Сохранение
        order.setPaymentId(payment.getId());
        order.setStatus(OrderStatus.CONFIRMED);
        Order savedOrder = orderRepository.save(order);
        
        // 5. Уведомления
        notificationService.notifyCustomer(
            request.getCustomerId(),
            "Order created: " + savedOrder.getId()
        );
        
        // 6. Ответ
        return new OrderResponse(savedOrder.getId(), OrderStatus.CONFIRMED);
    }
    
    private void validateOrder(CreateOrderRequest request) {
        if (request.getItems().isEmpty()) {
            throw new InvalidOrderException("Order must contain items");
        }
        if (request.getTotalPrice() <= 0) {
            throw new InvalidOrderException("Invalid price");
        }
    }
}

Пример 2: Транзакции и консистентность

@Service
public class MoneyTransferService {
    
    @Autowired
    private AccountRepository accountRepository;
    
    /**
     * @Transactional гарантирует atomicity:
     * Либо обе операции завершатся, либо ни одна
     */
    @Transactional
    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
        // Получаем счеты (с блокировкой)
        Account fromAccount = accountRepository.findByIdForUpdate(fromAccountId)
            .orElseThrow();
        Account toAccount = accountRepository.findByIdForUpdate(toAccountId)
            .orElseThrow();
        
        // Бизнес-правила
        if (fromAccount.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        
        // Операции
        fromAccount.withdraw(amount);
        toAccount.deposit(amount);
        
        // Сохраняем (atomicity гарантирована @Transactional)
        accountRepository.save(fromAccount);
        accountRepository.save(toAccount);
    }
}

Когда создавать новый Service?

Когда логика используется в нескольких местах:

// ❌ Повторение в разных контроллерах
@RestController
class UserController {
    @PostMapping("/register")
    public void register(UserRequest req) {
        if (userRepository.existsByEmail(req.getEmail())) {
            throw new Exception();
        }
        // ... еще код
    }
}

class AdminController {
    @PostMapping("/users")
    public void createUser(UserRequest req) {
        if (userRepository.existsByEmail(req.getEmail())) {  // ❌ Повторение!
            throw new Exception();
        }
        // ... еще код
    }
}

// ✅ Правильно: вынести в Service
@Service
public class UserService {
    public void createUser(UserRequest req) {
        if (userRepository.existsByEmail(req.getEmail())) {
            throw new Exception();
        }
    }
}

Мой совет для интервью:

Правильный ответ:

"Service в Spring имеет одну основную ответственность:
бизнес-логика приложения.

Service:
1. Содержит бизнес-правила (валидация, расчеты)
2. Оркестрирует работу repositories и других сервисов
3. Управляет транзакциями (@Transactional)
4. Трансформирует данные между слоями (DTO ↔ Entity)

Service НЕ должен:
- Содержать HTTP логику (это Controller)
- Обращаться напрямую к БД (это Repository)
- Знать про UI (это View/Template)
- Логировать ошибки (это AOP/Interceptor)

По сути: Service — это сердце приложения."

Ключевые моменты:

1. Бизнес-логика — главная ответственность
2. @Transactional — управление транзакциями
3. Оркестрация — координация repositories
4. Использование везде — Controllers, Scheduled tasks, других Services
5. Single Responsibility — один Service = одна область бизнеса

Service — это самый важный слой в Spring приложении, где живет вся бизнес-логика!