Что такое Injection в Java?

Что такое Injection в Java

Injection (внедрение, внедрение зависимостей, DI — Dependency Injection) — это паттерн проектирования, который позволяет объекту получить свои зависимости извне, вместо того чтобы создавать их самостоятельно. Это основной принцип инверсии управления (IoC — Inversion of Control).

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

Вместо того, чтобы класс сам создавал необходимые ему объекты (зависимости), эти объекты передаются ему извне — через конструктор, метод или поле:

// БЕЗ Dependency Injection (плохо)
public class UserService {
    private UserRepository repository;
    
    public UserService() {
        // Класс создает свою зависимость
        this.repository = new UserRepository();
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// Проблемы:
// - Сильная связанность (tight coupling)
// - Сложно тестировать (нельзя использовать mock)
// - Сложно менять реализацию UserRepository

// С Dependency Injection (хорошо)
public class UserService {
    private UserRepository repository;
    
    // Зависимость передаётся извне
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// Преимущества:
// - Слабая связанность (loose coupling)
// - Легко тестировать (можно передать mock)
// - Легко менять реализацию

Три типа Injection

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

Это рекомендуемый способ:

public interface UserRepository {
    User findById(Long id);
}

public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findById(Long id) {
        // Реализация
        return null;
    }
}

public class UserService {
    private final UserRepository repository; // final = неизменяемо
    
    // Constructor Injection
    public UserService(UserRepository repository) {
        this.repository = repository; // Зависимость задаётся один раз
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// Использование
UserRepository repo = new UserRepositoryImpl();
UserService service = new UserService(repo);
User user = service.getUser(1L);

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

• Зависимости видны в конструкторе
• Можно использовать final (безопасность потоков)
• Нельзя создать объект без зависимостей

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

public class UserService {
    private UserRepository repository;
    
    // Setter Injection
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// Использование
UserService service = new UserService();
service.setRepository(new UserRepositoryImpl());

Недостатки:

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

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

Используется в Spring с аннотацией @Autowired:

@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

Проблемы:

• Зависимости скрыты
• Сложно тестировать
• Spring создаёт reflection для внедрения
• NPE если зависимость null

Dependency Injection контейнеры

Spring Framework (самый популярный)

// 1. Определение компонентов
@Service
public class UserService {
    private final UserRepository repository;
    
    @Autowired // или просто конструктор с параметром в Spring 4.3+
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findById(Long id) {
        // БД запрос
        return null;
    }
}

// 2. Spring контейнер автоматически управляет зависимостями
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Spring создаёт контейнер, находит все @Service/@Repository/etc
        // и управляет их созданием и внедрением
        SpringApplication.run(Application.class, args);
    }
}

// 3. Использование
@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;
    
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id); // userService уже внедрена Spring
    }
}

Google Guice (альтернатива)

// Определение модуля
public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(UserRepository.class).to(UserRepositoryImpl.class);
    }
}

// Использование
Injector injector = Guice.createInjector(new AppModule());
UserService userService = injector.getInstance(UserService.class);
// Guice автоматически создаст UserService с нужной UserRepository

Тестирование с Injection

Это основное преимущество DI:

public interface UserRepository {
    User findById(Long id);
}

public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// Тестирование
public class UserServiceTest {
    
    @Test
    public void testGetUser() {
        // Создаём mock
        UserRepository mockRepository = Mockito.mock(UserRepository.class);
        User expectedUser = new User(1L, "John");
        Mockito.when(mockRepository.findById(1L)).thenReturn(expectedUser);
        
        // Внедряем mock в сервис
        UserService service = new UserService(mockRepository);
        
        // Тестируем
        User result = service.getUser(1L);
        assertEquals(expectedUser, result);
        
        // Проверяем что был вызван findById
        Mockito.verify(mockRepository).findById(1L);
    }
}

Практический пример с разными реализациями

// Interface
public interface EmailService {
    void sendEmail(String to, String message);
}

// Реализация 1: Production
@Service
@Profile("prod")
public class GmailService implements EmailService {
    @Override
    public void sendEmail(String to, String message) {
        // Отправляет через Gmail API
        System.out.println("Отправляю email через Gmail: " + to);
    }
}

// Реализация 2: Development
@Service
@Profile("dev")
public class MockEmailService implements EmailService {
    @Override
    public void sendEmail(String to, String message) {
        // Просто логирует
        System.out.println("[MOCK] Email для " + to + ": " + message);
    }
}

// Использование
@Service
public class UserRegistrationService {
    private final EmailService emailService; // Одна зависимость
    
    public UserRegistrationService(EmailService emailService) {
        this.emailService = emailService;
    }
    
    public void register(String email, String password) {
        // Сохранить пользователя
        
        // В prod будет GmailService, в dev будет MockEmailService
        emailService.sendEmail(email, "Добро пожаловать!");
    }
}

// Запуск
// java -jar app.jar --spring.profiles.active=prod   (использует GmailService)
// java -jar app.jar --spring.profiles.active=dev    (использует MockEmailService)

Инверсия управления (IoC)

DI — это часть более широкого принципа IoC:

// БЕЗ IoC: Ваш код управляет созданием объектов
public class Main {
    public static void main(String[] args) {
        // ВЫ создаёте объекты
        UserRepository repo = new UserRepositoryImpl();
        UserService service = new UserService(repo);
        UserController controller = new UserController(service);
        
        controller.getUser(1L);
    }
}

// С IoC: Контейнер управляет созданием объектов
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // Spring контейнер УПРАВЛЯЕТ созданием
        SpringApplication.run(Application.class, args);
        // Когда вам нужен UserController, Spring его создаст
        // и всё автоматически внедрит
    }
}

Циклические зависимости

Частая проблема:

// Проблема: A зависит от B, B зависит от A
@Service
public class ServiceA {
    private final ServiceB serviceB;
    public ServiceA(ServiceB serviceB) { // ServiceB зависит от ServiceA!
        this.serviceB = serviceB;
    }
}

@Service
public class ServiceB {
    private final ServiceA serviceA;
    public ServiceB(ServiceA serviceA) { // Круговая зависимость
        this.serviceA = serviceA;
    }
}

// Решение: Использовать setter injection или рефакторить архитектуру
@Service
public class ServiceB {
    private ServiceA serviceA;
    
    @Autowired
    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

Заключение

Dependency Injection — это критический паттерн для писания чистого, тестируемого и гибкого кода:

1. Constructor Injection — предпочтительный способ
2. Spring контейнер — управляет зависимостями автоматически
3. Для тестирования — DI позволяет использовать mock объекты
4. IoC контейнер — инвертирует управление созданием объектов
5. Слабая связанность — позволяет легко менять реализации

Любой современный Java фреймворк (Spring, Quarkus, Micronaut) использует DI как основной механизм для управления зависимостями.