Что изменится если использовать @Autowired

@Autowired: внедрение зависимостей в Spring

@Autowired — аннотация Spring Framework, которая обеспечивает автоматическое внедрение зависимостей (Dependency Injection). Это одна из ключевых особенностей Spring Framework.

Что происходит с @Autowired

// БЕЗ @Autowired — ручное управление
public class UserService {
    private UserRepository repository;
    
    // Нужно создавать вручную
    public UserService() {
        this.repository = new UserRepository();
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// С @Autowired — автоматическое управление
@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Spring сам инъектирует!
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

Три способа использования @Autowired

1. Инъекция в поле (Field Injection)

@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Spring инъектирует в поле
    
    @Autowired
    private EmailService emailService;
    
    public User createUser(User user) {
        User saved = repository.save(user);
        emailService.sendWelcomeEmail(saved.getEmail());
        return saved;
    }
}

// Что происходит:
// 1. Spring создает новый экземпляр UserService
// 2. Spring находит bean типа UserRepository
// 3. Spring устанавливает repository в поле
// 4. Spring находит bean типа EmailService
// 5. Spring устанавливает emailService в поле

2. Инъекция через конструктор (Constructor Injection) — рекомендуется

@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    
    // Spring инъектирует через конструктор
    @Autowired
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
    
    public User createUser(User user) {
        User saved = repository.save(user);
        emailService.sendWelcomeEmail(saved.getEmail());
        return saved;
    }
}

// Преимущества:
// ✅ Поля final (неизменяемость)
// ✅ Явное указание зависимостей
// ✅ Легче тестировать
// ✅ Нет NullPointerException

3. Инъекция через сеттер (Setter Injection)

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

// Используется когда зависимость опциональна

Жизненный цикл инъекции

public class InjectionLifecycle {
    
    // 1. Spring сканирует @ComponentScan или classpath
    @SpringBootApplication
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    // 2. Spring создает ApplicationContext
    // 3. Spring находит все @Component, @Service, @Repository
    @Service
    public class MyService {
        @Autowired
        private MyRepository repo;  // Эта зависимость нужна
    }
    
    // 4. Spring проверяет зависимости
    // 5. Spring создает экземпляры в правильном порядке
    // 6. Spring инъектирует зависимости
    // 7. Spring вызывает @PostConstruct методы
    // 8. Bean готов к использованию
    
    // 9. При завершении Spring вызывает @PreDestroy методы
}

Разрешение зависимостей

// Как Spring находит нужный bean

// Вариант 1: по типу (самый простой)
public class UserService {
    @Autowired
    private UserRepository repository;  // Spring ищет bean типа UserRepository
}

// Вариант 2: по имени (когда несколько реализаций)
public interface PaymentProcessor {
    void process(Payment payment);
}

@Component("stripPaymentProcessor")
public class StripePaymentProcessor implements PaymentProcessor { ... }

@Component("paypalPaymentProcessor")
public class PayPalPaymentProcessor implements PaymentProcessor { ... }

@Service
public class PaymentService {
    @Autowired
    @Qualifier("stripPaymentProcessor")  // Указываем по имени
    private PaymentProcessor processor;
}

// Вариант 3: по @Primary
@Component
@Primary  // Используется по умолчанию
public class DefaultPaymentProcessor implements PaymentProcessor { ... }

Проблема циклических зависимостей

// ❌ Циклическая зависимость
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;  // A зависит от B
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;  // B зависит от A
}

// Spring выбросит:
// BeanCurrentlyInCreationException: Bean A is currently in creation

// Решение 1: перестроить архитектуру
@Service
public class ServiceA {
    @Autowired
    private ServiceC serviceC;
}

@Service
public class ServiceB {
    @Autowired
    private ServiceC serviceC;
}

@Service
public class ServiceC {
    // Независимый сервис
}

// Решение 2: использовать ObjectProvider
@Service
public class ServiceA {
    private final ObjectProvider<ServiceB> serviceBProvider;
    
    @Autowired
    public ServiceA(ObjectProvider<ServiceB> serviceBProvider) {
        this.serviceBProvider = serviceBProvider;
    }
    
    public void doWork() {
        ServiceB serviceB = serviceBProvider.getIfAvailable();
        if (serviceB != null) {
            serviceB.doSomething();
        }
    }
}

Требуемые vs опциональные зависимости

// Требуемая зависимость (по умолчанию)
@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Обязательна, иначе ошибка
}
// Если нет bean типа UserRepository -> NoSuchBeanDefinitionException

// Опциональная зависимость
@Service
public class UserService {
    @Autowired(required = false)  // Может быть null
    private UserRepository repository;
    
    public void getUser(Long id) {
        if (repository != null) {
            return repository.findById(id);
        }
        return null;
    }
}

// С Optional (более элегантно)
@Service
public class UserService {
    private final Optional<UserRepository> repository;
    
    @Autowired
    public UserService(Optional<UserRepository> repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository
            .map(repo -> repo.findById(id))
            .orElse(null);
    }
}

Spring Boot и @Autowired

// @SpringBootApplication автоматически
// включает component scanning и @Autowired обработку

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Автоматически сканируются:
// - @Component
// - @Service
// - @Repository
// - @Controller
// - @Configuration
// И их @Autowired зависимости инъектируются

Тестирование с @Autowired

// Без Spring (более чистый тест)
@Test
public void testUserServiceWithoutSpring() {
    UserRepository mockRepo = mock(UserRepository.class);
    UserService service = new UserService(mockRepo);
    
    when(mockRepo.findById(1L)).thenReturn(new User());
    User user = service.getUser(1L);
    
    assertNotNull(user);
}

// С Spring (@SpringBootTest инициирует всё)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;
    
    @MockBean
    private UserRepository repository;  // Мокируемая зависимость
    
    @Test
    public void testWithSpring() {
        when(repository.findById(1L)).thenReturn(new User());
        User user = userService.getUser(1L);
        assertNotNull(user);
    }
}

Что изменится при использовании @Autowired

1. Контроль жизненного цикла — Spring управляет созданием и уничтожением объектов
2. Слабые связи — классы не знают о конкретных реализациях
3. Переиспользуемость — один bean используется для всех инъекций
4. Упрощение конфигурации — не нужно писать фабрики
5. Улучшение тестируемости — легче мокировать зависимости
6. Снижение boilerplate кода — не нужны конструкторы и сеттеры
7. Уменьшение вероятности ошибок — Spring проверяет зависимости при старте

Вывод

@Autowired превращает Spring в контейнер управления зависимостями, обеспечивая:

• Инверсию управления (IoC)
• Инъекцию зависимостей (DI)
• Слабую связанность (Loose Coupling)
• Высокую когезию (High Cohesion)

Выбирайте Constructor Injection как основной метод!