Используешь ли @Bean над методом для определения бина

@Bean аннотация для определения бинов

Да, я активно использую @Bean для определения бинов в Spring. Это один из ключевых способов явного конфигурирования бинов в Spring контексте.

Что такое @Bean

@Bean — это аннотация, которая указывает Spring'у, что метод производит bean (управляемый объект), который должен быть зарегистрирован в Spring Application Context.

@Configuration
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        // Spring зарегистрирует объект DataSource как бин
        return new HikariDataSource(config);
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        // Spring автоматически инъектирует DataSource
        return new JdbcTemplate(dataSource);
    }
}

Где использовать @Bean

Метод с @Bean должен находиться в классе, аннотированном @Configuration:

@Configuration  // Обязательно!
public class DatabaseConfig {
    
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
            .driverClassName("org.postgresql.Driver")
            .url("jdbc:postgresql://localhost/mydb")
            .username("user")
            .password("password")
            .build();
    }
    
    @Bean
    public SessionFactory sessionFactory(DataSource dataSource) {
        // Injection через параметры метода
        LocalSessionFactoryBuilder builder = new LocalSessionFactoryBuilder(dataSource);
        builder.scanPackages("com.example.domain");
        return builder.buildSessionFactory();
    }
}

@Bean vs @Component

Разница:

Пример:

// Свой класс — используем @Component
@Component
public class UserService {
    // Spring автоматически создаст бин
}

// Внешняя библиотека (например, Jackson) — используем @Bean
@Configuration
public class JacksonConfig {
    
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        return mapper;
    }
}

Когда @Bean необходимо

1. Внешние библиотеки (нет исходного кода)

@Configuration
public class ThirdPartyConfig {
    
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .build();
    }
    
    @Bean
    public AmazonS3 amazonS3Client() {
        return AmazonS3ClientBuilder.standard()
            .withRegion(Regions.US_EAST_1)
            .build();
    }
}

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

@Configuration
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CacheBuilder cacheBuilder = CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES);
        
        return new CaffeineCacheManager();
    }
}

3. Условное создание бинов

@Configuration
public class DatabaseConfig {
    
    @Bean
    @ConditionalOnProperty(name = "db.type", havingValue = "postgresql")
    public DataSource postgresDataSource() {
        return new PostgresDataSource();
    }
    
    @Bean
    @ConditionalOnProperty(name = "db.type", havingValue = "mysql")
    public DataSource mysqlDataSource() {
        return new MysqlDataSource();
    }
}

Dependency Injection через @Bean

Spring автоматически инъектирует другие бины:

@Configuration
public class ServiceConfig {
    
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new JdbcUserRepository(dataSource);
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        // Spring передаст UserRepository автоматически
        return new UserService(userRepository);
    }
    
    @Bean
    public EmailService emailService() {
        return new EmailService();
    }
    
    @Bean
    public NotificationService notificationService(
            UserService userService,
            EmailService emailService) {
        // Множественная injection
        return new NotificationService(userService, emailService);
    }
}

Имена бинов

По умолчанию имя бина = имя метода:

@Configuration
public class BeanNamesConfig {
    
    @Bean
    public UserService userService() {
        // Имя бина: "userService"
        return new UserService();
    }
    
    @Bean(name = "customUserService")
    public UserService userServiceCustom() {
        // Имя бина: "customUserService"
        return new UserService();
    }
    
    @Bean(name = {"userService2", "userServiceAlias"})
    public UserService userServiceMultiple() {
        // Множество имён
        return new UserService();
    }
}

Scope бинов

@Configuration
public class ScopeConfig {
    
    @Bean
    @Scope("singleton")  // Один экземпляр на весь контекст (по умолчанию)
    public UserService singletonUserService() {
        return new UserService();
    }
    
    @Bean
    @Scope("prototype")  // Новый экземпляр каждый раз
    public Request request() {
        return new Request();
    }
    
    @Bean
    @Scope("request")  // Новый экземпляр на каждый HTTP запрос
    public UserContext userContext() {
        return new UserContext();
    }
}

Lifecycle методы

@Configuration
public class LifecycleConfig {
    
    @Bean(initMethod = "init", destroyMethod = "cleanup")
    public DataSource dataSource() {
        return new CustomDataSource();
    }
}

public class CustomDataSource {
    public void init() {
        // Вызовется после создания бина
        System.out.println("DataSource инициализирован");
    }
    
    public void cleanup() {
        // Вызовется при завершении контекста
        System.out.println("DataSource закрыт");
    }
}

Или через аннотации:

@Component
public class ResourceService {
    
    @PostConstruct
    public void init() {
        // Вызовется после создания
    }
    
    @PreDestroy
    public void destroy() {
        // Вызовется перед удалением
    }
}

Реальный пример: REST клиент

@Configuration
public class HttpClientConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(10000);
        
        return new RestTemplate(factory);
    }
}

@Service
public class ApiClient {
    
    private final RestTemplate restTemplate;
    
    public ApiClient(RestTemplate restTemplate) {
        // Spring инъектирует бин, созданный через @Bean
        this.restTemplate = restTemplate;
    }
    
    public void callApi(String url) {
        ResponseEntity<String> response = 
            restTemplate.getForEntity(url, String.class);
    }
}

@Bean vs @Configuration

Можно вложить методы с @Bean в другие классы (они должны быть классами компонентов):

@Configuration  // Требуется для @Bean методов
public class AppConfig {
    @Bean
    public UserService userService() { /* ... */ }
}

// vs

@Component
public class ServiceProvider {
    @Bean  // Работает и здесь, но менее типично
    public UserService userService() { /* ... */ }
}

Когда избежать @Bean

Если создаёшь свой класс приложения, используй @Component, @Service, @Repository:

// Плохо
@Configuration
public class BadConfig {
    @Bean
    public UserService userService() {
        return new UserService();  // Зачем @Bean?
    }
}

// Хорошо
@Service
public class UserService {
    // Spring автоматически создаст бин
}

Итог

1. @Bean — явное определение бинов в методах
2. Используй @Bean для: внешних библиотек, сложной логики инициализации, условного создания
3. Используй @Component для: собственных классов приложения
4. Injection автоматическая — Spring подставляет зависимости через параметры методов
5. Важно: методы должны быть в классах с @Configuration

Это один из базовых и мощных механизмов Spring, без которого сложно представить modern Java приложение.