К какому способу внедрения зависимости относится иммутабельность

Ответ: Иммутабельность и способы внедрения зависимостей (Dependency Injection)

Вопрос касается связи между иммутабельностью (immutability) объектов и паттернами внедрения зависимостей. Иммутабельность наиболее естественно связана с конструкторным внедрением зависимостей (Constructor Injection).

Три основных способа внедрения зависимостей

1. Constructor Injection (конструкторное внедрение)

public class UserService {
    private final UserRepository repository;      // Иммутабельное поле
    private final EmailService emailService;      // Иммутабельное поле
    
    // Все зависимости передаются в конструктор
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
        // После конструктора поля НЕ могут быть изменены
    }
    
    public void createUser(String email) {
        // Можно безопасно использовать repository и emailService
        // Они гарантированно инициализированы и не изменятся
        User user = new User(email);
        repository.save(user);
        emailService.sendConfirmation(email);
    }
}

2. Setter Injection (сеттер внедрение)

public class UserService {
    private UserRepository repository;            // Мутабельное поле
    private EmailService emailService;            // Мутабельное поле
    
    // Зависимости устанавливаются через сеттеры
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
    
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
    
    // Проблема: объект может быть в частично инициализированном состоянии
    public void createUser(String email) {
        // Может быть null если сеттер не был вызван!
        if (repository == null) {
            throw new RuntimeException("Repository not initialized");
        }
        User user = new User(email);
        repository.save(user);
    }
}

3. Field Injection (полевое внедрение)

@Component
public class UserService {
    @Autowired
    private UserRepository repository;            // Мутабельное поле
    
    @Autowired
    private EmailService emailService;            // Мутабельное поле
    
    // Проблемы:
    // - Объект начинает с пустыми полями
    // - Сложно тестировать (нужны фреймворки)
    // - Скрытые зависимости (не видны в конструкторе)
}

Связь иммутабельности и Constructor Injection

Иммутабельность идеально подходит к constructor injection потому что:

// ✅ Правильный подход
public class PaymentService {
    private final BankService bankService;       // final — иммутабельно
    private final AuditLogger auditLogger;       // final — иммутабельно
    private final PaymentValidator validator;    // final — иммутабельно
    
    // Все зависимости требуются при создании объекта
    public PaymentService(
        BankService bankService,
        AuditLogger auditLogger,
        PaymentValidator validator
    ) {
        this.bankService = bankService;
        this.auditLogger = auditLogger;
        this.validator = validator;
    }
    
    // Преимущества:
    // 1. Объект полностью инициализирован сразу после конструктора
    // 2. Зависимости видны в сигнатуре конструктора
    // 3. Гарантия: зависимости никогда не будут null или изменены
    // 4. Потокобезопасность: final поля безопасны в многопоточной среде
    // 5. Облегченное тестирование: легко создавать моки
}

Почему Constructor Injection лучше для иммутабельности

// ❌ Setter injection — нарушает иммутабельность
public class OrderService {
    private OrderRepository repository = null;   // Может быть null
    private NotificationService notifier = null; // Может быть null
    
    public void setRepository(OrderRepository repo) {
        this.repository = repo; // Может менять зависимость во время работы!
    }
    
    public void processOrder(Order order) {
        // Опасно: кто-то может вызвать setRepository и изменить поведение
        if (repository == null) {
            throw new RuntimeException("Not initialized");
        }
        repository.save(order);
    }
}

// ✅ Constructor injection — гарантирует иммутабельность
public class OrderService {
    private final OrderRepository repository;    // Никогда не null, final
    private final NotificationService notifier;  // Никогда не null, final
    
    public OrderService(OrderRepository repo, NotificationService notif) {
        this.repository = repo;  // Устанавливается один раз
        this.notifier = notif;   // Устанавливается один раз
    }
    
    public void processOrder(Order order) {
        // Полная уверенность: зависимости инициализированы и не изменятся
        repository.save(order);
        notifier.notify(order.getCustomer());
    }
}

Spring примеры

// Spring с Constructor Injection (рекомендуется)
@Service
public class UserManagementService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final EmailService emailService;
    
    // Spring автоматически внедрит зависимости в конструктор
    public UserManagementService(
        UserRepository userRepository,
        PasswordEncoder passwordEncoder,
        EmailService emailService
    ) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.emailService = emailService;
    }
    
    public void registerUser(String email, String password) {
        String hashedPassword = passwordEncoder.encode(password);
        User user = new User(email, hashedPassword);
        userRepository.save(user);
        emailService.sendVerificationEmail(email);
    }
}

// Тестирование очень простое
class UserManagementServiceTest {
    
    @Test
    void testRegisterUser() {
        // Просто создаём объект с моками
        UserRepository mockRepo = mock(UserRepository.class);
        PasswordEncoder mockEncoder = mock(PasswordEncoder.class);
        EmailService mockEmail = mock(EmailService.class);
        
        UserManagementService service = new UserManagementService(
            mockRepo,
            mockEncoder,
            mockEmail
        );
        
        when(mockEncoder.encode("password123")).thenReturn("hashed_password");
        
        service.registerUser("user@example.com", "password123");
        
        verify(mockRepo).save(any(User.class));
        verify(mockEmail).sendVerificationEmail("user@example.com");
    }
}

Field Injection в Spring (менее предпочтительно)

@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;  // Не final, может быть null при создании
    
    @Autowired
    private PriceCalculator calculator;    // Не final, скрытая зависимость
    
    // Тестирование сложнее — нужна рефлексия или Spring контекст
    public void updatePrice(Product product) {
        Double price = calculator.calculate(product);
        product.setPrice(price);
        repository.save(product);
    }
}

// Тестирование требует специальных инструментов
class ProductServiceTest {
    private ProductService service = new ProductService();
    
    @Before
    void setup() throws Exception {
        // Нужно использовать рефлексию для установки зависимостей!
        Field field = ProductService.class.getDeclaredField("repository");
        field.setAccessible(true);
        field.set(service, mock(ProductRepository.class));
        
        // Это очень неудобно!
    }
}

Лучшие практики

// ✅ ВСЕГДА используйте Constructor Injection с final
@Service
public class GoodService {
    private final Dependency1 dep1;
    private final Dependency2 dep2;
    
    public GoodService(Dependency1 dep1, Dependency2 dep2) {
        this.dep1 = dep1;
        this.dep2 = dep2;
    }
}

// ❌ Избегайте Setter Injection
@Service
public class BadService {
    private Dependency1 dep1;
    
    public void setDep1(Dependency1 dep1) {
        this.dep1 = dep1;
    }
}

// ❌ Избегайте Field Injection (без необходимости)
@Service
public class AlsoBadService {
    @Autowired
    private Dependency1 dep1;
}

Вывод

Иммутабельность (использование final для зависимостей) наиболее тесно связана с Constructor Injection потому что:

1. Гарантирует полную инициализацию — объект готов к использованию сразу после конструктора
2. Предотвращает null-ошибки — зависимость не может быть null
3. Обеспечивает потокобезопасность — final поля безопасны в многопоточной среде
4. Упрощает тестирование — зависимости видны и легко подменяются
5. Явные зависимости — видны в сигнатуре конструктора

McLeod принцип: "сделайте зависимости явными через конструктор и иммутабельными через final".