Как лучше создавать бины в Spring Boot

# Как лучше создавать бины в Spring Boot

1. Аннотация @Component и её специализации (проще всего)

Для классов, которые будут управляться Spring, просто добавь аннотацию:

// Базовая аннотация (для любых компонентов)
@Component
public class UserValidator {
    public boolean validate(User user) {
        return user.getEmail() != null && user.getAge() > 0;
    }
}

// @Service — для бизнес-логики
@Service
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository; // Constructor Injection
    }
    
    public void createUser(User user) {
        repository.save(user);
    }
}

// @Repository — для доступа к БД (может обрабатывать исключения)
@Repository
public class UserRepository {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public void save(User user) {
        // SQL запрос
    }
}

// @Controller — для обработки HTTP запросов
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findById(id));
    }
}

2. @Configuration + @Bean (для сложных объектов)

Когда нужно контролировать создание объекта (параметры, условия и т.д.):

@Configuration
public class AppConfig {
    // Простой bean
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    // Bean с зависимостями
    @Bean
    public UserService userService(UserRepository repository, EmailService emailService) {
        return new UserService(repository, emailService);
    }
    
    // Bean с условиями
    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new RedisCacheManager();
    }
    
    // Bean с разными реализациями в зависимости от профиля
    @Bean
    @Profile("development")
    public Logger devLogger() {
        return new ConsoleLogger();
    }
    
    @Bean
    @Profile("production")
    public Logger prodLogger() {
        return new CloudLogger();
    }
    
    // Bean с инициализацией
    @Bean
    public DataSource dataSource() throws Exception {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("password");
        config.setMaximumPoolSize(10);
        return new HikariDataSource(config);
    }
}

3. Лучшие практики для создания beans

✅ Constructor Injection (рекомендуется)

@Service
public class OrderService {
    private final OrderRepository repository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    
    // Spring автоматически найдёт и инъектирует все параметры
    public OrderService(
        OrderRepository repository,
        PaymentService paymentService,
        NotificationService notificationService
    ) {
        this.repository = repository;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }
}

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

• Зависимости видны явно в конструкторе
• Immutability (final fields)
• Легче тестировать (просто передай зависимости)
• Ловит циклические зависимости на старте

❌ Field Injection (не рекомендуется)

@Service
public class OrderService {
    @Autowired
    private OrderRepository repository;
    
    @Autowired
    private PaymentService paymentService;
}

// Проблемы:
// - Сложно видеть зависимости
// - Нельзя сделать final
// - Сложнее тестировать
// - Циклические зависимости проявляются в runtime

⚠️ Setter Injection (редко используется)

@Service
public class OrderService {
    private OrderRepository repository;
    
    @Autowired
    public void setRepository(OrderRepository repository) {
        this.repository = repository;
    }
}

// Использую если зависимость опциональна
@Autowired(required = false)
public void setOptionalService(OptionalService service) {
    this.optionalService = service;
}

4. Управление областью видимости (Scope)

// SINGLETON (по умолчанию) — один объект на всё приложение
@Component
@Scope("singleton")
public class ApplicationContext {
    // Создаётся один раз
}

// PROTOTYPE — новый объект при каждом запросе
@Component
@Scope("prototype")
public class RequestProcessor {
    private LocalDateTime createdAt = LocalDateTime.now();
    // Каждый раз новый, со своим временем создания
}

// REQUEST — новый объект для каждого HTTP запроса
@Component
@Scope("request")
public class HttpRequestContext {
    // Доступен только внутри одного HTTP запроса
}

// SESSION — новый объект для каждой сессии
@Component
@Scope("session")
public class UserSession {
    // Один объект на всю сессию пользователя
}

// Использование в @Bean
@Bean
@Scope("prototype")
public RequestLogger requestLogger() {
    return new RequestLogger();
}

5. Условное создание beans

@Configuration
public class ConditionalBeanConfig {
    // Создать bean только если класс в classpath
    @Bean
    @ConditionalOnClass(name = "io.redis.clients.jedis.Jedis")
    public RedisService redisService() {
        return new RedisService();
    }
    
    // Создать если свойство установлено
    @Bean
    @ConditionalOnProperty(name = "feature.analytics.enabled", havingValue = "true")
    public AnalyticsService analyticsService() {
        return new AnalyticsService();
    }
    
    // Создать если другого bean нет
    @Bean
    @ConditionalOnMissingBean(CacheManager.class)
    public SimpleCacheManager simpleCacheManager() {
        return new SimpleCacheManager();
    }
    
    // Создать на основе выражения SpEL
    @Bean
    @ConditionalOnExpression("${app.mode} == ADVANCED")
    public AdvancedProcessor advancedProcessor() {
        return new AdvancedProcessor();
    }
}

6. Инициализация и очистка beans

@Component
public class ConnectionPool {
    private List<Connection> connections;
    
    // Вызовется после создания bean и инъекции зависимостей
    @PostConstruct
    public void init() {
        connections = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            connections.add(createConnection());
        }
    }
    
    // Вызовется при shutdown приложения
    @PreDestroy
    public void cleanup() {
        connections.forEach(Connection::close);
    }
}

// Или через IntializingBean / DisposableBean
@Component
public class LegacyComponent implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // Инициализация
    }
    
    @Override
    public void destroy() throws Exception {
        // Очистка
    }
}

7. Работа с несколькими реализациями

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

@Component("stripe")
public class StripeProcessor implements PaymentProcessor {
    public void process(Payment payment) { }
}

@Component("paypal")
public class PayPalProcessor implements PaymentProcessor {
    public void process(Payment payment) { }
}

// Инъектирование нужной реализации
@Service
public class PaymentService {
    private final PaymentProcessor processor;
    
    // @Qualifier указывает какую реализацию выбрать
    public PaymentService(@Qualifier("stripe") PaymentProcessor processor) {
        this.processor = processor;
    }
}

// Или через @Primary
@Component
@Primary // Будет выбран по умолчанию если нет @Qualifier
public class StripeProcessor implements PaymentProcessor { }

8. Сравнение подходов

Checklist: правильное создание bean

@Service // ✅ Выбери правильную аннотацию
public class MyService {
    
    // ✅ Constructor injection (обязательно)
    private final Dependency dependency;
    
    public MyService(Dependency dependency) {
        this.dependency = dependency; // ✅ Final fields
    }
    
    // ✅ Явные методы инициализации/очистки
    @PostConstruct
    public void initialize() { }
    
    @PreDestroy
    public void cleanup() { }
}

Главное правило: используй @Component/@Service/@Repository для 90% компонентов, а @Configuration + @Bean только для специальных случаев (конфигурация, library интеграция).