Для чего нужна @Bean, если можно использовать @Component?

Для чего нужна @Bean, если можно использовать @Component?

@Bean и @Component решают разные задачи. @Component используется для классов из вашего проекта, а @Bean — для регистрации объектов внешних библиотек и сложной конфигурации. Выбор зависит от контекста.

Основные различия

@Component — для вашего кода

// ваш класс
@Component
public class UserService {
    public void findUser(int id) {
        // логика
    }
}

@Bean — для конфигурации внешних объектов

@Configuration
public class AppConfig {
    // объект из внешней библиотеки
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();  // внешний класс
    }
}

Когда использовать @Component

// 1. Сервисы из вашего проекта
@Component
public class PaymentService {
    public void process(double amount) { }
}

// 2. Контроллеры
@RestController
public class UserController {  // это @Component по факту
    @Autowired
    private UserService userService;
}

// 3. Репозитории (если не используется Spring Data JPA)
@Component
public class UserRepository {
    public List<User> findAll() { }
}

// 4. Простые классы без сложной инициализации
@Component
public class Logger {
    public void log(String message) {
        System.out.println(message);
    }
}

Когда использовать @Bean

1. Внешние библиотеки

@Configuration
public class DatabaseConfig {
    // DataSource из HikariCP
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost/db");
        config.setUsername("root");
        config.setPassword("password");
        config.setMaximumPoolSize(20);
        return new HikariDataSource(config);
    }
    
    // SessionFactory из Hibernate
    @Bean
    public SessionFactory sessionFactory(DataSource dataSource) {
        LocalSessionFactoryBean bean = new LocalSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
}

2. Сложная инициализация

@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .interceptors((request, body, execution) -> {
                request.getHeaders().add("Authorization", "Bearer " + getToken());
                return execution.execute(request, body);
            })
            .build();
    }
}

3. Условная регистрация

@Configuration
public class CacheConfig {
    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "redis")
    public CacheManager redisCacheManager() {
        return RedisCacheManager.create(connectionFactory());
    }
    
    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "caffeine", matchIfMissing = true)
    public CacheManager caffeineCache() {
        return new CaffeineCacheManager();
    }
}

4. Несколько реализаций одного интерфейса

public interface PaymentGateway {
    void pay(double amount);
}

public class StripePayment implements PaymentGateway { }
public class PayPalPayment implements PaymentGateway { }

@Configuration
public class PaymentConfig {
    @Bean
    @Primary  // используется по умолчанию
    public PaymentGateway stripeGateway() {
        return new StripePayment();
    }
    
    @Bean
    public PaymentGateway paypalGateway() {
        return new PayPalPayment();
    }
}

// Использование
@Service
public class OrderService {
    @Autowired
    private PaymentGateway gateway;  // injected StripePayment
    
    @Autowired
    @Qualifier("paypalGateway")
    private PaymentGateway paypal;   // injected PayPalPayment
}

5. Prototype scope (новый экземпляр каждый раз)

@Configuration
public class BeanScopeConfig {
    @Bean
    @Scope("prototype")  // новый экземпляр каждый раз
    public RequestContext requestContext() {
        return new RequestContext();
    }
    
    // @Component всегда Singleton!
    // @Bean с @Scope("prototype") — новый каждый раз
}

Практическое сравнение

Сценарий 1: Инициализация DatabaseConnectionPool

// НЕПРАВИЛЬНО: @Component
@Component
public class MyConnectionPool {
    // Как инициализировать параметры из конфига?
    // Нельзя явно передать конфиг в конструктор
}

// ПРАВИЛЬНО: @Bean
@Configuration
public class DatabaseConfig {
    @Bean
    public DataSource dataSource(
            @Value("${db.url}") String url,
            @Value("${db.username}") String username,
            @Value("${db.password}") String password) {
        
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername(username);
        config.setPassword(password);
        return new HikariDataSource(config);
    }
}

Сценарий 2: Dependency между beans

@Configuration
public class ServiceConfig {
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        // явно передаем зависимость
        return new UserRepository(dataSource);
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        // явно передаем зависимость
        return new UserService(repository);
    }
}

// VS @Component подход
@Component
public class UserRepository {
    @Autowired
    private DataSource dataSource;  // неявная зависимость
}

@Component
public class UserService {
    @Autowired
    private UserRepository repository;  // неявная зависимость
}
// Сложнее отследить зависимости

Когда @Bean лучше, чем @Component

Комбинированный подход

// Configuration для инфраструктуры
@Configuration
public class InfrastructureConfig {
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

// Component для бизнес-логики
@Component
public class UserService {
    private final JdbcTemplate jdbc;
    
    public UserService(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }
    
    public User findById(int id) {
        return jdbc.queryForObject(
            "SELECT * FROM users WHERE id = ?",
            new UserRowMapper(),
            id
        );
    }
}

@RestController
public class UserController {
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable int id) {
        return userService.findById(id);
    }
}

Автоконфигурация Spring Boot

// Spring Boot автоматически создает beans
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // Spring Boot уже зарегистрировал через @Bean:
        // - DataSource
        // - JdbcTemplate
        // - RestTemplate
        // - Jackson ObjectMapper
        // - и многое другое
    }
}

// Можешь переопределить автоконфигурацию
@Configuration
public class CustomConfig {
    @Bean
    @Override
    public RestTemplate restTemplate() {
        // твой кастомный RestTemplate
        return new RestTemplate();
    }
}

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

// С @Component сложнее мокировать
@Component
public class UserService {
    @Autowired
    private UserRepository repository;  // трудно заменить в тесте
}

// С @Bean проще
@Configuration
public class TestConfig {
    @Bean
    public UserRepository userRepository() {
        return mock(UserRepository.class);
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        return new UserService(repository);
    }
}

@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;
    
    @Autowired
    private UserRepository mockRepository;
    
    @Test
    public void test() {
        when(mockRepository.findById(1)).thenReturn(new User());
        // тестируем
    }
}

Вывод

Используй @Component когда:

• Класс из вашего проекта
• Простая инициализация
• Не нужна конфигурация

Используй @Bean когда:

• Внешняя библиотека
• Сложная инициализация
• Нужна параметризация
• Несколько реализаций одного интерфейса
• Нужен контроль над жизненным циклом

Правило большого пальца:

• @Component — для сервисов и контроллеров
• @Bean — для конфигурации и инфраструктуры

Это не взаимоисключающие подходы. Хороший Spring проект использует оба вместе.