Какие знаешь варианты внедрения зависимостей?

Варианты внедрения зависимостей (Dependency Injection)

Внедрение зависимостей (DI) — это паттерн проектирования, который уменьшает связанность между классами. В Java существует несколько способов реализации DI.

1. Constructor Injection — инъекция через конструктор

Это наиболее рекомендуемый подход. Зависимости передаются через конструктор:

@Service
public class UserService {
    private final UserRepository userRepository;
    private final MailService mailService;
    
    // Constructor Injection
    public UserService(UserRepository userRepository, MailService mailService) {
        this.userRepository = userRepository;
        this.mailService = mailService;
    }
    
    public void registerUser(String email) {
        User user = new User(email);
        userRepository.save(user);
        mailService.sendWelcomeEmail(email);
    }
}

// Использование в Spring
@Configuration
public class AppConfig {
    @Bean
    public UserService userService(UserRepository repo, MailService mail) {
        return new UserService(repo, mail);
    }
}

Преимущества:

• Зависимости обязательны (final fields)
• Легко тестировать (можно передать mock'и)
• Объект неизменяемый (immutable)
• Явно видна зависимость сразу при создании
• Нет NullPointerException если зависимость не внедрена

⚠️ Недостаток: Многие параметры в конструкторе → нужен паттерн Builder.

2. Setter Injection — инъекция через setter

Зависимости устанавливаются после создания объекта:

@Service
public class OrderService {
    private OrderRepository orderRepository;
    private NotificationService notificationService;
    
    @Autowired
    public void setOrderRepository(OrderRepository repository) {
        this.orderRepository = repository;
    }
    
    @Autowired
    public void setNotificationService(NotificationService service) {
        this.notificationService = service;
    }
    
    public void processOrder(Order order) {
        orderRepository.save(order);
        notificationService.notify("Order processed");
    }
}

Особенности:

• Зависимости опциональны
• Удобно для большого количества зависимостей
• Возможны NullPointerException если забыли установить зависимость

❌ Недостатки:

• Объект может быть в неполном состоянии
• Сложнее тестировать
• Не очевидна зависимость при чтении конструктора

3. Field Injection — инъекция в поля

Зависимости внедряются напрямую в поля через аннотацию @Autowired:

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private ProductRepository productRepository;
    
    @GetMapping("/{id}")
    public ProductDTO getProduct(@PathVariable UUID id) {
        return productService.getProductDTO(id);
    }
}

Особенности:

• Простой и чистый синтаксис
• Мало кода
• Зависимости скрыты

❌ Недостатки (ИМЕННО ПОЭТОМУ НЕ РЕКОМЕНДУЕТСЯ):

• Сложно тестировать (нужна Spring конфигурация для тестов)
• NullPointerException если зависимость не внедрена
• Невозможно создать объект без DI контейнера
• Нарушает принцип инкапсуляции
• Скрытые зависимости при чтении кода

4. Interface Injection — инъекция через интерфейс

Объект реализует интерфейс, содержащий setter для зависимостей:

// Интерфейс для внедрения
public interface LoggerInjectable {
    void setLogger(Logger logger);
}

// Реализация
@Service
public class PaymentProcessor implements LoggerInjectable {
    private Logger logger;
    private PaymentGateway gateway;
    
    @Override
    public void setLogger(Logger logger) {
        this.logger = logger;
    }
    
    public void processPayment(Payment payment) {
        logger.info("Processing payment: " + payment.getId());
        gateway.charge(payment);
    }
}

⚠️ Редко используется в современной Java (устаревший подход).

5. Method Injection — инъекция через методы

Зависимости передаются как параметры методам:

@Service
public class ReportService {
    private ReportRepository reportRepository;
    
    // Зависимость передаётся в метод
    public void generateReport(ReportGenerator generator, ReportData data) {
        generator.generate(data);
    }
    
    @Transactional
    public void saveAndNotify(Report report, NotificationService notifier) {
        reportRepository.save(report);
        notifier.sendNotification(report);
    }
}

Преимущества:

• Зависимости явные
• Лёгко тестировать
• Не требует хранения состояния

⚠️ Менее удобно для постоянных зависимостей.

6. Spring @Inject vs @Autowired

В Spring можно использовать обе аннотации для внедрения:

// Spring аннотация
public class ServiceA {
    @Autowired
    private Repository repository; // Spring специфичная
}

// JSR 330 стандарт (более портативна)
public class ServiceB {
    @Inject
    private Repository repository; // Работает в любом DI контейнере
}

✓ Лучше использовать @Inject для портативности.

7. Optional Injection — опциональное внедрение

@Service
public class AnalyticsService {
    private final Optional<AnalyticsProvider> analyticsProvider;
    
    public AnalyticsService(Optional<AnalyticsProvider> analyticsProvider) {
        this.analyticsProvider = analyticsProvider;
    }
    
    public void trackEvent(String event) {
        analyticsProvider.ifPresent(provider -> provider.track(event));
    }
}

8. Lookup Method Injection — инъекция через переопределение метода

Меднее используемый подход с CGLIB:

public abstract class PrototypeClient {
    public void process() {
        PrototypeService service = createService();
        service.execute();
    }
    
    // Переопределяется Spring через CGLIB
    protected abstract PrototypeService createService();
}

Сравнение методов

Constructor Injection — Рекомендуется. Явные зависимости, immutable, легко тестировать.

Setter Injection — Когда много зависимостей и нужна гибкость.

Field Injection — НЕ рекомендуется (но распространена в legacy коде).

Interface Injection — Устаревшая.

Method Injection — Для динамических зависимостей.

Optional Injection — Для опциональных зависимостей.

Best Practices

1. Предпочитай Constructor Injection — это стандарт в современной Java
2. Делай зависимости final — это гарантирует immutability
3. Избегай Field Injection — особенно в бизнес-логике
4. Используй Optional для опциональных зависимостей
5. Spring конструктор инъекция работает явно — не нужна @Autowired на конструкторе
6. Проверяй circular dependencies — они нарушат запуск приложения

Примере modern approach:

@Service
public class BestPracticeService {
    private final UserRepository userRepository;
    private final MailService mailService;
    private final Optional<AnalyticsService> analyticsService;
    
    // Constructor injection - явно и безопасно
    public BestPracticeService(
        UserRepository userRepository,
        MailService mailService,
        Optional<AnalyticsService> analyticsService) {
        this.userRepository = userRepository;
        this.mailService = mailService;
        this.analyticsService = analyticsService;
    }
    
    public void register(User user) {
        userRepository.save(user);
        mailService.send(user.getEmail());
        analyticsService.ifPresent(a -> a.track("user_registered"));
    }
}