Для чего нужно использовать конструктор для внедрения бинов?

# Использование конструктора для внедрения зависимостей (Dependency Injection)

Основная идея

Внедрение зависимостей через конструктор — это паттерн, при котором все необходимые объекты передаются в класс через конструктор. Это один из трёх способов в Spring (field injection, setter injection, constructor injection), но наиболее рекомендуемый.

Почему конструктор лучше

1. Неизменяемость (Immutability)

Зависимости, введённые через конструктор, становятся final. Это гарантирует, что они не изменятся после создания объекта:

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // Зависимости final — неизменяемы
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

Сравните с field injection (ПЛОХО):

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository; // может быть переписан!
    
    @Autowired
    private EmailService emailService;
}

2. Тестируемость

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

@Test
public void testUserCreation() {
    // Создаём моки
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    
    // Передаём моки в конструктор
    UserService userService = new UserService(mockRepo, mockEmail);
    
    // Тест работает и без Spring!
    userService.createUser("john@example.com");
    verify(mockEmail).send(any());
}

Без конструктора пришлось бы использовать специальные Spring test-утилиты и @SpringBootTest.

3. Явные зависимости (Explicit dependencies)

Читая конструктор, сразу видно все зависимости класса:

public UserService(
    UserRepository userRepository,
    EmailService emailService,
    NotificationService notificationService,
    AuditService auditService
) { ... }

Это показывает, что класс много чего требует. Если список растёт — это сигнал нарушить Single Responsibility Principle.

4. Защита от NullPointerException

Если Spring не сможет найти бин, исключение будет выброшено при создании объекта (на старте приложения), а не при вызове метода:

// Ошибка выявляется сразу на старте приложения
public UserService(UserRepository userRepository) {
    this.userRepository = userRepository; // если null → Exception
}

// vs field injection — ошибка проявляется позже при вызове
public void someMethod() {
    userRepository.save(user); // NullPointerException здесь!
}

5. Правильное разрешение зависимостей

Spring контейнер знает все зависимости до создания объекта, что позволяет правильно разрешить циклические зависимости и построить граф объектов.

Пример: конструктор vs field injection

ПЛОХО (Field Injection):

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    public Order createOrder(OrderRequest request) {
        return paymentService.process(request); // может быть null!
    }
}

ХОРОШО (Constructor Injection):

@Service
public class OrderService {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public OrderService(
        PaymentService paymentService,
        InventoryService inventoryService
    ) {
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }
    
    public Order createOrder(OrderRequest request) {
        return paymentService.process(request); // гарантировано не null
    }
}

С Lombok ещё проще

@Service
@RequiredArgsConstructor // Lombok генерирует конструктор
public class OrderService {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public Order createOrder(OrderRequest request) {
        return paymentService.process(request);
    }
}

Выводы

Используй конструктор для внедрения, потому что:

1. ✅ Зависимости неизменяемы (final)
2. ✅ Легко тестировать без Spring
3. ✅ Явные зависимости видны сразу
4. ✅ Ошибки обнаруживаются на старте, не во время работы
5. ✅ Лучше соответствует SOLID принципам

Esra Field Injection только если очень нужно, а Setter Injection — практически никогда.