Почему предпочитаешь инъекции через конструктор в Spring?

Инъекция зависимостей через конструктор в Spring

Отличный вопрос про одно из лучших практик в Spring Framework! Давайте разберёмся, почему конструкторная инъекция стала стандартом в индустрии.

Три способа инъекции в Spring

1. Инъекция через конструктор:

@Component
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;

    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

2. Инъекция через поле (Field Injection):

@Component
public class UserService {
    @Autowired
    private UserRepository repository;
    
    @Autowired
    private EmailService emailService;
}

3. Инъекция через setter:

@Component
public class UserService {
    private UserRepository repository;
    private EmailService emailService;

    @Autowired
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }

    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

Почему конструкторная инъекция лучше?

1. Immutability - неизменяемость объектов.

С конструктором ты можешь использовать final:

@Component
public class UserService {
    private final UserRepository repository;    // final!
    private final EmailService emailService;    // final!

    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

Это гарантирует, что зависимости не могут измениться после инициализации. Field Injection не позволяет это:

@Component
public class UserService {
    @Autowired
    private UserRepository repository; // ОШИБКА: не может быть final!
}

2. Явные требования - Explicit Dependencies.

Конструктор показывает, что НУЖНО классу:

// Явно видно, что нужны repository и emailService
public UserService(UserRepository repository, EmailService emailService) { }

// С Field Injection - это скрыто
@Autowired private UserRepository repository; // неясно, что нужно

Это облегчает тестирование и понимание кода.

3. Легче тестировать:

// С конструктором - просто
@Test
public void testUserService() {
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    
    UserService service = new UserService(mockRepo, mockEmail);
    // Никаких reflection, всё явно
}

// С Field Injection - требуется Spring контекст
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService service; // нужен весь Spring контекст для инициализации
}

4. Проверка зависимостей на старте:

Если зависимость не найдена, ошибка в конструкторе:

// Если UserRepository не зарегистрирован в Spring - сразу ошибка при старте приложения
public UserService(UserRepository repository) { } // NullPointerException на старте

// С Field Injection - ошибка может появиться при первом использовании!
@Autowired
private UserRepository repository; // может быть null до первого использования

5. Решение циклических зависимостей:

Конструкторная инъекция предотвращает циклические зависимости на этапе компиляции:

// Плохо - циклические зависимости
public class ServiceA {
    public ServiceA(ServiceB serviceB) { }
}

public class ServiceB {
    public ServiceB(ServiceA serviceA) { }
}
// Spring выдаст ошибку - НЕВОЗМОЖНО разрешить

// С Field Injection это легко проскочить, но приведёт к ошибкам на runtime

Field Injection - когда использовать?

Единственный légitim случай - test fixtures в тестах:

@SpringBootTest
public class UserServiceIntegrationTest {
    @Autowired // OK для тестов
    private UserService userService;
    
    @Test
    public void testFullFlow() { }
}

Практический пример - правильный код

@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;
    }

    public void createOrder(Order order) {
        orderRepository.save(order);
        paymentService.charge(order);
        notificationService.sendConfirmation(order);
    }
}

Автоматизация с Lombok

Если много зависимостей - используй @RequiredArgsConstructor из Lombok:

@Service
@RequiredArgsConstructor // автоматически генерирует конструктор
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    // конструктор генерируется автоматически
}

Вывод

Конструкторная инъекция предпочтительна потому что:

• Неизменяемость - используй final
• Явные требования - видно, что нужно классу
• Тестируемость - легче создавать mock'и
• Ранее обнаружение ошибок - на старте приложения
• Предотвращение циклических зависимостей - на этапе компиляции

Это стало Best Practice в Spring и даже рекомендовано официально в Spring Boot документации.